elanous 0.2.9 → 0.2.11

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

@@ -1,5 +1,5 @@
 // The owner hands a seat a task from Telegram: /coo /cto /cmo /cxo → one «[대표] → <seat>» line on the coordination PR,
-// one 'ceo-task' message in the seat store, and a «받음» reply. Nothing is written unless it is the owner in a private chat.
+// one 'ceo-task' message in the seat store, and a «받음» reply. The Telegram entrypoint writes only for the owner in a private chat.
 // Goal: 내부 문서 `ASK-the-ceo-cannot-hand-a-seat-a-task-from-telegram-2026-10-02` (C2 phase 1).
 import { debug } from '../debug/log.js';
 import type { MessageEnvelope } from '../msg/msg-store.js';
@@ -16,6 +16,8 @@ export interface CeoCommandDeps {
   replyTarget: string | null;
   runGh: (args: string[], stdin: string) => Promise<number>;
   append: (message: MessageEnvelope) => unknown;
+  /** Whether the seat inbox already holds a message carrying this request ref (retry after a crash must not deliver twice). */
+  hasMessage?: (seat: string, ref: string) => boolean;
   now?: () => Date;
 }
 
@@ -43,21 +45,52 @@ export async function handleCeoSeatCommand(command: CeoSeatCommand, args: string
     debug.log('seat.dispatch', 'refused', { seat, reason: 'empty' });
     return `사용법: /${command} <할 일>`;
   }
-  deps.append({ from: 'CEO', to: seat, body: task, kind: 'ceo-task' });
-  const channelError = await postToChannel(seat, task, deps);
+  return (await dispatchCeoTask(seat, task, deps)).reply;
+}
+
+export interface CeoTaskExtra {
+  attachments?: Array<{ name: string; path: string }>;
+  /** Paths supplied by callers that do not have attachment names. */
+  attachmentPaths?: readonly string[];
+  via?: 'telegram' | 'discord' | 'pwa';
+  /** Request ref written into the message body; with `deps.hasMessage` it makes delivery idempotent per request. */
+  ref?: string;
+}
+
+export interface CeoTaskResult { reply: string; channel: 'posted' | 'failed' | 'unknown'; channelError?: string }
+
+/** Dispatch an already-authorized seat request; callers must authenticate before invoking this helper. */
+export async function dispatchCeoTask(seat: string, text: string, deps: CeoCommandDeps, extra: CeoTaskExtra = {}): Promise<CeoTaskResult> {
+  const task = text.replace(/\s+/g, ' ').trim();
+  if (!task) {
+    debug.log('seat.dispatch', 'refused', { seat, reason: 'empty' });
+    return { reply: '할 일을 입력해 주세요.', channel: 'unknown' };
+  }
+  const attachments = extra.attachments ?? [];
+  const attachmentPaths = extra.attachmentPaths ?? [];
+  const body = `${task}${attachments.map(({ name, path }) => `\n첨부: ${name} — ${path}`).join('')}${attachmentPaths.length ? `\n\n첨부 파일:\n${attachmentPaths.join('\n')}` : ''}${extra.ref ? `\n요청: ${extra.ref}` : ''}`;
+  if (extra.ref && deps.hasMessage?.(seat, extra.ref)) {
+    // A retry after a crash between delivery and the journal outcome: the message is already there, and whether
+    // the channel line went out is unknown — say so instead of posting it again or claiming it was posted.
+    debug.log('seat.dispatch', 'ceo-task-already-delivered', { seat, via: extra.via });
+    return { reply: `받음 — ${seat} 메시지함에 이미 있습니다.`, channel: 'unknown' };
+  }
+  deps.append({ from: 'CEO', to: seat, body, kind: 'ceo-task' });
+  debug.log('seat.dispatch', 'ceo-task', { seat, ...(extra.via ? { via: extra.via, attachments: attachments.length + attachmentPaths.length } : {}) });
+  const channelError = await postToChannel(seat, task, deps, extra);
   if (channelError) {
     debug.log('seat.dispatch', 'channel-failed', { seat, reason: channelError }, { level: 'warn' });
-    return `받음 — ${seat} 메시지함에는 넣었습니다. 다만 조율 채널에 못 남겼습니다(${channelError}).`;
+    return { reply: `받음 — ${seat} 메시지함에는 넣었습니다. 다만 조율 채널에 못 남겼습니다(${channelError}).`, channel: 'failed', channelError };
   }
-  debug.log('seat.dispatch', 'ceo-task', { seat });
-  return `받음 — ${seat}에 전했습니다.`;
+  return { reply: `받음 — ${seat}에 전했습니다.`, channel: 'posted' };
 }
 
