elanous 0.2.6 → 0.2.8

package/src/decisions/decision-cards.ts

@@ -0,0 +1,291 @@
+// DEC-TG(대표 10-02 07:1x) — «밖에 있어도 주요 결정을 텔레그램·디스코드로 다 끝낸다».
+// `elanous decisions raise` 로 올라온 결정 → 대표 DM 카드(SCQA 요약 ⊕ 선택지 버튼 ⊕ 메모 달기) → 누르면 CLI `decide` 와 같은
+// 원장 메서드로 기록 → 올린 자리에 회신 → 카드는 «결정됨: A · 시각»으로 바뀐다.
+// ⛔ 보안: 버튼은 대표 id 만 받는다(그 밖은 무시 ⊕ 관측). 되돌릴 수 없는 범주(결제·외부 게시·보안·비가역)는 «되돌릴 수 없음» ⊕ 두 번 확인.
+// 플랫폼(텔레그램·디스코드)은 `CardTransport` 하나만 구현한다 — 판단은 전부 여기 있다.
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { DecisionLedger, type DecisionEntry } from './decision-ledger.js';
+
+export type CardPlatform = 'telegram' | 'discord';
+export interface CardButton { label: string; data: string }
+export interface CardView { text: string; buttons: CardButton[][] }
+export interface CardRef { chat: string; message: string }
+
+/** What a platform must provide. Every method is best-effort; failures are observed, never thrown to the poller. */
+export interface CardTransport {
+  platform: CardPlatform;
+  /** Owner DM destinations (Telegram chat id = user id for a DM; Discord DM channel id). */
+  ownerChats(): Promise<string[]>;
+  send(chat: string, view: CardView): Promise<CardRef | null>;
+  edit(ref: CardRef, view: CardView): Promise<void>;
+  /** Plain text (reminders, list replies). */
+  notify(chat: string, text: string): Promise<void>;
+}
+
+const IRREVERSIBLE = new Set(['money', 'publish', 'security', 'irreversible', 'secret']);
+export const DECISION_DATA_PREFIX = 'dec:';
+const REMIND_BEFORE_MS = 2 * 3600_000;
+
+export function isIrreversible(entry: Pick<DecisionEntry, 'category'>): boolean {
+  return IRREVERSIBLE.has(entry.category);
+}
+
+const kst = (at: string) => new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(at));
+
+/** The card body: title, SCQA in four short lines, options with consequences, recommendation, deadline. */
+export function renderCardText(e: DecisionEntry, extra: { note?: string; confirm?: string } = {}): string {
+  const lines = [
+    `🗳 결정 요청 ${e.id}${isIrreversible(e) ? ' · ⚠️ 되돌릴 수 없음' : ''}`,
+    `«${e.title}» · 올린 자리: ${e.raisedBy.agent}${e.raisedBy.track ? `(${e.raisedBy.track})` : ''}`,
+    '',
+    `상황: ${e.scqa.s}`,
+    `문제: ${e.scqa.c}`,
+    ...(e.scqa.q ? [`질문: ${e.scqa.q}`] : []),
+    ...(e.scqa.a ? [`제안: ${e.scqa.a}`] : []),
+    '',
+    ...e.options.map((o) => `${o.key.toUpperCase()}) ${o.label} — ${o.consequence}`),
+    'skipped' in e.recommendation ? `권고 없음: ${e.recommendation.reason}` : `권고: ${e.recommendation.option.toUpperCase()} — ${e.recommendation.why}`,
+    ...(e.dueAt ? [`기한: ${kst(e.dueAt)}`] : []),
+    ...(extra.note ? ['', `📝 메모: ${extra.note}`] : []),
+  ];
+  if (extra.confirm) {
+    const option = e.options.find((o) => o.key === extra.confirm);
+    lines.push('', `⚠️ ${extra.confirm.toUpperCase()}) ${option?.label ?? ''} — 되돌릴 수 없습니다. 정말 이것으로 정할까요?`);
+  }
+  return lines.join('\n');
+}
+
+export function renderCard(e: DecisionEntry, extra: { note?: string; confirm?: string } = {}): CardView {
+  const text = renderCardText(e, extra);
+  if (e.status === 'decided') {
+    const option = e.options.find((o) => o.key === e.choice);
+    return { text: `${text}\n\n✅ 결정됨: ${e.choice?.toUpperCase() ?? '?'}) ${option?.label ?? ''} · ${e.decidedAt ? kst(e.decidedAt) : ''}${e.note ? `\n📝 ${e.note}` : ''}`, buttons: [] };
+  }
+  if (e.status === 'withdrawn') return { text: `${text}\n\n↩️ 철회됨${e.withdrawReason ? `: ${e.withdrawReason}` : ''}`, buttons: [] };
+  if (extra.confirm) {
+    return { text, buttons: [[
+      { label: `✅ 예, ${extra.confirm.toUpperCase()} 로 정한다`, data: `${DECISION_DATA_PREFIX}${e.id}:${extra.confirm}:ok` },
+      { label: '취소', data: `${DECISION_DATA_PREFIX}${e.id}:-` },
+    ]] };
+  }
+  const choices = e.options.map((o) => ({ label: Array.from(`${o.key.toUpperCase()}) ${o.label}`).slice(0, 60).join(''), data: `${DECISION_DATA_PREFIX}${e.id}:${o.key}` }));
+  const rows: CardButton[][] = [];
+  for (let i = 0; i < choices.length; i += 2) rows.push(choices.slice(i, i + 2));
+  rows.push([{ label: '📝 메모 달기', data: `${DECISION_DATA_PREFIX}${e.id}:memo` }]);
+  return { text, buttons: rows };
+}
+
+export type ParsedTap = { id: string; action: 'choose'; key: string; confirmed: boolean } | { id: string; action: 'memo' } | { id: string; action: 'cancel' };
+
+export function parseTap(data: string): ParsedTap | null {
+  const m = /^dec:(D-\d{8}-\d+):([a-z]|memo|-)(:ok)?$/.exec(data);
+  if (!m) return null;
+  if (m[2] === 'memo') return { id: m[1]!, action: 'memo' };
+  if (m[2] === '-') return { id: m[1]!, action: 'cancel' };
+  return { id: m[1]!, action: 'choose', key: m[2]!, confirmed: Boolean(m[3]) };
+}
+
+interface CardState {
+  /** First start of this platform's service — decisions raised before it are not pushed (no burst of old items at
+   *  deploy); they stay reachable through `/decisions`. */
+  since?: string;
+  cards: Record<string, { refs: CardRef[]; closed?: boolean; remindedAt?: string; note?: string }>;
+}
+
+export interface DecisionCardServiceOptions {
+  transport: CardTransport;
+  /** Owner user ids for this platform — taps from anyone else are refused and observed. */
+  ownerIds: readonly string[];
+  ledger?: DecisionLedger;
+  /** Where this platform keeps which card it sent (one file per platform — the two bots may run in different processes). */
+  statePath?: string;
+  now?: () => Date;
+  /** Tell the seat that raised it. Default: none (observed only). */
+  replyToRaiser?: (entry: DecisionEntry, via: CardPlatform) => Promise<void>;
+}
+
+export type TapOutcome =
+  | { kind: 'refused' } | { kind: 'ignored' } | { kind: 'unknown' }
+  | { kind: 'confirm'; view: CardView; toast: string }
+  | { kind: 'decided'; view: CardView; toast: string }
+  | { kind: 'cancelled'; view: CardView; toast: string }
+  | { kind: 'memo-requested'; toast: string }
+  | { kind: 'closed'; view: CardView; toast: string };
+
+/** One per platform bot. `tick()` sends new cards, closes decided ones, sends reminders; `tap()` handles a button. */
+export class DecisionCardService {
+  private readonly ledger: DecisionLedger;
+  private readonly statePath: string;
+  private readonly now: () => Date;
+  constructor(private readonly opts: DecisionCardServiceOptions) {
+    this.ledger = opts.ledger ?? new DecisionLedger();
+    this.statePath = opts.statePath ?? join(this.ledger.path, '..', `cards-${opts.transport.platform}.json`);
+    this.now = opts.now ?? (() => new Date());
+  }
+
+  private load(): CardState {
+    try { return JSON.parse(readFileSync(this.statePath, 'utf8')) as CardState; } catch { return { cards: {} }; }
+  }
+  private save(state: CardState): void {
+    mkdirSync(join(this.statePath, '..'), { recursive: true });
+    const tmp = `${this.statePath}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(state, null, 2), { mode: 0o600 });
+    renameSync(tmp, this.statePath);
+  }
+
+  isOwner(userId: string): boolean { return this.opts.ownerIds.includes(userId); }
+
+  /** Send cards for new open decisions · close cards decided elsewhere · remind two hours before a deadline. */
+  async tick(): Promise<{ sent: number; closed: number; reminded: number }> {
+    const platform = this.opts.transport.platform;
+    const state = this.load();
+    let sent = 0; let closed = 0; let reminded = 0;
+    let all: DecisionEntry[];
+    try { all = this.ledger.list({ status: 'all' }); } catch (error) {
+      debug.log('decisions.telegram', 'ledger-unreadable', { platform, reason: error instanceof Error ? error.message.slice(0, 80) : 'unknown' }, { level: 'warn' });
+      return { sent, closed, reminded };
+    }
+    let dirty = false;
+    if (!state.since) { state.since = this.now().toISOString(); dirty = true; debug.log('decisions.telegram', 'baseline', { platform, since: state.since }); }
+    const chats = await this.opts.transport.ownerChats().catch(() => [] as string[]);
+    for (const e of all) {
+      const card = state.cards[e.id];
+      if (e.status === 'open' && !card && e.options.length >= 2 && e.raisedAt !== undefined && e.raisedAt >= state.since) {
+        const refs: CardRef[] = [];
+        for (const chat of chats) {
+          const ref = await this.opts.transport.send(chat, renderCard(e)).catch(() => null);
+          if (ref) refs.push(ref);
+        }
+        if (refs.length) { state.cards[e.id] = { refs }; sent++; }
+        debug.log('decisions.telegram', 'card-sent', { platform, id: e.id, category: e.category, chats: chats.length, delivered: refs.length });
+        continue;
+      }
+      if (card && !card.closed && e.status !== 'open') {
+        for (const ref of card.refs) await this.opts.transport.edit(ref, renderCard(e)).catch(() => undefined);
+        card.closed = true; closed++;
+        debug.log('decisions.telegram', 'card-closed', { platform, id: e.id, status: e.status });
+        continue;
+      }
+      if (e.status === 'open' && card && e.dueAt && !card.remindedAt && this.now().getTime() >= Date.parse(e.dueAt) - REMIND_BEFORE_MS) {
+        for (const chat of chats) await this.opts.transport.notify(chat, `⏰ 기한 2시간 전 — ${e.id} «${e.title}» (기한 ${kst(e.dueAt)}) · 카드에서 정하거나 /decisions`).catch(() => undefined);
+        card.remindedAt = this.now().toISOString(); reminded++;
+        debug.log('decisions.telegram', 'reminded', { platform, id: e.id });
+      }
+    }
+    if (dirty || sent || closed || reminded) this.save(state);
+    return { sent, closed, reminded };
+  }
+
+  /** A button tap. Never throws. */
+  async tap(userId: string, data: string): Promise<TapOutcome> {
+    const platform = this.opts.transport.platform;
+    const parsed = parseTap(data);
+    if (!parsed) return { kind: 'ignored' };
+    if (!this.isOwner(userId)) {
+      debug.log('decisions.telegram', 'tap-refused', { platform, id: parsed.id }, { level: 'warn' });
+      return { kind: 'refused' };
+    }
+    let entry: DecisionEntry;
+    try { entry = this.ledger.show(parsed.id); } catch { return { kind: 'unknown' }; }
+    const state = this.load();
+    const card = state.cards[entry.id];
+    if (entry.status !== 'open') return { kind: 'closed', view: renderCard(entry), toast: '이미 정해진 결정입니다' };
+    if (parsed.action === 'memo') {
+      debug.log('decisions.telegram', 'memo-requested', { platform, id: entry.id });
+      return { kind: 'memo-requested', toast: '메모를 보내 주세요 — 다음 메시지가 메모가 됩니다' };
+    }
+    if (parsed.action === 'cancel') return { kind: 'cancelled', view: renderCard(entry, card?.note ? { note: card.note } : {}), toast: '취소했습니다' };
+    if (!entry.options.some((o) => o.key === parsed.key)) return { kind: 'unknown' };
+    if (isIrreversible(entry) && !parsed.confirmed) {
+      debug.log('decisions.telegram', 'confirm-asked', { platform, id: entry.id, key: parsed.key });
+      return { kind: 'confirm', view: renderCard(entry, { confirm: parsed.key, ...(card?.note ? { note: card.note } : {}) }), toast: '되돌릴 수 없는 결정 — 한 번 더 확인해 주세요' };
+    }
+    let decided: DecisionEntry;
+    try {
+      // Same ledger method the CLI `decide` uses — one record path.
+      decided = this.ledger.decide(entry.id, parsed.key, { kind: 'human' }, card?.note);
+    } catch (error) {
+      debug.log('decisions.telegram', 'decide-failed', { platform, id: entry.id, reason: error instanceof Error ? error.message.slice(0, 80) : 'unknown' }, { level: 'warn' });
+      try { const now = this.ledger.show(entry.id); if (now.status !== 'open') return { kind: 'closed', view: renderCard(now), toast: '이미 정해진 결정입니다' }; } catch { /* fall through */ }
+      return { kind: 'unknown' };
+    }
+    const view = renderCard(decided);
+    if (card) {
+      for (const ref of card.refs) await this.opts.transport.edit(ref, view).catch(() => undefined);
+      card.closed = true;
+      this.save(state);
+    }
+    debug.log('decisions.telegram', 'decided', { platform, id: decided.id, choice: decided.choice, category: decided.category, noted: Boolean(decided.note) });
+    await this.opts.replyToRaiser?.(decided, platform).catch((error: unknown) => {
+      debug.log('decisions.telegram', 'reply-failed', { platform, id: decided.id, reason: error instanceof Error ? error.message.slice(0, 80) : 'unknown' }, { level: 'warn' });
+    });
+    return { kind: 'decided', view, toast: `결정했습니다: ${decided.choice?.toUpperCase()}` };
+  }
+
+  /** Store a memo typed after «메모 달기»; the card shows it and the eventual decision carries it. */
+  async setNote(userId: string, id: string, note: string): Promise<CardView | null> {
+    if (!this.isOwner(userId)) return null;
+    let entry: DecisionEntry;
+    try { entry = this.ledger.show(id); } catch { return null; }
+    const clean = note.replace(/\s+/g, ' ').trim().slice(0, 300);
+    if (!clean || entry.status !== 'open') return null;
+    const state = this.load();
+    const card = state.cards[id] ?? { refs: [] };
+    card.note = clean;
+    state.cards[id] = card;
+    this.save(state);
+    const view = renderCard(entry, { note: clean });
+    for (const ref of card.refs) await this.opts.transport.edit(ref, view).catch(() => undefined);
+    debug.log('decisions.telegram', 'memo-set', { platform: this.opts.transport.platform, id, chars: clean.length });
+    return view;
+  }
+
+  /** `/decisions` — open decisions as one list; each card is sent again so the buttons are at hand. */
+  async listOpen(chat: string): Promise<string> {
+    let open: DecisionEntry[];
+    try { open = this.ledger.list({ status: 'open' }).filter((e) => e.options.length >= 2); } catch { return '결정 원장을 읽지 못했습니다.'; }
+    if (!open.length) return '열린 결정이 없습니다.';
+    const state = this.load();
+    for (const e of open) {
+      const ref = await this.opts.transport.send(chat, renderCard(e, state.cards[e.id]?.note ? { note: state.cards[e.id]!.note } : {})).catch(() => null);
+      if (ref) { const card = state.cards[e.id] ?? { refs: [] }; card.refs.push(ref); state.cards[e.id] = card; }
+    }
+    this.save(state);
+    debug.log('decisions.telegram', 'listed', { platform: this.opts.transport.platform, open: open.length });
+    return `열린 결정 ${open.length}건 — ${open.map((e) => `${e.id}${e.dueAt ? `(기한 ${kst(e.dueAt)})` : ''}`).join(' · ')}`;
+  }
+}
+
+/** Reply line for the seat that raised it. Posted to the coordination PR when `decisions.replyGhPr` = "owner/repo#N". */
+export function raiserReplyText(e: DecisionEntry, via: CardPlatform): string {
+  const option = e.options.find((o) => o.key === e.choice);
+  const at = e.decidedAt ? new Intl.DateTimeFormat('sv-SE', { timeZone: 'Asia/Seoul', dateStyle: 'short', timeStyle: 'short' }).format(new Date(e.decidedAt)) : '';
+  return `**[대표]** ${at} KST → ${e.raisedBy.agent} · 결정 ${e.id} «${e.title}» = ${e.choice?.toUpperCase()}) ${option?.label ?? ''}${e.note ? ` · 메모: ${e.note}` : ''} (${via === 'telegram' ? '텔레그램' : '디스코드'})`;
+}
+
+export function ghPrReplier(target: string, run: (args: string[], stdin: string) => Promise<number> = runGh): (e: DecisionEntry, via: CardPlatform) => Promise<void> {
+  const m = /^([\w.-]+\/[\w.-]+)#(\d+)$/.exec(target.trim());
+  return async (e, via) => {
+    if (!m) throw new Error('decisions.replyGhPr must be owner/repo#N');
+    const code = await run(['pr', 'comment', m[2]!, '--repo', m[1]!, '--body-file', '-'], raiserReplyText(e, via));
+    debug.log('decisions.telegram', 'replied', { id: e.id, via, target: 'gh-pr', ok: code === 0 });
+    if (code !== 0) throw new Error(`gh exit ${code}`);
+  };
+}
+
+/** Post as the automation App (not the machine's personal gh login — that would make 대표 a participant and mail them),
+ *  with proxy variables removed (they break gh on the ops host). TC review #22660. */
+async function runGh(args: string[], stdin: string): Promise<number> {
+  const env: Record<string, string> = {};
+  for (const [k, v] of Object.entries(process.env)) if (v !== undefined && !/^(https?|all|no)_proxy$/i.test(k)) env[k] = v;
+  try {
+    const { githubAutomationToken } = await import('../auth/github-app-token.js');
+    const token = githubAutomationToken();
+    if (token) env.GH_TOKEN = token;
+    debug.log('decisions.telegram', 'reply-identity', { app: Boolean(token) });
+  } catch { /* falls back to the machine login */ }
+  const proc = Bun.spawn(['gh', ...args], { stdin: new Blob([stdin]), stdout: 'ignore', stderr: 'ignore', env });
+  return proc.exited;
+}

package/src/decisions/decision-ledger.ts

@@ -15,11 +15,13 @@ export interface DecisionEntry {
   options: DecisionOption[]; recommendation: Recommendation; raisedAt?: string; importedAt?: string;
   raisedBy: { agent: string; track?: DecisionTrack; session?: string }; version?: Versions;
   status: 'open' | 'decided' | 'withdrawn'; refs?: string[];
+  /** DEC-TG — optional deadline (UTC). Cards remind the owner two hours before it. */
+  dueAt?: string;
   decidedAt?: string; decidedBy?: DecisionActor; choice?: string; note?: string; versionAtDecision?: Versions;
   withdrawnAt?: string; withdrawReason?: string;
   history: Array<{ type: 'raised' | 'options-added' | 'decided' | 'withdrawn'; at?: string; by: string; version?: Versions; choice?: string; reason?: string }>;
 }
-export type RaiseInput = Pick<DecisionEntry, 'title' | 'category' | 'scqa' | 'options' | 'recommendation' | 'raisedBy' | 'refs'> & { raisedAt?: string };
+export type RaiseInput = Pick<DecisionEntry, 'title' | 'category' | 'scqa' | 'options' | 'recommendation' | 'raisedBy' | 'refs' | 'dueAt'> & { raisedAt?: string };
 type Event = { type: 'raised'; entry: DecisionEntry } | { type: 'options-added'; id: string; at: string; options: DecisionOption[]; by: string } | { type: 'decided'; id: string; at?: string; by: DecisionActor; choice?: string; version?: Versions; note?: string } | { type: 'withdrawn'; id: string; at: string; reason: string; version: Versions };
 export interface DecisionLedgerOptions extends VersionOptions { stateDir?: string; now?: () => Date; resolveVersion?: (at: string) => Versions }
 const CATEGORIES: readonly string[] = ['secret', 'publish', 'money', 'security', 'scope', 'irreversible', 'other'];
@@ -73,7 +75,8 @@ function validate(input: RaiseInput, historical = false): RaiseInput {
   if ('option' in recommendation && !options.some(o => o.key === recommendation.option)) throw new Error('recommended option not found');
   return { ...input, title, scqa: { s, c, ...(q ? { q } : {}), ...(a ? { a } : {}) }, options, recommendation,
     raisedBy: { agent: safe(single(input.raisedBy.agent, 'agent')), ...(input.raisedBy.track ? { track: input.raisedBy.track } : {}), ...(input.raisedBy.session ? { session: safe(single(input.raisedBy.session, 'session')) } : {}) },
-    ...(input.refs ? { refs: input.refs.map(r => safe(single(r, 'ref'))) } : {}) };
+    ...(input.refs ? { refs: input.refs.map(r => safe(single(r, 'ref'))) } : {}),
+    ...(input.dueAt ? { dueAt: utc(input.dueAt) } : {}) };
 }
 
 export class DecisionLedger {

package/src/decisions/discord-decision-cards.ts

@@ -0,0 +1,133 @@
+// DEC-TG — 디스코드 운반(운영 봇 · 대표 DM). 판단은 decision-cards.ts. 버튼 = MESSAGE_COMPONENT · 메모 = 모달.
+import type { DiscordBot } from '../discord.js';
+import type { UserConfig } from '../user-config.js';
+import { debug } from '../debug/log.js';
+import { DECISION_DATA_PREFIX, DecisionCardService, ghPrReplier, type CardTransport, type CardView } from './decision-cards.js';
+
+const TICK_MS = 20_000;
+const MEMO_PREFIX = 'decmemo:';
+const EPHEMERAL = 64;
+let current: DecisionCardService | null = null;
+
+export function discordDecisionService(): DecisionCardService | null { return current; }
+
+export function discordDecisionOwner(cfg: UserConfig): string | null {
+  const raw = (cfg.raw?.decisions as { discordOwnerId?: unknown } | undefined)?.discordOwnerId;
+  if (typeof raw === 'string' && /^\d{5,}$/.test(raw)) {
+    debug.log('decisions.telegram', 'owner-source', { platform: 'discord', source: 'config' });
+    return raw;
+  }
+  debug.log('decisions.telegram', 'owner-source', { platform: 'discord', source: 'default-first', allowlist: cfg.discord.allowedUsers.length }, cfg.discord.allowedUsers.length > 1 ? { level: 'warn' } : undefined);
+  return cfg.discord.allowedUsers[0] ?? null;
+}
+
+/** `/decisions` typed in Discord — owner only, and only in a DM (a guild channel would show the cards to everyone). */
+export async function discordDecisionsCommand(service: DecisionCardService, ctx: { userId: string; channelId: string; isDm: boolean }): Promise<string> {
+  if (!service.isOwner(ctx.userId)) return '결정은 소유자만 볼 수 있습니다.';
+  if (!ctx.isDm) return '결정은 개인 대화(DM)에서만 볼 수 있습니다.';
+  return service.listOpen(ctx.channelId);
+}
+
+/** Card buttons → Discord action rows (choices primary · memo secondary · confirm success). */
+export function discordComponents(view: CardView): Array<Record<string, unknown>> {
+  return view.buttons.map((row) => ({
+    type: 1,
+    components: row.map((b) => ({
+      type: 2,
+      style: b.data.endsWith(':ok') ? 3 : b.data.endsWith(':memo') || b.data.endsWith(':-') ? 2 : 1,
+      label: Array.from(b.label).slice(0, 80).join(''),
+      custom_id: b.data.slice(0, 100),
+    })),
+  }));
+}
+
+type Bot = Pick<DiscordBot, 'openDmChannel' | 'sendMessageWithComponents' | 'editMessageWithComponents' | 'sendMessage' | 'respondToInteraction'>;
+
+export function discordTransport(bot: Bot, owner: string): CardTransport {
+  let dm: string | null = null;
+  return {
+    platform: 'discord',
+    ownerChats: async () => {
+      dm ??= await bot.openDmChannel(owner);
+      return dm ? [dm] : [];
+    },
+    send: async (chat, view) => {
+      const sent = await bot.sendMessageWithComponents(chat, view.text, discordComponents(view));
+      return sent ? { chat, message: sent.id } : null;
+    },
+    edit: async (ref, view) => { await bot.editMessageWithComponents(ref.chat, ref.message, view.text, discordComponents(view)); },
+    notify: async (chat, text) => { await bot.sendMessage(chat, text); },
+  };
+}
+
+function userOf(raw: Record<string, unknown>): string {
+  const member = raw.member as { user?: { id?: string } } | undefined;
+  const user = raw.user as { id?: string } | undefined;
+  return member?.user?.id ?? user?.id ?? '';
+}
+
+/** Handle a decision button or memo modal. Returns true when the interaction was ours (so nothing else answers it). */
+export async function handleDiscordDecisionInteraction(bot: Bot, service: DecisionCardService, raw: Record<string, unknown>): Promise<boolean> {
+  const data = raw.data as { custom_id?: string; components?: Array<{ components?: Array<{ value?: string }> }> } | undefined;
+  const customId = data?.custom_id ?? '';
+  const id = String(raw.id ?? '');
+  const token = String(raw.token ?? '');
+  const reply = (content: string) => bot.respondToInteraction(id, token, { type: 4, data: { content, flags: EPHEMERAL } });
+  if (raw.type === 5 && customId.startsWith(MEMO_PREFIX)) {
+    const value = data?.components?.[0]?.components?.[0]?.value ?? '';
+    const view = await service.setNote(userOf(raw), customId.slice(MEMO_PREFIX.length), value);
+    await reply(view ? '메모를 달았습니다 — 카드에서 선택지를 누르면 함께 기록됩니다.' : '메모를 달지 못했습니다(권한 또는 이미 정해진 결정).');
+    return true;
+  }
+  if (raw.type !== 3 || !customId.startsWith(DECISION_DATA_PREFIX)) return false;
+  const outcome = await service.tap(userOf(raw), customId);
+  switch (outcome.kind) {
+    case 'refused': await reply('권한이 없습니다.'); return true;
+    case 'ignored': case 'unknown': await reply('알 수 없는 결정입니다.'); return true;
+    case 'memo-requested': {
+      const decisionId = /^dec:([^:]+):memo$/.exec(customId)?.[1] ?? '';
+      await bot.respondToInteraction(id, token, { type: 9, data: {
+        custom_id: `${MEMO_PREFIX}${decisionId}`.slice(0, 100), title: Array.from(`메모 달기 · ${decisionId}`).slice(0, 45).join(''),
+        components: [{ type: 1, components: [{ type: 4, custom_id: 'note', style: 2, label: '메모', max_length: 300, required: true }] }],
+      } });
+      return true;
+    }
+    default:
+      // UPDATE_MESSAGE on the tapped card (decided: the service already edited every card it sent — same content).
+      await bot.respondToInteraction(id, token, { type: 7, data: { content: outcome.view.text, components: discordComponents(outcome.view) } });
+      return true;
+  }
+}
+
+export interface DiscordDecisionWire {
+  service: DecisionCardService;
+  onInteraction: (raw: Record<string, unknown>) => Promise<boolean>;
+  stop: () => void;
+}
+
+export function attachDiscordDecisionCards(bot: Bot, cfg: UserConfig, opts: { tickMs?: number } = {}): DiscordDecisionWire | null {
+  const owner = discordDecisionOwner(cfg);
+  if (!owner) {
+    debug.log('decisions.telegram', 'not-attached', { platform: 'discord', reason: 'no-owner' });
+    return null;
+  }
+  const replyTarget = (cfg.raw?.decisions as { replyGhPr?: unknown } | undefined)?.replyGhPr;
+  const service = new DecisionCardService({
+    transport: discordTransport(bot, owner),
+    ownerIds: [owner],
+    ...(typeof replyTarget === 'string' && replyTarget ? { replyToRaiser: ghPrReplier(replyTarget) } : {}),
+  });
+  current = service;
+  const timer = setInterval(() => {
+    void service.tick().catch((error: unknown) => {
+      debug.log('decisions.telegram', 'tick-failed', { platform: 'discord', reason: error instanceof Error ? error.message.slice(0, 80) : 'unknown' }, { level: 'warn' });
+    });
+  }, opts.tickMs ?? TICK_MS);
+  (timer as { unref?: () => void }).unref?.();
+  debug.log('decisions.telegram', 'attached', { platform: 'discord', reply: typeof replyTarget === 'string' && Boolean(replyTarget) });
+  return {
+    service,
+    onInteraction: (raw) => handleDiscordDecisionInteraction(bot, service, raw),
+    stop: () => { clearInterval(timer); if (current === service) current = null; },
+  };
+}

package/src/decisions/telegram-decision-cards.ts

@@ -0,0 +1,100 @@
+// DEC-TG — 텔레그램 운반(운영 봇 DM). 판단은 decision-cards.ts 에 있고 여기는 «보내고·고치고·누름을 넘긴다»만 한다.
+// ⛔ 카드는 «폴링하는» 본 봇만 보낸다(넥서스가 폴링 없는 봇을 따로 세울 수 있다 — 두 번 가면 안 된다).
+import type { TelegramBot, TgCallbackQuery } from '../telegram.js';
+import type { UserConfig } from '../user-config.js';
+import { debug } from '../debug/log.js';
+import { DECISION_DATA_PREFIX, DecisionCardService, ghPrReplier, type CardTransport, type CardView } from './decision-cards.js';
+
+const TICK_MS = 20_000;
+let current: DecisionCardService | null = null;
+
+/** The running Telegram card service (for the `/decisions` command), or null when none is attached. */
+export function telegramDecisionService(): DecisionCardService | null { return current; }
+
+function buttons(view: CardView): Array<Array<{ text: string; data: string }>> {
+  return view.buttons.map((row) => row.map((b) => ({ text: b.label, data: b.data })));
+}
+
+/** Owner = `decisions.telegramOwnerId` when set, else the first allowlisted user (the bot owner). */
+export function telegramDecisionOwner(cfg: UserConfig): string | null {
+  const raw = (cfg.raw?.decisions as { telegramOwnerId?: unknown } | undefined)?.telegramOwnerId;
+  if (typeof raw === 'number' || (typeof raw === 'string' && /^\d+$/.test(raw))) {
+    debug.log('decisions.telegram', 'owner-source', { platform: 'telegram', source: 'config' });
+    return String(raw);
+  }
+  const first = cfg.telegram.allowedUsers[0];
+  debug.log('decisions.telegram', 'owner-source', { platform: 'telegram', source: 'default-first', allowlist: cfg.telegram.allowedUsers.length }, cfg.telegram.allowedUsers.length > 1 ? { level: 'warn' } : undefined);
+  return typeof first === 'number' ? String(first) : null;
+}
+
+export function telegramTransport(bot: Pick<TelegramBot, 'sendInlineKeyboard' | 'editMessageWithKeyboard' | 'sendMessage'>, owner: string): CardTransport {
+  return {
+    platform: 'telegram',
+    ownerChats: async () => [owner],
+    send: async (chat, view) => {
+      const sent = await bot.sendInlineKeyboard(Number(chat), view.text, buttons(view));
+      return sent ? { chat, message: String(sent.messageId) } : null;
+    },
+    edit: async (ref, view) => { await bot.editMessageWithKeyboard(Number(ref.chat), Number(ref.message), view.text, buttons(view)); },
+    notify: async (chat, text) => { await bot.sendMessage(Number(chat), text); },
+  };
+}
+
+export interface AttachOptions { tickMs?: number; service?: DecisionCardService }
+
+/** Wire cards onto a bot: callback taps, memo capture, and a ticker that runs only while this bot polls. Returns a stop fn. */
+export function attachTelegramDecisionCards(bot: TelegramBot, cfg: UserConfig, opts: AttachOptions = {}): () => void {
+  const owner = telegramDecisionOwner(cfg);
+  if (!owner) {
+    debug.log('decisions.telegram', 'not-attached', { platform: 'telegram', reason: 'no-owner' });
+    return () => undefined;
+  }
+  const replyTarget = (cfg.raw?.decisions as { replyGhPr?: unknown } | undefined)?.replyGhPr;
+  const service = opts.service ?? new DecisionCardService({
+    transport: telegramTransport(bot, owner),
+    ownerIds: [owner],
+    ...(typeof replyTarget === 'string' && replyTarget ? { replyToRaiser: ghPrReplier(replyTarget) } : {}),
+  });
+  current = service;
+  const unsubscribe = bot.onCallbackQuery(async (q: TgCallbackQuery) => {
+    if (!q.data.startsWith(DECISION_DATA_PREFIX)) return;
+    const outcome = await service.tap(String(q.userId), q.data);
+    const where = q.chatId !== undefined && q.messageId !== undefined ? { chat: q.chatId, message: q.messageId } : null;
+    switch (outcome.kind) {
+      case 'refused': await bot.answerCallbackQuery(q.id, { text: '권한이 없습니다' }); return;
+      case 'ignored': case 'unknown': await bot.answerCallbackQuery(q.id, { text: '알 수 없는 결정입니다' }); return;
+      case 'memo-requested': {
+        // The next text in a GROUP could come from another allow-listed member — capture only in the owner's private chat.
+        if (q.chatId === undefined || q.chatId !== q.userId) {
+          debug.log('decisions.telegram', 'memo-refused', { platform: 'telegram', reason: 'not-private-chat' });
+          await bot.answerCallbackQuery(q.id, { text: '메모는 개인 대화에서만 달 수 있습니다' });
+          return;
+        }
+        await bot.answerCallbackQuery(q.id, { text: outcome.toast });
+        {
+          const id = /^dec:([^:]+):memo$/.exec(q.data)?.[1];
+          await bot.sendMessage(q.chatId, `📝 ${id} 메모를 한 줄로 보내 주세요(취소: /cancel).`);
+          bot.captureNextText(q.chatId, undefined, (text) => {
+            if (text && id) void service.setNote(String(q.userId), id, text).then((view) => {
+              if (view && q.chatId !== undefined) void bot.sendMessage(q.chatId, '메모를 달았습니다 — 카드에서 선택지를 누르면 함께 기록됩니다.');
+            });
+          });
+        }
+        return;
+      }
+      default:
+        await bot.answerCallbackQuery(q.id, { text: outcome.toast, ...(outcome.kind === 'confirm' ? { alert: true } : {}) });
+        // decided: the service already edited every card it sent; confirm/cancel/closed: edit the tapped one.
+        if (outcome.kind !== 'decided' && where) await bot.editMessageWithKeyboard(where.chat, where.message, outcome.view.text, buttons(outcome.view)).catch(() => undefined);
+    }
+  });
+  const timer = setInterval(() => {
+    if (!bot.isPolling()) return;
+    void service.tick().catch((error: unknown) => {
+      debug.log('decisions.telegram', 'tick-failed', { reason: error instanceof Error ? error.message.slice(0, 80) : 'unknown' }, { level: 'warn' });
+    });
+  }, opts.tickMs ?? TICK_MS);
+  (timer as { unref?: () => void }).unref?.();
+  debug.log('decisions.telegram', 'attached', { platform: 'telegram', reply: typeof replyTarget === 'string' && Boolean(replyTarget) });
+  return () => { clearInterval(timer); unsubscribe(); if (current === service) current = null; };
+}

package/src/directives/version-at.ts

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { spawnSync } from 'node:child_process';
+
+export interface Versions { released: string | null; dev: string | null; codename: string | null }
+export interface VersionOptions { releaseRoot?: string; repoRoot?: string; codenames?: Record<string, string> }
+
+/** SemVer order for release ledgers: numeric core, then a prerelease sorts before its release. */
+export function compareVersions(a: string, b: string): number {
+  const parse = (v: string) => { const [core, pre] = v.split('-', 2); return { nums: core!.split('.').map(n => Number(n) || 0), pre: pre ?? null }; };
+  const x = parse(a); const y = parse(b);
+  for (let i = 0; i < Math.max(x.nums.length, y.nums.length); i++) {
+    const d = (x.nums[i] ?? 0) - (y.nums[i] ?? 0);
+    if (d) return d;
+  }
+  if (x.pre === y.pre) return 0;
+  if (x.pre === null) return 1;
+  if (y.pre === null) return -1;
+  return x.pre.localeCompare(y.pre, undefined, { numeric: true });
+}
+
+export function createVersionResolver(opts: VersionOptions = {}): (ts: string) => Versions {
+  const releases: Array<{ at: number; version: string }> = [];
+  const root = opts.releaseRoot ?? join(elanousStateRoot(), 'release');
+  if (existsSync(root)) for (const dir of readdirSync(root, { withFileTypes: true })) {
+    if (!dir.isDirectory()) continue;
+    const path = join(root, dir.name, 'release.json');
+    if (!existsSync(path)) continue;
+    try {
+      const record = JSON.parse(readFileSync(path, 'utf8')) as Record<string, unknown>;
+      const stamp = record.publishedAt ?? record.published_at ?? record.releasedAt;
+      const at = Date.parse(String(stamp ?? ''));
+      if (typeof record.version === 'string' && Number.isFinite(at)) releases.push({ at, version: record.version });
+    } catch { /* a malformed ledger cannot supply a release boundary */ }
+  }
+  releases.sort((a, b) => a.at - b.at);
+  const repo = opts.repoRoot ?? process.cwd();
+  // A current-branch commit date is not proof of when that commit entered origin/main.
+  // Reflog updates are observed branch snapshots; before the first retained update the answer is unknown.
+  const reflog = spawnSync('git', ['reflog', 'show', '--date=unix', '--format=%H%x09%gd', 'refs/remotes/origin/main'], { cwd: repo, encoding: 'utf8', timeout: 10000 });
+  const snapshots: Array<{ at: number; commit: string; order: number }> = [];
+  if (reflog.status === 0) for (const line of reflog.stdout.split('\n')) {
+    const match = /^([0-9a-f]+)\torigin\/main@\{(\d+)\}$/.exec(line.trim());
+    // Reflog lists newest first; keep that order so two updates in the same second resolve to the later one.
+    if (match) snapshots.push({ at: Number(match[2]) * 1000, commit: match[1]!, order: snapshots.length });
+  }
+  snapshots.sort((a, b) => a.at - b.at || b.order - a.order);
+  const versions = new Map<string, string | null>();
+  for (const { commit } of snapshots) {
+    if (versions.has(commit)) continue;
+    const show = spawnSync('git', ['show', `${commit}:package.json`], { cwd: repo, encoding: 'utf8', timeout: 5000 });
+    let version: string | null = null;
+    if (show.status === 0) {
+      try {
+        const parsed = JSON.parse(show.stdout).version;
+        if (typeof parsed === 'string') version = parsed;
+      } catch { /* unreadable package at this snapshot */ }
+    }
+    versions.set(commit, version);
+  }
+  const cache = new Map<string, Versions>();
+  return ts => {
+    const existing = cache.get(ts);
+    if (existing) return existing;
+    const time = Date.parse(ts);
+    // The public version at a moment = the highest version published by then (a re-written old record must not win by date).
+    const released = Number.isFinite(time) ? releases.filter(x => x.at <= time).map(x => x.version).sort(compareVersions).at(-1) ?? null : null;
+    const snapshot = Number.isFinite(time) ? [...snapshots].reverse().find(x => x.at <= time) : undefined;
+    const dev = snapshot ? versions.get(snapshot.commit) ?? null : null;
+    const codenames = opts.codenames ?? {};
+    const codename = codenames[dev?.replace(/-.*/, '') ?? ''] ?? codenames[released ?? ''] ?? null;
+    const value = { released, dev, codename };
+    cache.set(ts, value);
+    return value;
+  };
+}