elanous 0.2.7 → 0.2.9

package/src/dashboard/index.ts

@@ -725,7 +725,8 @@ import { SELF_IMPLEMENT_TOOL_NAMES } from '../boot/daemon-tools/self-implement-n
 import { FOLD_LIMITS, type FoldMode } from '../log-entry.js';
 import { renderToolCallEvent, renderToolResultVariants } from '../chat/tool-render/index.js';
 import { FoldStack } from '../fold-stack.js';
-import { getSkillIndex, reloadSkillIndex, applySkillFilter } from '../skills/index.js';
+import { getSkillIndex, reloadSkillIndex, applySkillFilter, skillIndexProblems } from '../skills/index.js';
+import { skillRepairNotice } from '../skills/repair.js';
 import type { DetectResult } from '../skills/router.js';
 import { detectUrlRoute } from '../skills/url-router.js';
 import {
@@ -880,6 +881,10 @@ import { getModelFamily, getModelTier } from '../models/prompts.js';
 import { buildPromptInjection, getPromptBankStore } from '../prompt-bank/index.js';
 import { getInputHistoryStore, inputHistoryDbPath, inputHistoryJsonPath } from '../input-history.js';
 import { inspectActiveProvider } from '../provider-summary.js';
+import { activeCodexAccountView } from '../oauth/codex-account-store.js';
+import { buildDashboardStatusLines } from './dashboard-status-lines.js';
+import { buildFirstScreenBand } from './first-screen-band.js';
+import { runNexusShow, type NexusShowResult } from '../cli/nexus-show.js';
 import {
   workingDirSegment, sessionCwdSegment, modelSegment, gitSegment,
   ctxBarSegment, costSegment, speedSegment, elapsedSegment, cacheSegment,
@@ -2099,6 +2104,35 @@ export function createDashboardLogSearchOpener(deps: {
   };
 }
 
+export function renderDashboardFirstScreenBand(input: {
+  readonly history: ReadonlyArray<{ role: string }>;
+  readonly lines: string[];
+  readonly width: number;
+  readonly draw: () => void;
+  readonly observe: (data: { daemon: boolean; hasPwa: boolean; hasTailnet: boolean }) => void;
+  readonly show?: () => Promise<Pick<NexusShowResult, 'status' | 'urls'>>;
+}): Promise<void> {
+  if (input.history.some((message) => message.role !== 'system')) return Promise.resolve();
+  const band = buildFirstScreenBand({ width: input.width, daemon: false });
+  input.lines.unshift(...band);
+  const show = input.show ?? (() => runNexusShow({ format: 'json', out: { log: () => {}, error: () => {} } }));
+  const observe = (data: { daemon: boolean; hasPwa: boolean; hasTailnet: boolean }): void => {
+    try { input.observe(data); } catch { /* observation cannot interrupt the transcript */ }
+  };
+  return Promise.resolve().then(show).then((result) => {
+    const daemon = result.status !== 'absent';
+    const pwa = result.urls?.pwa;
+    const hasPwa = !!pwa;
+    const hasTailnet = !!pwa?.tailnet;
+    observe({ daemon, hasPwa, hasTailnet });
+    if (input.lines[1] !== band[1]) return;
+    input.lines[1] = buildFirstScreenBand({ width: input.width, daemon, pwa })[1]!;
+    try { input.draw(); } catch { /* screen may have closed */ }
+  }).catch(() => {
+    observe({ daemon: false, hasPwa: false, hasTailnet: false });
+  });
+}
+
 export async function showDashboard(opts: ShowDashboardOptions = {}): Promise<DashboardAction> {
   const dashboardQuitConfirmationState = createQuitConfirmationState();
   const signalQuitConfirmationState = createQuitConfirmationState();
@@ -6329,19 +6363,34 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     draw,
   });
 
-  const getDashboardStatusLines = () => [
-    'Dashboard status',
-    ...buildSessionDashboardStatusLines(resolveSessionSurfaceStatus({ chatModeState })).map(
-      line => `  ${line}`,
-    ),
-    `  view: ${workingDir.view}`,
-    `  focus: ${workingDir.focus}`,
-    `  cwd: ${workingDir.cwd}`,
-    `  preview: ${dockedPreview.sourceMode}`,
-    `  starterClosed: ${closedStarterPanes().length ? closedStarterPanes().map((pane) => paneLabel(pane)).join(', ') : 'none'}`,
-    `  chatOnly: ${effectiveChatOnlyMode() ? 'on' : 'off'}${chatOnlyMode ? ' (manual)' : ''}`,
-    `  acp: ${dashboardAcpChat.isBusy() ? 'busy' : 'idle'}`,
-  ];
+  let daemonAttached = false;
+  const getDashboardStatusLines = () => {
+    const cfg = getUserConfig();
+    const active = inspectActiveProvider(cfg);
+    const reasoningProvider = (['openai-codex', 'openai', 'anthropic', 'gemini', 'grok', 'local', 'openrouter'] as const)
+      .find(provider => active.provider === provider || active.provider === `auto:${provider}`);
+    return buildDashboardStatusLines({
+      provider: active.provider,
+      model: active.model,
+      reasoning: reasoningProvider
+        ? modelSupportsReasoning(reasoningProvider, active.model)
+          ? reasoningLevelLabel(effectiveReasoningLevel(cfg.llm, reasoningProvider, active.model))
+          : '미지원'
+        : undefined,
+      daemonAddress: opts.remote?.url,
+      daemonConnected: daemonAttached,
+      accountName: active.provider === 'openai-codex' || active.provider === 'auto:openai-codex'
+        ? activeCodexAccountView().name : undefined,
+      sessionSurfaceLines: buildSessionDashboardStatusLines(resolveSessionSurfaceStatus({ chatModeState })),
+      view: String(workingDir.view),
+      focus: workingDir.focus,
+      cwd: workingDir.cwd,
+      preview: dockedPreview.sourceMode,
+      starterClosed: closedStarterPanes().length ? closedStarterPanes().map((pane) => paneLabel(pane)).join(', ') : 'none',
+      chatOnly: `${effectiveChatOnlyMode() ? 'on' : 'off'}${chatOnlyMode ? ' (manual)' : ''}`,
+      acp: dashboardAcpChat.isBusy() ? 'busy' : 'idle',
+    });
+  };
 
   bootDashboardSlashExecutor({
     initDashboardSlashExecutor,
@@ -7190,6 +7239,21 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
   // and after each user-initiated skill cursor change.
   const skillView: SkillViewState = createSkillViewState(LOCAL_SKILLS_DIR);
   try { refreshSkills(skillView); refreshSkillFiles(skillView); } catch { /* missing root fine */ }
+  // SK2 — a skill the index could not read is a one-line notice with the repair command, never a crash.
+  try {
+    getSkillIndex();
+    const problems = skillIndexProblems();
+    const notice = skillRepairNotice(problems);
+    if (notice) chatLines.push(C.info(notice));
+    // ER1 — tell operations too (consented · scrubbed · async); a kept unsent report is retried once a day.
+    void import('../error-report/report.js').then(async ({ reportError, retryPendingErrorReport }) => {
+      await retryPendingErrorReport();
+      for (const p of problems.slice(0, 3)) {
+        const outcome = await reportError({ code: 'skill-index', message: `${p.name}: ${p.code ?? ''} ${p.error}`.trim(), surface: 'tui' });
+        if (outcome.sent && outcome.reportId) { chatLines.push(C.muted(`  운영팀에 알렸습니다 (보고 번호 ${outcome.reportId})`)); }
+      }
+    }).catch(() => { /* reporting never breaks the dashboard */ });
+  } catch { /* the notice is advisory */ }
 
   // Scratch visibility (Phase S5). When closed, the workingDir
   // layouts drop the scratch cell so the remaining panes expand
@@ -15381,6 +15445,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         ...(opts.remote ? {
           remote: opts.remote,
           onRemoteDisconnect: () => {
+            daemonAttached = false;
             pushChatLine(C.warning('  ⚠ 데몬 연결이 끊겼다 · 입력 중인 글은 그대로다 · 다시 붙으려면 TUI 를 다시 띄워라'));
             draw();
           },
@@ -15594,6 +15659,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         },
     });
     const dashboardAcpSession: DashboardSession = dashboardAcpBootResult.session;
+    daemonAttached = !!opts.remote && dashboardAcpBootResult.mode !== 'in-process';
     // ⭐ `B3` — 턴 중 발화를 «도는 턴»에 넣을 때 쓰는 키.
     try { acpSessionIdRef.current = dashboardAcpSession.currentSessionId ?? null; } catch { /* 없으면 넣지 않는다 */ }
     pushDebugLine(C.muted('[acp-boot] dashboard ACP session ready'));
@@ -15686,6 +15752,13 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       }
     }
     chatScrollOffset = -1;
