elanous 0.2.11 → 0.2.13

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

@@ -2,12 +2,32 @@
 // 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 { mkdirSync, readdirSync, readFileSync, renameSync, 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 HostLeaseRecord { pid: number; startedAt: string; at: string; stage?: 'authoring' | 'job'; claimed?: boolean; job?: string; context?: string; namespace?: string }
+
+export interface PendingJobIdentity { context: string; namespace: string; job: string }
+
+/** Only the same cluster, namespace and Job can account for an existing host lease. */
+export function leaseHasPendingPod(lease: HostLeaseRecord, pending: readonly PendingJobIdentity[]): boolean {
+  return lease.stage === 'job' && !!lease.context && !!lease.namespace && !!lease.job &&
+    pending.some((pod) => pod.context === lease.context && pod.namespace === lease.namespace && pod.job === lease.job);
+}
+
+export interface HostLeaseHandle {
+  (): void;
+  readonly id: string;
+  /** Job creation is not release: retain the lease until its Pod is observed Running or terminal. */
+  applied: (job: string, context: string, namespace: string) => void;
+}
+
+/** A Job without a Running/terminal Pod still occupies a host reservation. */
+export function hostLeaseCounts(records: readonly HostLeaseRecord[]): { reserved: number; waitingJobs: number } {
+  return { reserved: records.filter((r) => r.stage !== 'job').length, waitingJobs: records.filter((r) => r.stage === 'job').length };
+}
 
 export interface HostPoolLeaseOptions {
   /** Base directory — default `$TMPDIR/elanous-pod-leases-<uid>` (0700). */
@@ -53,8 +73,42 @@ export class HostPoolLease {
     this.staleLockMs = options.staleLockMs ?? 10_000;
   }
 
+  reservationIsOther(id: string): boolean {
+    if (!/^[A-Za-z0-9._-]+\.json$/.test(id)) return false;
+    try {
+      const record = JSON.parse(readFileSync(join(this.dir, id), 'utf8')) as HostLeaseRecord;
+      return record.stage === 'authoring' && Number.isSafeInteger(record.pid) && record.pid > 0 &&
+        typeof record.startedAt === 'string' && this.processStart(record.pid) === record.startedAt &&
+        (record.pid !== this.pid || record.startedAt !== this.selfStart());
+    } catch { return false; }
+  }
+
+  /** Transfer a reservation across the authoring → orchestrator process boundary. */
+  claim(id: string): HostLeaseHandle | null {
+    if (!/^[A-Za-z0-9._-]+\.json$/.test(id)) return null;
+    const file = join(this.dir, id);
+    const deadline = Date.now() + this.staleLockMs;
+    while (!this.lock()) {
+      if (Date.now() >= deadline) return null;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+    try {
+      if (this.ownStart === undefined) this.ownStart = this.processStart(this.pid);
+      if (!this.ownStart) return null;
+      const original = JSON.parse(readFileSync(file, 'utf8')) as HostLeaseRecord;
+      if (original.stage !== 'authoring' || original.claimed || !Number.isSafeInteger(original.pid) || original.pid <= 0 ||
+        typeof original.startedAt !== 'string' || this.processStart(original.pid) !== original.startedAt) return null;
+      const record: HostLeaseRecord = { ...original, pid: this.pid, startedAt: this.ownStart, claimed: true };
+      this.replaceRecord(file, record);
+      return this.handle(file, record, id);
+    } catch { return null; }
+    finally { this.unlock(); }
+  }
+
   /** Live leases after removing stale ones (dead pid or a recycled pid whose start time differs). */
-  live(): HostLeaseRecord[] {
+  live(): HostLeaseRecord[] { return this.readLive(false); }
+
+  private readLive(lockHeld: boolean): HostLeaseRecord[] {
     const out: HostLeaseRecord[] = [];
     let names: string[] = [];
     try { names = readdirSync(this.dir).filter((name) => name.endsWith('.json')); } catch { return out; }
@@ -62,50 +116,106 @@ export class HostPoolLease {
       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;
+      const alive = record && Number.isSafeInteger(record.pid) && record.pid > 0 && typeof record.startedAt === 'string'
+        && 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 });
+      // A concurrent claim can replace the record while we check the original PID.
+      if (!lockHeld && !this.lock()) { if (record) out.push(record); continue; }
+      try {
+        let current: HostLeaseRecord | null;
+        try { current = JSON.parse(readFileSync(file, 'utf8')) as HostLeaseRecord; } catch { current = null; }
+        if (current && Number.isSafeInteger(current.pid) && current.pid > 0 && typeof current.startedAt === 'string' &&
+          this.processStart(current.pid) === current.startedAt) { out.push(current); continue; }
+        try { unlinkSync(file); } catch { /* already cleaned */ }
+        debug.log('pod.lease', 'host-lease-stale-cleared', { file: name, pid: current?.pid ?? null });
+      } finally { if (!lockHeld) this.unlock(); }
     }
     return out;
   }
 
-  /** Unapplied leases held by other processes — launches admitted elsewhere whose Job the cluster can't see yet. */
-  othersPending(): number {
+  selfStart(): string | null {
     if (this.ownStart === undefined) this.ownStart = this.processStart(this.pid);
-    return this.live().filter((r) => !(r.pid === this.pid && r.startedAt === this.ownStart)).length;
+    return this.ownStart;
+  }
+
+  /** Reservations held by other processes while the cluster cannot yet observe them. */
+  othersPending(): number {
+    return this.live().filter((r) => !(r.pid === this.pid && r.startedAt === this.selfStart())).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).
+   * Under the host lock, take a lease only if `allowed(pending)` holds — the check and the write are one step.
+   * By default pending excludes this process's permits (the local admission gate owns them); includeOwn
+   * counts every reservation for independent authoring launches from the same process.
+   * Null = refused or lock busy (retry later).
    */
-  tryReserve(allowed: (othersPending: number) => boolean): (() => void) | null {
+  tryReserve(allowed: (othersPending: number) => boolean, includeOwn = false): HostLeaseHandle | 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;
+      const others = this.readLive(true).filter((r) => includeOwn || !(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() };
+      const record: HostLeaseRecord = { pid: this.pid, startedAt: this.ownStart, at: new Date(this.now()).toISOString(), stage: 'authoring' };
       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 */ }
-      };
+      return this.handle(file, record, file.slice(this.dir.length + 1));
     } finally {
       this.unlock();
     }
   }
 
