elanous 0.2.7 → 0.2.9

package/src/release-loop/checklist.ts

@@ -1,13 +1,13 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
-import { Database } from 'bun:sqlite';
-import { dirname, join } from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import * as store from './feature-store.js';
 import { debug } from '../debug/log.js';
-import { releaseLedgerRoot } from '../instance/resolve.js';
 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';
 export interface ChecklistItem {
   id: string;
   title: string;
@@ -15,6 +15,7 @@ export interface ChecklistItem {
   owner?: string;
   evidence?: string;
   disposition?: ChecklistDisposition;
+  kind?: ChecklistKind;
   updatedAt: string;
   updatedBy: string;
 }
@@ -40,67 +41,12 @@ export function devVersion(): string {
   return (JSON.parse(readFileSync(join(import.meta.dir, '..', '..', 'package.json'), 'utf8')) as { version: string }).version;
 }
 
-function releasedVersion(): string {
-  const dir = join(releaseLedgerRoot(), 'release');
-  if (!existsSync(dir)) return '';
-  return readdirSync(dir).filter((v) => /^\d+\.\d+\.\d+$/.test(v) && existsSync(join(dir, v, 'release.json')))
-    .filter((v) => {
-      try { const record = JSON.parse(readFileSync(join(dir, v, 'release.json'), 'utf8')) as { version?: string; publishedAt?: string }; return record.version === v && typeof record.publishedAt === 'string'; }
-      catch { return false; }
-    })
-    .sort((a, b) => {
-      const aa = a.split('.').map(Number), bb = b.split('.').map(Number);
-      return (bb[0]! - aa[0]!) || (bb[1]! - aa[1]!) || (bb[2]! - aa[2]!);
-    })[0] ?? '';
-}
-
-function pathFor(v: string): string {
-  if (!/^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/.test(v)) throw new CliUserError(`체크리스트 판이 아니다: ${v}`);
-  return join(releaseLedgerRoot(), 'release', v, 'checklist.json');
-}
-
 export function listChecklist(v: string): Checklist {
-  const path = pathFor(v);
-  if (existsSync(path)) {
-    const data = JSON.parse(readFileSync(path, 'utf8')) as Checklist;
-    refresh(data);
-    return data;
-  }
-  return { version: v, released: releasedVersion(), dev: devVersion(), items: [], history: [] };
+  return store.list(v);
 }
 
-// SQLite's OS-backed write lock is released when the owning process exits, even without a finally block.
-// Hold it across the JSON read/modify/atomic-rename sequence so writers never use stale snapshots.
 function mutate(v: string, apply: (data: Checklist) => boolean): Checklist {
-  const path = pathFor(v);
-  mkdirSync(dirname(path), { recursive: true });
-  const lock = `${path}.mutex.sqlite`;
-  const db = new Database(lock, { create: true, strict: true });
-  try {
-    chmodSync(lock, 0o600);
-    db.exec('PRAGMA busy_timeout = 10000');
-    db.exec('BEGIN IMMEDIATE');
-    try {
-      const data = listChecklist(v);
-      if (apply(data)) save(v, data);
-      db.exec('COMMIT');
-      return data;
-    } catch (error) {
-      db.exec('ROLLBACK');
-      throw error;
-    }
-  } finally { db.close(); }
-}
-
-function save(v: string, data: Checklist): void {
-  const path = pathFor(v);
-  mkdirSync(dirname(path), { recursive: true });
-  const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
-  try {
-    writeFileSync(temp, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
-    chmodSync(temp, 0o600);
-    renameSync(temp, path);
-  } finally { if (existsSync(temp)) rmSync(temp); }
+  return store.mutate(v, store.releasedVersion(), devVersion(), apply);
 }
 
 function change(data: Checklist, id: string, field: string, from: unknown, to: unknown, by: string, at: string): void {
@@ -108,29 +54,29 @@ 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 });
 }
 