+    void renderDashboardFirstScreenBand({
+      history: chat.history,
+      lines: chatLines,
+      width: Math.max(0, termSize().cols - 4),
+      draw: () => draw(),
+      observe: (data) => { try { debug.log('dashboard.first-screen-band', 'resolved', data); } catch { /* observation is best-effort */ } },
+    });
 
     while (true) {
       draw();

package/src/dashboard/provider-slash-runtime.ts

@@ -8,7 +8,7 @@ export interface DashboardProviderRotationEntryView {
 export interface DashboardProviderAvailabilityView {
   available: boolean;
   name: string;
-  model: string;
+  model: string | undefined;
 }
 
 export interface DashboardProviderSlashRuntimeDeps {
@@ -31,6 +31,7 @@ export interface DashboardProviderSlashRuntime {
   overviewLines(
     rotationEntries: readonly DashboardProviderRotationEntryView[],
     providers: readonly DashboardProviderAvailabilityView[],
+    catalogModelIds?: ReadonlySet<string>,
   ): string[];
 }
 
@@ -48,25 +49,41 @@ export function createDashboardProviderSlashRuntime(
     switchedLine: (label, provider, model) => deps.success(`  ✓ switched → ${label}  (${providerDetail(provider, model)})`),
     resetEmptyLine: () => deps.warning('  rotation empty — nothing to reset'),
     resetLine: (label) => deps.success(`  ✓ reset → ${label}`),
-    overviewLines: (rotationEntries, providers) => {
+    overviewLines: (rotationEntries, providers, catalogModelIds) => {
       const lines = ['', deps.accent('\u276f /provider')];
       if (rotationEntries.length > 0) {
-        lines.push(deps.muted('  Rotation (cycle with `/provider next` or `/provider use <label>`):'));
+        lines.push(deps.muted('  회전(바꾸기: /provider next · /provider use <이름>)'));
         for (const entry of rotationEntries) {
           const marker = entry.current ? deps.success('▸') : ' ';
-          lines.push(`  ${marker} ${entry.label.padEnd(14)} ${deps.subtext(entry.provider)}  ${deps.muted(entry.model)}`);
+          const missing = catalogModelIds && entry.model !== '(provider default)' && !catalogModelIds.has(entry.model)
+            ? deps.muted(' · 목록에 없는 모델 — /provider use 로 바꾸기')
+            : '';
+          lines.push(`  ${marker} ${entry.label.padEnd(14)} ${deps.subtext(entry.provider)}  ${deps.muted(entry.model)}${missing}`);
         }
         lines.push('');
       }
-      lines.push(deps.muted('  Available providers (env-detected):'));
+      lines.push(deps.muted('  쓸 수 있는 공급자'));
+      // PROVIDERS has anthropic, not claude; collapse the legacy claude display alias.
+      const canonicalName = (name: string): string => {
+        const lower = name.toLowerCase();
+        return lower === 'claude' ? 'anthropic' : lower;
+      };
+      const unique = new Map<string, DashboardProviderAvailabilityView>();
       for (const provider of providers) {
-        const mark = provider.available ? deps.success('\u2713') : deps.muted('\u00B7');
-        const label = provider.available ? deps.text(provider.name) : deps.muted(provider.name);
-        const hint = !provider.available
-          ? deps.muted(`  (set ${provider.name.toUpperCase()}_API_KEY${provider.name === 'local' ? ' or LOCAL_LLM_URL' : ''})`)
-          : '';
-        lines.push(`  ${mark} ${label.padEnd(20)} ${deps.subtext(provider.model)}${hint}`);
+        const key = canonicalName(provider.name);
+        const previous = unique.get(key);
+        if (!previous || (!previous.available && provider.available) || (key === provider.name && previous.name !== key && previous.available === provider.available)) {
+          unique.set(key, provider);
+        }
+      }
+      let unavailable = 0;
+      for (const provider of unique.values()) {
+        if (!provider.available) { unavailable++; continue; }
+        lines.push(`  ${deps.success('\u2713')} ${deps.text(provider.name).padEnd(20)} ${deps.subtext(provider.model ?? '')}`);
       }
+      if (unavailable > 0) lines.push(deps.muted(`  그 밖 ${unavailable}개는 키·로그인 필요 — elanous setup llm`));
+      // Keep the old English search terms as a subordinate hint, not section headings.
+      lines.push(deps.muted('  · Rotation (cycle with /provider next) · Available providers'));
       return lines;
     },
   };

package/src/dashboard/slash-runtime/dashboard-handlers.ts

@@ -301,6 +301,7 @@ import {
 import type { LLMProviderName } from '../../user-config.js';
 import { lookupLlmTierSpec } from '../../model-tier/index.js';
 import { listProviders } from '../../llm.js';
+import { enabledModels, loadCatalog } from '../../intelligence-map/model-catalog.js';
 import { selfOrchestrateRuntime } from '../../self-dev/self-orchestrate-runtime.js';
 import type { ToolRuntime } from '../../tool-runtime/types.js';
 import { getSessionCwd } from '../../session/working-dir.js';
@@ -742,6 +743,7 @@ export interface DashboardSlashContext {
       overviewLines(
         rotation: readonly { label: string; provider: string; model: string; current: boolean }[],
         providers: readonly { available: boolean; name: string; model: string | undefined }[],
+        catalogModelIds?: ReadonlySet<string>,
       ): readonly string[];
     };
     /** 2026-05-05 — open the visual model picker programmatically.
@@ -1370,8 +1372,8 @@ export function buildDashboardSlashRegistry(): SlashCommandRegistry<DashboardSla
     ctx.attachmentRowMap.clear();
     ctx.clearLogSearch();
     ctx.clearLogFilter();
-    ctx.pushDebugLine(ctx.muted('Status cleared'));
-    ctx.chatLines.push(ctx.muted('Status cleared'));
+    ctx.pushDebugLine(ctx.muted('Chat log cleared'));
+    ctx.chatLines.push(ctx.muted('Chat log cleared'));
     ctx.setChatScrollOffset(-1);
   });
 
@@ -5281,6 +5283,13 @@ export function buildDashboardSlashRegistry(): SlashCommandRegistry<DashboardSla
     const cfgNow = getUserConfig();
     const rot = cfgNow.llm.rotation;
     const curIdx = rot && rot.length > 0 ? currentRotationIndex(cfgNow) : -1;
+    let catalogModelIds: Set<string> | undefined;
+    try {
+      const loaded = loadCatalog();
+      if (loaded.source !== 'fallback') {
+        catalogModelIds = new Set(enabledModels(loaded.catalog).map((model) => model.id));
+      }
+    } catch { /* catalog unreadable: no stale-model verdict */ }
     ctx.chatLines.push(...ctx.provider.slashRuntime.overviewLines(
       (rot ?? []).map((entry, index) => ({
         label: rotationEntryLabel(entry),
@@ -5293,6 +5302,7 @@ export function buildDashboardSlashRegistry(): SlashCommandRegistry<DashboardSla
         name: provider.name,
         model: provider.model,
       })),
+      catalogModelIds,
     ));
     const currentRoute = currentRouteDecision('dashboard');
     if (currentRoute) ctx.chatLines.push(ctx.muted(`  current route: ${formatRouteDecisionSummary(currentRoute)}`));

package/src/dashboard/slash-runtime/help-from-registry.ts

@@ -3,7 +3,9 @@ import { visibleWidth } from '../../tui.js';
 
 const ESSENTIAL_KEYS = [
   ['Enter', 'Send message'],
-  ['Esc', 'Clear input / close help modal'],
+  // U1 · 2026-10-02 — stopping and queueing while an answer streams were missing from help (same line count:
+  // the modal has a row budget and falls back to the chat log when it is exceeded).
+  ['Esc', 'Stop the answer (Esc again = rewind) · clear input / close help'],
   ['Ctrl+U', 'Clear text before cursor'],
   ['Ctrl+W', 'Delete previous word'],
   ['Ctrl+← / →', 'Move by word'],
@@ -11,7 +13,7 @@ const ESSENTIAL_KEYS = [
   ['Home / End', 'Move to start / end of line'],
   ['Ctrl+A / E', 'Move to start / end of line'],
   ['PgUp / PgDn', 'Scroll chat log'],
-  ['Ctrl+↑', 'Recall sent line while streaming'],
+  ['Ctrl+↑', 'Recall a queued line (Enter while answering queues it)'],
 ] as const;
 
 function fitLine(text: string, width: number): string {

package/src/dashboard/turn-stream-formatter.ts

@@ -236,7 +236,7 @@ export function createTurnStreamFormatter(
     },
     onToolCall(call: TurnStreamCall): void {
       toolCallCount += 1;
-      deps.thinking.update(`Streaming ${call.name} (${toolCallCount} tools)`);
+      deps.thinking.update(`Streaming ${call.name} (${toolCallCount} ${toolCallCount === 1 ? 'tool' : 'tools'})`);
       const ptyLine = deps.ptyCallLine(call.name, call.args);
       if (ptyLine) {
         nonGenericCallIds.add(call.id);

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. */
+export 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 {