elanous 0.2.10 → 0.2.12

package/src/pod-lease/dependency-state.ts

@@ -0,0 +1,85 @@
+import { execFile } from 'node:child_process';
+import { listRunLedgers } from '../self-implement/run-ledger.js';
+import { runGitCommand } from '../git-fs/runner.js';
+import type { PodLeasePredecessor } from './admission.js';
+
+/** merged = admit · waiting = keep queued (open, unknown, unreadable) · blocked = predecessor closed without merging. */
+export type PredecessorState = 'merged' | 'waiting' | 'blocked';
+
+type PrState = string | null;
+
+type DependencyStateDeps = {
+  prState?: (number: number, signal?: AbortSignal) => PrState | Promise<PrState>;
+  ledgers?: () => ReturnType<typeof listRunLedgers>['matches'];
+};
+
+function githubRepository(): string | null {
+  const remote = runGitCommand(process.cwd(), ['config', '--get', 'remote.origin.url'], { encoding: 'utf8', timeout: 5_000 });
+  const repository = /^(?:https:\/\/github\.com\/|git@github\.com:|ssh:\/\/git@github\.com\/)([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\.git)?\/?$/.exec(remote.stdout.trim())?.[1];
+  return remote.status !== 0 || !repository || repository.includes('..') ? null : repository;
+}
+
+/** Async so a slow GitHub lookup never blocks the event loop (admission, cancellation, other launches). */
+function githubPrState(number: number, signal?: AbortSignal): Promise<PrState> {
+  const repository = githubRepository();
+  if (!repository) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    execFile('gh', ['pr', 'view', String(number), '--repo', repository, '--json', 'state'], {
+      encoding: 'utf8', timeout: 15_000, env: process.env, ...(signal ? { signal } : {}),
+    }, (error, stdout) => {
+      if (error) return resolve(null);
+      try {
+        const response: unknown = JSON.parse(stdout);
+        resolve(response && typeof response === 'object' && 'state' in response && typeof response.state === 'string' ? response.state : null);
+      } catch { resolve(null); }
+    });
+  });
+}
+
+const prNumberOf = (after: PodLeasePredecessor): number | null => {
+  const number = typeof after === 'number' ? after : Number(after.replace(/^#/, ''));
+  return Number.isSafeInteger(number) && number > 0 ? number : null;
+};
+
+async function readState(number: number, deps: DependencyStateDeps, signal?: AbortSignal): Promise<PrState> {
+  try { return await (deps.prState ?? githubPrState)(number, signal); } catch { return null; }
+}
+
+/** Only a verified merged predecessor grants a Pod lease; a predecessor closed without merging blocks; everything else waits. */
+export async function predecessorState(after: PodLeasePredecessor, deps: DependencyStateDeps = {}, signal?: AbortSignal): Promise<PredecessorState> {
+  const isPr = typeof after === 'number' || (typeof after === 'string' && !/^[a-f0-9]{16}$/.test(after) && /^#?[1-9]\d*$/.test(after));
+  if (isPr) {
+    const number = prNumberOf(after);
+    if (number === null) return 'waiting';
+    const state = await readState(number, deps, signal);
+    return state === 'MERGED' ? 'merged' : state === 'CLOSED' ? 'blocked' : 'waiting';
+  }
+  if (typeof after !== 'string' || !after.trim()) return 'waiting';
+  let numbers: Set<number>;
+  try {
+    const matches = (deps.ledgers ?? (() => listRunLedgers().matches))()
+      .filter(({ entries }) => entries.some((entry) => entry.goalId === after));
+    numbers = new Set<number>();
+    for (const { entries } of matches) {
+      for (const entry of entries) {
+        if (entry.event !== 'pr-opened' || entry.goalId !== after) continue;
+        const number = entry.data.number;
+        if (typeof number === 'number' && Number.isSafeInteger(number) && number > 0) numbers.add(number);
+      }
+    }
+  } catch { return 'waiting'; }
+  if (numbers.size === 0) return 'waiting';
+  // A later attempt or manual merge can land an opened PR without an in-run merged event.
+  let allClosed = true;
+  for (const number of numbers) {
+    const state = await readState(number, deps, signal);
+    if (state === 'MERGED') return 'merged';
+    if (state !== 'CLOSED') allClosed = false;
+  }
+  return allClosed ? 'blocked' : 'waiting';
+}
+
+/** Back-compat boolean view: true only when merged. */
+export async function predecessorMerged(after: PodLeasePredecessor, deps: DependencyStateDeps = {}, signal?: AbortSignal): Promise<boolean> {
+  return (await predecessorState(after, deps, signal)) === 'merged';
+}

package/src/pod-lease/host-lease.ts

@@ -0,0 +1,127 @@
+// L7b — cross-process Pod admission on one host. Each admitted launch holds a lease file (pid ⊕ process start time)
+// in a per-user directory; a launch is admitted only while live leases stay under the pool's measured total.
+// Without this, independent CLI processes each measured an empty pool and all launched (review round 2 of #23212).
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir, userInfo } from 'node:os';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+
+export interface HostLeaseRecord { pid: number; startedAt: string; at: string }
+
+export interface HostPoolLeaseOptions {
+  /** Base directory — default `$TMPDIR/elanous-pod-leases-<uid>` (0700). */
+  dir?: string;
+  pid?: number;
+  /** `ps -o lstart=` text for a pid, or null when the process is gone. */
+  processStart?: (pid: number) => string | null;
+  now?: () => number;
+  /** A lock older than this is a crash leftover and is cleared. */
+  staleLockMs?: number;
+}
+
+export function hostLeaseBaseDir(env: NodeJS.ProcessEnv = process.env): string {
+  if (env.ELANOUS_POD_LEASE_DIR?.trim()) return env.ELANOUS_POD_LEASE_DIR.trim();
+  // Test runs get a per-process directory so parallel test files never share real host leases.
+  if (env.NODE_ENV === 'test') return join(tmpdir(), `elanous-pod-leases-test-${process.pid}`);
+  let uid: string;
+  try { uid = String(userInfo().uid); } catch { uid = 'unknown'; }
+  return join(tmpdir(), `elanous-pod-leases-${uid}`);
+}
+
+/** Process start time as `ps` prints it (C locale so the text is stable). Null = no such process. */
+export function psProcessStart(pid: number): string | null {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return null;
+  const result = spawnSync('ps', ['-o', 'lstart=', '-p', String(pid)], { encoding: 'utf8', env: { ...process.env, LC_ALL: 'C', LANG: 'C' } });
+  const text = result.status === 0 ? result.stdout.trim() : '';
+  return text || null;
+}
+
+export class HostPoolLease {
+  readonly dir: string;
+  private readonly pid: number;
+  private readonly processStart: (pid: number) => string | null;
+  private readonly now: () => number;
+  private readonly staleLockMs: number;
+  private ownStart: string | null | undefined;
+
+  constructor(poolKey: string, options: HostPoolLeaseOptions = {}) {
+    this.dir = join(options.dir ?? hostLeaseBaseDir(), poolKey.replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 120) || 'pool');
+    this.pid = options.pid ?? process.pid;
+    this.processStart = options.processStart ?? psProcessStart;
+    this.now = options.now ?? Date.now;
+    this.staleLockMs = options.staleLockMs ?? 10_000;
+  }
+
+  /** Live leases after removing stale ones (dead pid or a recycled pid whose start time differs). */
+  live(): HostLeaseRecord[] {
+    const out: HostLeaseRecord[] = [];
+    let names: string[] = [];
+    try { names = readdirSync(this.dir).filter((name) => name.endsWith('.json')); } catch { return out; }
+    for (const name of names) {
+      const file = join(this.dir, name);
+      let record: HostLeaseRecord | null = null;
+      try { record = JSON.parse(readFileSync(file, 'utf8')) as HostLeaseRecord; } catch { record = null; }
+      const alive = record && this.processStart(record.pid) === record.startedAt;
+      if (record && alive) { out.push(record); continue; }
+      try { unlinkSync(file); } catch { /* another process cleaned it */ }
+      debug.log('pod.lease', 'host-lease-stale-cleared', { file: name, pid: record?.pid ?? null });
+    }
+    return out;
+  }
+
+  /** Unapplied leases held by other processes — launches admitted elsewhere whose Job the cluster can't see yet. */
+  othersPending(): number {
+    if (this.ownStart === undefined) this.ownStart = this.processStart(this.pid);
+    return this.live().filter((r) => !(r.pid === this.pid && r.startedAt === this.ownStart)).length;
+  }
+
+  /**
+   * Under the host lock, take a lease only if `allowed(othersPending)` holds — the check and the write are one step,
+   * so independent processes measuring the same empty pool cannot all pass. Null = refused or lock busy (retry later).
+   */
+  tryReserve(allowed: (othersPending: number) => boolean): (() => void) | null {
+    try { mkdirSync(this.dir, { recursive: true, mode: 0o700 }); } catch { return null; }
+    if (!this.lock()) return null;
+    try {
+      if (this.ownStart === undefined) this.ownStart = this.processStart(this.pid);
+      if (!this.ownStart) return null;
+      const others = this.live().filter((r) => !(r.pid === this.pid && r.startedAt === this.ownStart)).length;
+      if (!allowed(others)) {
+        debug.log('pod.lease', 'host-lease-refused', { othersPending: others });
+        return null;
+      }
+      const file = join(this.dir, `${this.pid}-${this.now()}-${Math.random().toString(36).slice(2, 8)}.json`);
+      const record: HostLeaseRecord = { pid: this.pid, startedAt: this.ownStart, at: new Date(this.now()).toISOString() };
+      writeFileSync(file, JSON.stringify(record), { flag: 'wx', mode: 0o600 });
+      debug.log('pod.lease', 'host-lease-acquired', { othersPending: others });
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        try { unlinkSync(file); } catch { /* already cleaned */ }
+      };
+    } finally {
+      this.unlock();
+    }
+  }
+
+  private lockDir(): string { return join(this.dir, '.lock'); }
+
+  private lock(): boolean {
+    const dir = this.lockDir();
+    try { mkdirSync(dir); return true; } catch { /* held */ }
+    try {
+      if (this.now() - statSync(dir).mtimeMs > this.staleLockMs) {
+        rmSync(dir, { recursive: true, force: true });
+        mkdirSync(dir);
+        return true;
+      }
+    } catch { /* raced */ }
+    return false;
+  }
+
+  private unlock(): void {
+    try { rmSync(this.lockDir(), { recursive: true, force: true }); } catch { /* gone */ }
+  }
+}

