elanous 0.2.16 → 0.2.18

package/src/context-bus/condense.ts

@@ -1,8 +1,9 @@
-import { closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync } from 'node:fs';
+import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync } from 'node:fs';
 import { dlopen, FFIType } from 'bun:ffi';
 import { join } from 'node:path';
 import { listMemories, memoryRoot, saveMemory, type MemoryEntry } from '../memory.js';
 import { DecisionLedger } from '../decisions/decision-ledger.js';
+import { debug } from '../debug/log.js';
 import { condenseContextWindowWithReport, readCondenseEvents, type CondenseFunnel, type CondenseSkipped, type MemoryDeps, type MemoryItem, type MemorySource, type MemorySummary } from './long-term-memory.js';
 
 const summarize = async (source: MemorySource): Promise<MemorySummary> =>
@@ -51,6 +52,7 @@ export function renderCondenseMarkdown(report: Pick<CondenseReport, 'since' | 'u
 
 type CondenseStore = {
   list(): MemoryEntry[];
+  hasMemoryDirectory?(): boolean;
   save(input: Parameters<typeof saveMemory>[0]): MemoryEntry;
   raise(input: Parameters<DecisionLedger['raiseOnce']>[0], ref: string): string;
   withLock<T>(action: () => T): T;
@@ -96,6 +98,7 @@ function defaultStore(root?: string): CondenseStore {
   const ledger = new DecisionLedger(root ? { stateDir: root } : {});
   return {
     list: () => listMemories({}, memoryDir),
+    hasMemoryDirectory: () => existsSync(memoryDir),
     save: input => saveMemory(input, memoryDir),
     raise: (input, ref) => ledger.raiseOnce(input, ref).id,
     withLock: action => withMemoryLock(memoryDir, action),
@@ -118,10 +121,22 @@ function newestActive(entries: readonly MemoryEntry[]): MemoryEntry | undefined
 }
 
 /** Apply candidate cards through the existing curated memory and decision ledger paths. */
-export function applyCondensedCards(cards: readonly MemoryItem[], store: CondenseStore): NonNullable<CondenseReport['applied']> {
+export function applyCondensedCards(cards: readonly MemoryItem[], store: CondenseStore, now: Date = new Date()): NonNullable<CondenseReport['applied']> {
   const decisions: string[] = [];
   let written = 0;
   let retired = 0;
+  const cutoff = now.getTime() - 30 * 24 * 3_600_000;
+  const retireAged = () => {
+    let agedRetired = 0;
+    for (const old of store.list()) {
+      if (old.contextCard?.status !== 'active' || !(Date.parse(old.contextCard.updatedAt) < cutoff)) continue;
+      store.save({ type: old.type, name: old.name, description: old.description, body: old.body, id: old.id,
+        pinned: false, priority: old.priority, contextCard: { ...old.contextCard, status: 'retired' } });
+      agedRetired++;
+    }
+    retired += agedRetired;
+    debug.log('context.condense', 'aged-out', { retired: agedRetired });
+  };
   for (const card of cards) {
     if (card.conflict) {
       const ref = `context-condense:${JSON.stringify([card.project, card.seat, card.topic, card.source, card.updatedAt])}`;
@@ -162,6 +177,7 @@ export function applyCondensedCards(cards: readonly MemoryItem[], store: Condens
     };
     store.withLock(applyTopic);
   }
+  if (store.hasMemoryDirectory?.() !== false) store.withLock(retireAged);
   return { written, retired, decisions };
 }
 
@@ -184,6 +200,6 @@ export async function runContextCondense(options: {
   const conflicts = cards.filter(card => card.conflict !== undefined).length;
   const report: CondenseReport = { since, until, cards, conflicts, skipped, folded, droppedHarnessChild, funnel,
     markdown: renderCondenseMarkdown({ since, until, cards, conflicts, skipped, droppedHarnessChild, funnel }) };
-  if (options.apply === true) report.applied = applyCondensedCards(cards, store ?? defaultStore(options.root));
+  if (options.apply === true) report.applied = applyCondensedCards(cards, store ?? defaultStore(options.root), now);
   return report;
 }

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

@@ -12,6 +12,16 @@ export interface ContextDayRow {
   status: '들어옴' | '안 들어옴';
 }
 export interface ContextDayReport { since: string; until: string; rows: ContextDayRow[] }
+export interface ContextDayTimelineEvent {
+  at: string;
+  source: ContextDaySource;
+  kind: ContextDayKind | 'other';
+  summary: string;
+  link: string | null;
+}
+export interface ContextDayTimelineReport { since: string; until: string; events: ContextDayTimelineEvent[] }
+interface JournalEvent { surface: string; kind: string; ts: string; refs: string | null; summary: string | null }
+type DayDeps = { now?: () => Date; dbPath?: string; seat?: ContextDaySource };
 
 /** Reject malformed windows instead of silently changing the time range being judged. */
 export function contextDayHours(since: string): number {
@@ -34,43 +44,86 @@ function kindFor(surface: string, kind: string): ContextDayKind | null {
   return null;
 }
 
+function sourceFor(event: JournalEvent): { source: ContextDaySource; refs: { url?: unknown; source?: unknown } } | null {
+  let refs: { seat?: unknown; origin?: unknown; url?: unknown; source?: unknown };
+  try { refs = JSON.parse(event.refs ?? '{}') as typeof refs; } catch { return null; }
+  if (!refs || typeof refs !== 'object') return null;
+  const source = event.surface === 'context:external' ? refs.origin : refs.seat;
+  if (typeof source !== 'string' || !CONTEXT_DAY_SOURCES.some(item => item === source)) return null;
+  const isExternal = CONTEXT_DAY_SOURCES.indexOf(source as ContextDaySource) >= 4;
+  // Do not attribute an external hook to a seat (or a seat event to an external origin).
+  if ((event.surface === 'context:external') !== isExternal) return null;
+  return { source: source as ContextDaySource, refs };
+}
+
 /** Read only the context journal, not recallEvents (which mutates recall counts) or the writable DB opener. */
-export function contextDay(since = '24h', deps: { now?: () => Date; dbPath?: string } = {}): ContextDayReport {
+function readDay(since: string, deps: DayDeps): { since: string; until: string; events: JournalEvent[] } {
   const hours = contextDayHours(since);
   const now = (deps.now ?? (() => new Date()))();
   const until = now.toISOString();
   const from = new Date(now.getTime() - hours * 3_600_000).toISOString();
-  const rows: ContextDayRow[] = CONTEXT_DAY_SOURCES.map(source => ({
-    source, counts: { 'task-claimed': 0, done: 0, asked: 0, 'guidance-changed': 0 }, lastAt: null, status: '안 들어옴',
-  }));
-  const bySource = new Map(rows.map(row => [row.source, row]));
   const path = deps.dbPath ?? surfaceEventsDbPath();
-  if (!existsSync(path)) return { since: from, until, rows };
+  if (!existsSync(path)) return { since: from, until, events: [] };
   const db = new Database(path, { readonly: true });
   try {
-    const events = db.prepare(`SELECT surface, kind, ts, refs FROM events
+    const events = db.prepare(`SELECT surface, kind, ts, refs, summary FROM events
       WHERE surface IN ('coord:channel', 'context:session', 'context:external')
-        AND direction='outbound' AND ts>=? AND ts<=? ORDER BY ts ASC`).all(from, until) as Array<{
-      surface: string; kind: string; ts: string; refs: string | null;
-    }>;
-    for (const event of events) {
-      let refs: { seat?: unknown; origin?: unknown };
-      try { refs = JSON.parse(event.refs ?? '{}') as typeof refs; } catch { continue; }
-      const source = event.surface === 'context:external' ? refs.origin : refs.seat;
-      if (typeof source !== 'string') continue;
-      const row = bySource.get(source as ContextDaySource);
-      if (!row) continue;
-      // Do not attribute an external hook to a seat (or a seat event to an external origin).
-      if ((event.surface === 'context:external') !== (rows.indexOf(row) >= 4)) continue;
-      row.lastAt = event.ts;
-      row.status = '들어옴';
-      const kind = kindFor(event.surface, event.kind);
-      if (kind) row.counts[kind]++;
-    }
+        AND direction='outbound' AND ts>=? AND ts<=? ORDER BY ts ASC`).all(from, until) as JournalEvent[];
+    return { since: from, until, events };
   } finally { db.close(); }
+}
+
+export function contextDay(since = '24h', deps: { now?: () => Date; dbPath?: string } = {}): ContextDayReport {
+  const { since: from, until, events } = readDay(since, deps);
+  const rows: ContextDayRow[] = CONTEXT_DAY_SOURCES.map(source => ({
+    source, counts: { 'task-claimed': 0, done: 0, asked: 0, 'guidance-changed': 0 }, lastAt: null, status: '안 들어옴',
+  }));
+  const bySource = new Map(rows.map(row => [row.source, row]));
+  for (const event of events) {
+    const attribution = sourceFor(event);
+    if (!attribution) continue;
+    const row = bySource.get(attribution.source)!;
+    row.lastAt = event.ts;
+    row.status = '들어옴';
+    const kind = kindFor(event.surface, event.kind);
+    if (kind) row.counts[kind]++;
+  }
   return { since: from, until, rows };
 }
 
+export function contextDayTimeline(since = '24h', deps: DayDeps = {}): ContextDayTimelineReport {
+  if (deps.seat !== undefined && !CONTEXT_DAY_SOURCES.some(source => source === deps.seat)) {
+    throw new Error(`unknown --seat: ${deps.seat}`);
+  }
+  const { since: from, until, events } = readDay(since, deps);
+  const timeline: ContextDayTimelineEvent[] = [];
+  for (const event of events) {
+    const attribution = sourceFor(event);
+    if (!attribution || (deps.seat && attribution.source !== deps.seat)) continue;
+    const { url, source } = attribution.refs;
+    const link = [url, source].find(value => typeof value === 'string' && /^(?:https?:\/\/|elanous:\/\/)[^\s]+$/.test(value));
+    timeline.push({ at: event.ts, source: attribution.source, kind: kindFor(event.surface, event.kind) ?? 'other',
+      summary: event.summary ?? '', link: typeof link === 'string' ? link : null });
+  }
+  return { since: from, until, events: timeline };
+}
+
+const kstFormatter = new Intl.DateTimeFormat('en-CA', {
+  timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hourCycle: 'h23',
+});
+function kst(at: string): string {
+  const parts = Object.fromEntries(kstFormatter.formatToParts(new Date(at)).map(part => [part.type, part.value]));
+  return `${parts.year}-${parts.month}-${parts.day} ${parts.hour}:${parts.minute} KST`;
+}
+
+export function renderContextDayTimeline(report: ContextDayTimelineReport, dbPath = surfaceEventsDbPath()): string {
+  const lines = [`맥락 사건 ${kst(report.since)} ~ ${kst(report.until)}`];
+  if (!report.events.length) lines.push(`이 창에 사건 0건 — 원장 경로: ${dbPath}`);
+  else lines.push(...report.events.map(event => `${kst(event.at).slice(11)} · ${event.source} · ${event.kind} · ${event.summary.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, ' ')} · ${event.link ?? '—'}`));
+  lines.push(`${report.events.length}건 · 출처 ${new Set(report.events.map(event => event.source)).size}곳`);
+  return lines.join('\n');
+}
+
 export function renderContextDay(report: ContextDayReport): string {
   return [
     `맥락 이벤트 ${report.since} ~ ${report.until} (UTC)`,

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

@@ -0,0 +1,33 @@
+import type { ContextNowAnswer, ContextNowDeps } from './context-now.js';
+
+const CONTEXT_FIRST_GAP_MS = 6 * 60 * 60 * 1000;
+const CONTEXT_UNREADABLE = '맥락 못 읽음';
+
+/** Track every allowed utterance, consuming a pending summary only on a normal turn. */
+export function createContextFirstGate({ now, gapMs = CONTEXT_FIRST_GAP_MS }: { now: () => number; gapMs?: number }) {
+  const lastUtteranceAt = new Map<string, number>();
+  const pending = new Set<string>();
+  return {
+    note(key: string): void {
+      const at = now();
+      const previous = lastUtteranceAt.get(key);
+      lastUtteranceAt.set(key, at);
+      if (previous === undefined || at - previous >= gapMs) pending.add(key);
+    },
+    take(key: string): boolean {
+      return pending.delete(key);
+    },
+  };
+}
+
+export function renderContextFirst(
+  read: (options: {}, deps?: ContextNowDeps) => ContextNowAnswer,
+  deps: ContextNowDeps | undefined,
+  render: (answer: ContextNowAnswer) => string,
+): string {
+  try {
+    return render(read({}, deps));
+  } catch {
+    return CONTEXT_UNREADABLE;
+  }
+}

package/src/context-card/index.ts

@@ -0,0 +1,45 @@
+/** A rebuildable view of the ledger and code, never an authoritative record. */
+export interface ContextCard {
+  readonly id: string;
+  readonly kind: 'task' | 'goal' | 'run' | 'pr' | 'cell' | 'doc';
+  readonly conclusion: string;
+  readonly why: string;
+  readonly verdict: string;
+  readonly remaining: readonly string[];
+  readonly pointers: readonly string[];
+  readonly source: string;
+  readonly updatedAt: string;
+  readonly supersedes?: string;
+}
+
+/** Serialized code points, including JSON escaping; callers may supply a smaller screen budget. */
+export const CONTEXT_CARD_SCREEN_CHARS = 1_600;
+const length = (text: string): number => [...text].length;
+
+/** Preserve the decision and provenance; fold only the two expandable lists. Never mutate the card. */
+export function serializeContextCard(card: ContextCard, maxChars = CONTEXT_CARD_SCREEN_CHARS): string {
+  if (!Number.isSafeInteger(maxChars) || maxChars < 1) throw new RangeError('maxChars must be a positive safe integer');
+  if (/[\r\n\u2028\u2029]/u.test(card.conclusion)) throw new Error('conclusion must be one line');
+  const remaining = [...card.remaining];
+  const pointers = [...card.pointers];
+  const render = () => JSON.stringify({
+    id: card.id, kind: card.kind, conclusion: card.conclusion, why: card.why,
+    verdict: card.verdict, remaining: remaining.length < card.remaining.length
+      ? [...remaining, `외 ${card.remaining.length - remaining.length}개`] : remaining,
+    pointers: pointers.length < card.pointers.length
+      ? [...pointers, `외 ${card.pointers.length - pointers.length}개`] : pointers,
+    source: card.source, updatedAt: card.updatedAt,
+    ...(card.supersedes === undefined ? {} : { supersedes: card.supersedes }),
+  });
+  let text = render();
+  while (length(text) > maxChars && (remaining.length || pointers.length)) {
+    // Remove the larger last entry first, then break ties by preferring remaining.
+    const remainingCost = remaining.length ? length(JSON.stringify(remaining.at(-1))) : -1;
+    const pointerCost = pointers.length ? length(JSON.stringify(pointers.at(-1))) : -1;
+    if (remainingCost >= pointerCost) remaining.pop();
+    else pointers.pop();
+    text = render();
+  }
+  if (length(text) > maxChars) throw new RangeError('card core and omission counts exceed maxChars');
+  return text;
+}

package/src/context-card/task.ts

@@ -0,0 +1,76 @@
+import type { RunLedgerEntry } from '../self-implement/run-ledger.js';
+import type { ContextCard } from './index.js';
+
+/** An injected, read-only view of the JSONL run ledger. No writer or store mutation is available. */
+export interface TaskLedgerReader {
+  readRuns(): readonly { readonly runId: string; readonly entries: readonly RunLedgerEntry[] }[];
+  /** Returns the verbatim original ask from the goal document named by start.goalFile. */
+  readOriginalAsk?(goalFile: string): string | null;
+  /** Returns must-fix text from the review artifact named by reviewed.artifactPath. */
+  readReviewMustFix?(artifactPath: string): readonly string[] | null;
+}
+
+export interface TaskContextCard extends ContextCard {
+  readonly kind: 'task';
+  readonly originalAsk: string;
+  readonly authoredGoal: { readonly path: string; readonly sha256: string } | null;
+  readonly runIds: readonly string[];
+  readonly mustFix: readonly string[];
+  readonly decisionCards: readonly string[];
+  readonly nextAction: string;
+}
+
+const text = (value: unknown): string | null => typeof value === 'string' && value.trim() ? value : null;
+const strings = (value: unknown): string[] | null => Array.isArray(value) && value.every((item) => typeof item === 'string') ? [...value] : null;
+
+/** Produce a task card from source events, not from the previous card or wall-clock time. */
+export function buildTaskCard(taskId: string, reader: TaskLedgerReader): TaskContextCard {
+  const runs = reader.readRuns().filter((run) => run.entries.some((entry) => entry.event === 'start' && entry.goalId === taskId))
+    .map((run) => ({ runId: run.runId, entries: run.entries.filter((entry) => entry.runId === run.runId && (entry.goalId === undefined || entry.goalId === taskId)) }))
+    .sort((a, b) => a.runId < b.runId ? -1 : a.runId > b.runId ? 1 : 0);
+  if (!runs.length) throw new Error(`no run-ledger start for task: ${taskId}`);
+  const events = runs.flatMap(({ entries }) => entries).sort((a, b) =>
+    (a.timestamp ?? '').localeCompare(b.timestamp ?? '') || a.runId.localeCompare(b.runId));
+  const start = events.find((event) => event.event === 'start')!;
+  const goalFile = text(start.data.goalFile);
+  const originalAsk = text(start.data.originalAsk)
+    ?? (goalFile ? reader.readOriginalAsk?.(goalFile) ?? null : null);
+  if (!originalAsk) throw new Error(`original ask unavailable for task: ${taskId}`);
+
+  const authored = [...events].reverse().find((event) => event.event === 'goal-authored'
+    && text(event.data.path) !== null && /^[a-f0-9]{64}$/i.test(text(event.data.sha256) ?? ''));
+  const authoredGoal = authored ? { path: text(authored.data.path)!, sha256: text(authored.data.sha256)! } : null;
+  const reviews = events.filter((event) => event.event === 'reviewed' && event.data.reviewed === true);
+  const review = reviews.at(-1);
+  const artifactPath = review ? text(review.data.artifactPath) : null;
+  const mustFix = review
+    ? strings(review.data.mustFix) ?? (artifactPath ? reader.readReviewMustFix?.(artifactPath) ?? null : null)
+    : [];
+  if (mustFix === null && review?.data.mustFix !== 0) throw new Error(`review must-fix unavailable for task: ${taskId}`);
+  const findings = mustFix ?? [];
+  const decisionCards = events.filter((event) => event.event === 'decision-card')
+    .flatMap((event) => {
+      const cardId = text(event.data.cardId);
+      return cardId ? [cardId] : [];
+    });
+  const nextAction = [...events].reverse().map((event) => text(event.data.nextAction)).find((value): value is string => value !== null)
+    ?? findings[0] ?? null;
+  if (!nextAction) throw new Error(`next action unavailable for task: ${taskId}`);
+  const updatedAt = events.at(-1)?.timestamp;
+  if (!updatedAt) throw new Error(`timestamp unavailable for task: ${taskId}`);
+  const pointers = [
+    ...(goalFile ? [goalFile] : []),
+    ...(authoredGoal ? [`${authoredGoal.path}#sha256=${authoredGoal.sha256}`] : []),
+    ...runs.map(({ runId }) => `run:${runId}`),
+    ...(artifactPath ? [artifactPath] : []),
+    ...decisionCards,
+  ];
+  return {
+    id: `task:${taskId}`, kind: 'task', conclusion: nextAction,
+    why: findings.length ? `최근 리뷰 must-fix ${findings.length}개` : '원문과 런 원장에 따른 다음 행동',
+    verdict: text(review?.data.verdict) ?? '리뷰 판정 없음',
+    remaining: [...findings], pointers,
+    source: `run-ledger:${runs.map(({ runId }) => runId).join(',')}`, updatedAt,
+    originalAsk, authoredGoal, runIds: runs.map(({ runId }) => runId), mustFix: [...findings], decisionCards, nextAction,
+  };
+}

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

@@ -2442,6 +2442,8 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
         cwd: () => process.cwd(),
         now: () => Date.now(),
         isInteractive: () => ctx.surfaceUx !== undefined,
+        selfResolveClarification: (await import('../../self-implement/goal-author-clarification.js')).defaultGoalAuthorSelfResolve,
+        writeGoalDocument: (await import('../../self-implement/goal-document-write.js')).writeGoalDocumentAtomic,
         buildPreflightDeps: askIo.buildAskPreflightDeps,
         priorBlockSamples: () => askIo.priorBlockSamplesFrom(rows),
         recentAuthoringSamples: () => askIo.recentAuthoringSamplesFrom(rows),

package/src/decisions/decision-ledger.ts

@@ -93,7 +93,16 @@ function validate(input: RaiseInput, historical = false): RaiseInput {
   const c = scqaField(input.scqa.c, 'c');
   const q = input.scqa.q?.trim() ? scqaField(input.scqa.q, 'q') : undefined;
   const a = input.scqa.a?.trim() ? scqaField(input.scqa.a, 'a') : undefined;
-  if (q && q === c) throw new Error('SCQA Q repeats C — leave Q empty');
+  if (q && q === c && input.raisedBy.agent !== 'seat-loop') throw new Error('SCQA Q repeats C — leave Q empty');
+  if (input.raisedBy.agent === 'seat-loop') {
+    if (!q || !a || !input.pendingQuestion?.trim()) throw new Error('seat-loop cards require --q, --a and --pending-question');
+    if ('skipped' in input.recommendation && !(['money', 'security', 'secret'].includes(input.category)
+      || (['publish', 'irreversible'].includes(input.category)
+        && /공개|게시|발행|출시|publish|release/i.test(`${title} ${input.pendingQuestion} ${input.recommendation.reason}`)
+        && /되돌릴 수 없|철회 불가|복구 불가|irreversib|cannot (?:undo|retract)/i.test(`${input.pendingQuestion} ${input.recommendation.reason}`)))) {
+      throw new Error('seat-loop recommendation may only be skipped for money, security or irreversible publication');
+    }
+  }
   if (!Array.isArray(input.options) || (input.options.length < 2 && !(historical && input.options.length === 0))) throw new Error('at least two options required');
   const options = input.options.map(o => ({ key: single(o.key, 'option key'), label: safe(single(o.label, 'option label')), consequence: safe(single(o.consequence, 'option consequence')) }));
   if (options.some(o => !/^[a-z]$/.test(o.key)) || new Set(options.map(o => o.key)).size !== options.length) throw new Error('option keys must be unique lowercase letters');

package/src/discord-self-message.ts

@@ -65,7 +65,9 @@ import { detectCard, runCardFollowup, NotACardError } from './card-followup/core
 import { localOcrText } from './telegram-card-followup.js';
 import type { runGraph } from './graph-runner/runner.js';
 import { readSlashContextNow, renderTelegramNow } from './context-bus/context-now-surfaces.js';
-import type { ContextNowDeps } from './context-bus/context-now.js';
+import { contextNow, type ContextNowDeps } from './context-bus/context-now.js';
+import { createContextFirstGate, renderContextFirst } from './context-bus/context-first.js';
+import { telegramLoopsStatus, type LoopsSources } from './telegram-loops-command.js';
 import { botUnavailableSlashReply, deriveTuiSlashAvailability, type TuiSlashAvailability } from './maturity/tui-slash-availability.js';
 
 const SLASH_FOCUS_TURNS_DEFAULT = 8;
@@ -143,6 +145,9 @@ export interface DiscordSelfMessageDeps {
   log?: (msg: string) => void;
   cardFollowupDeps?: { ocrText?: (path: string) => Promise<string | null>; runGraph?: typeof runGraph; rootDir?: () => string };
   nowDeps?: ContextNowDeps;
+  /** Override the clock for the context-first gate in isolated message-path tests. */
+  contextFirstNow?: () => number;
+  loopsSources?: LoopsSources;
   /** Override the TUI slash projection for isolated message-path tests. */
   tuiSlashAvailability?: readonly TuiSlashAvailability[];
 }
@@ -151,6 +156,15 @@ export interface DiscordSelfMessageDeps {
 export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessageHandler {
   const log = deps.log ?? ((): void => {});
   const cfg = deps.userConfig;
+  const contextFirstGate = createContextFirstGate({ now: deps.contextFirstNow ?? Date.now });
+  const maybeSendContextFirst = async (channelId: string): Promise<void> => {
+    if (!contextFirstGate.take(channelId) || cfg.discord?.contextFirst === false) return;
+    try {
+      await deps.getBot()?.sendMessage(channelId, renderContextFirst(contextNow, deps.nowDeps, renderTelegramNow));
+    } catch (err) {
+      log(`discord context-first failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
   // C2+ (2026-07-12 dogfood): 디스코드 첨부는 메시지 단위라 "사진 먼저,
   // !cdx 명령은 다음 메시지" 패턴에서 위임 턴이 빈손이 된다. 채널별로
   // 마지막 첨부를 기억해 두고, 첨부 없는 위임 명령이 2분 내 같은
@@ -359,6 +373,7 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
 
   return async (ctx, streamer) => {
     if (deps.channelScope && ctx.channelId !== deps.channelScope) return undefined;
+    contextFirstGate.note(ctx.channelId);
     // Voice text commands pass the guild gate for the voice adapter's
     // sake — never route them into the LLM turn (legacy behavior).
     if (/^\/voice-(join|leave|status)\b/.test(ctx.text.trim())) return undefined;
@@ -367,6 +382,8 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
       const args = nowCommand[1]?.trim().split(/\s+/).filter(Boolean) ?? [];
       return renderTelegramNow(readSlashContextNow(args, deps.nowDeps));
     }
+    if (/^[/!]loops$/.test(ctx.text.trim())) return telegramLoopsStatus([], deps.loopsSources);
+    if (/^[/!]loops\s+\S/.test(ctx.text.trim())) return telegramLoopsStatus(['extra'], deps.loopsSources);
     if (!ctx.text.trim() && ctx.attachments.length === 1 && ctx.attachments[0]!.contentType?.startsWith('image/')) {
       const photo = ctx.attachments[0]!;
       if (detectCard({ width: photo.width, height: photo.height, ocrText: null }).decision !== 'skip') {
@@ -408,6 +425,8 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
       const unavailable = botUnavailableSlashReply(entry, 'discord');
       if (unavailable) return unavailable;
     }
+    const cmd = parseDiscordAcpCommand(ctx.text);
+    if (!cmd && !/^[!/]/.test(ctx.text.trim())) await maybeSendContextFirst(ctx.channelId);
     log(`◀ ${ctx.userName ?? ctx.userId}: ${ctx.text.slice(0, 80)}${ctx.attachments.length ? ` (+첨부 ${ctx.attachments.length})` : ''}`);
     debug.log('discord.self.turn', 'inbound', { channelId: ctx.channelId, chars: ctx.text.length, attachments: ctx.attachments.length });
     // C2+ — 첨부 기억(사진만 먼저 올리는 패턴 지원). 명령 여부와 무관.
@@ -416,7 +435,6 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
     const delegationKey = delegationChatKey('dc', ctx.channelId);
 
     // 1) Explicit text commands — /cc·/cdx·/gem delegate, /brain exits.
-    const cmd = parseDiscordAcpCommand(ctx.text);
     if (cmd?.kind === 'brain') {
       clearActiveDelegation(delegationKey);
       return '🧠 브레인 모드로 복귀했습니다 (active delegation 해제).';

package/src/discord-slash-wire.ts

@@ -48,6 +48,7 @@ export const ELANOUS_SLASH_COMMANDS: readonly SlashCommandSchema[] = [
   { name: 'now', description: '지금 판·칸·결정·자리·최근 맥락 보기', options: [
     { name: 'topic', description: '좁혀 볼 주제 (선택)', type: 3, required: false },
   ] },
+  { name: 'loops', description: '루프·크론 현황 (늦음·실패 먼저)' },
   { name: 'sessions', description: '바인딩된 세션 목록' },
   { name: 'new', description: '새 세션으로 시작 (이전 대화 보존)' },
   { name: 'attach', description: '이 채널을 다른 세션에 연결', options: [