elanous 0.2.20 → 0.2.22

package/src/core-turn/run-goal-loop.ts

@@ -180,6 +180,7 @@ export const GOAL_CONTINUATION_PROMPT = [
   '[continue]',
   '아직 목표가 완료로 증명되지 않았다. 완료를 미리 선언하지 말고, 현재 상태 대비 실제로 검증하라:',
   '남은 요구사항을 식별하고, 다음 최고가치 스텝을 지금 도구로 실행하라.',
+  '이미 사용자에게 한 답을 다시 쓰지 마라 — 새 사실이 없으면 텍스트 없이 update_goal 만 호출하라.',
   // evidence-audit(ref codex ext/goal continuation.md:41,51) — 스푸핑·조기완료 차단.
   '완료 증거로 의도/부분진전/이전 작업 기억/그럴듯한 답을 쓰지 마라. 현재 상태(파일·명령출력·테스트결과·PR·런타임 동작)를 실제로 확인한 증거만 인정한다.',
   '예산이 곧 소진된다거나 그만두고 싶다는 이유로 완료를 선언하지 마라.',
@@ -196,6 +197,7 @@ export const GOAL_READBACK_PROMPT = [
   '[finalize]',
   `완료를 텍스트로만 말했다. 텍스트 문장은 완료 신호가 아니다 — 완료가 사실이면 ${UPDATE_GOAL_TOOL_NAME} 도구를 status="complete" 로 호출하고 evidence 에 현재 상태에서 실제로 확인한 증거(파일·명령출력·테스트·PR)를 적어라.`,
   '아직 미충족 항목이 있으면 완료를 주장하지 말고 다음 스텝을 지금 실행하라.',
+  '이미 사용자에게 한 답을 다시 쓰지 마라 — 새 사실이 없으면 텍스트 없이 update_goal 만 호출하라.',
 ].join('\n');
 
 /** evidence 누락 complete 재주입 — update_goal(complete) 를 호출했으나 evidence 가 비었을 때. */
@@ -689,6 +691,7 @@ export async function runGoalLoop(
       },
     };
 
