elanous 0.2.10 → 0.2.11

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

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

package/src/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(); }
+}