-function refresh(data: Checklist): void { data.released = releasedVersion(); data.dev = devVersion(); }
-
-export function addItem(v: string, input: { id: string; title: string; owner?: string }): Checklist {
+export function addItem(v: string, input: { id: string; title: string; owner?: string; kind?: ChecklistKind }): 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');
   return mutate(v, (data) => {
     if (data.items.some((item) => item.id === input.id)) throw new CliUserError(`이미 있는 칸: ${input.id}`, 'set <id> 로 고친다');
     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 } : {}), 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 } : {}), 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 }, by: string): Checklist {
+export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; owner?: string; disposition?: ChecklistDisposition; kind?: ChecklistKind }, 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}`);
-    const fields = (['evidence', 'owner', 'status', 'disposition'] as const).filter((field) => patch[field] !== undefined && patch[field] !== item[field]);
+    if (patch.kind !== undefined && patch.kind !== 'screen') throw new CliUserError(`잘못된 종류: ${patch.kind}`, 'screen');
+    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind'] as const).filter((field) => patch[field] !== undefined && patch[field] !== item[field]);
     if (fields.length === 0) return false;
     const at = new Date().toISOString();
     for (const field of fields) {
@@ -180,11 +126,29 @@ export interface ChecklistGate {
   blocked: string[];
   moved: string[];
   knownIssues: Array<{ id: string; title: string; evidence: string }>;
+  /** Screen cells whose `짝:` line is missing or has an untracked ⏳ — a warning; it never changes `ok`. */
+  parity?: Array<{ id: string; why: string }>;
+}
+
+const PARITY_LINE = /짝:\s*PWA\s*(.+?)\s*·\s*데스크톱\s*(.+?)\s*·\s*폴드\s*(.+?)\s*·\s*아이폰\s*(.+?)\s*·\s*아이패드\s*(.+?)\s*$/m;
+const PARITY_SURFACES = ['PWA', '데스크톱', '폴드', '아이폰', '아이패드'] as const;
+
+/** Why a screen cell's evidence fails the five-surface rule, or null when it passes. */
+export function parityGap(evidence: string | undefined): string | null {
+  if (!evidence || !/짝:/.test(evidence)) return '근거에 짝: 줄이 없다';
+  const match = PARITY_LINE.exec(evidence);
+  if (!match) return '짝: 줄에 다섯 열(PWA · 데스크톱 · 폴드 · 아이폰 · 아이패드)이 다 없다';
+  const untracked = PARITY_SURFACES.filter((_, i) => match[i + 1]!.includes('⏳') && !/\(칸 /.test(match[i + 1]!));
+  return untracked.length ? `⏳ 에 (칸 …) 번호가 없다: ${untracked.join(', ')}` : null;
 }
 
 export function checklistGate(v: string): ChecklistGate {
-  const result: ChecklistGate = { ok: true, red: [], undecided: [], blocked: [], moved: [], knownIssues: [] };
+  const result: ChecklistGate = { ok: true, red: [], undecided: [], blocked: [], moved: [], knownIssues: [], parity: [] };
   for (const item of listChecklist(v).items) {
+    if (item.kind === 'screen') {
+      const why = parityGap(item.evidence);
+      if (why) result.parity!.push({ id: item.id, why });
+    }
     if (item.status === 'red') result.red.push(item.id);
     if (item.status !== 'yellow') continue;
     if (item.disposition === 'block') result.blocked.push(item.id);

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

@@ -0,0 +1,327 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { Database } from 'bun:sqlite';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import { CliUserError } from '../cli/cli-user-error.js';
+import { debug } from '../debug/log.js';
+import { devVersion, type Checklist, type ChecklistHistory, type ChecklistItem } from './checklist.js';
+
+export function validateVersion(version: string): void {
+  if (!/^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/.test(version)) throw new CliUserError(`체크리스트 판이 아니다: ${version}`);
+}
+
+function jsonPath(version: string): string { validateVersion(version); return join(releaseLedgerRoot(), 'release', version, 'checklist.json'); }
+function legacyVersions(): string[] {
+  const root = join(releaseLedgerRoot(), 'release');
+  if (!existsSync(root)) return [];
+  return readdirSync(root).filter((version) => /^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/.test(version) && existsSync(jsonPath(version)));
+}
+export function releasedVersion(): string {
+  const root = join(releaseLedgerRoot(), 'release');
+  if (!existsSync(root)) return '';
+  return readdirSync(root).filter((version) => /^\d+\.\d+\.\d+$/.test(version) && existsSync(join(root, version, 'release.json')))
+    .filter((version) => {
+      try { const record = JSON.parse(readFileSync(join(root, version, 'release.json'), 'utf8')) as { version?: string; publishedAt?: string }; return record.version === version && typeof record.publishedAt === 'string'; }
+      catch { return false; }
+    }).sort((a, b) => {
+      const aa = a.split('.').map(Number), bb = b.split('.').map(Number);
+      return (bb[0]! - aa[0]!) || (bb[1]! - aa[1]!) || (bb[2]! - aa[2]!);
+    })[0] ?? '';
+}
+const walWait = new Int32Array(new SharedArrayBuffer(4));
+function open(): Database {
+  const path = join(releaseLedgerRoot(), 'release', 'features.sqlite');
+  mkdirSync(dirname(path), { recursive: true });
+  const db = new Database(path, { create: true, strict: true });
+  try {
+    chmodSync(path, 0o600);
+    db.exec('PRAGMA busy_timeout = 10000');
+    if ((db.query('PRAGMA journal_mode').get() as { journal_mode: string }).journal_mode !== 'wal') {
+      // First open may race another process initializing the same database; journal_mode needs an exclusive lock.
+      for (let attempt = 0; ; attempt++) {
+        try { db.exec('PRAGMA journal_mode = WAL'); break; }
+        catch (error) {
+          if (!(error instanceof Error) || !/database is locked/.test(error.message) || attempt >= 500) throw error;
+          Atomics.wait(walWait, 0, 0, 20);
+        }
+      }
+    }
+    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);
+    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);`);
+    return db;
+  } catch (error) { db.close(); throw error; }
+}
+
+function transaction<T>(db: Database, work: () => T): T {
+  db.exec('BEGIN IMMEDIATE');
+  try { const result = work(); db.exec('COMMIT'); return result; }
+  catch (error) { db.exec('ROLLBACK'); throw error; }
+}
+/** Read-only counterpart: one deferred transaction so a snapshot never mixes rows from before and after a concurrent write. */
+function readTransaction<T>(db: Database, work: () => T): T {
+  db.exec('BEGIN DEFERRED');
+  try { const result = work(); db.exec('COMMIT'); return result; }
+  catch (error) { db.exec('ROLLBACK'); throw error; }
+}
+
+type EventRow = { seq: number; at: string; by: string; feature_id: string; version: string; field: string; from: string; to: string; released: string; dev: string };
+function decode(value: string | null): unknown { return value === null ? null : JSON.parse(value); }
+function historyRow(row: EventRow): ChecklistHistory {
+  return { at: row.at, by: row.by, id: row.feature_id, field: row.field, from: decode(row.from), to: decode(row.to), released: row.released, dev: row.dev };
+}
+function record(db: Database, version: string, entry: ChecklistHistory): void {
+  db.query('INSERT INTO events (at, by, feature_id, version, field, "from", "to", released, dev) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+    .run(entry.at, entry.by, entry.id, version, entry.field, JSON.stringify(entry.from ?? null), JSON.stringify(entry.to ?? null), entry.released, entry.dev);
+}
+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>>;
+  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.evidence !== null || evidence ? { evidence } : {}), ...(r.disposition !== null ? { disposition: r.disposition as ChecklistItem['disposition'] } : {}),
+      updatedAt: r.updated_at!, updatedBy: r.updated_by! };
+  });
+}
+function snapshot(db: Database, version: string, released: string, dev: string): Checklist {
+  const rows = db.query('SELECT * FROM events WHERE version = ? ORDER BY seq').all(version) as EventRow[];
+  return { version, released, dev, items: items(db, version), history: rows.map(historyRow) };
+}
+function putItem(db: Database, version: string, item: ChecklistItem): void {
+  const feature = db.query('SELECT title FROM features WHERE id = ?').get(item.id) as { title: string } | null;
+  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);
+}
+function importOnDb(db: Database, version: string): boolean {
+  if (db.query('SELECT 1 FROM imported_versions WHERE version = ?').get(version)) return false;
+  const path = jsonPath(version);
+  if (!existsSync(path)) {
+    db.query('INSERT INTO imported_versions (version) VALUES (?)').run(version);
+    return false;
+  }
+  const data = JSON.parse(readFileSync(path, 'utf8')) as Checklist;
+  if (data.version !== version) throw new CliUserError(`체크리스트 판 불일치: ${path}`);
+  if (!Array.isArray(data.items) || !Array.isArray(data.history)) throw new CliUserError(`잘못된 체크리스트: ${path}`);
+  const duplicate = new Set<string>();
+  for (const item of data.items) {
+    if (!item.id?.trim() || !item.title?.trim() || duplicate.has(item.id) || !['green', 'yellow', 'red', 'done'].includes(item.status)) throw new CliUserError(`잘못된 체크리스트 칸: ${version} ${item.id}`);
+    duplicate.add(item.id);
+  }
+  for (const item of data.items) {
+    const existing = db.query('SELECT title FROM features WHERE id = ?').get(item.id) as { title: string } | null;
+    // 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);
+    }
+  }
+  for (const entry of data.history) record(db, version, entry);
+  db.query('INSERT INTO imported_versions (version) VALUES (?)').run(version);
+  return true;
+}
+export function importJson(version: string): boolean {
+  validateVersion(version);
+  if (!existsSync(jsonPath(version))) return false;
+  const db = open();
+  try {
+    if (db.query('SELECT 1 FROM imported_versions WHERE version = ?').get(version)) return false;
+    const imported = transaction(db, () => importOnDb(db, version));
+    if (imported) debug.log('release.features', 'imported', { version });
+    return imported;
+  } finally { db.close(); }
+}
+function importLegacyAll(): void {
+  const db = open();
+  try {
+    const imported = transaction(db, () => legacyVersions().filter((version) => importOnDb(db, version)));
+    for (const version of imported) debug.log('release.features', 'imported', { version });
+  } finally { db.close(); }
+}
+
+export function list(version: string, released = releasedVersion(), dev = devVersion()): Checklist {
+  validateVersion(version);
+  importJson(version);
+  const db = open();
+  try { return readTransaction(db, () => snapshot(db, version, released, dev)); } finally { db.close(); }
+}
+
+/** The checklist API supplies its existing validation, field ordering and legacy history shape. */
+export function mutate(version: string, released: string, dev: string, apply: (data: Checklist) => boolean): Checklist {
+  validateVersion(version);
+  const db = open();
+  try {
+    let imported = false;
+    const result = transaction(db, () => {
+      imported = importOnDb(db, version);
+      const data = snapshot(db, version, released, dev);
+      const before = new Map(data.items.map((item) => [item.id, JSON.stringify(item)]));
+      const count = data.history.length;
+      if (apply(data)) {
+        for (const item of data.items) if (before.get(item.id) !== JSON.stringify(item)) {
+          const previous = before.get(item.id);
+          const evidenceChanged = previous && (JSON.parse(previous) as ChecklistItem).evidence !== item.evidence;
+          if (evidenceChanged) db.query('DELETE FROM evidence WHERE feature_id = ? AND version = ?').run(item.id, version);
+          const persisted = previous && !evidenceChanged
+            ? { ...item, evidence: (db.query('SELECT evidence FROM assignments WHERE feature_id = ? AND version = ?').get(item.id, version) as { evidence: string | null }).evidence ?? undefined }
+            : item;
+          putItem(db, version, persisted);
+        }
+        for (const id of before.keys()) if (!data.items.some((item) => item.id === id)) {
+          db.query('DELETE FROM evidence WHERE feature_id = ? AND version = ?').run(id, version);
+          db.query('DELETE FROM assignments WHERE feature_id = ? AND version = ?').run(id, version);
+        }
+        for (const entry of data.history.slice(count)) record(db, version, entry);
+      }
+      return data;
+    });
+    if (imported) debug.log('release.features', 'imported', { version });
+    return result;
+  } finally { db.close(); }
+}
+
+export function add(version: string, item: ChecklistItem, released = releasedVersion(), dev = devVersion()): Checklist {
+  if (!item.id.trim()) throw new CliUserError('칸 id 가 비었다');
+  if (!item.title.trim()) throw new CliUserError('칸 제목이 비었다');
+  return mutate(version, released, dev, (data) => {
+    if (data.items.some((i) => i.id === item.id)) throw new CliUserError(`이미 있는 칸: ${item.id}`, 'set <id> 로 고친다');
+    data.items.push(item);
+    data.history.push({ at: item.updatedAt, by: item.updatedBy, id: item.id, field: 'add', from: null, to: item, released, dev });
+    return true;
+  });
+}
+export function set(version: string, id: string, patch: Partial<ChecklistItem>, by: string, released = releasedVersion(), dev = devVersion()): Checklist {
+  return mutate(version, released, dev, (data) => {
+    const item = data.items.find((i) => i.id === id);
+    if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
+    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind'] as const).filter((field) => patch[field] !== undefined && patch[field] !== item[field]);
+    if (!fields.length) return false;
+    const at = new Date().toISOString();
+    for (const field of fields) {
+      const from = item[field]; const to = patch[field]!;
+      (item as unknown as Record<string, unknown>)[field] = to;
+      item.updatedAt = at; item.updatedBy = by;
+      data.history.push({ at, by, id, field, from: from ?? null, to, released, dev });
+    }
+    return true;
+  });
+}
+export function remove(version: string, id: string, by: string, released = releasedVersion(), dev = devVersion()): Checklist {
+  return mutate(version, released, dev, (data) => {
+    const index = data.items.findIndex((i) => i.id === id);
+    if (index < 0) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
+    const [item] = data.items.splice(index, 1);
+    data.history.push({ at: new Date().toISOString(), by, id, field: 'remove', from: item, to: null, released, dev });
+    return true;
+  });
+}
+export function move(id: string, from: string, to: string, by: string, released = releasedVersion(), dev = devVersion()): Checklist {
+  validateVersion(from); validateVersion(to);
+  if (from === to) throw new CliUserError('같은 판으로 옮길 수 없다');
+  const db = open();
+  try {
+    let importedFrom = false; let importedTo = false;
+    const result = transaction(db, () => {
+      importedFrom = importOnDb(db, from); importedTo = importOnDb(db, to);
+      const item = items(db, from).find((i) => i.id === id);
+      if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
+      if (db.query('SELECT 1 FROM assignments WHERE feature_id = ? AND version = ?').get(id, to)) throw new CliUserError(`이미 있는 칸: ${id}`);
+      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);
+      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 });
+      return snapshot(db, to, released, dev);
+    });
+    if (importedFrom) debug.log('release.features', 'imported', { version: from });
+    if (importedTo) debug.log('release.features', 'imported', { version: to });
+    debug.log('release.features', 'moved', { id, from, to, by });
+    return result;
+  } finally { db.close(); }
+}
+export function retitle(id: string, title: string, by: string, released = releasedVersion(), dev = devVersion()): void {
+  if (!title.trim()) throw new CliUserError('칸 제목이 비었다');
+  importLegacyAll();
+  const db = open();
+  try {
+    const changed = transaction(db, () => {
+      const old = db.query('SELECT title FROM features WHERE id = ?').get(id) as { title: string } | null;
+      if (!old) throw new CliUserError(`없는 칸: ${id}`);
+      const versions = db.query('SELECT version, COALESCE(title_override, ?) AS title FROM assignments WHERE feature_id = ? ORDER BY version')
+        .all(old.title, id) as Array<{ version: string; title: string }>;
+      if (!versions.length) throw new CliUserError(`없는 칸: ${id}`);
+      const changed = versions.filter((row) => row.title !== title);
+      if (!changed.length && old.title === title) return false;
+      const at = new Date().toISOString();
+      db.query('UPDATE features SET title = ? WHERE id = ?').run(title, id);
+      db.query('UPDATE assignments SET title_override = NULL WHERE feature_id = ?').run(id);
+      for (const { version, title: previousTitle } of changed) {
+        db.query('UPDATE assignments SET updated_at = ?, updated_by = ? WHERE feature_id = ? AND version = ?').run(at, by, id, version);
+        record(db, version, { at, by, id, field: 'title', from: previousTitle, to: title, released, dev });
+      }
+      return true;
+    });
+    if (changed) debug.log('release.features', 'retitled', { id, title, by });
+  } finally { db.close(); }
+}
+export function evidenceAdd(id: string, version: string, ref: string, by: string, released = releasedVersion(), dev = devVersion()): void {
+  validateVersion(version);
+  if (!ref.trim()) throw new CliUserError('근거 ref 가 비었다');
+  const db = open();
+  try {
+    const imported = transaction(db, () => {
+      const loaded = importOnDb(db, version);
+      if (!db.query('SELECT 1 FROM assignments WHERE feature_id = ? AND version = ?').get(id, version)) throw new CliUserError(`없는 칸: ${id}`);
+      const at = new Date().toISOString();
+      db.query('INSERT INTO evidence (feature_id, version, ref, at, by) VALUES (?, ?, ?, ?, ?)').run(id, version, ref, at, by);
+      record(db, version, { at, by, id, field: 'evidence.add', from: null, to: ref, released, dev });
+      return loaded;
+    });
+    if (imported) debug.log('release.features', 'imported', { version });
+  } finally { db.close(); }
+}
+export function history(id: string): Array<ChecklistHistory & { version: string; seq: number }> {
+  importLegacyAll();
+  const db = open();
+  try { return (db.query('SELECT * FROM events WHERE feature_id = ? ORDER BY at, seq').all(id) as EventRow[]).map((row) => ({ ...historyRow(row), version: row.version, seq: row.seq })); }
+  finally { db.close(); }
+}
+
+export function details(id: string): { id: string; title: string; owner: string | null; kind: string | null; createdAt: string; evidence: Array<{ version: string; ref: string; at: string; by: string }> } | null {
+  importLegacyAll();
+  const db = open();
+  try {
+    const row = db.query('SELECT id, title, owner, kind, created_at FROM features WHERE id = ?').get(id) as { id: string; title: string; owner: string | null; kind: string | null; created_at: string } | null;
+    if (!row) return null;
+    const evidence = db.query('SELECT version, ref, at, by FROM evidence WHERE feature_id = ? ORDER BY at, rowid').all(id) as Array<{ version: string; ref: string; at: string; by: string }>;
+    return { id: row.id, title: row.title, owner: row.owner, kind: row.kind, createdAt: row.created_at, evidence };
+  } finally { db.close(); }
+}
+
+export function exportJson(version: string, released = releasedVersion(), dev = devVersion()): Checklist {
+  const data = list(version, released, dev);
+  const path = jsonPath(version);
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temp, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+    chmodSync(temp, 0o600);
+    renameSync(temp, path);
+  } finally { if (existsSync(temp)) rmSync(temp); }
+  const db = open();
+  try { transaction(db, () => { db.query('INSERT OR IGNORE INTO imported_versions (version) VALUES (?)').run(version); }); }
+  finally { db.close(); }
+  return data;
+}

