elanous 0.2.9 → 0.2.11

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

@@ -0,0 +1,48 @@
+import { contextNow, type ContextFact, type ContextNowAnswer, type ContextNowDeps } from './context-now.js';
+
+export function readSlashContextNow(args: string[], deps?: ContextNowDeps): ContextNowAnswer {
+  return contextNow({ topic: args.join(' ').trim() }, deps);
+}
+
+function factText(fact: ContextFact): string {
+  switch (fact.kind) {
+    case 'version': return fact.version;
+    case 'cell': return `${fact.id} ${fact.title} (${fact.status})`;
+    case 'decision': return `${fact.id} ${fact.title} (${fact.status})`;
+    case 'seat': return `${fact.seat} ${fact.id ?? ''} ${fact.title ?? ''} (${fact.status})`.trim();
+  }
+}
+
+export function renderTelegramNow(answer: ContextNowAnswer): string {
+  const rows = [
+    ['판', answer.facts.filter(f => f.kind === 'version')],
+    ['칸', answer.facts.filter(f => f.kind === 'cell')],
+    ['결정', answer.facts.filter(f => f.kind === 'decision')],
+    ['자리', answer.facts.filter(f => f.kind === 'seat')],
+  ] as const;
+  const lines = rows.map(([label, facts]) => `${label}: ${facts.length ? facts.map(f => `${factText(f)} — ${f.source}`).join(' · ') : '없음'}`);
+  lines.push(`최근: ${answer.events.length ? answer.events.map(e => `${e.summary} — ${e.source}`).join(' · ') : '없음'}${answer.guide.length ? ` · 안내 ${answer.guide.join(' · ')}` : ''}`);
+  return lines.map(line => line.replace(/\s+/g, ' ').trim()).join('\n');
+}
+
+export function renderTuiNow(answer: ContextNowAnswer): string[] {
+  const rows = [
+    ...answer.facts.map(f => [f.kind, factText(f), f.source]),
+    ...answer.events.map(e => [e.kind, e.summary, e.source]),
+    ...answer.guide.map(guide => ['안내', guide, '']),
+  ];
+  return [
+    `지금${answer.topic ? ` · ${answer.topic}` : ''} (${answer.at})`,
+    '| 종류 | 사실 | 출처 |',
+    '| --- | --- | --- |',
+    ...rows.map(row => `| ${row.map(cell => cell.replaceAll('|', '\\|').replaceAll(/\r?\n/g, ' ')).join(' | ')} |`),
+  ];
+}
+
+export function telegramNowSlash(args: string[], deps?: ContextNowDeps): string {
+  return renderTelegramNow(readSlashContextNow(args, deps));
+}
+
+export function tuiNowSlash(args: string[], deps?: ContextNowDeps): string[] {
+  return renderTuiNow(readSlashContextNow(args, deps));
+}

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

