elanous 0.2.12 → 0.2.13

package/src/persona/team.ts

@@ -0,0 +1,105 @@
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { parseDocument } from 'yaml';
+import { parsePersonaYaml } from './loader.js';
+
+export interface TeamMember {
+  persona: string;
+  title: string;
+  checklistTemplate: string[];
+}
+
+export interface TeamHandoff {
+  from: string;
+  to: string;
+}
+
+export interface TeamDefinition {
+  name: string;
+  members: TeamMember[];
+  handoffs: TeamHandoff[];
+}
+
+function mapping(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function fields(value: Record<string, unknown>, required: readonly string[], label: string): void {
+  for (const key of required) {
+    if (!Object.hasOwn(value, key)) throw new Error(`${label}.${key} is required`);
+  }
+  for (const key of Object.keys(value)) {
+    if (!required.includes(key)) throw new Error(`${label}.${key} is not a team schema field`);
+  }
+}
+
+function text(value: unknown, label: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`${label} must be a non-empty string`);
+  return value;
+}
+
+/** Read-only validation: resolve persona paths relative to the team file, not the caller's cwd. */
+export function validateTeamFile(file: string): TeamDefinition {
+  const document = parseDocument(readFileSync(file, 'utf8'), { uniqueKeys: true });
+  if (document.errors.length) throw new Error(`invalid team YAML: ${document.errors[0]!.message}`);
+  const raw: unknown = document.toJS();
+  if (!mapping(raw)) throw new Error('team must be a YAML mapping');
+  fields(raw, ['name', 'members', 'handoffs'], 'team');
+  const name = text(raw.name, 'team.name');
+  if (!Array.isArray(raw.members) || raw.members.length === 0) {
+    throw new Error('team.members must be a non-empty list');
+  }
+  const titles = new Set<string>();
+  const personaIds = new Set<string>();
+  const members: TeamMember[] = raw.members.map((item: unknown, index: number) => {
+    const label = `team.members[${index}]`;
+    if (!mapping(item)) throw new Error(`${label} must be a mapping`);
+    fields(item, ['persona', 'title', 'checklistTemplate'], label);
+    const persona = text(item.persona, `${label}.persona`);
+    const title = text(item.title, `${label}.title`);
+    if (titles.has(title)) throw new Error(`duplicate team title: ${title}`);
+    titles.add(title);
+    if (!Array.isArray(item.checklistTemplate) || item.checklistTemplate.length === 0) {
+      throw new Error(`${label}.checklistTemplate must be a non-empty list of strings`);
+    }
+    const checklistTemplate = item.checklistTemplate.map((entry: unknown) => text(entry, `${label}.checklistTemplate item`));
+    const personaPath = resolve(dirname(file), persona);
+    let yaml: string;
+    try {
+      yaml = readFileSync(personaPath, 'utf8');
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') throw new Error(`persona not found: ${persona} (${title})`);
+      throw error;
+    }
+    const parsed = parsePersonaYaml(yaml, personaPath);
+    if (!parsed.ok) throw new Error(`invalid persona ${persona}: ${parsed.error.message}`);
+    if (parsed.profile.seat !== title) throw new Error(`persona seat mismatch: ${persona} requires seat ${title}`);
+    if (personaIds.has(parsed.profile.personaId)) throw new Error(`duplicate personaId: ${parsed.profile.personaId}`);
+    personaIds.add(parsed.profile.personaId);
+    return { persona, title, checklistTemplate };
+  });
+  if (!Array.isArray(raw.handoffs)) throw new Error('team.handoffs must be a list');
+  const handoffs: TeamHandoff[] = raw.handoffs.map((item: unknown, index: number) => {
+    const label = `team.handoffs[${index}]`;
+    if (!mapping(item)) throw new Error(`${label} must be a mapping`);
+    fields(item, ['from', 'to'], label);
+    const from = text(item.from, `${label}.from`);
+    const to = text(item.to, `${label}.to`);
+    if (!titles.has(from) || !titles.has(to)) throw new Error(`handoff references missing title: ${from} -> ${to}`);
+    return { from, to };
+  });
+  const edges = new Map([...titles].map((title) => [title, [] as string[]]));
+  for (const { from, to } of handoffs) edges.get(from)!.push(to);
+  const visiting = new Set<string>();
+  const visited = new Set<string>();
+  const visit = (title: string): void => {
+    if (visiting.has(title)) throw new Error(`handoff cycle at ${title}`);
+    if (visited.has(title)) return;
+    visiting.add(title);
+    for (const next of edges.get(title)!) visit(next);
+    visiting.delete(title);
+    visited.add(title);
+  };
+  for (const title of titles) visit(title);
+  return { name, members, handoffs };
+}

package/src/persona/types.ts

@@ -19,6 +19,10 @@ export type PersonaBrand =
 export interface PersonaProfile {
   readonly personaId: string;
   readonly displayName: string;
+  /** Seat address (title, id or alias) represented by this persona. */
+  readonly seat?: string;
+  /** Per-persona JSONL todo filename in the state persona directory. */
+  readonly todo?: string;
   readonly description?: string;
 
   /** System prompt to prepend in LLM calls. Markdown text. May

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/landed-but-yellow.ts

@@ -11,6 +11,18 @@ export interface LandedButYellowRow {
   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[] = [];

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