package/src/project/project-suggestion.ts

@@ -0,0 +1,16 @@
+// 작업 폴더 → 프로젝트 제안을 «폴더가 바뀔 때마다» 다시 계산한다(IA1 리뷰 must-fix · 시작 시 process.cwd() 한 번만 보던 것).
+// 같은 프로젝트를 연달아 다시 알리지 않는다 — 바뀐 경우에만 돌려준다.
+import type { Project } from './project-store.js';
+
+export function createProjectSuggester(suggest: (folder: string) => Project | null): (folder: string) => Project | null {
+  let lastId: string | null = null;
+  return (folder) => {
+    let project: Project | null;
+    try { project = suggest(folder); }
+    catch { return null; } // 제안은 대화를 끊지 않는다
+    const id = project?.id ?? null;
+    if (id === lastId) return null;
+    lastId = id;
+    return project;
+  };
+}

package/src/project/session-context.ts

@@ -0,0 +1,24 @@
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { getProject } from './project-store.js';
+import { loadSession } from '../session/index.js';
+
+/** Resolve the assigned project's folder for a persisted conversation, never from client-supplied paths. */
+export function resolveSessionProjectContext(sessionId: string | undefined): { cwd: string; instructions?: string } | null {
+  if (!sessionId) return null;
+  const projectId = loadSession(sessionId)?.meta.projectId;
+  if (!projectId) return null;
+  const folder = getProject(projectId)?.primaryFolder;
+  if (!folder) return null;
+  try {
+    if (!statSync(folder).isDirectory()) return null;
+  } catch { return null; }
+  const file = join(folder, 'AGENTS.md');
+  try {
+    const instructions = readFileSync(file, 'utf8');
+    return { cwd: folder, ...(instructions.trim() ? { instructions: `Project instructions (${file}):\n${instructions}` } : {}) };
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    return { cwd: folder };
+  }
+}