-async function postToChannel(seat: string, task: string, deps: CeoCommandDeps): Promise<string | null> {
+async function postToChannel(seat: string, task: string, deps: CeoCommandDeps, extra: CeoTaskExtra): Promise<string | null> {
   const target = /^([\w.-]+\/[\w.-]+)#(\d+)$/.exec(deps.replyTarget?.trim() ?? '');
   if (!target) return deps.replyTarget ? 'decisions.replyGhPr 형식이 owner/repo#N 이 아님' : 'decisions.replyGhPr 미설정';
   try {
-    const code = await deps.runGh(['pr', 'comment', target[2]!, '--repo', target[1]!, '--body-file', '-'], ceoTaskLine(seat, task, deps.now?.() ?? new Date()));
+    const attachmentCount = (extra.attachments?.length ?? 0) + (extra.attachmentPaths?.length ?? 0);
+    const code = await deps.runGh(['pr', 'comment', target[2]!, '--repo', target[1]!, '--body-file', '-'], `${ceoTaskLine(seat, task, deps.now?.() ?? new Date())}${attachmentCount ? ` · 첨부 ${attachmentCount}` : ''}${extra.via === 'pwa' ? ' (PWA)' : ''}`);
     return code === 0 ? null : `gh 종료 코드 ${code}`;
   } catch (error) {
     return error instanceof Error ? error.message.slice(0, 80) : 'gh 실행 실패';

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

@@ -0,0 +1,38 @@
+import { runGh } from '../decisions/decision-cards.js';
+import { openMsgStore } from '../msg/msg-store.js';
+import type { UserConfig } from '../user-config.js';
+import type { CeoCommandDeps } from './ceo-commands.js';
+
+/** Endings are ordered from explicit punctuation to Korean question endings. Every row has a test example. */
+export const CEO_QUESTION_ENDINGS = [
+  /[?？]$/,
+  /야$/,
+  /니$/,
+  /나요$/,
+  /까요$/,
+  /인가요$/,
+  /어때$/,
+  /알려\s?줘$/,
+  /보여줘$/,
+  /상황$/,
+  /어디까지$/,
+] as const;
+
+export function classifyCeoIntent(text: string): 'question' | 'task' {
+  const body = text.trim();
+  return CEO_QUESTION_ENDINGS.some((ending) => ending.test(body)) ? 'question' : 'task';
+}
+
+/** The same channel + seat inbox delivery dependencies used by /coo, /cto, /cmo and /cxo. */
+export function ceoTaskDeps(cfg: UserConfig, ownerId: string | null): CeoCommandDeps {
+  const replyTarget = (cfg.raw?.decisions as { replyGhPr?: unknown } | undefined)?.replyGhPr;
+  return {
+    ownerId,
+    replyTarget: typeof replyTarget === 'string' ? replyTarget : null,
+    runGh,
+    append: (message) => {
+      const store = openMsgStore();
+      try { return store.append(message); } finally { store.close(); }
+    },
+  };
+}

package/src/seat-dispatch/seat-ask.ts

@@ -0,0 +1,130 @@
+import { randomUUID } from 'node:crypto';
+import { debug } from '../debug/log.js';
+import { openMsgStore, type MsgStore } from '../msg/msg-store.js';
+import { dispatchCeoTask, type CeoCommandDeps } from './ceo-commands.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 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 }
+
+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'
+  ); 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 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 SeatAskDeps {
+  open?: () => MsgStore;
+  now?: () => number;
+  timeoutMs?: number;
+  dispatch?: typeof dispatchCeoTask;
+  send: (origin: AskOrigin, text: string) => Promise<void>;
+  channel?: AskOrigin['channel'];
+  clientId?: string;
+  botId?: string;
+}
+
+/** Persist the return address before delivering through the /cto channel and seat inbox. */
+export async function askSeat(text: string, origin: AskOrigin, command: CeoCommandDeps, deps: SeatAskDeps): Promise<string> {
+  const body = parseSeatAsk(text);
+  if (!body) throw new Error('not a CTO ask');
+  const id = randomUUID();
+  const timeout = deps.timeoutMs ?? DEFAULT_ASK_TIMEOUT_MS;
+  if (!Number.isSafeInteger(timeout) || timeout < 1) throw new Error('invalid seat ask timeout');
+  const minutes = Math.ceil(timeout / 60000);
+  const store = (deps.open ?? openMsgStore)();
+  try {
+    createTable(store);
+    store.db.query('INSERT INTO seat_asks (id, seat, origin, deadline, timeout_minutes, status) VALUES (?, ?, ?, ?, ?, ?)')
+      .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,
+      { 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}` : ''}`;
+  } catch (error) {
+    const failed = (deps.open ?? openMsgStore)();
+    try { createTable(failed); failed.db.query('DELETE FROM seat_asks WHERE id = ?').run(id); }
+    finally { failed.close(); }
+    throw error;
+  }
+}
+
+/** Read the seat mailbox without advancing its cursor (other CEO messages remain untouched). */
+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 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;
+      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() : '';
+      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}분 안에 답이 오지 않았습니다.`;
+      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);
+      return status;
+    });
+    for (const ask of pending) {
+      const origin = JSON.parse(ask.origin) as AskOrigin;
+      if (deps.channel && origin.channel !== deps.channel) continue;
+      if (origin.channel === 'pwa' && deps.clientId !== origin.clientId) continue;
+      if (origin.channel === 'telegram' && origin.botId && origin.botId !== deps.botId) continue;
+      const status = decide(ask.id, (deps.now ?? Date.now)());
+      if (status) debug.log('seat.ask', status, { seat: ask.seat, id: ask.id, via: origin.channel });
+    }
+    const outbox = store.db.query("SELECT id, origin, text FROM seat_ask_outbox WHERE status = 'pending'").all() as Array<{ id: string; origin: string; text: string }>;
+    for (const item of outbox) {
+      const origin = JSON.parse(item.origin) as AskOrigin;
+      if (deps.channel && origin.channel !== deps.channel) continue;
+      if (origin.channel === 'telegram' && origin.botId && origin.botId !== deps.botId) continue;
+      if (origin.channel === 'pwa') {
+        if (deps.clientId === origin.clientId) await deps.send(origin, item.text);
+        continue; // A browser poll is not a receipt; only its explicit acknowledgement consumes the answer.
+      }
+      const token = randomUUID();
+      const now = Date.now();
+      // SQLite's conditional write is the claim across concurrent bot loops and processes.
+      const claimed = store.db.query(`UPDATE seat_ask_outbox SET claim_until = ?, claim_token = ?
+        WHERE id = ? AND status = 'pending' AND claim_until <= ?`).run(now + 5 * 60_000, token, item.id, now);
+      if (claimed.changes !== 1) continue;
+      try {
+        await deps.send(origin, item.text);
+        store.db.query("UPDATE seat_ask_outbox SET status = 'sent', claim_token = NULL WHERE id = ? AND claim_token = ?").run(item.id, token);
+      } catch (error) {
+        store.db.query('UPDATE seat_ask_outbox SET claim_until = 0, claim_token = NULL WHERE id = ? AND claim_token = ?').run(item.id, token);
+        throw error;
+      }
+    }
+  } finally { store.close(); }
+}
+
+/** Confirm only this browser's displayed answers; polling alone never removes them. */
+export function acknowledgeSeatAnswers(clientId: string, ids: string[], open: () => MsgStore = openMsgStore): void {
+  const store = open();
+  try {
+    createTable(store);
+    const ack = store.db.query("UPDATE seat_ask_outbox SET status = 'sent' WHERE id = ? AND origin = ? AND status = 'pending'");
+    for (const id of ids) ack.run(id, JSON.stringify({ channel: 'pwa', clientId }));
+  } finally { store.close(); }
+}

package/src/seat-dispatch/seat-questions.ts

@@ -0,0 +1,100 @@
+import { join } from 'node:path';
+import { openMsgStore, type Message } from '../msg/msg-store.js';
+
+export const SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
+export type SeatId = typeof SEATS[number];
+
+export function isSeatId(value: string): value is SeatId {
+  return SEATS.some((seat) => seat === value);
+}
+
+function storeAt(root: string) { return openMsgStore(join(root, 'msg', 'messages.db')); }
+
+// Keep the delivery receipt in the same SQLite transaction as the inbox message.
+// An interrupted sender can retry without producing a second delivery.
+function deliverOnce(root: string, key: string, envelope: { from: SeatId; to: SeatId; body: string; kind: string }): Message {
+  const store = storeAt(root);
+  try {
+    store.db.exec(`CREATE TABLE IF NOT EXISTS seat_dispatch_receipts (
+      key TEXT PRIMARY KEY, message_id INTEGER NOT NULL UNIQUE
+    )`);
+    return store.db.transaction(() => {
+      const prior = store.db.query(`SELECT m.id, m.sender, m.recipient, m.body, m.kind, m.created_at
+        FROM seat_dispatch_receipts r JOIN msg_messages m ON m.id = r.message_id WHERE r.key = ?`)
+        .get(key) as { id: number; sender: string; recipient: string; body: string; kind: string; created_at: string } | null;
+      if (prior) {
+        if (prior.sender !== envelope.from || prior.recipient !== envelope.to || prior.kind !== envelope.kind || prior.body !== envelope.body) {
+          throw new Error('seat delivery retry changed its recorded message');
+        }
+        return { id: prior.id, from: prior.sender, to: prior.recipient, body: prior.body, kind: prior.kind, createdAt: prior.created_at };
+      }
+      const message = store.append(envelope);
+      store.db.query('INSERT INTO seat_dispatch_receipts(key, message_id) VALUES (?, ?)').run(key, message.id);
+      return message;
+    })();
+  } finally { store.close(); }
+}
+
+/** The message id is the durable correlation key; the caller's seat ledger records it as handled. */
+export function askSeat(root: string, from: SeatId, to: SeatId, question: string, deliveryKey?: string): Message {
+  if (from === to || !question.trim()) throw new Error('seat question requires another seat and nonempty text');
+  const envelope = { from, to, body: question.trim(), kind: 'seat-question' };
+  if (deliveryKey) return deliverOnce(root, deliveryKey, envelope);
+  const store = storeAt(root);
+  try { return store.append(envelope); }
+  finally { store.close(); }
+}
+
+export function deliveredSeatQuestion(root: string, key: string): Message | null {
+  const store = storeAt(root);
+  try {
+    const row = store.db.query(`SELECT m.id, m.sender, m.recipient, m.body, m.kind, m.created_at
+      FROM seat_dispatch_receipts r JOIN msg_messages m ON m.id = r.message_id WHERE r.key = ?`)
+      .get(key) as { id: number; sender: SeatId; recipient: SeatId; body: string; kind: string; created_at: string } | null;
+    return row ? { id: row.id, from: row.sender, to: row.recipient, body: row.body, kind: row.kind, createdAt: row.created_at } : null;
+  } catch (error) {
+    if (String(error).includes('no such table: seat_dispatch_receipts')) return null;
+    throw error;
+  } finally { store.close(); }
+}
+
+export function seatQuestions(root: string, seat: SeatId): Message[] {
+  const store = storeAt(root);
+  try {
+    const found: Message[] = [];
+    let cursor = 0;
+    while (true) {
+      const batch = store.listByRecipient(seat, cursor, 1000);
+      found.push(...batch.filter((message) => message.kind === 'seat-question' && isSeatId(message.from) && message.from !== seat));
+      if (batch.length < 1000) break;
+      cursor = batch[batch.length - 1]!.id;
+    }
+    return found;
+  } finally { store.close(); }
+}
+
+export function answerSeat(root: string, question: Message, answer: string): Message {
+  if (question.kind !== 'seat-question' || !isSeatId(question.to) || !isSeatId(question.from) || !answer.trim()) {
+    throw new Error('invalid seat answer');
+  }
+  return deliverOnce(root, `answer:${question.id}`, {
+    from: question.to, to: question.from, body: JSON.stringify({ questionId: question.id, answer: answer.trim() }), kind: 'seat-answer',
+  });
+}
+
+export function hasSeatAnswer(root: string, question: Message): boolean {
+  const store = storeAt(root);
+  try {
+    let cursor = 0;
+    while (true) {
+      const batch = store.listByRecipient(question.from, cursor, 1000);
+      for (const message of batch) {
+        if (message.kind !== 'seat-answer' || message.from !== question.to) continue;
+        try { if ((JSON.parse(message.body) as { questionId?: unknown }).questionId === question.id) return true; }
+        catch { /* unrelated malformed message */ }
+      }
+      if (batch.length < 1000) return false;
+      cursor = batch[batch.length - 1]!.id;
+    }
+  } finally { store.close(); }
+}