elanous 0.2.11 → 0.2.12

package/src/cli/pod-memory-advice.ts

@@ -0,0 +1,35 @@
+import { readPodMemoryMeasurement, type MemoryMeasurement } from '../../scripts/measure-pod-memory-by-goal.js';
+
+export type PodMemoryAdvice = {
+  window: MemoryMeasurement['window'];
+  sources: MemoryMeasurement['sources'];
+  byGoalType: Array<{
+    goalType: MemoryMeasurement['byGoalType'][number]['goalType'];
+    recommended: 'standard' | 'high';
+    limit: '16Gi' | '32Gi';
+    reason: string;
+    evidence: MemoryMeasurement['byGoalType'][number];
+  }>;
+};
+
+/** Advice only: the launch selector and its configuration remain independent. */
+export function advisePodMemory(measurement: MemoryMeasurement): PodMemoryAdvice {
+  return {
+    window: measurement.window,
+    sources: measurement.sources,
+    byGoalType: measurement.byGoalType.map((evidence) => {
+      const high = evidence.oomKilled > 0 || (evidence.peakMiB.p95 !== null && evidence.peakMiB.p95 >= 16 * 1024);
+      const reason = evidence.oomKilled > 0
+        ? `${evidence.oomKilled}/${evidence.runs} OOMKilled; measured peak p50=${evidence.peakMiB.p50 ?? 'n/a'} MiB, p95=${evidence.peakMiB.p95 ?? 'n/a'} MiB (${evidence.measured}/${evidence.runs} measured)`
+        : evidence.measured === 0
+          ? `No measured peaks (${evidence.missingPeak}/${evidence.runs} missing); standard is provisional, not evidence of safety`
+          : `Measured peak p50=${evidence.peakMiB.p50} MiB, p95=${evidence.peakMiB.p95} MiB (${evidence.measured}/${evidence.runs} measured, ${evidence.missingPeak} missing); ${high ? 'at or above' : 'below'} 16Gi`;
+      return { goalType: evidence.goalType, recommended: high ? 'high' as const : 'standard' as const,
+        limit: high ? '32Gi' as const : '16Gi' as const, reason, evidence };
+    }),
+  };
+}
+
+export function readPodMemoryAdvice(path?: string): PodMemoryAdvice {
+  return advisePodMemory(readPodMemoryMeasurement(path));
+}

package/src/cli/release-cli.ts

@@ -26,6 +26,7 @@ import { envLiteral } from '../platform/env-literal.js';
 import { userConfigPath } from '../user-config.js';
 import { addItem, claimItem, decodeClaimHistoryEntry, devVersion, listChecklist, ownerMatches, parseOwner, parityGap, removeItem, seedFromRoadmap, setItem, summarizeChecklist, type ChecklistStatus, type ChecklistDisposition, type ChecklistKind } from '../release-loop/checklist.js';
 import * as features from '../release-loop/feature-store.js';
+import { landedButYellow, type MergedChecklistPr } from '../release-loop/landed-but-yellow.js';
 import { formatSchedule, getSchedule, listSchedules, setSchedule } from '../release-loop/release-schedule.js';
 import { writeStdoutJson } from './stdout-json.js';
 import { CliUserError } from './cli-user-error.js';
@@ -499,7 +500,13 @@ async function checklistOutput(v: string, codenames: Record<string, string>, mod
   }
 }
 
-export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}): void {
+export interface LandedButYellowDeps {
+  run?: Runner;
+  checklist?: typeof listChecklist;
+  now?: () => Date;
+}
+
+export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}, landedDeps: LandedButYellowDeps = {}): void {
   const release = program.command('release').description('공개 배포 한 판 — prepare(로컬) → publish(--yes) → verify (docs/manual/MANUAL-versioning-and-release-2026-09-25.md)');
   const schedule = release.command('schedule').description('판별 컷·착지 마감 조회·갱신');
   const scheduleLedgerRoot = () => releaseRunDeps.ledgerRoot ?? releaseLedgerRoot();
@@ -538,10 +545,43 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     const { version, codenames, json } = context(cmd);
     await checklistOutput(version, codenames, 'status', json, opts.owner);
   });