package/src/release-loop/checklist.ts

@@ -29,6 +29,7 @@ export interface ChecklistHistory {
   released: string;
   dev: string;
   force?: true;
+  reason?: string;
 }
 export interface Checklist {
   version: string;
@@ -68,8 +69,13 @@ function decodeClaimHistory(data: Checklist): Checklist {
   return { ...data, history: data.history.map(decodeClaimHistoryEntry) };
 }
 
-export function listChecklist(v: string): Checklist {
-  return decodeClaimHistory(store.list(v));
+export function listChecklist(v: string, root?: string): Checklist {
+  return decodeClaimHistory(root === undefined ? store.list(v) : store.list(v, undefined, undefined, root));
+}
+
+/** Events for this id across every release, ordered by event time (then ledger sequence). */
+export function checklistHistory(id: string): Array<ChecklistHistory & { version: string; seq: number }> {
+  return store.history(id).map(decodeClaimHistoryEntry);
 }
 
 /** Status events in the requested window; other ledger fields never become status changes. */
@@ -78,7 +84,7 @@ export function statusChangesSince(history: readonly ChecklistHistory[], sinceIs
   return history.filter((entry) => entry.field === 'status' && Date.parse(entry.at) >= since);
 }
 
-function mutate(v: string, apply: (data: Checklist) => boolean): Checklist {
+function mutate(v: string, apply: (data: Checklist, otherItems: (id: string) => store.ChecklistCollision[]) => boolean): Checklist {
   return decodeClaimHistory(store.mutate(v, store.releasedVersion(), devVersion(), apply));
 }
 
@@ -87,13 +93,19 @@ 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 }): Checklist {
+export function addItem(v: string, input: { id: string; title: string; owner?: string; kind?: ChecklistKind }, 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);
-  return mutate(v, (data) => {
+  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);
+    if (collisions.length) {
+      const displayedId = JSON.stringify(input.id).slice(1, -1);
+      console.error(`⚠ 중복 id: ${displayedId} — ${collisions.map((item) => `${item.version} · 담당 ${JSON.stringify(item.owner ?? '-').slice(1, -1)} · ${item.title.replace(/\s+/g, ' ').slice(0, 40)}`).join(' / ')}`);
+      if (!options.allowDuplicateId) throw new CliUserError(`다른 판에 이미 있는 칸: ${displayedId}`, '--allow-duplicate-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 } : {}), ...(input.kind !== undefined ? { kind: input.kind } : {}), updatedAt: at, updatedBy: by };

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

@@ -50,12 +50,13 @@ 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);
+    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)');
     return db;
   } catch (error) { db.close(); throw error; }
@@ -119,14 +120,15 @@ function readTransaction<T>(db: Database, work: () => T): T {
   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 };
+type EventRow = { seq: number; at: string; by: string; feature_id: string; version: string; field: string; from: string; to: string; released: string; dev: string; reason: string | null };
 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 };
+  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,
+    ...(row.reason !== null ? { reason: row.reason } : {}) };
 }
 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);