package/src/release-loop/manifest.ts

@@ -15,6 +15,8 @@ export interface ReleaseManifestInput {
   cutoff: { sha: string };
   landings: ReleaseLanding[];
   notes?: Map<number, ReleaseNoteFragment>;
+  /** Note lines from release/next.md at the cutoff, each tied to the landing that added it when known. */
+  nextMd?: NextMdNote[];
   runningGoalPaths: string[];
   publicCommandsBefore: string[];
   publicCommandsAfter: string[];
@@ -24,9 +26,41 @@ export interface ReleaseManifest {
   version: string;
   baseline: ReleaseManifestInput['baseline'];
   cutoff: ReleaseManifestInput['cutoff'];
-  in: Array<{ sha: string; title: string; prNumber?: number; docs: 'present' | 'missing' | 'n/a'; line?: string; kind?: ReleaseNoteFragment['kind'] | 'unknown'; note?: 'missing' }>;
+  in: Array<{ sha: string; title: string; prNumber?: number; docs: 'present' | 'missing' | 'n/a'; line?: string; kind?: ReleaseNoteFragment['kind'] | NextMdKind | 'unknown'; note?: 'missing' }>;
   deferred: Array<{ sha: string; reason: 'release-target-later' | 'run-in-flight' }>;
-  escalate: Array<{ kind: 'command-removed'; command: string }>;
+  escalate: Array<{ kind: 'command-removed'; command: string } | { kind: 'notes-empty'; featFixLandings: number; nextMdLines: number }>;
+  /** Where each IN line came from — present when next.md was read. */
+  fragments?: { byPr: number; byNextMd: number; unlinked: number; unknown: number };
+}
+
+export type NextMdKind = 'feat' | 'fix' | 'security' | 'perf' | 'docs' | 'internal';
+export interface NextMdNote { kind: NextMdKind; line: string; sha?: string; /** The list line as written, to find the landing that added it. */ raw?: string }
+
+const NEXT_MD_KINDS: readonly NextMdKind[] = ['feat', 'fix', 'security', 'perf', 'docs', 'internal'];
+const USER_KINDS = new Set(['feat', 'fix', 'security']);
+
+/**
+ * Read `release/next.md` note lines: the `## Feat` / `## Fix` … heading gives the kind, an explicit `- <kind> — ` prefix wins.
+ * The trailing `Documentation: … Target: …` fields are dropped from the sentence; `Target: later` lines are skipped.
+ */
+export function parseNextMdNotes(text: string): NextMdNote[] {
+  const notes: NextMdNote[] = [];
+  let section: NextMdKind | null = null;
+  for (const raw of text.split(/\r?\n/)) {
+    const heading = /^##\s+(\S+)\s*$/.exec(raw.trim());
+    if (heading) { const kind = heading[1]!.toLowerCase(); section = (NEXT_MD_KINDS as readonly string[]).includes(kind) ? kind as NextMdKind : null; continue; }
+    const item = /^-\s+(.*\S)\s*$/.exec(raw);
+    if (!item) continue;
+    let body = item[1]!;
+    if (/\bTarget:\s*later\b/i.test(body)) continue;
+    const prefix = /^(feat|fix|security|perf|docs|internal)\s+[—-]\s+/i.exec(body);
+    const kind = prefix ? prefix[1]!.toLowerCase() as NextMdKind : section;
+    if (!kind) continue;
+    if (prefix) body = body.slice(prefix[0].length);
+    body = body.replace(/\s+Documentation:.*$/s, '').replace(/\s+Target:\s*\S+\.?\s*$/, '').trim();
+    if (body) notes.push({ kind, line: body, raw: raw.trim() });
+  }
+  return notes;
 }
 
 /** Classify the already-observed landings without reading git, run ledgers or the filesystem. */
@@ -41,6 +75,14 @@ export function buildReleaseManifest(input: ReleaseManifestInput): ReleaseManife
     deferred: [],
     escalate: [],
   };