+  withContext(checklist.command('landed-but-yellow').description('병합 PR 이 있지만 노랑·빨강인 칸(읽기 전용)'))
+    .option('--owner <owner>', '자리 또는 하위 자리로 거르기')
+    .action(async (opts: { owner?: string }, cmd: Command) => {
+      const { version, json } = context(cmd);
+      try {
+        if (opts.owner !== undefined) parseOwner(opts.owner);
+        const since = new Date((landedDeps.now ?? (() => new Date()))().getTime() - 7 * 86_400_000).toISOString().slice(0, 10);
+        const raw = must((landedDeps.run ?? defaultRunner)('gh', ['pr', 'list', '--state', 'merged', '--search', `merged:>=${since}`, '--limit', '400', '--json', 'number,title,body,mergedAt'], process.cwd()), '병합 PR 조회(gh)');
+        const prs = JSON.parse(raw) as MergedChecklistPr[];
+        if (!Array.isArray(prs)) throw new Error('병합 PR 조회(gh): 배열이 아니다');
+        const items = (landedDeps.checklist ?? listChecklist)(version).items;
+        const rows = landedButYellow(items, prs, { owner: opts.owner });
+        if (json) await writeStdoutJson(`${JSON.stringify(rows)}\n`);
+        else {
+          const updatedAtById = new Map(items.map((item) => [item.id, item.updatedAt]));
+          const date = (iso: string) => {
+            const parts = new Intl.DateTimeFormat('en-US', { timeZone: 'Asia/Seoul', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }).formatToParts(new Date(iso));
+            const part = (name: string) => parts.find((entry) => entry.type === name)?.value;
+            return `${part('month')}-${part('day')} ${part('hour')}:${part('minute')}`;
+          };
+          for (const row of rows) {
+            const icon = row.status === 'yellow' ? '🟡' : '🔴';
+            console.log(`${row.id} ${row.owner ?? '-'} ${icon} ← ${row.prs.map((pr, i) => `#${pr.number} «${pr.title}» (${date(pr.mergedAt)} · 근거에 ${row.alreadyInEvidence[i] ? '있음' : '없음'}${pr.mergedAt > (updatedAtById.get(row.id) ?? '') ? ' · 칸보다 새것' : ''})`).join(' · ')}`);
+          }
+          console.log(`${rows.length}칸 · 그중 근거에 없는 PR 이 있는 칸 ${rows.filter((row) => row.alreadyInEvidence.includes(false)).length}`);
+        }
+        if (prs.length >= 400) console.error('⚠ 병합 PR 400개 상한: 목록이 잘렸을 수 있다');
+      } catch (error) {
+        console.error(`⛔ ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+      }
+    });
   withContext(checklist.command('add <id> <title>').description('칸 추가')).option('--owner <owner>', '담당').option('--kind <kind>', 'screen = 다섯 화면 짝 칸 · 근거에 짝: PWA … · 데스크톱 … · 폴드 … · 아이폰 … · 아이패드 … 한 줄')
-    .action((id: string, title: string, opts: { owner?: string; kind?: string }, cmd: Command) => {
+    .option('--allow-duplicate-id', '다른 판에 같은 id 가 있어도 경고 후 추가')
+    .action((id: string, title: string, opts: { owner?: string; kind?: string; allowDuplicateId?: boolean }, cmd: Command) => {
     const { version, json } = context(cmd);
-    const data = addItem(version, { id, title, ...(opts.owner !== undefined ? { owner: opts.owner } : {}), ...(opts.kind !== undefined ? { kind: opts.kind as ChecklistKind } : {}) });
+    const data = addItem(version, { id, title, ...(opts.owner !== undefined ? { owner: opts.owner } : {}), ...(opts.kind !== undefined ? { kind: opts.kind as ChecklistKind } : {}) }, { allowDuplicateId: opts.allowDuplicateId });
     if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${id} 추가`);
   });
   withContext(checklist.command('set <id>').description('칸 상태·근거·담당·처분 갱신'))
@@ -581,11 +621,11 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     });
   const actor = () => process.env.ELANOUS_TRACK || 'cli';
   withContext(checklist.command('move <id>').description('칸을 한 트랜잭션으로 다른 판에 옮긴다'))