+  private replaceRecord(file: string, record: HostLeaseRecord): void {
+    const temp = `${file}.${this.pid}-${Math.random().toString(36).slice(2)}.tmp`;
+    try {
+      writeFileSync(temp, JSON.stringify(record), { flag: 'wx', mode: 0o600 });
+      renameSync(temp, file);
+    } catch (error) {
+      try { unlinkSync(temp); } catch { /* already gone */ }
+      throw error;
+    }
+  }
+
+  private handle(file: string, record: HostLeaseRecord, id: string): HostLeaseHandle {
+    let released = false;
+    const release = (() => {
+      if (released) return;
+      // Claim replaces the same file under this lock. An old owner must not unlink a
+      // newly transferred reservation between reading and removing its record.
+      const deadline = Date.now() + this.staleLockMs;
+      while (!this.lock()) {
+        if (Date.now() >= deadline) return;
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+      }
+      try {
+        const current = JSON.parse(readFileSync(file, 'utf8')) as HostLeaseRecord;
+        if (current.pid === record.pid && current.startedAt === record.startedAt && current.claimed === record.claimed) unlinkSync(file);
+      } catch { /* transferred or already cleaned */ }
+      finally { released = true; this.unlock(); }
+    }) as HostLeaseHandle;
+    Object.defineProperty(release, 'id', { value: id });
+    release.applied = (job, context, namespace) => {
+      if (released) return;
+      const deadline = Date.now() + this.staleLockMs;
+      while (!this.lock()) {
+        if (Date.now() >= deadline) throw new Error('pod lease: cannot update Job reservation');
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+      }
+      try {
+        const current = JSON.parse(readFileSync(file, 'utf8')) as HostLeaseRecord;
+        if (current.pid !== record.pid || current.startedAt !== record.startedAt || current.claimed !== record.claimed) throw new Error('pod lease: reservation owner changed');
+        if (!job || !context || !namespace) throw new Error('pod lease: Job identity requires context, namespace and name');
+        this.replaceRecord(file, { ...record, stage: 'job', job, context, namespace });
+      } finally { this.unlock(); }
+    };
+    return release;
+  }
+
   private lockDir(): string { return join(this.dir, '.lock'); }
 
   private lock(): boolean {

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;
@@ -72,13 +73,18 @@ 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. */
 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 {
+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);
@@ -288,7 +290,9 @@ export function list(version: string, released?: string, dev = devVersion(), roo
 }
 
 /** 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 {
@@ -298,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;
@@ -356,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();
@@ -366,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,60 @@
+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;
+}
+
+export function evidencePlan(rows: readonly LandedButYellowRow[]): Array<{ id: string; ref: string }> {
+  const seen = new Set<string>();
+  return rows.flatMap((row) => row.prs.flatMap((pr, index) => {
+    if (pr.basis === 'mention' || row.alreadyInEvidence[index]) return [];
+    const ref = `#${pr.number}`;
+    const key = JSON.stringify([row.id, ref]);
+    if (seen.has(key)) return [];
+    seen.add(key);
+    return [{ id: row.id, ref }];
+  }));
+}
+
+/** 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/seat-dispatch/seat-ask.ts

@@ -1,31 +1,58 @@
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
+import { join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { openMsgStore, type MsgStore } from '../msg/msg-store.js';
 import { dispatchCeoTask, type CeoCommandDeps } from './ceo-commands.js';
+import type { SeatId } from './seat-questions.js';
 
 export type AskOrigin =
   | { channel: 'telegram'; chatId: number | string; messageId: number; threadId?: number; botId?: string }
   | { channel: 'discord'; channelId: string; messageId: string; threadId?: string }
   | { channel: 'pwa'; clientId: string };
 
-export const DEFAULT_ASK_TIMEOUT_MS = 30 * 60 * 1000;
+export const DEFAULT_ASK_TIMEOUT_MS = 2 * 60 * 60 * 1000;
 export const parseSeatAsk = (text: string): string | null => /^\s*CTO\s*에게\s*물어봐\s*[:：]\s*(\S[\s\S]*)$/i.exec(text)?.[1]?.trim() ?? null;
 
-interface AskRow { id: string; seat: string; origin: string; deadline: number; timeout_minutes: number }
+interface AskRow { id: string; seat: string; origin: string; deadline: number; timeout_minutes: number; answer: string | null; answered_at: number | null }
 
 function createTable(store: MsgStore): void {
   store.db.exec(`CREATE TABLE IF NOT EXISTS seat_asks (
     id TEXT PRIMARY KEY, seat TEXT NOT NULL, origin TEXT NOT NULL,
-    deadline INTEGER NOT NULL, timeout_minutes INTEGER NOT NULL DEFAULT 30, status TEXT NOT NULL DEFAULT 'pending'
+    deadline INTEGER NOT NULL, timeout_minutes INTEGER NOT NULL DEFAULT 120, status TEXT NOT NULL DEFAULT 'pending',
+    answer TEXT, answered_at INTEGER
   ); CREATE TABLE IF NOT EXISTS seat_ask_outbox (
     id TEXT PRIMARY KEY, origin TEXT NOT NULL, text TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'pending',
     claim_until INTEGER NOT NULL DEFAULT 0, claim_token TEXT
   )`);
+  const askColumns = store.db.query('PRAGMA table_info(seat_asks)').all() as Array<{ name: string }>;
+  if (!askColumns.some(({ name }) => name === 'answer')) store.db.exec('ALTER TABLE seat_asks ADD COLUMN answer TEXT');
+  if (!askColumns.some(({ name }) => name === 'answered_at')) store.db.exec('ALTER TABLE seat_asks ADD COLUMN answered_at INTEGER');
   const columns = store.db.query('PRAGMA table_info(seat_ask_outbox)').all() as Array<{ name: string }>;
   if (!columns.some(({ name }) => name === 'claim_until')) store.db.exec('ALTER TABLE seat_ask_outbox ADD COLUMN claim_until INTEGER NOT NULL DEFAULT 0');
   if (!columns.some(({ name }) => name === 'claim_token')) store.db.exec('ALTER TABLE seat_ask_outbox ADD COLUMN claim_token TEXT');
 }
 
+export interface SeatAskShadow {
+  from: SeatId;
+  to: SeatId;
+  itemId: string;
+  version: string;
+  question: string;
+}
+
+/** Keep an internal seat-to-seat question in the existing ask ledger, without dispatching or queuing an outbox message. */
+export function recordSeatAskShadow(root: string, ask: SeatAskShadow, now: number): boolean {
+  if (ask.from === ask.to || !ask.itemId || !ask.question.trim() || !Number.isFinite(now)) throw new Error('invalid shadow seat ask');
+  const id = `seat-loop:${createHash('sha256').update(JSON.stringify([ask.from, ask.to, ask.version, ask.itemId])).digest('hex')}`;
+  const store = openMsgStore(join(root, 'msg', 'messages.db'));
+  try {
+    createTable(store);
+    const origin = JSON.stringify({ channel: 'seat-loop', from: ask.from, itemId: ask.itemId, version: ask.version, question: ask.question.trim() });
+    return store.db.query("INSERT OR IGNORE INTO seat_asks (id, seat, origin, deadline, timeout_minutes, status) VALUES (?, ?, ?, ?, ?, 'shadow')")
+      .run(id, ask.to, origin, now + DEFAULT_ASK_TIMEOUT_MS, Math.ceil(DEFAULT_ASK_TIMEOUT_MS / 60000)).changes === 1;
+  } finally { store.close(); }
+}
+
 export interface SeatAskDeps {
   open?: () => MsgStore;
   now?: () => number;
@@ -52,7 +79,7 @@ export async function askSeat(text: string, origin: AskOrigin, command: CeoComma
       .run(id, 'TC', JSON.stringify(origin), (deps.now ?? Date.now)() + timeout, minutes, 'pending');
   } finally { store.close(); }
   try {
-    const result = await (deps.dispatch ?? dispatchCeoTask)('TC', `질문: ${body}\n답장 요청: ${id}\n회신: elanous msg post --from TC --to CEO --kind seat-ask-reply --body '${id}: <답>'`, command,
+    const result = await (deps.dispatch ?? dispatchCeoTask)('TC', `질문: ${body}\n답장 요청: ${id}\n회신: elanous seat answer ${id} "<답>"`, command,
       { via: origin.channel, ref: `ask:${id}` });
     debug.log('seat.ask', 'sent', { seat: 'TC', id, via: origin.channel, channel: result.channel });
     return `CTO에게 물었습니다. 답을 기다립니다 (최대 ${minutes}분). 요청: ${id}${result.channel === 'failed' ? ` · 조율 채널 전송 실패: ${result.channelError}` : ''}`;
@@ -64,22 +91,40 @@ export async function askSeat(text: string, origin: AskOrigin, command: CeoComma
   }
 }
 
-/** Read the seat mailbox without advancing its cursor (other CEO messages remain untouched). */
+/** Record a seat reply in its original request row; delivery stays with the originating surface's worker. */
+export function answerSeatAsk(id: string, text: string, deps: Pick<SeatAskDeps, 'open' | 'now'> = {}): void {
+  const answer = text.trim();
+  if (!answer) throw new Error('seat answer must not be empty');
+  const store = (deps.open ?? openMsgStore)();
+  try {
+    createTable(store);
+    const now = (deps.now ?? Date.now)();
+    const updated = store.db.query(`UPDATE seat_asks SET answer = ?, answered_at = ?
+      WHERE id = ? AND seat = 'TC' AND status = 'pending' AND answer IS NULL AND deadline > ?`)
+      .run(answer, now, id, now);
+    if (updated.changes !== 1) throw new Error(`seat ask not pending or deadline passed: ${id}`);
+    debug.log('seat.ask', 'reply-recorded', { seat: 'TC', id });
+  } finally { store.close(); }
+}
+
+/** Deliver recorded seat answers or expiration notices via the original surface. */
 export async function deliverSeatAnswers(deps: SeatAskDeps): Promise<void> {
   const store = (deps.open ?? openMsgStore)();
   try {
     createTable(store);
-    const pending = store.db.query("SELECT id, seat, origin, deadline, timeout_minutes FROM seat_asks WHERE status = 'pending'").all() as AskRow[];
+    const pending = store.db.query("SELECT id, seat, origin, deadline, timeout_minutes, answer, answered_at FROM seat_asks WHERE status = 'pending'").all() as AskRow[];
     const decide = store.db.transaction((id: string, now: number): 'answered' | 'expired' | null => {
-      const ask = store.db.query("SELECT id, seat, origin, deadline, timeout_minutes FROM seat_asks WHERE id = ? AND status = 'pending'").get(id) as AskRow | null;
+      const ask = store.db.query("SELECT id, seat, origin, deadline, timeout_minutes, answer, answered_at FROM seat_asks WHERE id = ? AND status = 'pending'").get(id) as AskRow | null;
       if (!ask) return null;
-      const reply = store.db.query("SELECT id, body, created_at FROM msg_messages WHERE recipient = 'CEO' AND kind = 'seat-ask-reply' AND substr(body, 1, ?) = ? AND sender = ? ORDER BY id LIMIT 1")
-        .get(id.length + 2, `${id}: `, ask.seat) as { id: number; body: string; created_at: string } | null;
-      const answer = reply && Date.parse(reply.created_at) < ask.deadline ? reply.body.slice(id.length + 2).trim() : '';
+      // Retain compatibility with replies already posted to the existing seat mailbox.
+      const reply = ask.answer === null ? store.db.query("SELECT id, body, created_at FROM msg_messages WHERE recipient = 'CEO' AND kind = 'seat-ask-reply' AND substr(body, 1, ?) = ? AND sender = ? ORDER BY id LIMIT 1")
+        .get(id.length + 2, `${id}: `, ask.seat) as { id: number; body: string; created_at: string } | null : null;
+      const answer = ask.answer !== null && ask.answered_at !== null && ask.answered_at < ask.deadline ? ask.answer
+        : reply && Date.parse(reply.created_at) < ask.deadline ? reply.body.slice(id.length + 2).trim() : '';
       const status = answer ? 'answered' : now >= ask.deadline ? 'expired' : null;
       if (!status) return null;
       const text = status === 'answered' ? `CTO 답변 (${id}): ${answer}`
-        : `CTO 미답 (${id}): ${ask.timeout_minutes}분 안에 답이 오지 않았습니다.`;
+        : `CTO 미답 (${id}): 아직 답 없음 (${ask.timeout_minutes}분 경과).`;
       const updated = store.db.query("UPDATE seat_asks SET status = ? WHERE id = ? AND status = 'pending'").run(status, id);
       if (updated.changes !== 1) return null;
       store.db.query('INSERT INTO seat_ask_outbox (id, origin, text) VALUES (?, ?, ?)').run(id, ask.origin, text);