elanous 0.2.13 → 0.2.15

package/src/dashboard/slash-runtime/chat-persona.ts

@@ -0,0 +1,66 @@
+import { awaitGlobalPersonaLoad, getGlobalPersonaRegistry } from '../../persona/global-registry.js';
+import { resolvePersonaAddress } from '../../intake-plane/persona-answer.js';
+import { loadSession, updateSessionMeta } from '../../session/index.js';
+import { assemblePersonaPrompt } from '../../persona/prompt-assembler.js';
+import type { LLMMessage } from '../../llm.js';
+
+/** Unattached conversations use a dashboard-local id; attached sessions use persisted metadata. */
+export class TuiChatPersonaSelection {
+  private readonly selected = new Map<string, string>();
+
+  get(sessionId: string): string | undefined {
+    return loadSession(sessionId)?.meta.chatPersonaId ?? this.selected.get(sessionId);
+  }
+
+  set(sessionId: string, personaId: string | undefined): void {
+    const meta = updateSessionMeta(sessionId, (m) => {
+      if (personaId) m.chatPersonaId = personaId;
+      else delete m.chatPersonaId;
+    });
+    if (!meta) {
+      if (personaId) this.selected.set(sessionId, personaId);
+      else this.selected.delete(sessionId);
+    } else {
+      this.selected.delete(sessionId);
+    }
+  }
+}
+
+export async function handleTuiChatPersona(
+  args: readonly string[], sessionId: string,
+  selection: TuiChatPersonaSelection,
+): Promise<string> {
+  if (args[0] === '-') {
+    if (args.length !== 1) return '쓰는 법: /persona [이름|-]';
+    selection.set(sessionId, undefined);
+    return '이 대화의 페르소나를 뺐습니다';
+  }
+  try {
+    await awaitGlobalPersonaLoad();
+    const registry = getGlobalPersonaRegistry();
+    if (!args.length) {
+      const selected = selection.get(sessionId);
+      const personas = registry.list().sort((a, b) => a.displayName.localeCompare(b.displayName));
+      const current = personas.find(p => p.personaId === selected);
+      return `이 대화의 페르소나: ${current ? `${current.displayName} (${current.personaId})` : '없음'}\n고를 수 있는 페르소나: ${personas.map(p => `${p.displayName} (${p.personaId})${p.personaId === selected ? ' (지금)' : ''}`).join(' · ') || '없음'}\n고르기: /persona <이름> · 빼기: /persona -`;
+    }
+    const name = args.join(' ');
+    const persona = resolvePersonaAddress(name, registry);
+    if (!persona) return `그런 페르소나가 없습니다: ${name}`;
+    selection.set(sessionId, persona.personaId);
+    return `${persona.displayName} 페르소나를 이 대화에 골랐습니다`;
+  } catch {
+    return '페르소나 목록을 읽지 못했습니다';
+  }
+}
+
+export function tuiChatPersonaMessages(
+  sessionId: string, selection: TuiChatPersonaSelection,
+): LLMMessage[] {
+  const id = selection.get(sessionId);
+  if (!id) return [];
+  const persona = getGlobalPersonaRegistry().get(id);
+  if (!persona) return [];
+  const prompt = assemblePersonaPrompt(persona, '').systemPrompt;
+  return prompt ? [{ role: 'system', content: prompt }] : [];
+}

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

@@ -273,6 +273,7 @@
 // of circular dependency on dashboard/index.ts.
 
 import { tuiNowSlash } from '../../context-bus/context-now-surfaces.js';
+import { handleTuiChatPersona, type TuiChatPersonaSelection } from './chat-persona.js';
 import { createWishCard } from '../../intake-plane/wish-card.js';
 import { CardStore } from '../../task-cards/card-store.js';
 import type { ContextNowDeps } from '../../context-bus/context-now.js';
@@ -390,6 +391,8 @@ import { resolveTerminalMoveDestination } from '../../terminal-matrix/mobility.j
 import { loadPersistedSessions } from '../../terminal/session-persistence.js';
 import { dispatchTerminalModalObserve } from '../../skills/tools/terminal-modal.js';
 import { SlashCommandRegistry } from './registry.js';