+  const nextBySha = new Map<string, NextMdNote[]>();
+  const landingShas = new Set(input.landings.map((landing) => landing.sha));
+  const unlinked: NextMdNote[] = [];
+  for (const note of input.nextMd ?? []) {
+    if (note.sha && landingShas.has(note.sha)) nextBySha.set(note.sha, [...(nextBySha.get(note.sha) ?? []), note]);
+    else unlinked.push(note);
+  }
+  const counts = { byPr: 0, byNextMd: 0, unlinked: 0, unknown: 0 };
   for (const landing of input.landings) {
     const fragment = landing.prNumber === undefined ? undefined : input.notes?.get(landing.prNumber);
     if (landing.goalPath && running.has(landing.goalPath)) {
@@ -53,11 +95,23 @@ export function buildReleaseManifest(input: ReleaseManifestInput): ReleaseManife
         : landing.changedFiles.some((file) => file.startsWith('release/public/docs/')) ? 'present'
         : landing.changedFiles.some((file) => file.startsWith('src/cli/') || file === 'src/index.ts') ? 'missing'
         : 'n/a';
-      result.in.push({ sha: landing.sha, title: landing.title, ...(landing.prNumber === undefined ? {} : { prNumber: landing.prNumber }), docs,
-        ...(fragment ? { line: fragment.line, kind: fragment.kind } : input.notes ? { line: landing.title, kind: 'unknown', note: 'missing' as const } : {}),
-      });
+      const base: ReleaseManifest['in'][number] = { sha: landing.sha, title: landing.title, ...(landing.prNumber === undefined ? {} : { prNumber: landing.prNumber }), docs };
+      // PR fragment first, then the next.md lines this landing added; only with neither is the line unknown.
+      const fromNext = fragment ? [] : nextBySha.get(landing.sha) ?? [];
+      if (fragment) { counts.byPr++; result.in.push({ ...base, line: fragment.line, kind: fragment.kind }); }
+      else if (fromNext.length) for (const note of fromNext) { counts.byNextMd++; result.in.push({ ...base, line: note.line, kind: note.kind }); }
+      else { if (input.notes) counts.unknown++; result.in.push({ ...base, ...(input.notes ? { line: landing.title, kind: 'unknown' as const, note: 'missing' as const } : {}) }); }
     }
   }