@@ -0,0 +1,104 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { debug, redactSecretText } from '../debug/log.js';
+import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { listChecklist, devVersion, type Checklist } from '../release-loop/checklist.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { seatDay, seatLedgerPath, type SeatEntry } from '../seat-loop/seat-loop.js';
+import { listCoordEvents, type CoordEvent } from './coord-events.js';
+
+export type ContextFact =
+  | { kind: 'version'; version: string; source: string }
+  | { kind: 'cell'; version: string; id: string; title: string; status: string; owner: string | null; source: string }
+  | { kind: 'decision'; id: string; title: string; status: string; dueAt: string | null; source: string }
+  | { kind: 'seat'; seat: string; at: string; status: string; id: string | null; title: string | null; source: string };
+export type ContextEvent = { at: string; kind: string; summary: string; source: string };
+export type ContextNowAnswer = { at: string; topic: string | null; facts: ContextFact[]; events: ContextEvent[]; guide: string[] };
+
+export interface ContextNowDeps {
+  now?: () => Date;
+  version?: () => string;
+  checklist?: (version: string) => Checklist;
+  decisions?: () => DecisionEntry[];
+  seatEntries?: (now: Date) => Array<{ entry: SeatEntry; source: string }>;
+  events?: (since: string) => CoordEvent[];
+}
+
+function todaySeatEntries(now: Date): Array<{ entry: SeatEntry; source: string }> {
+  const root = effectiveInstanceRoot();
+  const day = seatDay(now);
+  return ['OP', 'TC', 'MK', 'UX'].flatMap(seat => {
+    const path = seatLedgerPath(seat, root, now);
+    if (!existsSync(path)) return [];
+    return readFileSync(path, 'utf8').split('\n').flatMap((line, index) => line.trim() ? [{
+      entry: JSON.parse(line) as SeatEntry,
+      source: `elanous://seat-loop/${seat}/${day}#${index + 1}`,
+    }] : []);
+  });
+}
+
+/** Read a bounded, source-labelled view of current ledgers, never a transcript or decision body. */
+export function contextNow(options: { topic?: string; limit?: number } = {}, deps: ContextNowDeps = {}): ContextNowAnswer {
+  const now = (deps.now ?? (() => new Date()))();
+  const at = `${now.toISOString().slice(0, 16)}:00.000Z`;
+  const topic = options.topic?.trim() || null;
+  const limit = typeof options.limit === 'number' && Number.isFinite(options.limit)
+    ? Math.max(1, Math.min(100, Math.floor(options.limit))) : 20;
+  const version = (deps.version ?? devVersion)().replace(/-.*$/, '');
+  const next = version.replace(/^(\d+)\.(\d+)\.(\d+)$/, (_, major: string, minor: string, patch: string) => `${major}.${minor}.${Number(patch) + 1}`);
+  const facts: ContextFact[] = [];
+  for (const v of [...new Set([version, next])]) {
+    const checklist = (deps.checklist ?? listChecklist)(v);
+    if (v === version) facts.push({ kind: 'version', version: v, source: `elanous://release/${v}/checklist` });
+    for (const item of checklist.items) {
+      if (item.status === 'done') continue;
+      facts.push({ kind: 'cell', version: v, id: item.id, title: redactSecretText(item.title.split(/\r?\n/, 1)[0] ?? '').slice(0, 120),
+        status: item.status, owner: item.owner ?? null, source: `elanous://release/${v}/checklist#${encodeURIComponent(item.id)}` });
+    }
+  }
+  for (const item of (deps.decisions ?? (() => new DecisionLedger().list({ status: 'open' })))()) {
+    if (item.status !== 'open') continue;
+    facts.push({ kind: 'decision', id: item.id, title: redactSecretText(item.title.split(/\r?\n/, 1)[0] ?? '').slice(0, 120),
+      status: item.status, dueAt: item.dueAt ?? null, source: `elanous://decisions/${encodeURIComponent(item.id)}` });
+  }
+  for (const { entry, source } of (deps.seatEntries ?? todaySeatEntries)(now)) {
+    facts.push({ kind: 'seat', seat: entry.seat, at: entry.at, status: entry.status,
+      id: entry.item?.id ?? null, title: entry.item?.source === 'checklist'
+        ? 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 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 ?? ''}`)));
+  const groups = (['version', 'cell', 'decision', 'seat'] as const).map(kind => selectedFacts.filter(f => f.kind === kind));
+  groups[3]!.sort((a, b) => (a.kind === 'seat' && b.kind === 'seat' ? b.at.localeCompare(a.at) : 0));
+  const nonEmpty = groups.filter(group => group.length > 0);
+  const perKind = Math.floor(limit / nonEmpty.length);
+  const chosen = groups.map(group => group.splice(0, perKind));
+  let remaining = limit - chosen.reduce((total, group) => total + group.length, 0);
+  for (const index of [2, 3, 0, 1]) {
+    if (remaining <= 0) break;
+    if (chosen[index]!.length === 0 && groups[index]!.length > 0) {
+      chosen[index]!.push(...groups[index]!.splice(0, 1));
+      remaining--;
+    }
+  }
+  for (const index of [1, 2, 3, 0]) {
+    if (remaining <= 0) break;
+    const extra = groups[index]!.splice(0, remaining);
+    chosen[index]!.push(...extra);
+    remaining -= extra.length;
+  }
+  const boundedFacts = chosen.flat();
+  const summaries = chronologicalEvents.map(event => ({
+    at: event.at, kind: event.kind, summary: redactSecretText(event.summary.split(/\r?\n/, 1)[0] ?? '').slice(0, 120),
+    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('📌안내'))
+    .filter(event => matches(event.summary)).reverse().slice(0, limit)
+    .map(event => `📌 ${event.summary} — ${event.source}`);
+  const answer = { at, topic, facts: boundedFacts, events: selectedEvents, guide };
+  debug.log('context.now', 'answer', { topic, facts: answer.facts, events: answer.events });
+  return answer;
+}

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

@@ -0,0 +1,115 @@
+import type { Database } from 'bun:sqlite';
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { debug, redactSecretText } from '../debug/log.js';
+import { openSurfaceEventsDb, recordEvent, surfaceEventsDbPath } from '../domains/surface-events.js';
+
+export interface CoordEventInput {
+  seat: string;
+  recipients: string[];
+  all: boolean;
+  kind: string | null;
+  slot: string | null;
+  deadline: string | null;
+  url: string | null;
+  headline: string;
+  at?: string;
+}
+
+export interface CoordEvent {
+  id: string;
+  at: string;
+  text: string;
+  summary: string;
+  kind: string;
+  refs: Pick<CoordEventInput, 'seat' | 'recipients' | 'all' | 'kind' | 'slot' | 'deadline' | 'url'> & { origin?: string; source?: string };
+}
+
+function seatIds(): Set<string> {
+  return new Set((JSON.parse(readFileSync(resolve(import.meta.dir, '../../scripts/coord-tracks.json'), 'utf8')) as
+    { tracks: Array<{ id: string }> }).tracks.map((track) => track.id));
+}
+const kinds = new Set(['요청', '결정', '사고', '보고', '정정']);
+
+/** Mirror the sender's ordered envelope fields; only the first line enters this parser. */
+export function parseCoordHeader(seat: string, header: string): Omit<CoordEventInput, 'url' | 'at'> {
+  const first = header.split(/\r?\n/, 1)[0] ?? '';
+  if (!first.startsWith(`**[${seat}]**`)) throw new Error('조율 글 신원 접두 불일치');
+  const headline = first.slice(`**[${seat}]**`.length)
+    .replace(/^\s*(?:📌안내\s*)?\d{4}-\d\d-\d\d\s+\d\d:\d\d\s+KST\s*/, '').trim();
+  const headerBody = first.slice(`**[${seat}]**`.length);
+  const arrow = headerBody.indexOf('→');
+  const envelope = arrow >= 0 && !headerBody.slice(0, arrow).includes(' · ') ? headerBody.slice(arrow + 1).trim() : '';
+  const fields = envelope ? envelope.split(' · ') : [];
+  const ids = seatIds();
+  const recipients: string[] = [];
+  let all = false;
+  let i = 0;
+  for (; i < fields.length; i++) {
+    const field = fields[i]!.trim().split(' — ')[0]!;
+    const tokens = field.replaceAll(',', ' ').split(/\s+/).filter(Boolean);
+    if (!tokens.length || !tokens.every((t) => t === '전원' || ids.has(t))) break;
+    for (const token of tokens) {
+      if (token === '전원') all = true;
+      else recipients.push(token);
+    }
+    if (fields[i]!.includes(' — ')) { i++; break; }
+  }
+  const candidate = fields[i]?.trim() ?? '';
+  const kind = kinds.has(candidate) ? candidate : null;
+  const slot = fields[i + 1]?.trim() || null;
+  const deadline = fields.slice(i + 1).map((f) => f.trim()).find((f) => /^기한\s+\S/.test(f)) ?? null;
+  return { seat, recipients, all, kind, slot, deadline, headline };
+}
+
+/** Atomic lookup+insert makes retries safe, including URL-less posts in the same minute. */
+export function recordCoordEvent(input: CoordEventInput, deps: { db?: Database } = {}): string {
+  const hasUrl = !!input.url;
+  let db: Database | undefined;
+  try {
+    db = deps.db ?? openSurfaceEventsDb();
+    const at = input.at ?? new Date().toISOString();
+    const first = input.headline.split(/\r?\n/, 1)[0] ?? '';
+    const withoutPrefix = first.replace(/^\*\*\[[A-Z]+\]\*\*\s*/, '')
+      .replace(/^(?:📌안내\s*)?\d{4}-\d\d-\d\d\s+\d\d:\d\d\s+KST\s*/, '');
+    const headline = redactSecretText(withoutPrefix).trim().slice(0, 120);
+    const safe = (value: string) => redactSecretText(value.split(/\r?\n/, 1)[0] ?? '');
+    const refs = { seat: safe(input.seat), recipients: input.recipients.map(safe), all: input.all,
+      kind: input.kind === null ? null : safe(input.kind), slot: input.slot === null ? null : safe(input.slot),
+      deadline: input.deadline === null ? null : safe(input.deadline), url: input.url ? safe(input.url) : null };
+    const result = db.transaction(() => {
+      const prior = (refs.url
+        ? db!.prepare(`SELECT id FROM events WHERE surface='coord:channel' AND json_extract(refs,'$.url')=? LIMIT 1`).get(refs.url)
+        : db!.prepare(`SELECT id FROM events WHERE surface='coord:channel' AND json_extract(refs,'$.url') IS NULL
+            AND json_extract(refs,'$.seat')=? AND summary=? AND substr(ts,1,16)=? LIMIT 1`)
+          .get(refs.seat, headline, at.slice(0, 16))) as { id: string } | null;
+      if (prior) return { id: prior.id, dedup: true };
+      return { id: recordEvent(db!, { surface: 'coord:channel', direction: 'outbound', kind: refs.kind ?? 'unknown',
+        domain: 'elanous', category: 'coordination', text: headline, summary: headline,
+        refs: JSON.stringify(refs), ts: at }), dedup: false };
+    }).immediate();
+    try { debug.log('context.coord', result.dedup ? 'dedup' : 'recorded', { seat: refs.seat, kind: refs.kind, hasUrl }); }
+    catch { /* observation cannot turn a successful write into a failed send */ }
+    return result.id;
+  } catch (error) {
+    try { debug.log('context.coord', 'failed', { seat: redactSecretText(input.seat), kind: input.kind && redactSecretText(input.kind), hasUrl }); }
+    catch { /* preserve the original write error */ }
+    throw error;
+  } finally { if (!deps.db) db?.close(); }
+}
+
+/** Read-only chronological list; a missing store is an empty ledger, not a newly created one. */
+export function listCoordEvents(opts: { since: string; seat?: string }, deps: { db?: Database } = {}): CoordEvent[] {
+  if (!deps.db && !existsSync(surfaceEventsDbPath())) return [];
+  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>=?
+      ${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;
+      }>;
+    return rows.map((r) => ({ id: r.id, at: r.ts, text: r.text, summary: r.summary, kind: r.kind,
+      refs: JSON.parse(r.refs) as CoordEvent['refs'] }));
+  } finally { if (!deps.db) db.close(); }
+}

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

@@ -0,0 +1,52 @@
+import type { Database } from 'bun:sqlite';
+import { debug, redactSecretText } from '../debug/log.js';
+import { openSurfaceEventsDb, recordEvent } from '../domains/surface-events.js';
+
+export type ExternalEventOrigin = 'claude-code' | 'codex-agent-mission' | 'harness-child';
+export type ContextHookKind = 'claimed' | 'done' | 'asked' | 'guide-changed';
+export type ExternalEventKind = ContextHookKind | 'started' | 'finished';
+export const CONTEXT_SUMMARY_MAX = 120;
+export const CONTEXT_SOURCE_MAX = 512;
+
+export interface ExternalEventInput {
+  origin: ExternalEventOrigin;
+  kind: ExternalEventKind;
+  summary: string;
+  source: string;
+  at?: string;
+}
+
+/** Only a single, bounded, redacted summary and a locator enter the journal; no prompt or transcript. */
+export function recordExternalEvent(input: ExternalEventInput, deps: { db?: Database } = {}): string {
+  if (!['claude-code', 'codex-agent-mission', 'harness-child'].includes(input.origin)) throw new Error('invalid context origin');
+  if (input.origin === 'claude-code'
+    ? !['claimed', 'done', 'asked', 'guide-changed'].includes(input.kind)
+    : !['started', 'finished'].includes(input.kind)) throw new Error('invalid context kind');
+  const summary = redactSecretText(input.summary.split(/\r?\n/, 1)[0] ?? '').trim().slice(0, CONTEXT_SUMMARY_MAX);
+  const source = redactSecretText(input.source.split(/\r?\n/, 1)[0] ?? '').trim();
+  if (!summary) throw new Error('context summary must be one nonempty line');
+
+  if (!/^(?:https?:\/\/|elanous:\/\/)[^\s]+$/.test(source) || source.length > CONTEXT_SOURCE_MAX) {
+    throw new Error('context source must be a link (http(s) or elanous://), at most 512 characters');
+  }
+  const db = deps.db ?? openSurfaceEventsDb();
+  try {
+    return recordEvent(db, {
+      surface: 'context:external', direction: 'outbound', domain: 'elanous', category: 'coordination',
+      kind: input.kind, text: summary, summary,
+      refs: JSON.stringify({ seat: input.origin, recipients: [], all: false, kind: input.kind,
+        slot: null, deadline: null, url: source, origin: input.origin, source }),
+      ...(input.at ? { ts: input.at } : {}),
+    });
+  } finally { if (!deps.db) db.close(); }
+}
+
+/** Instrumentation never changes an agent's result. Failures remain visible without logging untrusted payloads. */
+export function observeExternalEvent(input: ExternalEventInput, record: typeof recordExternalEvent = recordExternalEvent): void {
+  try { record(input); }
+  catch (error) {
+    try { debug.log('context.external', 'record-failed', {
+      origin: input.origin, kind: input.kind, reason: error instanceof Error ? error.message : String(error),
+    }, { level: 'warn' }); } catch { /* A broken logger cannot change an agent's result. */ }
+  }
+}

package/src/context-bus/long-term-memory.ts

@@ -0,0 +1,108 @@
+import { redactSecretText } from '../debug/log.js';
+import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { listCoordEvents, type CoordEvent } from './coord-events.js';
+
+export interface MemoryItem {
+  project: string;
+  seat: string;
+  topic: string;
+  summary: string;
+  source: string;
+  updatedAt: string;
+  status: 'active' | 'retired';
+  /** A normalized, comparable assertion supplied by the summarizer; absent means no conflict judgment. */
+  claim?: { key: string; value: string };
+  conflict?: { owner: 'OP'; sources: [string, string] };
+}
+
+export type MemorySource =
+  | { kind: 'event'; at: string; seat: string; text: string; source: string }
+  | { kind: 'decision'; at: string; seat: string; text: string; source: string };
+
+export interface MemorySummary {
+  project: string;
+  topic: string;
+  summary: string;
+  /** Only supply this when the two strings identify the same fact and mutually exclusive values. */
+  claim?: { key: string; value: string };
+}
+
+export interface MemoryDeps {
+  summarize: (source: MemorySource) => Promise<MemorySummary>;
+  events?: (since: string) => CoordEvent[];
+  decisions?: () => DecisionEntry[];
+}
+
+const DAY_MS = 86_400_000;
+const oneLine = (text: string) => redactSecretText(text.split(/\r?\n/, 1)[0] ?? '').trim();
+
+/** Condense one UTC day; callers persist the returned snapshot, not raw transcripts. Read-only ledger access. */
+export async function condenseContextDay(
+  day: string, previous: readonly MemoryItem[], deps: MemoryDeps, now: Date = new Date(),
+): Promise<MemoryItem[]> {
+  if (!/^\d{4}-\d\d-\d\d$/.test(day) || new Date(`${day}T00:00:00.000Z`).toISOString().slice(0, 10) !== day) {
+    throw new Error('day must be a valid UTC YYYY-MM-DD');
+  }
+  const since = `${day}T00:00:00.000Z`;
+  const start = Date.parse(since);
+  const until = start + DAY_MS;
+  // The store compares timestamp text, so fetch the previous local day too before UTC filtering.
+  const events = (deps.events ?? (from => listCoordEvents({ since: from })))(new Date(start - DAY_MS).toISOString());
+  const decisions = (deps.decisions ?? (() => new DecisionLedger().list({ status: 'all' })))();
+  const sources: MemorySource[] = [
+    ...events.map(event => ({ kind: 'event' as const, at: event.at, seat: event.refs.seat,
+      text: event.summary, source: event.refs.source ?? event.refs.url ?? `elanous://context/event/${encodeURIComponent(event.id)}` })),
+    ...decisions.map(decision => ({ kind: 'decision' as const,
+      at: decision.decidedAt ?? decision.raisedAt ?? decision.importedAt ?? '',
+      seat: decision.raisedBy.track ?? 'OP',
+      text: decision.status === 'decided' ? `${decision.title}: ${decision.options.find(o => o.key === decision.choice)?.label ?? decision.note ?? decision.scqa.a ?? '결정됨'}` : `${decision.title}: ${decision.status}`,
+      source: `elanous://decisions/${encodeURIComponent(decision.id)}` })),
+  ].filter(source => {
+    const at = Date.parse(source.at);
+    return Number.isFinite(at) && at >= start && at < until;
+  }).sort((a, b) => Date.parse(a.at) - Date.parse(b.at) || a.source.localeCompare(b.source));
+
+  const items = new Map<string, MemoryItem>();
+  const keyFor = (item: Pick<MemoryItem, 'project' | 'seat' | 'topic'>) => JSON.stringify([item.project, item.seat, item.topic]);
+  for (const item of previous) items.set(keyFor(item), { ...item });
+  for (const source of sources) {
+    const summary = await deps.summarize(source);
+    const project = oneLine(summary.project);
+    const seat = oneLine(source.seat);
+    const topic = oneLine(summary.topic);
+    const text = oneLine(summary.summary);
+    const link = oneLine(source.source);
+    if (!project || !seat || !topic || !text || !/^(?:https?:\/\/|elanous:\/\/)[^\s]+$/.test(link)) {
+      throw new Error('memory summary needs a project, seat, topic, one-line summary and source link');
+    }
+    const claim = summary.claim && { key: oneLine(summary.claim.key), value: oneLine(summary.claim.value) };
+    if (claim && (!claim.key || !claim.value)) throw new Error('memory claim needs key and value');
+    const key = keyFor({ project, seat, topic });
+    const old = items.get(key);
+    // Equal timestamps are resolved by the source link, so shuffled input does not change the winner.
+    if (old && (Date.parse(old.updatedAt) > Date.parse(source.at)
+      || (Date.parse(old.updatedAt) === Date.parse(source.at) && old.source >= link))) continue;
+    items.set(key, { project, seat, topic, summary: text, source: link, updatedAt: source.at,
+      status: 'active', ...(claim ? { claim } : {}) });
+  }
+  const cutoff = now.getTime() - 30 * DAY_MS;
+  // Compare only the winning, non-retired assertions; a superseded claim cannot keep a decision candidate alive.
+  const finalItems: MemoryItem[] = [...items.values()].map(({ conflict: _conflict, ...item }) => ({ ...item,
+    status: Date.parse(item.updatedAt) < cutoff ? 'retired' as const : 'active' as const,
+  }));
+  finalItems.sort((a, b) => Date.parse(a.updatedAt) - Date.parse(b.updatedAt) || a.source.localeCompare(b.source)
+    || a.seat.localeCompare(b.seat));
+  for (let index = 0; index < finalItems.length; index++) {
+    const item = finalItems[index]!;
+    if (item.status !== 'active' || !item.claim) continue;
+    const { key, value } = item.claim;
+    const conflicting = finalItems.slice(0, index).find(other => other.status === 'active'
+      && other.project === item.project
+      && other.claim?.key === key && other.claim.value !== value);
+    if (conflicting) {
+      finalItems[index] = { ...item, conflict: { owner: 'OP', sources: [conflicting.source, item.source] } };
+    }
+  }
+  return finalItems.sort((a, b) => a.project.localeCompare(b.project) || a.seat.localeCompare(b.seat)
+    || a.topic.localeCompare(b.topic));
+}

package/src/dashboard/dashboard-boot-fixture.ts

@@ -0,0 +1,23 @@
+import { showDashboard } from './index.js';
+
+const expected = process.env.DASHBOARD_BOOT_SUGGESTION;
+if (!expected) throw new Error('DASHBOARD_BOOT_SUGGESTION is required');
+
+const originalWrite = process.stdout.write.bind(process.stdout);
+let screen = '';
+process.stdout.write = ((chunk: string | Uint8Array, ...args: unknown[]) => {
+  screen += typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8');
+  if (screen.includes(expected)) {
+    originalWrite(`FIRST_SCREEN_SUGGESTION=${expected}\n`);
+    process.exit(0);
+  }
+  return true;
+}) as typeof process.stdout.write;
+
+setTimeout(() => {
+  originalWrite(`FIRST_SCREEN_TIMEOUT=${screen.slice(-2000)}\n`);
+  process.exit(1);
+}, 20_000).unref();
+
+await showDashboard();
+throw new Error('dashboard exited before suggestion appeared');

package/src/dashboard/index.ts

@@ -17,6 +17,8 @@ import type { CommandRunner } from '../ad-pipeline/higgsfield-backend.js';
 import type { ShootRunOptions } from '../ad-pipeline/shoot-run.js';
 import type { QcThresholds } from '../ad-pipeline/qc.js';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { suggestProjectForFolder } from '../project/project-store.js';
+import { createProjectSuggester } from '../project/project-suggestion.js';
 
 const dashboardDefaultShootRunOptions: Required<Pick<ShootRunOptions, 'pollIntervalMs' | 'maxPollsPerJob' | 'submitStaggerMs'>> = {
   pollIntervalMs: 3_000,
@@ -425,7 +427,6 @@ import {
   renderTurnTypeaheadEcho,
 } from '../chat/turn-typeahead.js';
 import { dispatchStreamingTurnTypeaheadSubmission } from './input/streaming-turn-typeahead.js';
-import { wireDashboardTurnTypeaheadEcho } from './turn-typeahead-echo.js';
 import { composeVertical, type LayoutZone } from '../layout/composer.js';
 import type { CoreTurnDispatchTool } from '../core-turn/index.js';
 // streamGrok kept as back-compat shim in chat.ts — not imported here
@@ -2656,6 +2657,41 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     }
     chatScrollOffset = -1;
   };
