elanous 0.2.9 → 0.2.11

package/src/release-loop/checklist.ts

@@ -28,6 +28,7 @@ export interface ChecklistHistory {
   to: unknown;
   released: string;
   dev: string;
+  force?: true;
 }
 export interface Checklist {
   version: string;
@@ -41,12 +42,44 @@ export function devVersion(): string {
   return (JSON.parse(readFileSync(join(import.meta.dir, '..', '..', 'package.json'), 'utf8')) as { version: string }).version;
 }
 
-export function listChecklist(v: string): Checklist {
-  return store.list(v);
+export function parseOwner(value: string): { seat: string; sub?: string } {
+  const match = /^([A-Z]{2,8})(?:\/([a-z][a-z0-9-]{0,31}))?$/.exec(value);
+  if (!match || match[0] !== value) throw new CliUserError(`잘못된 담당: ${value}`, 'TC 또는 TC/rel');
+  return match[2] ? { seat: match[1]!, sub: match[2] } : { seat: match[1]! };
+}
+
+export function ownerMatches(owner: string | undefined, filter: string): boolean {
+  if (owner === undefined) return false;
+  try {
+    const parsed = parseOwner(owner);
+    const requested = parseOwner(filter);
+    return parsed.seat === requested.seat && (requested.sub === undefined || parsed.sub === requested.sub);
+  } catch { return false; }
+}
+
+// The ledger event schema has no force column; decode its claim target for every checklist snapshot.
+export function decodeClaimHistoryEntry<T extends ChecklistHistory>(entry: T): T {
+  if (entry.field !== 'claim' || !entry.to || typeof entry.to !== 'object') return entry;
+  const target = entry.to as { owner?: unknown; force?: unknown };
+  return typeof target.owner === 'string' && target.force === true ? { ...entry, to: target.owner, force: true } as T : entry;
+}
+
+function decodeClaimHistory(data: Checklist): Checklist {
+  return { ...data, history: data.history.map(decodeClaimHistoryEntry) };
+}
+
+export function listChecklist(v: string, root?: string): Checklist {
+  return decodeClaimHistory(root === undefined ? store.list(v) : store.list(v, undefined, undefined, root));
+}
+
+/** Status events in the requested window; other ledger fields never become status changes. */
+export function statusChangesSince(history: readonly ChecklistHistory[], sinceIso: string): ChecklistHistory[] {
+  const since = Date.parse(sinceIso);
+  return history.filter((entry) => entry.field === 'status' && Date.parse(entry.at) >= since);
 }
 
 function mutate(v: string, apply: (data: Checklist) => boolean): Checklist {
-  return store.mutate(v, store.releasedVersion(), devVersion(), apply);
+  return decodeClaimHistory(store.mutate(v, store.releasedVersion(), devVersion(), apply));
 }
 
 function change(data: Checklist, id: string, field: string, from: unknown, to: unknown, by: string, at: string): void {
@@ -58,6 +91,7 @@ export function addItem(v: string, input: { id: string; title: string; owner?: s
   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);
   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';
@@ -76,6 +110,12 @@ export function setItem(v: string, id: string, patch: { status?: ChecklistStatus
     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.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]);
     if (fields.length === 0) return false;
     const at = new Date().toISOString();
@@ -91,6 +131,34 @@ export function setItem(v: string, id: string, patch: { status?: ChecklistStatus
   });
 }
 
+export function claimItem(v: string, id: string, by: string, options: { force?: boolean } = {}): Checklist {
+  const requested = parseOwner(by);
+  let outcome: 'claimed' | 'same' | 'refused' = 'refused';
+  let from: string | null = null;
+  try {
+    const result = mutate(v, (data) => {
+      const item = data.items.find((i) => i.id === id);
+      if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
+      from = item.owner ?? null;
+      if (from === by) { outcome = 'same'; return false; }
+      if (from && !options.force && !(from === requested.seat && requested.sub)) {
+        throw new CliUserError(`지금 주인: ${from} — --force 로만 바꾼다`);
+      }
+      const at = new Date().toISOString();
+      item.owner = by;
+      item.updatedAt = at;
+      item.updatedBy = by;
+      data.history.push({ at, by, id, field: 'claim', from, to: options.force ? { owner: by, force: true } : by,
+        released: data.released, dev: data.dev });
+      outcome = 'claimed';
+      return true;
+    });
+    return result;
+  } finally {
+    debug.log('release-loop.checklist', 'claim', { version: v, id, from, to: by, force: options.force === true, outcome });
+  }
+}
+
 export function removeItem(v: string, id: string, by: string): Checklist {
   return mutate(v, (data) => {
     const index = data.items.findIndex((i) => i.id === id);
@@ -106,15 +174,21 @@ export function summarize(v: string): ChecklistSummary {
   return summarizeChecklist(listChecklist(v));
 }
 
-export interface ChecklistSummary { green: number; yellow: number; red: number; done: number; blocked: string[]; byOwner: Record<string, number> }
+export interface ChecklistSummary { green: number; yellow: number; red: number; done: number; blocked: string[]; byOwner: Record<string, number>; bySeat: Record<string, number> }
 
 export function summarizeChecklist(data: Checklist): ChecklistSummary {
-  const summary = { green: 0, yellow: 0, red: 0, done: 0, blocked: [] as string[], byOwner: Object.create(null) as Record<string, number> };
+  const summary = { green: 0, yellow: 0, red: 0, done: 0, blocked: [] as string[], byOwner: Object.create(null) as Record<string, number>, bySeat: Object.create(null) as Record<string, number> };
   for (const item of data.items) {
     summary[item.status]++;
     if (item.status === 'red') summary.blocked.push(item.id);
     const owner = item.owner ?? 'unassigned';
     summary.byOwner[owner] = (summary.byOwner[owner] ?? 0) + 1;
+    if (item.owner !== undefined) {
+      try {
+        const { seat } = parseOwner(item.owner);
+        summary.bySeat[seat] = (summary.bySeat[seat] ?? 0) + 1;
+      } catch { /* Preserve legacy owner in byOwner without assigning it to a seat. */ }
+    }
   }
   return summary;
 }

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

@@ -1,5 +1,5 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
 import { Database } from 'bun:sqlite';
 import { releaseLedgerRoot } from '../instance/resolve.js';
@@ -17,8 +17,8 @@ function legacyVersions(): string[] {
   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');
+export function releasedVersion(ledgerRoot = releaseLedgerRoot()): string {
+  const root = join(ledgerRoot, 'release');
   if (!existsSync(root)) return '';
   return readdirSync(root).filter((version) => /^\d+\.\d+\.\d+$/.test(version) && existsSync(join(root, version, 'release.json')))
     .filter((version) => {
@@ -30,8 +30,8 @@ export function releasedVersion(): string {
     })[0] ?? '';
 }
 const walWait = new Int32Array(new SharedArrayBuffer(4));
-function open(): Database {
-  const path = join(releaseLedgerRoot(), 'release', 'features.sqlite');
+function open(root = releaseLedgerRoot()): Database {
+  const path = join(root, 'release', 'features.sqlite');
   mkdirSync(dirname(path), { recursive: true });
   const db = new Database(path, { create: true, strict: true });
   try {
@@ -52,11 +52,61 @@ function open(): Database {
     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);`);
+    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');
+    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)');
     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 };
+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 };
+}
+
+export function readSchedule(version: string, root?: string): ScheduleRow | null {
+  validateVersion(version);
+  if (!existsSync(join(root ?? releaseLedgerRoot(), 'release', 'features.sqlite'))) return null;
+  const db = open(root);
+  try {
+    const row = db.query('SELECT * FROM release_schedules WHERE version = ?').get(version) as StoredSchedule | null;
+    return row ? scheduleRow(row) : null;
+  } finally { db.close(); }
+}
+
+export function readSchedules(root?: string): ScheduleRow[] {
+  const db = open(root);
+  try { return (db.query('SELECT * FROM release_schedules ORDER BY version').all() as StoredSchedule[]).map(scheduleRow); }
+  finally { db.close(); }
+}
+
+export function writeSchedule(version: string, patch: { cutAt?: string; landBy?: string }, by: string, root?: string): ScheduleRow {
+  validateVersion(version);
+  const db = open(root);
+  try {
+    return transaction(db, () => {
+      const previous = db.query('SELECT * FROM release_schedules WHERE version = ?').get(version) as StoredSchedule | null;
+      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 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);
+      for (const [field, from, to] of [
+        ['cut_at', previous?.cut_at ?? null, cutAt], ['land_by', previous?.land_by ?? null, landBy],
+      ] as const) {
+        if (from !== to) record(db, version, { at, by, id: '@version', field, from, to, released: releasedVersion(root), dev: devVersion() });
+      }
+      return { version, cutAt, landBy, updatedAt: at, updatedBy: by };
+    });
+  } finally { db.close(); }
+}
+
 function transaction<T>(db: Database, work: () => T): T {
   db.exec('BEGIN IMMEDIATE');
   try { const result = work(); db.exec('COMMIT'); return result; }
@@ -105,14 +155,32 @@ function putItem(db: Database, version: string, item: ChecklistItem): void {
     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 jsonHash(contents: string | Buffer): string { return createHash('sha256').update(contents).digest('hex'); }
+
+/**
+ * When did the ledger take this item away from `version`? A `move` out of it, a `remove` at it, or (carry-forward
+ * without a move event) the item now living in another version. null = never left — a JSON-only item is new.
+ * OP 10-02: without this, an old build's checklist.json re-added items the ledger had moved or removed (duplicates).
+ */
+function ledgerLeftAt(db: Database, id: string, version: string): string | null {
+  const event = db.query(`SELECT MAX(at) AS at FROM events WHERE feature_id = ? AND
+    ((field = 'move' AND "from" = ?) OR (field = 'remove' AND version = ?))`).get(id, JSON.stringify(version), version) as { at: string | null };
+  const elsewhere = db.query('SELECT MAX(updated_at) AS at FROM assignments WHERE feature_id = ? AND version <> ?').get(id, version) as { at: string | null };
+  const times = [event.at, elsewhere.at].filter((t): t is string => typeof t === 'string');
+  return times.length ? times.sort().at(-1)! : null;
+}
+
 function importOnDb(db: Database, version: string): boolean {
-  if (db.query('SELECT 1 FROM imported_versions WHERE version = ?').get(version)) return false;
+  const previous = db.query('SELECT json_hash FROM imported_versions WHERE version = ?').get(version) as { json_hash: string | null } | null;
   const path = jsonPath(version);
   if (!existsSync(path)) {
-    db.query('INSERT INTO imported_versions (version) VALUES (?)').run(version);
+    if (!previous) db.query('INSERT INTO imported_versions (version) VALUES (?)').run(version);
     return false;
   }
-  const data = JSON.parse(readFileSync(path, 'utf8')) as Checklist;
+  const contents = readFileSync(path);
+  const hash = jsonHash(contents);
+  if (previous && previous.json_hash === hash) return false;
+  const data = JSON.parse(contents.toString('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>();
@@ -120,25 +188,83 @@ function importOnDb(db: Database, version: string): boolean {
     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);
   }
+  if (!previous) {
+    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, json_hash, imported_at) VALUES (?, ?, ?)').run(version, hash, new Date().toISOString());
+    return true;
+  }
+
+  const ledger = new Map(items(db, version).map((item) => [item.id, item]));
+  const changed: string[] = [];
+  let added = 0;
+  const ledgerWonIds: string[] = [];
+  const leftIds: string[] = [];
   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);
+    const current = ledger.get(item.id);
+    if (!current) {
+      // Moved or removed in the ledger: only a JSON edit made after that may bring it back.
+      const leftAt = ledgerLeftAt(db, item.id, version);
+      if (leftAt && !(Date.parse(item.updatedAt) > Date.parse(leftAt))) { leftIds.push(item.id); continue; }
+      const feature = db.query('SELECT title FROM features WHERE id = ?').get(item.id) as { title: string } | null;
+      putItem(db, version, item);
+      if (feature && feature.title !== item.title) db.query('UPDATE assignments SET title_override = ? WHERE feature_id = ? AND version = ?').run(item.title, item.id, version);
+      added++;
+      changed.push(item.id);
+      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 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]);
+    if (!differs) continue;
+    if (!(Date.parse(item.updatedAt) > Date.parse(current.updatedAt))) {
+      ledgerWonIds.push(item.id);
+      continue;
     }
+    const incoming: ChecklistItem = { ...current, status: item.status, updatedAt: item.updatedAt, updatedBy: item.updatedBy };
+    for (const field of fields) {
+      if (field === 'status') continue;
+      if (field === 'evidence' && preserveRefs) continue;
+      if (item[field] === undefined) delete (incoming as unknown as Record<string, unknown>)[field];
+      else (incoming as unknown as Record<string, unknown>)[field] = item[field];
+    }
+    if (!preserveRefs) db.query('DELETE FROM evidence WHERE feature_id = ? AND version = ?').run(item.id, version);
+    const persisted = preserveRefs ? { ...incoming, evidence: baseEvidence } : incoming;
+    putItem(db, version, persisted);
+    if (incoming.title !== current.title) {
+      db.query('UPDATE assignments SET title_override = ? WHERE feature_id = ? AND version = ?')
+        .run(incoming.title === (db.query('SELECT title FROM features WHERE id = ?').get(item.id) as { title: string }).title ? null : incoming.title, item.id, version);
+    }
+    changed.push(item.id);
+    record(db, version, { at: new Date().toISOString(), by: item.updatedBy, id: item.id, field: 'reimport', from: current, to: incoming, released: data.released, dev: data.dev });
   }
-  for (const entry of data.history) record(db, version, entry);
-  db.query('INSERT INTO imported_versions (version) VALUES (?)').run(version);
-  return true;
+  db.query('UPDATE imported_versions SET json_hash = ?, imported_at = ? WHERE version = ?').run(hash, new Date().toISOString(), version);
+  const ledgerWon = ledgerWonIds.length;
+  debug.log('release.features', 'reimported', { version, changed: changed.length - added, added, ledgerWon, notReadded: leftIds.length });
+  // Two separate lines: what was taken from the old build's JSON, and where the JSON differs but the ledger is newer
+  // (a conflict a person should know about even though nothing changed in the ledger).
+  if (changed.length) console.error(`⚠ checklist ${version}: 옛 판이 checklist.json 에 쓴 ${changed.length}칸을 다시 들였다(${changed.slice(0, 5).join(', ')})`);
+  if (leftIds.length) console.error(`⚠ checklist ${version}: 원장에서 옮기거나 지운 칸 ${leftIds.length}은 옛 판 checklist.json 에 남아 있어도 다시 넣지 않았다(${leftIds.slice(0, 5).join(', ')})`);
+  if (ledgerWon) console.error(`⚠ checklist ${version}: 옛 판 checklist.json 과 원장이 다르다 — 원장이 더 새로워 원장 값 유지 ${ledgerWon}칸(${ledgerWonIds.slice(0, 5).join(', ')})`);
+  return false;
 }
 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;
@@ -152,10 +278,12 @@ function importLegacyAll(): void {
   } finally { db.close(); }
 }
 
-export function list(version: string, released = releasedVersion(), dev = devVersion()): Checklist {
+/** `root` reads another ledger (no legacy JSON import there); omitted = the default ledger as before. */
+export function list(version: string, released?: string, dev = devVersion(), root?: string): Checklist {
   validateVersion(version);
-  importJson(version);
-  const db = open();
+  if (root === undefined) importJson(version);
+  released ??= releasedVersion(root);
+  const db = open(root);
   try { return readTransaction(db, () => snapshot(db, version, released, dev)); } finally { db.close(); }
 }
 
@@ -315,13 +443,20 @@ export function exportJson(version: string, released = releasedVersion(), dev =
   const path = jsonPath(version);
   mkdirSync(dirname(path), { recursive: true });
   const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  const contents = `${JSON.stringify(data, null, 2)}\n`;
   try {
-    writeFileSync(temp, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+    writeFileSync(temp, contents, { 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); }); }
+  try { transaction(db, () => {
+    // Track only our bytes: a legacy replacement after rename must remain detectable.
+    const hash = jsonHash(contents);
+    db.query(`INSERT INTO imported_versions (version, json_hash, imported_at) VALUES (?, ?, ?)
+      ON CONFLICT(version) DO UPDATE SET json_hash = excluded.json_hash, imported_at = excluded.imported_at`)
+      .run(version, hash, new Date().toISOString());
+  }); }
   finally { db.close(); }
   return data;
 }

package/src/release-loop/next-md-merge.ts

@@ -0,0 +1,58 @@
+// Deterministic merge for `release/next.md` — two landings that each append a line to the same section
+// keep both lines (union per section, same sentence once). Returns null when it cannot decide (the caller
+// falls back to its usual resolver): a side deleted a line, or a stage is missing.
+
+export const NEXT_MD_PATH = 'release/next.md';
+
+type Section = { header: string | null; lines: string[] };
+
+function sections(text: string): Section[] {
+  const out: Section[] = [{ header: null, lines: [] }];
+  for (const line of text.replace(/\r\n/g, '\n').split('\n')) {
+    if (/^## /.test(line)) out.push({ header: line.trim(), lines: [] });
+    else out[out.length - 1]!.lines.push(line);
+  }
+  return out;
+}
+
+const key = (line: string) => line.trim();
+
+function added(base: Section | undefined, side: Section): string[] {
+  const before = new Set((base?.lines ?? []).map(key));
+  return side.lines.filter((line) => key(line) !== '' && !before.has(key(line)));
+}
+
+function deletedAny(base: Section[], side: Section[]): boolean {
+  for (const b of base) {
+    const s = side.find((x) => x.header === b.header);
+    const kept = new Set((s?.lines ?? []).map(key));
+    if (b.lines.some((line) => key(line) !== '' && !kept.has(key(line)))) return true;
+  }
+  return false;
+}
+
+/** Union of both sides' additions over `theirs` (the branch being merged in). Null = not decidable here. */
+export function resolveNextMdConflict(base: string, ours: string, theirs: string): string | null {
+  const b = sections(base);
+  const o = sections(ours);
+  // Our side only appends (harness landings add one line); a deletion on our side is not ours to decide.
+  if (deletedAny(b, o)) return null;
+  const result = sections(theirs);
+  for (const section of o) {
+    const extra = added(b.find((x) => x.header === section.header), section);
+    if (extra.length === 0) continue;
+    let target = result.find((x) => x.header === section.header);
+    if (!target) {
+      target = { header: section.header, lines: [''] };
+      result.push(target);
+    }
+    const present = new Set(target.lines.map(key));
+    const fresh = extra.filter((line) => !present.has(key(line)));
+    if (fresh.length === 0) continue;
+    // Insert before the section's trailing blank lines so the blank separator stays last.
+    let end = target.lines.length;
+    while (end > 0 && key(target.lines[end - 1]!) === '') end -= 1;
+    target.lines.splice(end, 0, ...fresh);
+  }
+  return result.map((section) => (section.header === null ? section.lines : [section.header, ...section.lines]).join('\n')).join('\n');
+}

package/src/release-loop/release-note.ts

@@ -1,6 +1,7 @@
 import { closeSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
+import { debug } from '../debug/log.js';
 
 export interface ReleaseNoteFragment {
   pr: number;
@@ -12,7 +13,8 @@ export interface ReleaseNoteFragment {
   mergeSha?: string;
 }
 
-type Section = Omit<ReleaseNoteFragment, 'pr' | 'source' | 'mergeSha'>;
+export type ReleaseNoteSection = Omit<ReleaseNoteFragment, 'pr' | 'source' | 'mergeSha'>;
+type Section = ReleaseNoteSection;
 
 /** Blank out fenced code blocks (``` / ~~~) line-for-line so example headings and fields inside them are never read as the real section. */
 function blankFencedCode(text: string): string {
@@ -69,10 +71,10 @@ export function renderReleaseNoteSection(fragment: Section): string {
   return `## 릴리스 노트\n- 한 줄: ${fragment.line}\n- 종류: ${fragment.kind}\n- 문서: ${'path' in fragment.docs ? fragment.docs.path : `없음(${fragment.docs.none})`}\n- 대상: ${fragment.target}\n`;
 }
 
-export function harnessReleaseNote(goalDocument: string, title: string): Section {
+export function parseGoalReleaseNoteSection(goalDocument: string): ReturnType<typeof parseReleaseNoteSection> & { hasSection: boolean } {
   const document = blankFencedCode(goalDocument);
   const goal = /^ {0,3}## 목표[ \t]*\r?$/m.exec(document);
-  let section = '';
+  let section = goal ? '' : document;
   if (goal) {
     const rest = document.slice(goal.index + goal[0].length);
     let end = rest.length;
@@ -84,7 +86,20 @@ export function harnessReleaseNote(goalDocument: string, title: string): Section
     }
     section = rest.slice(0, end);
   }
-  return parseReleaseNoteSection(section).fragment ?? {
+  return {
+    ...parseReleaseNoteSection(section),
+    hasSection: /(?:^|\n)## 릴리스 노트[ \t]*\r?(?:\n|$)/.test(section),
+  };
+}
+
+export function harnessReleaseNote(goalDocument: string, title: string, shard = false): Section {
+  const parsed = parseGoalReleaseNoteSection(goalDocument);
+  if (parsed.fragment) return parsed.fragment;
+  debug.log('release-note', 'harness-fallback', {
+    reason: parsed.hasSection ? 'invalid' : 'missing',
+    shard,
+  });
+  return {
     line: title,
     kind: 'internal',
     docs: { none: '하니스 자동 생성' },
@@ -92,6 +107,46 @@ export function harnessReleaseNote(goalDocument: string, title: string): Section
   };
 }
 
+/** Only the worktree's release notes enter the public cut. Keep repeats byte-for-byte idempotent. */
+export function addNextMdReleaseNote(worktreePath: string, note: Section): boolean {
+  if (note.target !== 'next' || note.kind === 'internal') return false;
+  const path = join(worktreePath, 'release', 'next.md');
+  // Public next notes require the worktree's cut source; ENOENT must stop PR creation.
+  const text = readFileSync(path, 'utf8');
+  const sentence = note.line.trim();
+  const prefixed = sentence.startsWith(`${note.kind} — `) ? sentence : `${note.kind} — ${sentence}`;
+  const item = `- ${prefixed.replace(/\.$/, '')}. Documentation: ${'path' in note.docs ? note.docs.path : 'none'}. Target: next.`;
+  const lines = text.split('\n');
+  const sameSentence = (line: string) => line.replace(/\r$/, '')
+    .replace(/\. Documentation:.*$/, '').replace(/\.$/, '') === `- ${prefixed.replace(/\.$/, '')}`;
+  const existing = lines.findIndex(sameSentence);
+  if (existing >= 0) {
+    if (lines[existing]!.replace(/\r$/, '') === item) return false;
+    // Same sentence, different documentation: the PR body is the source — make next.md say the same thing.
+    lines[existing] = item;
+    writeFileSync(path, lines.join('\n'));
+    debug.log('release-note', 'next-md-updated', { kind: note.kind, docs: 'path' in note.docs ? 'path' : 'none' });
+    return true;
+  }
+  const heading = `## ${note.kind === 'feat' ? 'Feat' : note.kind === 'fix' ? 'Fix' : 'Security'}`;
+  let index = lines.findIndex((line) => line.trimEnd() === heading);
+  if (index < 0) {
+    const fix = lines.findIndex((line) => line.trimEnd() === '## Fix');
+    if (fix < 0) throw new Error(`release/next.md has no ## Fix section: ${path}`);
+    index = fix + 1;
+    while (index < lines.length && !/^##\s/.test(lines[index]!)) index++;
+    lines.splice(index, 0, heading, '');
+    index++;
+  }
+  index++;
+  while (index < lines.length && !/^##\s/.test(lines[index]!)) index++;
+  while (index > 0 && lines[index - 1] === '') index--;
+  if (index === lines.findIndex((line) => line.trimEnd() === heading) + 1) lines.splice(index++, 0, '');
+  lines.splice(index, 0, item);
+  writeFileSync(path, lines.join('\n'));
+  return true;
+}
+
 export function releaseNotesDir(instanceRoot: string): string {
   return join(instanceRoot, 'release', 'notes');
 }

package/src/release-loop/release-schedule.ts

@@ -0,0 +1,53 @@
+import { CliUserError } from '../cli/cli-user-error.js';
+import { debug } from '../debug/log.js';
+import { readSchedule, readSchedules, writeSchedule, type ScheduleRow } from './feature-store.js';
+
+export type ReleaseSchedule = ScheduleRow;
+
+function utcIso(input: string): string {
+  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2})(?::(\d{2})(?:\.\d{1,3})?)?(Z|([+-])(\d{2}):(\d{2}))$/.exec(input);
+  if (!match) throw new CliUserError(`시각에는 ISO 오프셋 필요: ${input}`);
+  const hours = Number(match[6] ?? 0), minutes = Number(match[7] ?? 0);
+  const offset = (match[5] === '-' ? -1 : 1) * (hours * 60 + minutes);
+  const millis = Date.parse(input);
+  if (hours > 23 || minutes > 59 || !Number.isFinite(millis) ||
+      new Date(millis + offset * 60_000).toISOString().slice(0, 19) !== `${match[1]}T${match[2]}:${match[3] ?? '00'}`) {
+    throw new CliUserError(`잘못된 ISO 시각: ${input}`);
+  }
+  return new Date(millis).toISOString();
+}
+
+export function formatKst(utc: string): string {
+  const parts = new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: '2-digit', day: '2-digit', weekday: 'short', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }).formatToParts(new Date(utc));
+  const get = (type: Intl.DateTimeFormatPartTypes) => parts.find((part) => part.type === type)!.value;
+  return `${get('month')}-${get('day')}(${get('weekday')}) ${get('hour')}:${get('minute')} KST`;
+}
+
+export function getSchedule(version: string, root?: string): ReleaseSchedule | null {
+  const schedule = readSchedule(version, root);
+  debug.log('release.schedule', 'read', { version, cutAt: schedule?.cutAt ?? null, landBy: schedule?.landBy ?? null });
+  return schedule;
+}
+
+export function listSchedules(root?: string): ReleaseSchedule[] {
+  const schedules = readSchedules(root);
+  for (const { version, cutAt, landBy } of schedules) debug.log('release.schedule', 'read', { version, cutAt, landBy });
+  return schedules;
+}
+
+export function setSchedule(version: string, patch: { cutAt?: string; landBy?: string }, by: string, root?: string): ReleaseSchedule {
+  const schedule = writeSchedule(version, {
+    ...(patch.cutAt !== undefined ? { cutAt: utcIso(patch.cutAt) } : {}),
+    ...(patch.landBy !== undefined ? { landBy: utcIso(patch.landBy) } : {}),
+  }, by, root);
+  debug.log('release.schedule', 'set', { version, cutAt: schedule.cutAt, landBy: schedule.landBy });
+  return schedule;
+}
+
+export function formatSchedule(schedule: ReleaseSchedule): string {
+  const cut = formatKst(schedule.cutAt);
+  const deadline = schedule.landBy ? formatKst(schedule.landBy) : null;
+  const sameDay = schedule.landBy && new Date(Date.parse(schedule.landBy) + 9 * 60 * 60_000).toISOString().slice(0, 10)
+    === new Date(Date.parse(schedule.cutAt) + 9 * 60 * 60_000).toISOString().slice(0, 10);
+  return `${schedule.version} 컷 ${cut}${deadline ? ` · 착지 마감 ${sameDay ? deadline.split(' ')[1] : deadline}` : ''}`;
+}

package/src/repl/index.ts

@@ -21,6 +21,7 @@ import { createInterface, type Interface as ReadlineInterface } from 'node:readl
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve as resolvePath, isAbsolute, basename } from 'node:path';
 import * as ui from '../ui.js';
+import { suggestProjectForFolder } from '../project/project-store.js';
 import { runTurn } from '../session/chat.js';
 import {
   ensureCliSession,
@@ -450,6 +451,12 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
   const session = ensureCliSession(cfg, initialId);
   setActiveSessionId(session.id);
   setAmbientSessionId(session.id);
+  if (!opts.jsonOutput && (!initialId || session.id !== initialId)) {
+    try {
+      const project = suggestProjectForFolder(process.cwd());
+      if (project) ui.info(`Project suggestion: ${project.name} (${project.id})`);
+    } catch { /* suggestions must not interrupt the REPL */ }
+  }
   const sessionIdRef = { current: session.id };
 
   const tools = opts.enableTools ? buildReplTools() : undefined;