+  // A next.md line no landing in range claims still belongs to this release.
+  for (const note of unlinked) { counts.unlinked++; result.in.push({ sha: note.sha ?? '', title: note.line, docs: 'n/a', line: note.line, kind: note.kind }); }
+  if (input.nextMd) {
+    result.fragments = counts;
+    const shown = result.in.filter((entry) => entry.line && entry.kind && USER_KINDS.has(entry.kind)).length;
+    const featFixLandings = input.landings.filter((landing) => /^(feat|fix)\b/i.test(landing.title)).length;
+    const nextMdLines = input.nextMd.filter((note) => USER_KINDS.has(note.kind)).length;
+    if (!shown && (featFixLandings || nextMdLines)) result.escalate.push({ kind: 'notes-empty', featFixLandings, nextMdLines });
+  }
   for (const command of input.publicCommandsBefore) {
     if (!after.has(command)) result.escalate.push({ kind: 'command-removed', command });
   }

package/src/seat-dispatch/ceo-commands.ts

@@ -0,0 +1,65 @@
+// The owner hands a seat a task from Telegram: /coo /cto /cmo /cxo → one «[대표] → <seat>» line on the coordination PR,
+// one 'ceo-task' message in the seat store, and a «받음» reply. Nothing is written unless it is the owner in a private chat.
+// Goal: 내부 문서 `ASK-the-ceo-cannot-hand-a-seat-a-task-from-telegram-2026-10-02` (C2 phase 1).
+import { debug } from '../debug/log.js';
+import type { MessageEnvelope } from '../msg/msg-store.js';
+
+export const CEO_SEAT_COMMANDS = { coo: 'OP', cto: 'TC', cmo: 'MK', cxo: 'UX' } as const;
+export type CeoSeatCommand = keyof typeof CEO_SEAT_COMMANDS;
+
+export interface CeoCommandContext { chatId: number | string; userId: number | string }
+
+export interface CeoCommandDeps {
+  /** Telegram user id of the owner (`telegramDecisionOwner`), null when none is configured. */
+  ownerId: string | null;
+  /** `decisions.replyGhPr` — "owner/repo#N". */
+  replyTarget: string | null;
+  runGh: (args: string[], stdin: string) => Promise<number>;
+  append: (message: MessageEnvelope) => unknown;
+  now?: () => Date;
+}
+
+function kstStamp(at: Date): string {
+  return new Intl.DateTimeFormat('sv-SE', { timeZone: 'Asia/Seoul', dateStyle: 'short', timeStyle: 'short' }).format(at);
+}
+
+export function ceoTaskLine(seat: string, task: string, at: Date): string {
+  return `**[대표]** ${kstStamp(at)} KST → ${seat} · ${task}`;
+}
+
+export async function handleCeoSeatCommand(command: CeoSeatCommand, args: string[], ctx: CeoCommandContext, deps: CeoCommandDeps): Promise<string> {
+  const seat = CEO_SEAT_COMMANDS[command];
+  if (!deps.ownerId || String(ctx.userId) !== deps.ownerId) {
+    debug.log('seat.dispatch', 'refused', { seat, reason: 'not-owner' });
+    return '소유자만 쓸 수 있습니다.';
+  }
+  // A group would show the task to every member — private chat only (same rule as /decisions).
+  if (String(ctx.chatId) !== String(ctx.userId)) {
+    debug.log('seat.dispatch', 'refused', { seat, reason: 'not-private' });
+    return '개인 대화에서만 쓸 수 있습니다.';
+  }
+  const task = args.join(' ').replace(/\s+/g, ' ').trim();
+  if (!task) {
+    debug.log('seat.dispatch', 'refused', { seat, reason: 'empty' });
+    return `사용법: /${command} <할 일>`;
+  }
+  deps.append({ from: 'CEO', to: seat, body: task, kind: 'ceo-task' });
+  const channelError = await postToChannel(seat, task, deps);
+  if (channelError) {
+    debug.log('seat.dispatch', 'channel-failed', { seat, reason: channelError }, { level: 'warn' });
+    return `받음 — ${seat} 메시지함에는 넣었습니다. 다만 조율 채널에 못 남겼습니다(${channelError}).`;
+  }
+  debug.log('seat.dispatch', 'ceo-task', { seat });
+  return `받음 — ${seat}에 전했습니다.`;
+}
+
+async function postToChannel(seat: string, task: string, deps: CeoCommandDeps): Promise<string | null> {
+  const target = /^([\w.-]+\/[\w.-]+)#(\d+)$/.exec(deps.replyTarget?.trim() ?? '');
+  if (!target) return deps.replyTarget ? 'decisions.replyGhPr 형식이 owner/repo#N 이 아님' : 'decisions.replyGhPr 미설정';
+  try {
+    const code = await deps.runGh(['pr', 'comment', target[2]!, '--repo', target[1]!, '--body-file', '-'], ceoTaskLine(seat, task, deps.now?.() ?? new Date()));
+    return code === 0 ? null : `gh 종료 코드 ${code}`;
+  } catch (error) {
+    return error instanceof Error ? error.message.slice(0, 80) : 'gh 실행 실패';
+  }
+}