+  const liveTypeaheadEchoes: { at: number; lines: string[] }[] = [];
+  const restoreLiveTypeaheadEchoes = (): void => {
+    let after = 0;
+    for (const echo of liveTypeaheadEchoes) {
+      let found = -1;
+      for (let i = after; i <= chatLines.length - echo.lines.length; i++) {
+        if (echo.lines.every((line, offset) => chatLines[i + offset] === line)) {
+          found = i;
+          break;
+        }
+      }
+      if (found < 0) {
+        found = Math.max(after, Math.min(echo.at, chatLines.length));
+        chatLines.splice(found, 0, ...echo.lines);
+      }
+      echo.at = found;
+      after = found + echo.lines.length;
+    }
+  };
+  const echoSubmittedUserText = (text: string, opts?: { live?: boolean }): void => {
+    const echoStart = chatLines.length;
+    chatLines.push('');
+    if (opts?.live) chatLines.push(C.muted('  ↳ 이어서'));
+    const echoWrapCols = Math.max(20, termSize().cols - 6);
+    const echoRows = wrapAnsiByWidth(`❯ ${text}`, echoWrapCols);
+    if (echoRows.length === 0) {
+      chatLines.push(C.accent('❯ '));
+    } else {
+      echoRows.forEach((row, i) => {
+        chatLines.push(C.accent(i === 0 ? row : `  ${row}`));
+      });
+    }
+    if (opts?.live) liveTypeaheadEchoes.push({ at: echoStart, lines: chatLines.slice(echoStart) });
+    chatScrollOffset = -1;
+  };
   const pushDebugLine = (line: string): void => {
     debugLines.push(line);
     const dropCount = trimLogBuffer(debugLines, DEBUG_LOG_BUFFER_SOFT_LIMIT);
@@ -6907,7 +6943,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             turnTypeaheadRef.state = r.state;
             if (r.submissionDisposition) {
               debug.log('dashboard.turn-typeahead', 'submission-classified', {
-                text: r.immediateSubmission ?? turnTypeaheadRef.state.queuedSubmissions.at(-1),
+                length: (r.immediateSubmission ?? turnTypeaheadRef.state.queuedSubmissions.at(-1))?.length ?? 0,
                 disposition: r.submissionDisposition,
               });
               // ⭐⭐⭐ `B3`(2026-08-19 · 대표 지시 ②) — FIFO 로 «턴 종료 후» 나가던 것을,
@@ -6934,6 +6970,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                     // 배수된 만큼을 앞에서부터 떨어낸다(FIFO · 순서 보존).
                     const remaining = turnTypeaheadRef.state.queuedSubmissions.slice(drained.length);
                     turnTypeaheadRef.state = { ...turnTypeaheadRef.state, queuedSubmissions: remaining };
+                    for (const text of drained) {
+                      echoSubmittedUserText(text, { live: true });
+                      debug.log('dashboard.turn-typeahead', 'echoed', { path: 'live', length: text.length });
+                    }
+                    if (drained.length > 0) draw();
                     debug.log('dashboard.turn-typeahead', 'drained-into-live-turn', {
                       drained: drained.length, remaining: remaining.length,
                     });
@@ -15751,6 +15792,16 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
         chatLines.push(C.muted(`    ${resume.turns} turns restored. Next turn continues this conversation.`));
       }
     }