-    .requiredOption('--from <v>', '현재 판').requiredOption('--to <v>', '새 판')
-    .action((id: string, opts: { from: string; to: string }, cmd: Command) => {
+    .requiredOption('--from <v>', '현재 판').requiredOption('--to <v>', '새 판').option('--reason <reason>', '이동 사유')
+    .action((id: string, opts: { from: string; to: string; reason?: string }, cmd: Command) => {
       const { codenames, json } = context(cmd);
       const from = checklistVersion(opts.from, codenames), to = checklistVersion(opts.to, codenames);
-      features.move(id, from, to, actor());
+      features.move(id, from, to, actor(), undefined, undefined, opts.reason);
       if (json) console.log(JSON.stringify(listChecklist(to))); else console.log(`✅ ${id} ${from} → ${to}`);
     });
   withContext(checklist.command('retitle <id> <title>').description('칸 제목 수정')).action((id: string, title: string, _opts: unknown, cmd: Command) => {

package/src/context-bus/context-now-surfaces.ts

@@ -4,6 +4,23 @@ export function readSlashContextNow(args: string[], deps?: ContextNowDeps): Cont
   return contextNow({ topic: args.join(' ').trim() }, deps);
 }
 
+export function seatsNowLine(answer: ContextNowAnswer, now: number): string | null {
+  const seats = [ ['OP', 'COO'], ['MK', 'CMO'], ['TC', 'CTO'], ['UX', 'CXO'] ] as const;
+  const facts = answer.facts.filter(fact => fact.kind === 'seat');
+  const lines = seats.flatMap(([seat, label]) => {
+    const latest = facts.filter(fact => fact.seat === seat)
+      .sort((a, b) => b.at.localeCompare(a.at))[0];
+    if (!latest) return [];
+    const minutes = Math.max(0, Math.floor((now - Date.parse(latest.at)) / 60_000));
+    const age = minutes >= 24 * 60 ? '하루 넘음'
+      : minutes >= 60 ? `${Math.floor(minutes / 60)}시간 전`
+      : minutes > 0 ? `${minutes}분 전` : '방금';
+    const title = latest.title?.split(/\r?\n/, 1)[0]?.trim();
+    return [`${label} ${title ? title.slice(0, 20) : latest.status} · ${age}`];
+  });
+  return lines.length ? `지금 자리들: ${lines.join(' | ')}` : null;
+}
+
 function factText(fact: ContextFact): string {
   switch (fact.kind) {
     case 'version': return fact.version;

package/src/context-bus/context-now.ts

@@ -66,7 +66,7 @@ export function contextNow(options: { topic?: string; limit?: number } = {}, dep
         ? redactSecretText(entry.item.title.split(/\r?\n/, 1)[0] ?? '').slice(0, 120) : null, source });
   }
   const rawEvents = (deps.events ?? (since => listCoordEvents({ since })))(new Date(now.getTime() - 7 * 86_400_000).toISOString());
-  const chronologicalEvents = rawEvents.slice().sort((a, b) => a.at.localeCompare(b.at) || a.id.localeCompare(b.id));
+  const chronologicalEvents = rawEvents.slice().sort((a, b) => a.at.localeCompare(b.at));
   const matches = (text: string) => !topic || text.toLocaleLowerCase().includes(topic.toLocaleLowerCase());
   const selectedFacts = facts.filter(f => !topic || (f.kind === 'cell' && matches(`${f.id} ${f.title}`))
     || (f.kind === 'seat' && matches(`${f.id ?? ''} ${f.title ?? ''}`)));
@@ -95,7 +95,7 @@ export function contextNow(options: { topic?: string; limit?: number } = {}, dep
     source: event.refs.source ?? event.refs.url ?? `elanous://context/event/${encodeURIComponent(event.id)}`,
   }));
   const selectedEvents = summaries.filter(event => matches(event.summary)).reverse().slice(0, limit);
-  const guide = summaries.filter(event => event.kind === 'guide-changed' || event.summary.startsWith('📌안내'))
+  const guide = summaries.filter(event => event.kind === 'guide-changed' || event.kind === 'guidance-changed' || event.summary.startsWith('📌안내'))
     .filter(event => matches(event.summary)).reverse().slice(0, limit)
     .map(event => `📌 ${event.summary} — ${event.source}`);
   const answer = { at, topic, facts: boundedFacts, events: selectedEvents, guide };

package/src/context-bus/coord-events.ts

@@ -22,7 +22,7 @@ export interface CoordEvent {
   text: string;
   summary: string;
   kind: string;
-  refs: Pick<CoordEventInput, 'seat' | 'recipients' | 'all' | 'kind' | 'slot' | 'deadline' | 'url'> & { origin?: string; source?: string };
+  refs: Pick<CoordEventInput, 'seat' | 'recipients' | 'all' | 'kind' | 'slot' | 'deadline' | 'url'> & { origin?: string; source?: string; ref?: string | null };
 }
 
 function seatIds(): Set<string> {
@@ -104,7 +104,7 @@ export function listCoordEvents(opts: { since: string; seat?: string }, deps: {
   const db = deps.db ?? openSurfaceEventsDb();
   try {
     const rows = db.prepare(`SELECT id, ts, text, summary, kind, refs FROM events
-      WHERE surface IN ('coord:channel', 'context:external') AND direction='outbound' AND ts>=?
+      WHERE surface IN ('coord:channel', 'context:external', 'context:session') AND direction='outbound' AND ts>=?
       ${opts.seat ? "AND json_extract(refs,'$.seat')=?" : ''} ORDER BY ts ASC, rowid ASC`)
       .all(...(opts.seat ? [opts.since, opts.seat] : [opts.since])) as Array<{
         id: string; ts: string; text: string; summary: string; kind: string; refs: string;

package/src/context-bus/nightly-condense.ts

@@ -0,0 +1,153 @@
+import { readFileSync, readdirSync, mkdirSync, writeFileSync, renameSync, existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { streamLLM } from '../llm.js';
+import { condenseContextDay, type MemoryItem, type MemorySource, type MemorySummary } from './long-term-memory.js';
+import { listCoordEvents, type CoordEvent } from './coord-events.js';
+import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { acquireLockAsync } from '../storage/file-lock.js';
+
+type Stage = 'collect' | 'condense' | 'record' | 'conflict-candidates';
+type Input = { day?: string; events?: CoordEvent[]; decisions?: DecisionEntry[]; summaries?: Record<string, MemorySummary> };
+type Context = { graphId?: string; nodeId?: string; input: Input | null; outputs: Record<string, { day?: string; events?: CoordEvent[]; decisions?: DecisionEntry[]; items?: MemoryItem[] } | null> };
+
+const dayBefore = (date: Date) => new Date(date.getTime() - 86_400_000).toISOString().slice(0, 10);
+const fileName = (value: string) => encodeURIComponent(value).replace(/\./g, '%2E');
+
+function snapshotPath(root: string, project: string, seat: string): string {
+  if (project === '.' || project === '..' || seat === '.' || seat === '..') throw new Error('invalid memory path');
+  return join(root, 'context-memory', fileName(project), `${fileName(seat)}.json`);
+}
+
+function save(file: string, value: unknown): void {
+  mkdirSync(dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  writeFileSync(temp, JSON.stringify(value, null, 2) + '\n');
+  renameSync(temp, file);
+}
+
+async function withCurrentDay<T>(root: string, day: string, write: () => T): Promise<T> {
+  const dir = join(root, 'context-memory');
+  mkdirSync(dir, { recursive: true });
+  const lock = await acquireLockAsync(join(dir, '.nightly-write.lock'));
+  try {
+    const marker = join(dir, 'latest-day');
+    const latest = latestDay(root);
+    if ((latest && latest > day) || storedItems(root).some(item =>
+      Date.parse(item.updatedAt) >= Date.parse(`${day}T00:00:00Z`) + 86_400_000)) {
+      throw new Error(`cannot replay ${day}: later project/seat memory exists`);
+    }
+    if (!lock.stillHeld()) throw new Error('nightly memory write lock lost');
+    // Reserve the day before touching either output, so a failed writer cannot let an older run overwrite it.
+    if (!latest || latest < day) save(marker, day);
+    return write();
+  } finally { lock.release(); }
+}
+
+function latestDay(root: string): string | undefined {
+  const marker = join(root, 'context-memory', 'latest-day');
+  return existsSync(marker) ? JSON.parse(readFileSync(marker, 'utf8')) as string : undefined;
+}
+
+function storedItems(root: string): MemoryItem[] {
+  const dir = join(root, 'context-memory');
+  if (!existsSync(dir)) return [];
+  const items: MemoryItem[] = [];
+  for (const project of readdirSync(dir, { withFileTypes: true })) {
+    if (!project.isDirectory()) continue;
+    for (const seat of readdirSync(join(dir, project.name))) {
+      if (!seat.endsWith('.json')) continue;
+      const content: unknown = JSON.parse(readFileSync(join(dir, project.name, seat), 'utf8'));
+      if (!Array.isArray(content)) throw new Error('invalid context memory file');
+      items.push(...content as MemoryItem[]);
+    }
+  }
+  return items;
+}
+
+async function summarize(source: MemorySource, injected?: Record<string, MemorySummary>): Promise<MemorySummary> {
+  if (injected) {
+    const result = injected[source.source];
+    if (!result) throw new Error(`missing test summary: ${source.source}`);
+    return result;
+  }
+  const response = await streamLLM([
+    { role: 'system', content: 'Summarize this one-line context event as a compact project/seat memory item. Return ONLY JSON: {"project":"...","topic":"...","summary":"...","claim":{"key":"...","value":"..."}}. Omit claim when the event makes no comparable factual assertion. Never invent a project, topic or claim.' },
+    { role: 'user', content: JSON.stringify(source) },
+  ], () => {}, { maxTokens: 350, usageRole: 'research' });
+  const parsed: unknown = JSON.parse(response.replace(/^```(?:json)?\s*|\s*```$/g, '').trim());
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('invalid memory summary');
+  const value = parsed as Record<string, unknown>;
+  if (typeof value.project !== 'string' || typeof value.topic !== 'string' || typeof value.summary !== 'string' ||
+    (value.claim !== undefined && (!value.claim || typeof value.claim !== 'object' || Array.isArray(value.claim) ||
+      typeof (value.claim as Record<string, unknown>).key !== 'string' || typeof (value.claim as Record<string, unknown>).value !== 'string'))) {
+    throw new Error('invalid memory summary');
+  }
+  return value as unknown as MemorySummary;
+}
+
+/** Stage outputs travel only through the graph runner's per-run contexts. No decision ledger write occurs here. */
+export async function runNightlyStage(stage: Stage, context: Context, root: string, dryRun: boolean, now = new Date()): Promise<Record<string, unknown>> {
+  const input = context.input ?? {};
+  if (dryRun && stage !== 'collect' && (!input.events || !input.decisions || !input.summaries)) {
+    throw new Error('dry-run requires fake events, decisions and summaries');
+  }
+  const day = context.outputs.collect?.day ?? input.day ?? dayBefore(now);
+  if (!/^\d{4}-\d\d-\d\d$/.test(day) || new Date(`${day}T00:00:00Z`).toISOString().slice(0, 10) !== day) {
+    throw new Error('invalid UTC day');
+  }
+  if (stage === 'collect') {
+    if (!dryRun && ((latestDay(root) ?? '') > day || storedItems(root).some(item =>
+      Date.parse(item.updatedAt) >= Date.parse(`${day}T00:00:00Z`) + 86_400_000))) {
+      throw new Error(`cannot replay ${day}: later project/seat memory exists`);
+    }
+    if (dryRun && (!input.events || !input.decisions || !input.summaries)) {
+      throw new Error('dry-run requires fake events, decisions and summaries');
+    }
+    const events = input.events ?? listCoordEvents({ since: new Date(Date.parse(`${day}T00:00:00Z`) - 86_400_000).toISOString() });
+    const decisions = input.decisions ?? (dryRun ? [] : new DecisionLedger().list({ status: 'all' }));
+    return { outcome: 'ok', day, events, decisions };
+  }
+  const collected = context.outputs.collect;
+  if (!collected?.day || !collected.events || !collected.decisions) throw new Error('collect output missing');
+  if (stage === 'condense') {
+    const items = await condenseContextDay(collected.day, dryRun ? [] : storedItems(root).filter(item => Date.parse(item.updatedAt) < Date.parse(`${collected.day}T00:00:00Z`)), {
+      events: () => collected.events!, decisions: () => collected.decisions!,
+      summarize: source => summarize(source, input.summaries),
+    }, now);
+    return { outcome: 'ok', items };
+  }
+  const items = context.outputs.condense?.items;
+  if (!items) throw new Error('condense output missing');
+  if (stage === 'record') {
+    const grouped = new Map<string, MemoryItem[]>();
+    for (const item of items) {
+      const file = snapshotPath(root, item.project, item.seat);
+      grouped.set(file, [...grouped.get(file) ?? [], item]);
+    }
+    if (!dryRun) await withCurrentDay(root, day, () => {
+      for (const [file, group] of grouped) save(file, group);
+    });
+    return { outcome: 'ok', files: [...grouped.keys()], items: items.length, memoryItems: dryRun ? items : undefined, dryRun };
+  }
+  if (stage === 'conflict-candidates') {
+    if (!context.outputs.record) throw new Error('record output missing');
+    const candidates = items.filter(item => item.conflict && item.status === 'active').map(item => ({
+      project: item.project, topic: item.topic, owner: item.conflict!.owner,
+      sources: item.conflict!.sources, status: 'candidate' as const,
+    }));
+    if (!dryRun) await withCurrentDay(root, day, () => save(join(root, 'context-memory', 'conflict-candidates.json'), candidates));
+    return { outcome: 'ok', candidates, published: 0 };
+  }
+  throw new Error(`unknown stage: ${stage}`);
+}
+
+if (import.meta.main) {
+  const stage = process.argv[2] as Stage;
+  const path = process.env.ELANOUS_GRAPH_CONTEXT;
+  if (!path || !['collect', 'condense', 'record', 'conflict-candidates'].includes(stage)) throw new Error('invalid nightly graph stage');
+  const context = JSON.parse(readFileSync(path, 'utf8')) as Context;
+  if (context.graphId !== 'nightly-condense' || context.nodeId !== stage) throw new Error('nightly graph context mismatch');
+  const statePath = resolve(path, '..', '..', '..', '..');
+  const result = await runNightlyStage(stage, context, statePath, process.env.ELANOUS_GRAPH_DRY_RUN === '1');
+  console.log(JSON.stringify(result));
+}

package/src/context-bus/session-events.ts

@@ -0,0 +1,35 @@
+import type { Database } from 'bun:sqlite';
+import { redactSecretText } from '../debug/log.js';
+import { openSurfaceEventsDb, recordEvent } from '../domains/surface-events.js';
+
+export const SESSION_EVENT_KINDS = ['task-claimed', 'task-done', 'asked', 'guidance-changed'] as const;
+export type SessionEventKind = typeof SESSION_EVENT_KINDS[number];
+
+export interface SessionEventInput {
+  kind: SessionEventKind;
+  seat: string;
+  text: string;
+  ref?: string;
+  at?: string;
+}
+
+/** Publish a one-line external-agent session signal to the existing context journal. */
+export function emitSessionEvent(input: SessionEventInput, deps: { db?: Database } = {}): string {
+  if (!SESSION_EVENT_KINDS.includes(input.kind)) throw new Error('unknown context session kind');
+  if (!['OP', 'TC', 'MK', 'UX'].includes(input.seat)) throw new Error('context session seat must be OP|TC|MK|UX');
+  if (/\r|\n/.test(input.text) || !input.text.trim()) throw new Error('context session text must be one nonempty line');
+  if (input.ref !== undefined && (/\r|\n/.test(input.ref) || !input.ref.trim())) throw new Error('context session ref must be one nonempty line');
+  const summary = redactSecretText(input.text).trim().slice(0, 120);
+  const ref = input.ref ?? null;
+  const db = deps.db ?? openSurfaceEventsDb();
+  try {
+    return recordEvent(db, {
+      surface: 'context:session', direction: 'outbound', domain: 'elanous', category: 'coordination',
+      kind: input.kind, text: input.text, summary,
+      refs: JSON.stringify({ seat: input.seat, recipients: [], all: false, kind: input.kind,
+        slot: null, deadline: null, url: null, ref,
+        ...(ref ? { source: `elanous://context/ref/${encodeURIComponent(ref)}` } : {}) }),
+      ...(input.at ? { ts: input.at } : {}),
+    });
+  } finally { if (!deps.db) db.close(); }
+}

package/src/dashboard/dashboard-status-lines.ts

@@ -5,6 +5,7 @@ export interface DashboardStatusLinesInput {
   readonly daemonAddress?: string | null;
   readonly daemonConnected: boolean;
   readonly accountName?: string | null;
+  readonly seatsNow?: string | null;
   readonly sessionSurfaceLines: readonly string[];
   readonly view: string;
   readonly focus: string;
@@ -31,6 +32,7 @@ export function buildDashboardStatusLines(input: DashboardStatusLinesInput): str
     `모델: ${known(input.provider)}/${known(input.model)} (${known(input.reasoning)})`,
     `연결: 데몬 ${address} ${input.daemonConnected ? '붙음' : '안 붙음'}`,
     `계정: ${input.accountName?.trim() === 'default' ? '기본' : known(input.accountName)}`,
+    ...(input.seatsNow ? [input.seatsNow] : []),
     '',
     '자세히',
     ...input.sessionSurfaceLines.map(line => `  ${line}`),

package/src/dashboard/index.ts

@@ -884,6 +884,7 @@ import { getInputHistoryStore, inputHistoryDbPath, inputHistoryJsonPath } from '
 import { inspectActiveProvider } from '../provider-summary.js';
 import { activeCodexAccountView } from '../oauth/codex-account-store.js';
 import { buildDashboardStatusLines } from './dashboard-status-lines.js';
+import { readSlashContextNow, seatsNowLine } from '../context-bus/context-now-surfaces.js';
 import { buildFirstScreenBand } from './first-screen-band.js';
 import { runNexusShow, type NexusShowResult } from '../cli/nexus-show.js';
 import {
@@ -6405,7 +6406,14 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     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}`);
+    let seatsNow: string | null = null;
+    try {
+      seatsNow = seatsNowLine(readSlashContextNow([]), Date.now());
+    } catch (error) {
+      debug.log('dashboard.status', 'seats-unreadable', { error: String(error) });
+    }
     return buildDashboardStatusLines({
+      seatsNow,
       provider: active.provider,
       model: active.model,
       reasoning: reasoningProvider

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

@@ -273,6 +273,8 @@
 // of circular dependency on dashboard/index.ts.
 
 import { tuiNowSlash } from '../../context-bus/context-now-surfaces.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';
 import { runRebindCommand } from '../../input-core/index.js';
 // B4 (TUI half) — /design reuses the CLI's own resolution so the three
@@ -422,6 +424,8 @@ export interface DashboardSlashContext {
   /** Existing TUI structured-question capability. Absent means /ask keeps
    * the self-dev noninteractive deferred-clarification contract. */
   surfaceUx?: Pick<SurfaceUx, 'question'>;
+  /** Optional wish-card store for isolated slash dispatch tests. */
+  wishCardStore?: CardStore;
   attachmentRowMap: { clear(): void };
   pushDebugLine(line: string): void;
   pushChatLine(line: string): void;
@@ -1367,6 +1371,26 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
     for (const line of tuiNowSlash(args, nowDeps)) ctx.pushChatLine(line);
   });
 
+  registry.register('wish', (args, ctx) => {
+    const text = args.join(' ').trim();
+    if (!text) {
+      ctx.pushChatLine(ctx.warning('  usage: /wish <소원 한 줄>'));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    let store: CardStore | undefined;
+    try {
+      store = ctx.wishCardStore ?? new CardStore();
+      const card = createWishCard({ text, source: 'tui', ref: crypto.randomUUID() }, store);
+      ctx.pushChatLine(ctx.success(`  소원 카드로 남겼습니다 — ${card.title}`));
+    } catch (err) {
+      ctx.pushChatLine(ctx.error(`  소원 카드 등록 실패 — ${err instanceof Error ? err.message : String(err)}`));
+    } finally {
+      if (!ctx.wishCardStore) store?.close();
+    }
+    ctx.setChatScrollOffset(-1);
+  });
+
   // ── B-1.a pilot ────────────────────────────────────────────────────
   registry.register(['quit', 'q', 'exit'], (_args, ctx) => {
     (ctx.exitTui ?? ctx.closeTui)();