+import { cronSecondDueAt, filterLoopRows, formatLoopsTable, localLoopRows, type LoopsTableRow } from './loops-table.js';
+import { loopCronVerdict } from '../../loops/verdict.js';
 import { executeImmediateDashboardSlash } from '../input/slash-executor.js';
 import {
   buildContextSlashCommand,
@@ -1029,6 +1032,7 @@ export interface DashboardSlashContext {
   /** Currently-attached session id (TUI's pointer to a JSONL on disk). */
   getAttachedSessionId(): string | null;
   setAttachedSessionId(id: string | null): void;
+  chatPersona?: { sessionId(): string; selection: TuiChatPersonaSelection; newConversation?(): void };
   /** Telegram chat id paired with the attached session, when handed off. */
   getAttachedChatId(): number | null;
   setAttachedChatId(id: number | null): void;
@@ -1038,6 +1042,9 @@ export interface DashboardSlashContext {
     send: (cfg: ReturnType<typeof getUserConfig>, text: string) => Promise<boolean>;
   };
 
+  /** Test seam for the local read-only loop and cron registry. */
+  loopsLocalRows?: (now: Date) => LoopsTableRow[];
+
   sessionSlash: {
     /** opts.remote — when the dashboard is attached to a remote daemon. */
     remoteDaemon(): { url: string; token: string | undefined } | null;
@@ -1364,6 +1371,28 @@ function emitReplyToChat(ctx: Pick<DashboardSlashContext, 'pushChatLine'>, line:
   ctx.pushChatLine(line);
 }
 
+async function fetchLoopsDaemonJson<T>(url: string, headers: Record<string, string>): Promise<T> {
+  const controller = new AbortController();
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      (async () => {
+        const response = await fetch(url, { headers, signal: controller.signal });
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        return await response.json() as T;
+      })(),
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => {
+          controller.abort();
+          reject(new Error('request timed out'));
+        }, 1_000);
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
 export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn> {
   const registry = new SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn>();
 
@@ -1371,6 +1400,61 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
     for (const line of tuiNowSlash(args, nowDeps)) ctx.pushChatLine(line);
   });
 
+  registry.register('loops', async (args, ctx) => {
+    if (args.length > 1) {
+      ctx.pushChatLine(ctx.warning('  usage: /loops [owner]'));
+      return;
+    }
+    const now = new Date(Date.now());
+    let rows: LoopsTableRow[] = [];
+    const remote = ctx.sessionSlash.remoteDaemon();
+    if (remote) {
+      const base = deriveDaemonHttpBase(remote.url);
+      if (base) {
+        try {
+          const headers: Record<string, string> = remote.token ? { authorization: `Bearer ${remote.token}` } : {};
+          const body = await fetchLoopsDaemonJson<{ schedules?: Array<{ name: string; domain?: string | null; runVia?: string | null;
+            source: string; cron?: string | null; state: string; lastRun?: { at: string; status: string | null; exit: number | null } | null;
+            intervalMs?: number | null }> }>(`${base}/v1/schedules?includeOff=1`, headers);
+          rows = (body.schedules ?? []).map(schedule => ({
+            layer: 'daemon cron', name: schedule.name, owner: schedule.domain ?? '—', mode: schedule.runVia ?? schedule.source,
+            lastRun: schedule.lastRun?.at ?? null,
+            verdict: loopCronVerdict({ enabled: schedule.state !== 'off', lastRunAt: schedule.lastRun?.at ?? null,
+              lastStatus: schedule.lastRun?.exit != null && schedule.lastRun.exit !== 0 ? 'failed' : schedule.lastRun?.status ?? null,
+              intervalMs: schedule.intervalMs ?? null,
+              secondDueAt: cronSecondDueAt(schedule.cron ?? null, schedule.lastRun?.at ?? null) }, now.getTime()),
+          }));
+        } catch (err) {
+          ctx.pushChatLine(ctx.warning(`  daemon cron unavailable: ${err instanceof Error ? err.message : String(err)}`));
+        }
+        try {
+          const headers: Record<string, string> = remote.token ? { authorization: `Bearer ${remote.token}` } : {};
+          const body = await fetchLoopsDaemonJson<{ loops?: { loops?: Array<{
+            name: string; label: string; armed: boolean | null; category?: string;
+            last: { at: string; status: string } | null;
+          }> } | null }>(`${base}/v1/dashboard/loops`, headers);
+          // dashboardLoops returns LoopStatus (no owner field). Its category is
+          // exec/reflect, not an owner; keep ownership unknown rather than
+          // attributing every daemon loop to a guessed domain.
+          rows.push(...(body.loops?.loops ?? []).map(loop => ({
+            layer: 'daemon loop', name: loop.label || loop.name, owner: '—', mode: loop.category ?? 'loop',
+            lastRun: loop.last?.at ?? null,
+            verdict: loopCronVerdict({ enabled: loop.armed !== false, lastRunAt: loop.last?.at ?? null,
+              lastStatus: loop.last?.status ?? null, intervalMs: null }, now.getTime()),
+          })));
+        } catch (err) {
+          ctx.pushChatLine(ctx.warning(`  daemon loops unavailable: ${err instanceof Error ? err.message : String(err)}`));
+        }
+      }
+    }
+    try { rows.push(...(ctx.loopsLocalRows ?? localLoopRows)(now)); }
+    catch (err) { ctx.pushChatLine(ctx.warning(`  local loops unavailable: ${err instanceof Error ? err.message : String(err)}`)); }
+    const filtered = filterLoopRows(rows, args[0]);
+    for (const line of formatLoopsTable(filtered, text => ctx.error(text))) ctx.pushChatLine(`  ${line}`);
+    if (!filtered.length) ctx.pushChatLine(ctx.muted('  No loops or cron jobs found.'));
+    ctx.setChatScrollOffset(-1);
+  });
+
   registry.register('wish', (args, ctx) => {
     const text = args.join(' ').trim();
     if (!text) {
@@ -1427,6 +1511,16 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
     }
   });
 
+  registry.register('persona', async (args, ctx) => {
+    if (!ctx.chatPersona) {
+      ctx.pushChatLine(ctx.warning('  페르소나를 사용할 수 없습니다'));
+    } else {
+      const text = await handleTuiChatPersona(args, ctx.chatPersona.sessionId(), ctx.chatPersona.selection);
+      for (const line of text.split('\n')) ctx.pushChatLine(ctx.muted(`  ${line}`));
+    }
+    ctx.setChatScrollOffset(-1);
+  });
+
   registry.register('directive', async (args, ctx) => {
     try {
       const { addDirective } = await import('../../steward/directive.js');
@@ -4042,6 +4136,7 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
       const prev = attached;
       ctx.setAttachedSessionId(null);
       ctx.setAttachedChatId(null);
+      ctx.chatPersona?.newConversation?.();
       const chatHistory = ctx.compactSlash.chatHistory;
       const sysFromDash = chatHistory.find(m => m.role === 'system');
       chatHistory.length = 0;
@@ -4151,6 +4246,10 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
           sessionAppendMessage(meta.id, { role: m.role, content, ts: nowTs });
         }
         sessionAttachTelegram(meta.id, chatTarget);
+        if (ctx.chatPersona) {
+          const selected = ctx.chatPersona.selection.get(ctx.chatPersona.sessionId());
+          if (selected) ctx.chatPersona.selection.set(meta.id, selected);
+        }
         ctx.setAttachedSessionId(meta.id);
         ctx.setAttachedChatId(chatTarget);
         ctx.chatLines.push(ctx.success(`  ✓ attached session ${meta.id.slice(0, 8)} → chat ${chatTarget}  (${chatHistory.length} turns mirrored)`));

package/src/dashboard/slash-runtime/loops-table.ts

@@ -0,0 +1,77 @@
+import { Database } from 'bun:sqlite';
+import { existsSync } from 'node:fs';
+import { listLoops, type LoopEntry } from '../../loops/registry.js';
+import { loopCronVerdict, type LoopCronVerdict } from '../../loops/verdict.js';
+import { listSchedules, schedulesDbPath, type ScheduleRow } from '../../domains/schedule-registry.js';
+import { nextRuns } from '../../domains/schedule-state.js';
+
+export interface LoopsTableRow {
+  layer: string;
+  name: string;
+  owner: string;
+  mode: string;
+  lastRun: string | null;
+  verdict: LoopCronVerdict;
+}
+
+/** Read the already-inventoried local registry without opening/migrating a writable store. */
+export function localLoopRows(now: Date): LoopsTableRow[] {
+  let schedules: ScheduleRow[] = [];
+  if (existsSync(schedulesDbPath())) {
+    const db = new Database(schedulesDbPath(), { readonly: true });
+    try { schedules = listSchedules(db); } finally { db.close(); }
+  }
+  const loops = listLoops({ schedules, now });
+  const rows: LoopsTableRow[] = loops.map(loop => graphLoopRow(loop, schedules, now));
+  const graphJobIds = new Set(loops.flatMap(loop => loop.jobs.map(job => job.id)));
+  for (const schedule of schedules) {
+    if (graphJobIds.has(schedule.id)) continue;
+    rows.push(scheduleRow(schedule, 'local cron', now));
+  }
+  return rows;
+}
+
+export function cronSecondDueAt(cron: string | null, lastRun: string | null): string | null {
+  if (!cron || !lastRun) return null;
+  const last = new Date(lastRun);
+  if (!Number.isFinite(last.getTime())) return null;
+  return nextRuns(cron, last, 2)[1] ?? null;
+}
+
+export function graphLoopRow(loop: LoopEntry, schedules: ScheduleRow[], now: Date): LoopsTableRow {
+  const active = loop.jobs.map(job => schedules.find(row => row.id === job.id)).filter((r): r is ScheduleRow => !!r);
+  const cron = loop.trigger.cron ?? active[0]?.cron ?? null;
+  const interval = active.find(r => r.interval_ms && r.interval_ms > 0)?.interval_ms ?? null;
+  const lastRun = loop.lastRun?.at ?? active.map(r => r.last_run).filter((at): at is string => !!at).sort().at(-1) ?? null;
+  const status = loop.lastRun?.status ?? active.find(r => r.last_run === lastRun)?.last_status ?? null;
+  return {
+    layer: 'local loop', name: loop.title, owner: loop.owner ?? '—', mode: loop.mode ?? (loop.trigger.cron ? 'cron' : 'event'), lastRun,
+    verdict: loopCronVerdict({ enabled: loop.enabled, lastRunAt: lastRun, lastStatus: status, intervalMs: interval,
+      secondDueAt: cronSecondDueAt(cron, lastRun) }, now.getTime()),
+  };
+}
+
+export function scheduleRow(row: ScheduleRow, layer: string, now: Date): LoopsTableRow {
+  return {
+    layer, name: row.name, owner: row.domain ?? '—', mode: row.run_via || row.source,
+    lastRun: row.last_run,
+    verdict: loopCronVerdict({ enabled: !!row.enabled && row.disabled_reason !== 'vanished', lastRunAt: row.last_run,
+      lastStatus: row.last_exit !== null && row.last_exit !== undefined && row.last_exit !== 0 ? 'failed' : row.last_status ?? null,
+      intervalMs: row.interval_ms, secondDueAt: cronSecondDueAt(row.cron, row.last_run) }, now.getTime()),
+  };
+}
+
+export function filterLoopRows(rows: LoopsTableRow[], owner?: string): LoopsTableRow[] {
+  return owner ? rows.filter(row => row.owner !== '—' && row.owner.toLowerCase() === owner.toLowerCase()) : rows;
+}
+
+export function formatLoopsTable(rows: LoopsTableRow[], verdictColor: (text: string) => string): string[] {
+  const columns = ['LAYER', 'NAME', 'OWNER', 'MODE', 'LAST RUN', 'VERDICT'];
+  const data = rows.map(r => [r.layer, r.name, r.owner, r.mode, r.lastRun ?? '—', r.verdict]);
+  const widths = columns.map((col, i) => Math.max(col.length, ...data.map(cells => cells[i]!.length)));
+  const format = (cells: string[]) => cells.map((cell, i) => cell.padEnd(widths[i]!)).join('  ');
+  return [format(columns), ...rows.map((row, i) => {
+    const cells = data[i]!;
+    return `${format(cells.slice(0, 5))}  ${row.verdict === 'late' || row.verdict === 'failed' ? verdictColor(cells[5]!) : cells[5]}`;
+  })];
+}

package/src/decisions/decision-cards.ts

@@ -28,6 +28,7 @@ export interface CardTransport {
 const IRREVERSIBLE = new Set(['money', 'publish', 'security', 'irreversible', 'secret']);
 export const DECISION_DATA_PREFIX = 'dec:';
 const REMIND_BEFORE_MS = 2 * 3600_000;
+const WEBPUSH_MAX_SEND_ATTEMPTS = 3;
 
 export function isIrreversible(entry: Pick<DecisionEntry, 'category'>): boolean {
   return IRREVERSIBLE.has(entry.category);
@@ -99,7 +100,8 @@ 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 }>;
+  cards: Record<string, { refs: CardRef[]; closed?: boolean; remindedAt?: string; note?: string; attempts?: number; noSubscribers?: boolean }>;
+  testOriginQuestions?: Record<string, true>;
 }
 
 export interface DecisionCardServiceOptions {
@@ -165,16 +167,27 @@ export class DecisionCardService {
       for (const record of pending.questions) {
         for (const question of record.questions) {
           const data = { questionId: record.id, runId: record.runId };
+          const logSkip = (reason: string): void => debug.log('hitl.card-bridge', 'skipped', { ...data, reason });
+          // Path is not provenance: operational goals can live under the OS temporary directory too.
+          if (record.testOrigin === true) {
+            state.testOriginQuestions ??= {};
+            if (!state.testOriginQuestions[record.id]) {
+              state.testOriginQuestions[record.id] = true;
+              dirty = true;
+              debug.log('hitl.card-bridge', 'skipped', { ...data, reason: 'test-origin' });
+            }
+            continue;
+          }
           if (record.expiresAt && record.expiresAt <= this.now().toISOString()) {
-            debug.log('hitl.card-bridge', 'skipped', { ...data, reason: 'expired' });
+            logSkip('expired');
             continue;
           }
           if (question.impact !== 'high' && question.impact !== 'critical') {
-            debug.log('hitl.card-bridge', 'skipped', { ...data, reason: 'impact' });
+            logSkip('impact');
             continue;
           }
           if (record.questions.length !== 1 || question.options.length < 2 || question.options.length > 4) {
-            debug.log('hitl.card-bridge', 'skipped', { ...data, reason: 'options' });
+            logSkip('options');
             continue;
           }
           if (seen.has(record.id)) {
@@ -200,7 +213,7 @@ export class DecisionCardService {
             all.unshift(entry);
             debug.log('hitl.card-bridge', 'raised', { ...data, decisionId: entry.id });
           } catch (error) {
-            debug.log('hitl.card-bridge', 'skipped', { ...data, reason: error instanceof Error ? error.name : 'unknown' });
+            logSkip(error instanceof Error ? error.name : 'unknown');
           }
         }
       }
@@ -208,13 +221,26 @@ export class DecisionCardService {
     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) {
+      if (e.status === 'open' && (!card || (platform === 'webpush' && !card.refs.length && (card.attempts ?? 0) < WEBPUSH_MAX_SEND_ATTEMPTS))
+        && e.options.length >= 2 && e.raisedAt !== undefined && e.raisedAt >= state.since) {
+        if (platform === 'webpush' && !chats.length) {
+          if (!card?.noSubscribers) {
+            state.cards[e.id] = { ...(card ?? { refs: [] }), noSubscribers: true };
+            dirty = true;
+            debug.log('decisions.webpush', 'no-subscribers', { id: e.id });
+          }
+          continue;
+        }
         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++; }
+        if (platform === 'webpush') {
+          state.cards[e.id] = { ...(card ?? { refs: [] }), refs, attempts: (card?.attempts ?? 0) + 1 };
+          dirty = true;
+        } else if (refs.length) state.cards[e.id] = { refs };
+        if (refs.length) sent++;
         debug.log('decisions.telegram', 'card-sent', { platform, id: e.id, category: e.category, chats: chats.length, delivered: refs.length });
         continue;
       }

package/src/decisions/decision-ledger.ts

@@ -31,7 +31,15 @@ export interface DecisionEntry {
   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' | 'dueAt' | 'resume' | 'pendingQuestion' | 'crossCheck' | 'crossCheckSkipped' | 'alternative' | 'dissent'> & { 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 type Seat = 'OP' | 'MK' | 'TC' | 'UX';
+export interface SeatDecisionRecord {
+  id: string; title: string; decision: string; seat: Seat; delegation: string;
+  reporting: 'posthoc'; recordedAt: string;
+  /** Present only when the actual decision time is known. */
+  decidedAt?: string; versionAtDecision?: Versions; refs?: string[];
+}
+export type SeatDecisionInput = Pick<SeatDecisionRecord, 'title' | 'decision' | 'seat' | 'delegation' | 'refs'> & { decidedAt?: string };
+type Event = { type: 'raised'; entry: DecisionEntry } | { type: 'seat-recorded'; entry: SeatDecisionRecord } | { 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; writeAnswer?: typeof writePendingQuestionAnswer }
 
 /** null = the decision resumes no run; otherwise whether the answer file was written (or already matched). */
@@ -196,6 +204,7 @@ export class DecisionLedger {
     if (filters.category && !CATEGORIES.includes(filters.category)) throw new Error('invalid category');
     const map = new Map<string, DecisionEntry>();
     for (const event of this.events()) {
+      if (event.type === 'seat-recorded') continue;
       if (event.type === 'raised') {
         if (map.has(event.entry.id)) throw new Error(`duplicate decision: ${event.entry.id}`);
         map.set(event.entry.id, event.entry);
@@ -221,6 +230,36 @@ export class DecisionLedger {
       && (!filters.decidedBy || e.decidedBy?.kind === filters.decidedBy)
       && (!filters.category || e.category === filters.category)).sort((a, b) => (b.raisedAt ?? b.importedAt ?? '').localeCompare(a.raisedAt ?? a.importedAt ?? '') || a.id.localeCompare(b.id));
   }
+  /** Delegated decisions are already made: they share the append-only ledger, never the owner's open-card state machine. */
+  recordSeatDecision(input: SeatDecisionInput): SeatDecisionRecord {
+    const seat = input.seat;
+    if (!['OP', 'MK', 'TC', 'UX'].includes(seat)) throw new Error('invalid seat');
+    const title = safe(single(input.title, 'title'));
+    const decision = safe(single(input.decision, 'decision'));
+    const delegation = safe(single(input.delegation, 'delegation'));
+    const refs = input.refs?.map(ref => safe(single(ref, 'ref')));
+    const decidedAt = input.decidedAt === undefined ? undefined : utc(input.decidedAt);
+    return this.locked(() => {
+      const existing = this.seatReport();
+      if (refs?.some(ref => existing.some(entry => entry.seat === seat && entry.title === title && entry.decision === decision && entry.refs?.includes(ref)))) throw new Error('seat decision source already recorded');
+      const recordedAt = utc(this.now().toISOString());
+      const prefix = `SD-${recordedAt.slice(0, 10).replaceAll('-', '')}-`;
+      const next = existing.reduce((n, entry) => entry.id.startsWith(prefix) ? Math.max(n, Number(entry.id.slice(prefix.length)) + 1) : n, 1);
+      const entry: SeatDecisionRecord = { id: `${prefix}${String(next).padStart(2, '0')}`, title, decision, seat, delegation,
+        reporting: 'posthoc', recordedAt, ...(decidedAt ? { decidedAt, versionAtDecision: this.version(decidedAt) } : {}), ...(refs?.length ? { refs } : {}) };
+      this.append({ type: 'seat-recorded', entry });
+      debug.log('decisions', 'seat-recorded', { id: entry.id, seat });
+      return entry;
+    });
+  }
+  seatReport(filters: { since?: string; seat?: Seat } = {}): SeatDecisionRecord[] {
+    const since = filters.since === undefined ? undefined : utc(filters.since);
+    if (filters.seat && !['OP', 'MK', 'TC', 'UX'].includes(filters.seat)) throw new Error('invalid seat');
+    return this.events().filter((event): event is Extract<Event, { type: 'seat-recorded' }> => event.type === 'seat-recorded')
+      .map(event => event.entry)
+      .filter(entry => (!since || (entry.recordedAt ?? entry.decidedAt ?? '') >= since) && (!filters.seat || entry.seat === filters.seat))
+      .sort((a, b) => (b.recordedAt ?? b.decidedAt ?? '').localeCompare(a.recordedAt ?? a.decidedAt ?? '') || a.id.localeCompare(b.id));
+  }
   show(id: string): DecisionEntry { const entry = this.list({ status: 'all' }).find(e => e.id === id); if (!entry) throw new Error(`decision not found: ${id}`); return entry; }
   raise(input: RaiseInput): DecisionEntry {
     const clean = validate(input);