+    // 제안은 세션 작업 폴더 기준 — 시작 폴더 한 번이 아니라 폴더가 바뀔 때마다 다시 계산한다(IA1 리뷰 must-fix).
+    const nextProjectSuggestion = createProjectSuggester(suggestProjectForFolder);
+    const pushProjectSuggestion = (folder: string): void => {
+      const project = nextProjectSuggestion(folder);
+      if (project) chatLines.push(C.muted(`  Project suggestion: ${project.name} (${project.id})`));
+    };
+    if (dashboardAcpBootResult.mode !== 'resumed' && !chat.history.some((message) => message.role !== 'system')) {
+      pushProjectSuggestion(getSessionCwd());
+    }
+    subscribeSessionCwd((state) => { pushProjectSuggestion(state.cwd); });
     chatScrollOffset = -1;
     void renderDashboardFirstScreenBand({
       history: chat.history,
@@ -16820,8 +16871,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           lastTurnFinalStatus = undefined;
           turnTypeaheadRef.state = drained.state;
           nextInitial = drained.nextInitial;
-          const turnTypeaheadEcho = wireDashboardTurnTypeaheadEcho(drained);
-          if (turnTypeaheadEcho) chatLines.push(C.muted(turnTypeaheadEcho));
+          const queuedTurnEndText = drained.injectEnter ? drained.nextInitial : undefined;
           if (interrupted && queuedBeforeDrain > 0) {
             debug.log('dashboard.turn-typeahead', 'restored-after-interrupt', { count: queuedBeforeDrain });
           }
@@ -18655,25 +18705,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           // pattern. Without this draw(), the echo sits in the chatLines
           // array but doesn't paint until after the skill router's
           // classifier LLM call returns (~1-2s of visual silence).
-          chatLines.push('');
-          // Wrap the echoed user message to the log width so long input
-          // soft-wraps onto continuation rows instead of being truncated
-          // with a `\u2026+N` marker by the log-pane renderer (which keeps a
-          // strict 1-line-per-row invariant and only truncates lines that
-          // weren't pre-wrapped). termCols-6 leaves room for the log
-          // pane's 2-col left margin plus the 2-col hanging indent on
-          // continuation rows; the \u276f marker stays on the first row only.
-          const echoWrapCols = Math.max(20, termSize().cols - 6);
-          const echoRows = wrapAnsiByWidth(`\u276f ${tok.text}`, echoWrapCols);
-          if (echoRows.length === 0) {
-            chatLines.push(C.accent('\u276f '));
-          } else {
-            echoRows.forEach((row, i) => {
-              chatLines.push(C.accent(i === 0 ? row : `  ${row}`));
-            });
+          echoSubmittedUserText(tok.text);
+          if (queuedTurnEndText !== undefined && input.text === queuedTurnEndText) {
+            debug.log('dashboard.turn-typeahead', 'echoed', { path: 'turn-end', length: queuedTurnEndText.length });
           }
           renderAttachmentSummary(tok.added);
-          chatScrollOffset = -1;
           draw();
 
           // Start the animated thinking indicator BEFORE the router so
@@ -19031,6 +19067,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             createTurnStreamRuntime: (initialAssistantStart) => {
               latestTurnUsage = undefined;
               createDashboardTurnStreamRuntimeEscBoundary(escAbortToolState);
+              liveTypeaheadEchoes.length = 0;
               const toolRendering = {
                 ...getUserConfig().chat.rendering.tool,
                 expandHint: false,
@@ -19070,6 +19107,11 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
               });
               return {
                 ...turnStreamRuntime,
+                onText: (chunk, accumulated) => {
+                  turnStreamRuntime.onText(chunk, accumulated);
+                  restoreLiveTypeaheadEchoes();
+                  draw();
+                },
                 onToolCall: (call) => {
                   const toolCall = call as DashboardTurnStreamCall;
                   trackEscAbortToolCall(escAbortToolState, toolCall);

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

@@ -272,6 +272,8 @@
 // `../index.ts`) instead of importing the type — keeps this module free
 // of circular dependency on dashboard/index.ts.
 
+import { tuiNowSlash } from '../../context-bus/context-now-surfaces.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
 // surfaces (CLI, PWA panel, this) cannot answer differently.
@@ -1358,9 +1360,13 @@ function emitReplyToChat(ctx: Pick<DashboardSlashContext, 'pushChatLine'>, line:
   ctx.pushChatLine(line);
 }
 
-export function buildDashboardSlashRegistry(): SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn> {
+export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn> {
   const registry = new SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn>();
 
+  registry.register(['now'], (args, ctx) => {
+    for (const line of tuiNowSlash(args, nowDeps)) ctx.pushChatLine(line);
+  });
+
   // ── B-1.a pilot ────────────────────────────────────────────────────
   registry.register(['quit', 'q', 'exit'], (_args, ctx) => {
     (ctx.exitTui ?? ctx.closeTui)();
@@ -3995,6 +4001,13 @@ export function buildDashboardSlashRegistry(): SlashCommandRegistry<DashboardSla
     }
 
     if (seSub === 'new' || seSub === 'clear') {
+      if (seSub === 'new') {
+        try {
+          const { suggestProjectForFolder } = await import('../../project/project-store.js');
+          const project = suggestProjectForFolder(process.cwd());
+          if (project) ctx.chatLines.push(ctx.muted(`  Project suggestion: ${project.name} (${project.id})`));
+        } catch { /* suggestions must not interrupt a new conversation */ }
+      }
       // Clear the in-memory history and detach if attached. Doesn't
       // delete any session files — those stay on disk for
       // /session list to enumerate.