+    const previousFinalText = lastResult.finalText;
     try {
       lastResult = await runTurn(turnCtx);
     } finally {
@@ -786,8 +789,26 @@ export async function runGoalLoop(
         debug.log('goal.loop', 'complete', {
           sessionId: ctx.sessionId, ...runAttribution, iterations, via: 'update_goal', evidenceCheck,
         }, { level: 'info' });
+        const normalizeAnswer = (text: string) => text.trim().replace(/\s+/g, ' ');
+        const previousAnswer = normalizeAnswer(previousFinalText);
+        const completionAnswer = normalizeAnswer(lastResult.finalText);
+        const previousAt = previousAnswer ? completionAnswer.indexOf(previousAnswer) : -1;
+        const prefix = previousAt >= 0 ? completionAnswer.slice(0, previousAt).trim() : '';
+        const suffix = previousAt >= 0 ? completionAnswer.slice(previousAt + previousAnswer.length).trim() : '';
+        // Only a readback preface is non-factual; a new sentence before the old answer
+        // (including one joined by a colon) must survive just like a new suffix.
+        const readbackPreface = /^(?:확인 결과|(?:방금\s+)?다시\s+확인(?:했습니다|했지만|해보니|해 보니|해봤지만|해 봤지만|했으나|했는데))[\s:：,.!?。！？-]*$/u;
+        const hasNewFact = (prefix.length > 0 && !readbackPreface.test(prefix)) || /\p{L}|\p{N}/u.test(suffix);
+        const duplicateAnswer = previousAnswer.length > 0 && (
+          completionAnswer.length === 0 || (previousAt >= 0 && !hasNewFact)
+        );
+        if (duplicateAnswer) {
+          debug.log('goal.loop', 'complete-duplicate-answer-suppressed', {
+            sessionId: ctx.sessionId, ...runAttribution, iterations, chars: lastResult.finalText.length,
+          });
+        }
         return finish(
-          { finalText: lastResult.finalText, iterations, stopReason: 'goal_complete', goalComplete: true },
+          { finalText: duplicateAnswer ? previousFinalText : lastResult.finalText, iterations, stopReason: 'goal_complete', goalComplete: true },
           { summary: completionSummary, changedFiles: completionChangedFiles },
         );
       }

package/src/dashboard/index.ts

@@ -769,6 +769,15 @@ export function clearEscAbortToolState(toolState: EscAbortToolState): void {
   toolState.activeToolNamesByCallId.clear();
 }
 
+export function activeEscHarnessSpace(
+  toolState: EscAbortToolState,
+  spacesByCallId: ReadonlyMap<string, string>,
+): string | null {
+  const active = [...toolState.activeToolNamesByCallId].filter(([, name]) =>
+    (SELF_IMPLEMENT_TOOL_NAMES as readonly string[]).includes(name));
+  return active.length === 1 ? spacesByCallId.get(active[0]![0]) ?? null : null;
+}
+
 /** Reset per-turn ESC tool tracking before a new stream runtime begins. */
 export function createDashboardTurnStreamRuntimeEscBoundary(toolState: EscAbortToolState): void {
   clearEscAbortToolState(toolState);
@@ -1324,6 +1333,8 @@ import {
   PULSE_HALF_PERIOD_MS,
 } from '../agent-activity-hud.js';
 import { DASHBOARD_CLARIFICATION_REQUEST, consumeStreamingTopModalEscape, createEscAbortGate, createHarnessEscHint, routeStreamingEscapeKey } from '../esc-abort-gate.js';
+import { enqueueSoftStop, readSoftStopRequestStatus } from '../harness/control-inbox.js';
+import { setSelfImplementSoftStopSpaceObserver } from '../self-implement/self-implement-runtime.js';
 import { createViEditor, type ViEditorHandle } from '../vi-editor.js';
 import { launchEditor, canLaunchEditor } from '../editor-launcher.js';
 import { createSshPickerModal } from '../ssh/ssh-picker-modal.js';
@@ -6700,6 +6711,13 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
    * this function is invoked.
    */
   const escAbortToolState = createEscAbortToolState();
+  const escHarnessSpacesByCallId = new Map<string, string>();
+  setSelfImplementSoftStopSpaceObserver((callId, spaceId) => {
+    const toolName = escAbortToolState.activeToolNamesByCallId.get(callId);
+    if (toolName && (SELF_IMPLEMENT_TOOL_NAMES as readonly string[]).includes(toolName)) {
+      escHarnessSpacesByCallId.set(callId, spaceId);
+    }
+  });
   let clarificationModalId: string | null = null;
 
   const attachChatStreamingKeys = (abortCtrl: AbortController): () => void => {
@@ -6713,6 +6731,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // so the user can make an informed call.
     let abortGateModalId: string | null = null;
     const showHarnessEscHint = createHarnessEscHint((line) => pushChatLine(line));
+    let stoppedHarnessSpace: string | null = null;
+    const activeHarnessSpace = (): string | null => activeEscHarnessSpace(escAbortToolState, escHarnessSpacesByCallId);
     const escGate = createEscAbortGate({
       abortCtrl,
       getRunningCount: () => getEscAbortRunningCount(escAbortToolState),
@@ -6726,14 +6746,25 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       requestRedraw: () => draw(),
       getTheme: () => currentThemeTokens(),
       getWaitingTargetNames: () => getEscAbortWaitingToolNames(escAbortToolState),
+      shouldAbortImmediately: () => activeHarnessSpace() !== null,
       onAbortPending: ({ targets }) => {
-        if (!showHarnessEscHint(targets)) {
+        const spaceId = activeHarnessSpace();
+        if (spaceId) {
+          try {
+            enqueueSoftStop(spaceId);
+            if (readSoftStopRequestStatus(spaceId).status !== 'present') throw new Error('soft-stop marker not persisted');
+            stoppedHarnessSpace = spaceId;
+            pushChatLine('  ⏹ 멈췄다 — 해당 하니스 런에 중단 요청을 보냈습니다.');
+          } catch {
+            pushChatLine('  ⚠ 하니스 런 중단 요청을 보내지 못했습니다. /harness runs 에서 확인해 주세요.');
+          }
+        } else if (!showHarnessEscHint(targets)) {
           pushChatLine(`  ⏳ 중단 요청됨 — ${formatEscAbortWaitingTargets(targets)} 종료를 기다리는 중입니다.`);
         }
         chatScrollOffset = -1;
       },
       onAbortRepeat: ({ repeat, targets }) => {
-        if (!showHarnessEscHint(targets)) {
+        if (!stoppedHarnessSpace && !showHarnessEscHint(targets)) {
           pushChatLine(`  ⏳ ESC 재시도 ${repeat}회 — ${formatEscAbortWaitingTargets(targets)} 종료를 기다리는 중입니다.`);
         }
         chatScrollOffset = -1;
@@ -7251,7 +7282,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     return () => {
       cleanup();
       escGate.dispose();
-      settleEscAbortPendingLines(chatLines, chatLinesStartIndex);
+      if (!stoppedHarnessSpace) settleEscAbortPendingLines(chatLines, chatLinesStartIndex);
       userScrolledDuringStream = false;
       streamingInFlight = false;
     };
@@ -15674,6 +15705,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             pushChatLine,
             draw,
             signal: acpTurnRef.abortCtrl?.signal ?? new AbortController().signal,
+            toolCallId: ctx?.callId,
             // ⛔⭐ 폴백은 `''` 가 아니라 `undefined` 다 — 「안 넘김」과 「말했는데 어휘가 없음」은 «다른 값»이다.
             //   harnessMentionState(session-runtime 소비처)는 `undefined → 'absent'` · `'' → 'not-matched'` 로
             //   가른다. `?? ''` 로 접으면 그 둘이 같은 값이 되고, 그것이 2026-08-06 에 「TUI 가 하니스에게
@@ -15695,9 +15727,10 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             ptyDashboardOn:
               uc.shell.allowDashboardPty === true && (acpPtyAvailable?.() ?? false),
             getToolRuntime: (toolName) => runtime.getToolRuntime(toolName),
-            dispatchToolRuntime: (toolName, input) =>
+            dispatchToolRuntime: (toolName, input, toolCallId) =>
               runtime.dispatchToolByName(toolName, input, {
                 surface: 'tui',
+                toolCallId,
                 signal: acpTurnRef.abortCtrl?.signal,
                 // ⭐ Agent-family context. Without these two the sub-agent runs
                 //  text-only (see getTools above). `agentDispatchTool` routes the
@@ -19171,6 +19204,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             createTurnStreamRuntime: (initialAssistantStart) => {
               latestTurnUsage = undefined;
               createDashboardTurnStreamRuntimeEscBoundary(escAbortToolState);
+              escHarnessSpacesByCallId.clear();
               liveTypeaheadEchoes.length = 0;
               const toolRendering = {
                 ...getUserConfig().chat.rendering.tool,
@@ -19225,6 +19259,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                   const toolCall = call as DashboardTurnStreamCall;
                   turnStreamRuntime.onToolResult(toolCall);
                   settleEscAbortToolCall(escAbortToolState, toolCall);
+                  escHarnessSpacesByCallId.delete(toolCall.id);
                 },
               };
             },
@@ -19524,6 +19559,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     closeDashboardTui();
     throw err;
   } finally {
+    setSelfImplementSoftStopSpaceObserver(null);
     if (tuiSeatAskTimer) clearInterval(tuiSeatAskTimer);
   }
 }

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

@@ -395,6 +395,8 @@ import { dispatchTerminalModalObserve } from '../../skills/tools/terminal-modal.
 import { SlashCommandRegistry } from './registry.js';
 import { cronSecondDueAt, filterLoopRows, formatLoopsTable, localLoopRows, type LoopsTableRow } from './loops-table.js';
 import { loopCronVerdict } from '../../loops/verdict.js';
+import { checklistBoardSlash } from '../../release-loop/checklist-board.js';
+import type { Checklist } from '../../release-loop/checklist.js';
 import { executeImmediateDashboardSlash } from '../input/slash-executor.js';
 import {
   buildContextSlashCommand,
@@ -1046,6 +1048,8 @@ export interface DashboardSlashContext {
 
   /** Test seam for the local read-only loop and cron registry. */
   loopsLocalRows?: (now: Date) => LoopsTableRow[];
+  /** Test seam for the read-only release checklist. */
+  checklistRead?: (version: string) => Checklist;
 
   sessionSlash: {
     /** opts.remote — when the dashboard is attached to a remote daemon. */
@@ -1467,6 +1471,11 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
     ctx.setChatScrollOffset(-1);
   });
 
+  registry.register('board', (args, ctx) => {
+    for (const line of checklistBoardSlash(args, ctx.checklistRead).split('\n')) ctx.pushChatLine(line);
+    ctx.setChatScrollOffset(-1);
+  });
+
   registry.register('wish', (args, ctx) => {
     const text = args.join(' ').trim();
     if (!text) {

package/src/decisions/decision-cards.ts

@@ -34,7 +34,9 @@ export function isIrreversible(entry: Pick<DecisionEntry, 'category'>): boolean
   return IRREVERSIBLE.has(entry.category);
 }
 
-const kst = (at: string) => new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(at));
+const kst = (at: string) => Number.isFinite(Date.parse(at))
+  ? new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(at))
+  : '읽을 수 없음';
 
 /** The card opens with a short pitch; the full question and choice buttons remain below it. */
 export function renderCardText(e: DecisionEntry, extra: { note?: string; confirm?: string } = {}): string {
@@ -101,6 +103,7 @@ interface CardState {
    *  deploy); they stay reachable through `/decisions`. */
   since?: string;
   cards: Record<string, { refs: CardRef[]; closed?: boolean; remindedAt?: string; note?: string; attempts?: number; noSubscribers?: boolean }>;
+  deferred?: Record<string, true>;
   testOriginQuestions?: Record<string, true>;
 }
 
@@ -113,6 +116,10 @@ export interface DecisionCardServiceOptions {
   /** Where this platform keeps which card it sent (one file per platform — the two bots may run in different processes). */
   statePath?: string;
   now?: () => Date;
+  /** Optional gate for new-card delivery. Omit to send every eligible open decision. */
+  sendFilter?: (entry: DecisionEntry, now: Date) => boolean;
+  /** Label recorded in the `push-deferred` observation when `sendFilter` holds a decision back. */
+  deferredReason?: (entry: DecisionEntry, now: Date) => string;
   /** Tell the seat that raised it. Default: none (observed only). */
   replyToRaiser?: (entry: DecisionEntry, via: CardPlatform) => Promise<void>;
 }
@@ -223,6 +230,18 @@ export class DecisionCardService {
       const card = state.cards[e.id];
       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 (this.opts.sendFilter) {
+          const now = this.now();
+          if (!this.opts.sendFilter(e, now)) {
+            if (!state.deferred?.[e.id]) {
+              (state.deferred ??= {})[e.id] = true;
+              dirty = true;
+              debug.log(platform === 'webpush' ? 'decisions.webpush' : 'decisions.telegram', 'push-deferred',
+                { ...(platform === 'webpush' ? {} : { platform }), id: e.id, urgency: this.opts.deferredReason?.(e, now) ?? 'filtered' });
+            }
+            continue;
+          }
+        }
         if (platform === 'webpush' && !chats.length) {
           if (!card?.noSubscribers) {
             state.cards[e.id] = { ...(card ?? { refs: [] }), noSubscribers: true };

package/src/decisions/decision-ledger.ts

@@ -5,6 +5,8 @@ import { readPendingQuestionAnswer, readPendingQuestions, writePendingQuestionAn
 import { debug, redactSecretText } from '../debug/log.js';
 import { createVersionResolver, type VersionOptions, type Versions } from '../directives/version-at.js';
 import { getUserConfig } from '../user-config.js';
+import { registeredSeats, resolveSeat } from '../seat-address/seat-address.js';
+import { isSeatId } from '../seat-dispatch/seat-questions.js';
 
 export type DecisionCategory = 'secret' | 'publish' | 'money' | 'security' | 'scope' | 'irreversible' | 'other';
 /** Old track letters (S·T·F·O) stay readable; seat names (OP·MK·TC·UX) are the current identities. */
@@ -53,7 +55,8 @@ export class DecisionAnswerDeliveryError extends Error {
   }
 }
 const CATEGORIES: readonly string[] = ['secret', 'publish', 'money', 'security', 'scope', 'irreversible', 'other'];
-const TRACKS: readonly string[] = ['S', 'T', 'F', 'O', 'OP', 'MK', 'TC', 'UX'];
+const isDecisionTrack = (value: string): boolean => registeredSeats().some(({ id, alias }) => value === id || value === alias);
+const isRegisteredSeat = (value: string): boolean => isSeatId(value) && resolveSeat(value)?.id === value;
 
 function required(value: string, name: string): string {
   if (typeof value !== 'string' || !value.trim()) throw new Error(`${name} is required`);
@@ -88,7 +91,7 @@ function validate(input: RaiseInput, historical = false): RaiseInput {
   const title = safe(single(input.title, 'title'));
   if (!CATEGORIES.includes(input.category)) throw new Error('invalid category');
   if (!input.raisedBy?.agent) throw new Error('raisedBy.agent is required');
-  if (input.raisedBy.track && !TRACKS.includes(input.raisedBy.track)) throw new Error('invalid track');
+  if (input.raisedBy.track && !isDecisionTrack(input.raisedBy.track)) throw new Error('invalid track');
   const s = scqaField(input.scqa.s, 's');
   const c = scqaField(input.scqa.c, 'c');
   const q = input.scqa.q?.trim() ? scqaField(input.scqa.q, 'q') : undefined;
@@ -117,7 +120,7 @@ function validate(input: RaiseInput, historical = false): RaiseInput {
   if (input.crossCheck !== undefined && !Array.isArray(input.crossCheck)) throw new Error('cross-check must be a list');
   const crossCheck = input.crossCheck?.map(check => {
     const seat = single(check.seat, 'cross-check seat');
-    if (!['OP', 'MK', 'TC', 'UX'].includes(seat)) throw new Error('invalid cross-check seat');
+    if (!isRegisteredSeat(seat)) throw new Error('invalid cross-check seat');
     return { seat, at: utc(check.at), note: safe(single(check.note, 'cross-check note')) };
   });
   const crossCheckSkipped = input.crossCheckSkipped === undefined ? undefined : safe(single(input.crossCheckSkipped, 'cross-check skipped reason'));
@@ -242,7 +245,7 @@ export class DecisionLedger {
   /** 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');
+    if (!isRegisteredSeat(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'));
@@ -263,7 +266,7 @@ export class DecisionLedger {
   }
   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');
+    if (filters.seat && !isRegisteredSeat(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))
@@ -307,7 +310,7 @@ export class DecisionLedger {
     if (!by || (by.kind !== 'human' && by.kind !== 'auto')) throw new Error('decidedBy is required');
     if (by.kind === 'auto') {
       single(by.delegation, 'delegation'); single(by.agent, 'agent');
-      if (by.track && !TRACKS.includes(by.track)) throw new Error('invalid track');
+      if (by.track && !isDecisionTrack(by.track)) throw new Error('invalid track');
       by = { ...by, agent: safe(single(by.agent, 'agent')), delegation: safe(single(by.delegation, 'delegation')) };
     }
     return this.locked(() => {
@@ -424,7 +427,7 @@ export class DecisionLedger {
     if (choice ? !clean.options.some(o => o.key === choice) : clean.options.length !== 0) throw new Error(`option not found: ${choice}`);
     if (by.kind === 'auto') {
       single(by.agent, 'agent'); single(by.delegation, 'delegation');
-      if (by.track && !TRACKS.includes(by.track)) throw new Error('invalid track');
+      if (by.track && !isDecisionTrack(by.track)) throw new Error('invalid track');
       by = { ...by, agent: safe(single(by.agent, 'agent')), delegation: safe(single(by.delegation, 'delegation')) };
     }
     const cleanNote = safe(single(note, 'note'));
@@ -449,7 +452,7 @@ export class DecisionLedger {
   completeRecorded(id: string, choice: string | undefined, by: DecisionActor, note: string, sourceOptions: DecisionOption[]): DecisionEntry {
     if (by.kind === 'auto') {
       single(by.agent, 'agent'); single(by.delegation, 'delegation');
-      if (by.track && !TRACKS.includes(by.track)) throw new Error('invalid track');
+      if (by.track && !isDecisionTrack(by.track)) throw new Error('invalid track');
       by = { ...by, agent: safe(single(by.agent, 'agent')), delegation: safe(single(by.delegation, 'delegation')) };
     }
     const cleanNote = safe(single(note, 'note'));

package/src/decisions/web-push-decision-cards.ts

@@ -1,8 +1,24 @@
 import { debug } from '../debug/log.js';
 import { listSubscriptions } from '../web-push/subscriptions.js';
 import { sendPushToAll } from '../web-push/sender.js';
-import { type CardTransport, type CardView } from './decision-cards.js';
-import { DecisionLedger } from './decision-ledger.js';
+import { isIrreversible, type CardTransport, type CardView } from './decision-cards.js';
+import { DecisionLedger, type DecisionEntry } from './decision-ledger.js';
+
+/** How close a deadline must be for an otherwise reversible decision to ring the phone. */
+export const WEB_PUSH_URGENT_WINDOW_MS = 24 * 3600_000;
+
+export type WebPushUrgency = 'irreversible' | 'due-soon' | 'not-urgent' | 'due-unreadable';
+
+/** Web push rings only for urgent decisions; an unreadable deadline is its own value (fail open, never folded into not-urgent). */
+export function webPushUrgency(entry: DecisionEntry, now: Date): WebPushUrgency {
+  if (isIrreversible(entry)) return 'irreversible';
+  if (entry.dueAt !== undefined) {
+    const due = Date.parse(entry.dueAt);
+    if (!Number.isFinite(due)) return 'due-unreadable';
+    if (due - now.getTime() <= WEB_PUSH_URGENT_WINDOW_MS) return 'due-soon';
+  }
+  return 'not-urgent';
+}
 
 const ID_IN_CARD = /^🗳 결정 요청 (D-\d{8}-\d+)(?: ·|\n)/;
 const ID_IN_REMINDER = /^⏰ 기한 2시간 전 — (D-\d{8}-\d+) /;
@@ -26,7 +42,7 @@ export function webPushDecisionTransport(
       const entry = ledger.show(id);
       if (entry.status !== 'open') return null;
       const recommendation = 'skipped' in entry.recommendation ? '추천안 없음' : `추천안: ${entry.recommendation.option.toUpperCase()}`;
-      const body = `${recommendation}${entry.dueAt ? ` · 기한: ${new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(entry.dueAt))}` : ''}`;
+      const body = `${recommendation}${entry.dueAt ? ` · 기한: ${Number.isFinite(Date.parse(entry.dueAt)) ? new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(entry.dueAt)) : '읽을 수 없음'}` : ''}`;
       const result = await push({ title: title('대표 결정 · ', entry.title), body, url: url(id), tag: tag(id) });
       if (result.attempted) debug.log('decisions.webpush', 'card-sent', { id, delivered: result.delivered });
       return result.delivered ? { chat: 'webpush', message: id } : null;

package/src/discord-self-message.ts

@@ -64,7 +64,7 @@ import { getUserConfig } from './user-config.js';
 import { detectCard, runCardFollowup, NotACardError } from './card-followup/core.js';
 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 { readSlashContextNow, renderContextFirstNow, renderTelegramNow } from './context-bus/context-now-surfaces.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';
@@ -160,7 +160,7 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
   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));
+      await deps.getBot()?.sendMessage(channelId, renderContextFirst(contextNow, deps.nowDeps, renderContextFirstNow));
     } catch (err) {
       log(`discord context-first failed: ${err instanceof Error ? err.message : String(err)}`);
     }