+  db.query('INSERT INTO events (at, by, feature_id, version, field, "from", "to", released, dev, reason) 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, entry.reason ?? null);
 }
 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);
@@ -278,15 +280,19 @@ 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(); }
 }
 
 /** 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 {
+export interface ChecklistCollision { version: string; owner?: string; title: string }
+
+export function mutate(version: string, released: string, dev: string, apply: (data: Checklist, otherItems: (id: string) => ChecklistCollision[]) => boolean): Checklist {
   validateVersion(version);
   const db = open();
   try {
@@ -296,7 +302,16 @@ export function mutate(version: string, released: string, dev: string, apply: (d
       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)) {
+      if (apply(data, (id) => {
+        for (const other of legacyVersions()) if (other !== version) importOnDb(db, other);
+        return db.query(`SELECT a.version, a.owner, COALESCE(a.title_override, f.title) AS title
+          FROM assignments a JOIN features f ON f.id = a.feature_id
+          WHERE a.feature_id = ? AND a.version <> ? ORDER BY a.version`).all(id, version)
+          .map((row) => {
+            const item = row as { version: string; owner: string | null; title: string };
+            return { version: item.version, ...(item.owner !== null ? { owner: item.owner } : {}), title: item.title };
+          });
+      })) {
         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;
@@ -354,7 +369,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()): Checklist {
+export function move(id: string, from: string, to: string, by: string, released = releasedVersion(), dev = devVersion(), reason?: string): Checklist {
   validateVersion(from); validateVersion(to);
   if (from === to) throw new CliUserError('같은 판으로 옮길 수 없다');
   const db = open();
@@ -364,11 +379,12 @@ export function move(id: string, from: string, to: string, by: string, released
       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 collision = items(db, to).find((i) => i.id === id);
+      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);
       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 });
+      record(db, to, { at, by, id, field: 'move', from, to, released, dev, ...(reason !== undefined ? { reason } : {}) });
       return snapshot(db, to, released, dev);
     });
     if (importedFrom) debug.log('release.features', 'imported', { version: from });

package/src/release-loop/landed-but-yellow.ts

@@ -0,0 +1,48 @@
+import { ownerMatches, type ChecklistItem } from './checklist.js';
+
+export interface MergedChecklistPr { number: number; title: string; body: string | null; mergedAt: string }
+type PrMatchBasis = 'cell-line' | 'title-strong' | 'mention';
+export interface LandedButYellowRow {
+  id: string;
+  owner: string | undefined;
+  status: 'yellow' | 'red';
+  prs: Array<Pick<MergedChecklistPr, 'number' | 'title' | 'mergedAt'> & { basis: PrMatchBasis }>;
+  alreadyInEvidence: boolean[];
+  newer: boolean;
+}
+
+/** Prefer a dedicated body cell line over title evidence; incidental mentions only qualify for long ids. */
+export function landedButYellow(items: readonly ChecklistItem[], prs: readonly MergedChecklistPr[], { owner }: { owner?: string } = {}): LandedButYellowRow[] {
+  const rows: LandedButYellowRow[] = [];
+  for (const item of items) {
+    if (item.status !== 'yellow' && item.status !== 'red') continue;
+    if (owner !== undefined && !ownerMatches(item.owner, owner)) continue;
+    const id = item.id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const word = new RegExp(`(?<![A-Za-z0-9])${id}(?![A-Za-z0-9])`);
+    const shortId = /^[A-Z]{1,2}\d{1,2}[a-z]?$/.test(item.id);
+    const titleStart = shortId
+      ? new RegExp(`^${id}(?:$|\\s+(?:수확|(?:첫|둘째|셋째)\\s*조각|fixed|new|old)(?=\\s|:|$))`)
+      : new RegExp(`^${id}(?:\\s|$)`);
+    const explicitTitle = new RegExp(`(?<![A-Za-z0-9])${id}\\s+(?:수확|(?:첫|둘째|셋째)\\s*조각)(?![A-Za-z0-9가-힣])|\\(${id}\\)`);
+    const rank: Record<PrMatchBasis, number> = { 'cell-line': 0, 'title-strong': 1, mention: 2 };
+    const matched = prs.flatMap((pr) => {
+      const cellLine = (pr.body ?? '').split('\n').some((line) => {
+        const match = /^[ \t]*칸(?:[ \t]*:[ \t]*|[ \t]+)([A-Za-z0-9_-]+(?:[ \t]*,[ \t]*[A-Za-z0-9_-]+)*)[ \t]*$/.exec(line.endsWith('\r') ? line.slice(0, -1) : line);
+        return match?.[1]?.split(',').some((candidate) => candidate.trim() === item.id) ?? false;
+      });
+      const basis: PrMatchBasis | undefined = cellLine ? 'cell-line'
+        : titleStart.test(pr.title) || explicitTitle.test(pr.title) ? 'title-strong'
+          : !shortId && (word.test(pr.title) || word.test(pr.body ?? '')) ? 'mention' : undefined;
+      return basis ? [{ number: pr.number, title: pr.title, mergedAt: pr.mergedAt, basis }] : [];
+    }).sort((a, b) => rank[a.basis] - rank[b.basis] || b.mergedAt.localeCompare(a.mergedAt) || b.number - a.number);
+    if (!matched.length) continue;
+    const shown = matched.slice(0, 5);
+    rows.push({
+      id: item.id, owner: item.owner, status: item.status,
+      prs: shown,
+      alreadyInEvidence: shown.map(({ number }) => new RegExp(`(?<![A-Za-z0-9_#])#${number}(?![A-Za-z0-9_])`).test(item.evidence ?? '')),
+      newer: matched.some((pr) => pr.mergedAt > item.updatedAt),
+    });
+  }
+  return rows.sort((a, b) => Number(b.newer) - Number(a.newer));
+}

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');
 }