elanous 0.2.21 → 0.2.23

package/src/domains/coo-admin-tool.ts

@@ -4,10 +4,23 @@ import { getUserConfig } from '../user-config.js';
 import { getSecretAsync } from '../nexus/config/secrets/index.js';
 import { fetchLinearProjectIssues, type LinearProjectIssue } from '../connectors/linear.js';
 import { formatElanousCard } from './elanous-card.js';
+import recordedDateEvidence from './coo-admin-dates.evidence.json';
+
+type CooDateEvidence = {
+  project: string;
+  verifiedIssues: Array<{
+    identifier: string;
+    title: string;
+    url: string;
+    officialDeadline: string | null;
+    preparationPeriod: string | { start: string } | null;
+    representativeActionDate: string | null;
+  }>;
+};
 
 export const COO_ADMIN_SPEC: LLMToolSpec = {
   name: 'coo_admin',
-  description: '읽기 전용 Linear COO 행정 조회 — «행정 뭐 남았어 · COO 할 일 · 마감 다가오는 행정» 질문에 사용. 외부 행정 프로젝트의 열린 일을 마감 순으로 읽는다.',
+  description: '읽기 전용 Linear COO 행정 조회 — «행정 뭐 남았어 · COO 할 일 · 마감 다가오는 행정» 질문에 사용. 외부 행정 프로젝트의 열린 일을 우선순위와 확인된 날짜 근거로 브리핑한다.',
   parameters: { type: 'object', properties: {}, required: [] },
 };
 
@@ -16,6 +29,8 @@ export interface CooAdminDeps {
   fetch?: typeof fetch;
   project?: string;
   now?: Date;
+  dateEvidence?: CooDateEvidence;
+  briefing?: boolean;
 }
 
 /** Reads the configured Linear project without changing any Linear issue. */
@@ -32,27 +47,73 @@ export async function dispatchCooAdmin(_args: Record<string, unknown>, deps: Coo
     const issues = await fetchLinearProjectIssues({ apiKey, project, fetch: deps.fetch ?? fetch });
     const today = deps.now ?? new Date();
     const todayUtc = Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate());
-    const daysUntil = (date: string) => Math.round((Date.parse(`${date.slice(0, 10)}T00:00:00Z`) - todayUtc) / 86_400_000);
+    const daysUntil = (date: string) => Math.round((Date.parse(`${date}T00:00:00Z`) - todayUtc) / 86_400_000);
+    const dateEvidence = deps.dateEvidence ?? (recordedDateEvidence as CooDateEvidence);
+    const verifiedDate = (date: string | null | undefined): string | null => {
+      if (!date || !/^\d{4}-\d{2}-\d{2}$/.test(date)) return null;
+      const time = Date.parse(`${date}T00:00:00Z`);
+      return Number.isFinite(time) && new Date(time).toISOString().slice(0, 10) === date ? date : null;
+    };
+    const evidenceFor = (item: LinearProjectIssue) => dateEvidence.project === project
+      ? dateEvidence.verifiedIssues.find(row => row.identifier === item.identifier && row.url === item.url && row.title === item.title)
+      : undefined;
+    const deadlineFor = (item: LinearProjectIssue) => verifiedDate(evidenceFor(item)?.officialDeadline);
+    const rank = (item: LinearProjectIssue) => item.priority === 0 ? 5 : item.priority;
+    if (deps.briefing) {
+      const todayKst = new Date(today.getTime() + 9 * 3_600_000).toISOString().slice(0, 10);
+      const day = (date: string) => Date.parse(`${date}T00:00:00Z`);
+      const todayDay = day(todayKst);
+      const byDeadline = (a: LinearProjectIssue, b: LinearProjectIssue) =>
+        day(deadlineFor(a)!) - day(deadlineFor(b)!) || rank(a) - rank(b) || a.identifier.localeCompare(b.identifier);
+      const dated = issues.filter(item => deadlineFor(item) !== null).sort(byDeadline);
+      const format = (item: LinearProjectIssue) => {
+        const due = deadlineFor(item);
+        const representative = verifiedDate(evidenceFor(item)?.representativeActionDate);
+        const priority = item.priority === 1 ? 'Urgent' : item.priority === 2 ? 'High' : `우선순위 ${item.priority || '미지정'}`;
+        const title = item.title.replace(/[\r\n\u2028\u2029]+/g, ' ').trim();
+        const url = item.url.replace(/[\r\n\u2028\u2029]+/g, '');
+        return `- ${due ? `확인된 마감일 ${due}` : '기한 미확인'} · ${priority} · ${title}${representative ? ` · 대표 손이 필요한 날 ${representative}` : ''}\n  ${url}`;
+      };
+      const overdueItems = dated.filter(item => day(deadlineFor(item)!) < todayDay);
+      const upcoming = dated.filter(item => day(deadlineFor(item)!) >= todayDay && day(deadlineFor(item)!) <= todayDay + 14 * 86_400_000);
+      const later = dated.filter(item => day(deadlineFor(item)!) > todayDay + 14 * 86_400_000);
+      const unknown = issues.filter(item => deadlineFor(item) === null).sort((a, b) => rank(a) - rank(b) || a.identifier.localeCompare(b.identifier));
+      debug.log('coo.admin', 'read', { count: issues.length, overdue: overdueItems.length, reason: 'ok' });
+      return [issues.truncated ? '조회 상한 250건 · 아래 목록은 일부이며 빠진 항목의 기한은 측정 불가' : '',
+        `지난 기한 ${overdueItems.length}건\n${overdueItems.map(format).join('\n') || '없음'}`,
+        `14일 안 기한 ${upcoming.length}건\n${upcoming.map(format).join('\n') || '없음'}`,
+        ...(later.length || unknown.length ? [`그 밖 · 14일 이후 ${later.length}건 · 기한 미확인 ${unknown.length}건\n${[...later, ...unknown].map(format).join('\n')}`] : []),
+      ].filter(Boolean).join('\n');
+    }
     issues.sort((a, b) => {
-      const deadlineOrder = a.dueDate == null ? (b.dueDate == null ? 0 : 1)
-        : b.dueDate == null ? -1 : daysUntil(a.dueDate) - daysUntil(b.dueDate);
-      return deadlineOrder || (a.priority === 0 ? 5 : a.priority) - (b.priority === 0 ? 5 : b.priority);
+      const aDue = deadlineFor(a);
+      const bDue = deadlineFor(b);
+      return rank(a) - rank(b) || (aDue === null ? (bDue === null ? 0 : 1)
+        : bDue === null ? -1 : daysUntil(aDue) - daysUntil(bDue));
     });
     count = issues.length;
     const lines = issues.map((item: LinearProjectIssue) => {
-      const days = item.dueDate ? daysUntil(item.dueDate) : null;
+      const evidence = evidenceFor(item);
+      const due = deadlineFor(item);
+      const days = due ? daysUntil(due) : null;
       if (days !== null && days < 0) overdue++;
-      const deadline = days === null ? '마감 없음' : days < 0 ? `지남 ${-days}일` : `D-${days}`;
-      return `${deadline} · ${item.title} · ${item.state.name} · ${item.assignee?.name ?? '미배정'}\n${item.url}`;
+      const deadline = due ? `확인된 마감일 ${due} (${days !== null && days < 0 ? `지남 ${-days}일` : `D-${days}`})` : '기한 미확인 · 확인 예정일 미정';
+      const preparation = verifiedDate(typeof evidence?.preparationPeriod === 'string'
+        ? evidence.preparationPeriod : evidence?.preparationPeriod?.start);
+      const representative = verifiedDate(evidence?.representativeActionDate);
+      const dates = [preparation && `준비 시작일 ${preparation}`, representative && `대표 손이 필요한 날 ${representative}`].filter(Boolean);
+      return `${deadline} · 우선순위 ${item.priority || '미지정'} · ${item.title} · ${item.state.name} · ${item.assignee?.name ?? '미배정'}${dates.length ? ` · ${dates.join(' · ')}` : ''}\n${item.url}`;
     });
     debug.log('coo.admin', 'read', { count, overdue, reason: 'ok' });
-    const scope = issues.truncated ? '최대 250건 중 조회한 항목만 마감 순으로 표시 (이후 항목은 포함되지 않음)\n' : '';
+    const scope = issues.truncated ? '최대 250건 중 조회한 항목만 우선순위·확인된 마감 순으로 표시 (이후 항목은 포함되지 않음)\n' : '';
     const prose = lines.length ? `${scope}${lines.join('\n')}` : '남은 행정 0건';
-    const card = formatElanousCard({ kind: 'coo-admin', items: issues.map(item => ({
-      title: item.title, due: item.dueDate?.slice(0, 10) ?? null,
-      daysLeft: item.dueDate ? daysUntil(item.dueDate) : null,
-      state: item.state.name, owner: item.assignee?.name ?? '미배정', url: item.url,
-    })) });
+    const card = formatElanousCard({ kind: 'coo-admin', items: issues.map(item => {
+      const due = deadlineFor(item);
+      return {
+        title: item.title, due, daysLeft: due ? daysUntil(due) : null,
+        state: item.state.name, owner: item.assignee?.name ?? '미배정', url: item.url,
+      };
+    }) });
     return `${prose}\n${card}`;
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);

package/src/domains/cron-match.ts

@@ -13,6 +13,7 @@
 // 레포 내부 계약(src/time/format.ts)에 위임한다. 로컬 게터로 시/분/요일을 뽑으면
 // 프로세스 주변 TZ 에 종속돼 launchd 환경에서 조용히 어긋나기 때문.
 import { calendarFields, resolveTimeZone } from '../time/format.js';
+import '../user-config.js'; // Standalone catch-up queries share the saved timezone with the scheduler.
 
 // 한 파트 매칭 — 지원: 별표, 별표+스텝, 범위 a-b, 범위+스텝, 단일 값 n.
 function matchPart(part: string, value: number, min: number, max: number): boolean {

package/src/domains/ops-status.ts

@@ -26,6 +26,7 @@ import { loadMandate, type TradeMandate } from './trade-mandate.js';
 import { debug, redactSecretText } from '../debug/log.js';
 import { LogStore, logsDbPath, type LogStoreRow } from '../mss/logging/log-store.js';
 import { detectRepeatedFailures, explainFailure } from './repeated-failure.js';
+import { listLoops, loopRecentRuns, type LoopRun } from '../loops/registry.js';
 
 /** 예약 레지스트리 조회 관측 — 실패가 0으로 접히지 않게 남기는 창구. */
 export const OPS_STATUS_LOG_CATEGORY = 'ops.status';
@@ -34,6 +35,29 @@ export const OPS_SCHEDULES_LOOKUP_FAILED_EVENT = 'schedules.lookup-failed';
 /** 예약 레지스트리 행 조회 seam — 미지정 시 실 레지스트리 reader. */
 export type ListScheduleRows = () => ScheduleRow[];
 
+/** Graph-loop health input — run history is newest first. */
+export type GraphLoopRuns = () => Array<{
+  id: string;
+  enabled: boolean;
+  runs: Array<Pick<LoopRun, 'at' | 'status' | 'failedNodes'>>;
+}>;
+
+/** Bounded window per loop: a streak whose oldest read run is already >24h old is flagged; a longer
+ * all-failed history than this window can only under-report (never over-report) the streak length. */
+export const GRAPH_LOOP_HEALTH_RUN_WINDOW = 50;
+
+function defaultGraphLoopRuns(): ReturnType<GraphLoopRuns> {
+  const out: ReturnType<GraphLoopRuns> = [];
+  for (const loop of listLoops().filter(entry => entry.enabled)) {
+    // One unreadable run history must not hide the other loops.
+    try { out.push({ id: loop.id, enabled: loop.enabled, runs: loopRecentRuns(loop.id, {}, GRAPH_LOOP_HEALTH_RUN_WINDOW) }); }
+    catch (err) {
+      debug.log('ops.health', 'graph-loop-failure-skipped', { loop: loop.id, reason: redactSecretText(err instanceof Error ? err.message : String(err)) });
+    }
+  }
+  return out;
+}
+
 /** 조회 seam(테스트) — 미지정 시 실 스토어. */
 export interface OpsStatusOpts {
   now?: Date;
@@ -47,6 +71,8 @@ export interface OpsStatusOpts {
   planDraftFor?: (missionId: string) => string;
   /** Health-only log reader seam; the default reads the current instance's last ten minutes read-only. */
   recentLogs?: () => LogStoreRow[];
+  /** Health-only graph-loop registry reader; injection avoids the real state directory. */
+  graphLoopRuns?: GraphLoopRuns;
 }
 
 export interface CountByStatus { [status: string]: number }
@@ -341,6 +367,33 @@ export function opsHealth(opts: OpsStatusOpts = {}): OpsHealthReport {
     }
   }
 
+  // Graph-run history is independent of ops_events loops and of log-store failures.
+  try {
+    const loops = (opts.graphLoopRuns ?? defaultGraphLoopRuns)();
+    const nowMs = (opts.now ?? new Date()).getTime();
+    let flagged = 0;
+    for (const loop of loops) {
+      if (!loop.enabled) continue;
+      const runs = [...loop.runs].sort((a, b) => Date.parse(b.at) - Date.parse(a.at));
+      const failures = [] as typeof runs;
+      for (const run of runs) {
+        if (run.status !== 'failed') break;
+        failures.push(run);
+      }
+      const first = failures.at(-1);
+      if (failures.length < 2 || !first || !Number.isFinite(Date.parse(first.at)) || nowMs - Date.parse(first.at) <= 24 * 3600_000) continue;
+      anomalies.push({
+        kind: 'repeated_failure', entity: `loop:${loop.id}`,
+        detail: `그래프 루프 ${loop.id} 연속 실패 ${failures.length}회 · ${first.at} 부터 · 마지막 실패 노드 ${failures[0]!.failedNodes.join(', ')}`,
+        since: first.at,
+      });
+      flagged++;
+    }
+    debug.log('ops.health', 'graph-loop-failure', { loops: loops.length, flagged });
+  } catch (err) {
+    debug.log('ops.health', 'graph-loop-failure-skipped', { reason: redactSecretText(err instanceof Error ? err.message : String(err)) });
+  }
+
   // Independent log check: an unreadable log store must not hide task/loop/schedule anomalies.
   try {
     const recentLogs = opts.recentLogs ?? (() => {

package/src/domains/outbound-alert.ts

@@ -17,6 +17,7 @@ import { getUserConfig, type UserConfig } from '../user-config.js';
 import { resolveChannelBotToken } from '../channel-bot-token.js';
 import { explainReportRoute, isOperationalKind, kindRouteTarget, logKindRouteFallback, mainHomeTarget } from './telegram-kind-route.js';
 import { debug } from '../debug/log.js';
+import type { AddBriefItem } from '../briefing/brief-items.js';
 import { registerLogStoreSink, setLogInstanceName } from '../mss/logging/log-store.js';
 import type { LogSink } from '../mss/logging/sink.js';
 import { resolveDaemonEndpoint } from '../nexus/daemon-endpoint.js';
@@ -25,7 +26,7 @@ import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js'
 //   import 라 런타임 순환 없음(발송 로직은 이 파일에 self-contained). origin 없으면 report 폴백.
 import type { MissionOrigin } from '../autopilot/mission-origin.js';
 import { conatusDataDir, conatusPath } from './conatus-data-dir.js';
-import { assertNoRealSendFromTest, assertNotTestWritingOps, isTestDouble } from '../instance/test-write-guard.js';
+import { assertNoRealSendFromTest, assertNotTestWritingOps, isTestDouble, TestOpsWriteRefusedError } from '../instance/test-write-guard.js';
 
 /** Explicit `ELANOUS_NEXUS_URL` wins. Otherwise ask the daemon endpoint resolver.
  *  A missing daemon is not a guessed port — the caller falls through to direct send. */
@@ -626,6 +627,7 @@ export function deliver(text: string, kind = 'alert', onBot?: (bot: string) => v
   }
   // 2) fallback: 텔레그램 sendMessage 직접(3900자 분할) — 데몬 미경유라 클라가 원장 기록.
   //    The same config judges the route and explains a failure (review r1).
+  //    deliver → sendTelegramDirect: the refusal propagates to the caller instead of becoming «undeliverable».
   let cfg: UserConfig | undefined;
   try { cfg = getUserConfig(); } catch { /* sendTelegramDirect fails closed without config */ }
   if (sendTelegramDirect(text, kind, cfg ? { config: cfg } : {}, onBot)) return 'direct';
@@ -633,6 +635,13 @@ export function deliver(text: string, kind = 'alert', onBot?: (bot: string) => v
   return false;
 }
 
+type UndeliverableRecorder = (item: AddBriefItem) => void;
+let undeliverableRecorder: UndeliverableRecorder | null = null;
+/** Replace the ledger writer in tests; null restores the production ledger. */
+export function setUndeliverableRecorder(recorder: UndeliverableRecorder | null): void {
+  undeliverableRecorder = recorder;
+}
+
 /** OB8b — both paths failed: say so loudly, with the universe this process resolved, instead of a silent false.
  *  The usual cause (10-01 · MK): an ad-hoc `bun -e` or a script from a source tree resolves a cwd-derived test
  *  universe, so it finds neither the production daemon nor the production bot token. */
@@ -647,7 +656,22 @@ function reportUndeliverable(kind: string, daemonPath: DaemonPathClass | 'not-fo
   let route: ReturnType<typeof explainReportRoute> | null = null;
   try { if (cfg) route = explainReportRoute(cfg, kind); } catch { /* the report still goes out */ }
   ensureOutboundLogSink();
-  try { debug.log('outbound.send', 'undeliverable', { kind: safeObservationLabel(kind), daemonPath, universe, root, route: route?.reason ?? 'unknown' }); } catch { /* fail-soft */ }
+  const reason = route?.reason ?? 'unknown';
+  try { debug.log('outbound.send', 'undeliverable', { kind: safeObservationLabel(kind), daemonPath, universe, root, route: reason }); } catch { /* fail-soft */ }
+  try {
+    const record = undeliverableRecorder ?? ((item: AddBriefItem) => {
+      const { BriefItemsLedger } = require('../briefing/brief-items.js') as typeof import('../briefing/brief-items.js');
+      new BriefItemsLedger().add(item);
+    });
+    record({
+      domain: '운영', priority: 'P1', source: 'outbound.undeliverable',
+      text: `미전달: kind ${kind} · 데몬 ${daemonPath} · 경로 ${reason} · 우주 ${universe}`,
+      evidence: 'elanous logs --category outbound.send --event undeliverable',
+      dedupeKey: `${kind} · ${reason}`, dedupeWithinMs: 60 * 60_000,
+    });
+  } catch (error) {
+    try { debug.log('outbound.send', 'undeliverable-record-failed', { kind: safeObservationLabel(kind), route: reason, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+  }
   const hint = universe === 'prod'
     ? '운영 데몬이 떠 있는지 확인: elanous nexus show'
     : '운영으로 보내려면 설치본 elanous 로 실행하거나 ELANOUS_STATE_DIR=~/.elanous 와 --config-dir ~/.elanous 를 준다';
@@ -681,16 +705,26 @@ export function sendTelegramDirect(
   deps: { config?: UserConfig; sendRaw?: typeof sendTelegramRaw; legacyEnv?: typeof conatusEnv } = {},
   onBot?: (bot: string) => void,
 ): boolean {
-  const sendRaw = deps.sendRaw ?? sendTelegramRaw;
-  // An injected sender still may not run in a test that resolved the ops universe.
-  if (deps.sendRaw) assertTestSendFaked('send a Telegram message from the ops universe', false);
+  const sendRaw = (token: string, chatId: string | number, body: string): boolean => {
+    // The transport is checked only after a route is eligible; a test double cannot target the ops universe.
+    assertTestSendFaked('send a real Telegram message', !deps.sendRaw);
+    return (deps.sendRaw ?? sendTelegramRaw)(token, chatId, body);
+  };
   let cfg: UserConfig | undefined;
   try { cfg = deps.config ?? getUserConfig(); } catch { /* unavailable config: operational delivery still fails closed */ }
   if (cfg) {
     try {
       const target = kindRouteTarget(cfg, kind);
-      if (target) { onBot?.(botLabel(target.botToken)); return sendRaw(target.botToken, String(target.chatId), text); }
-    } catch { /* unavailable channel routing: fall through */ }
+      if (target) {
+        // Refusal must escape the routing fallback; other routing/callback/transport failures retain that fallback.
+        assertTestSendFaked('send a real Telegram message', !deps.sendRaw);
+        onBot?.(botLabel(target.botToken));
+        return (deps.sendRaw ?? sendTelegramRaw)(target.botToken, String(target.chatId), text);
+      }
+    } catch (error) {
+      if (error instanceof TestOpsWriteRefusedError) throw error;
+      /* unavailable channel routing: fall through */
+    }
     // A declared table is authoritative: missing roles cannot escape to an env bot.
     if (cfg.telegram.channels?.length) {
       logKindRouteFallback(kind, 'none', false);

package/src/domains/release-tool.ts

@@ -1,17 +1,31 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import type { LLMToolSpec } from '../llm.js';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import { contextNow, type ContextNowAnswer, type ContextFact } from '../context-bus/context-now.js';
 import type { ToolRuntimeContext } from '../tool-runtime/types.js';
 import { debug } from '../debug/log.js';
 import { requestConfirmation, type ConfirmOpts, type ConfirmResult } from '../hitl/confirm.js';
-import { devVersion, checklistDevVersion, listChecklist, summarizeChecklist, type Checklist } from '../release-loop/checklist.js';
+import { devVersion, checklistDevVersion, listChecklist, summarizeChecklist, type Checklist, type ChecklistItem } from '../release-loop/checklist.js';
 import { add, move, validateVersion } from '../release-loop/feature-store.js';
-import { formatKst, getSchedule, setSchedule, type ReleaseSchedule } from '../release-loop/release-schedule.js';
+import { formatKst, formatSchedule, getSchedule, listSchedules, setSchedule, type ReleaseSchedule } from '../release-loop/release-schedule.js';
 import { latestGraphRun, type GraphRunState } from '../graph-runner/runner.js';
 import { formatElanousCard, type ElanousCard } from './elanous-card.js';
 
 export const RELEASE_STATUS_SPEC: LLMToolSpec = {
   name: 'release_status',
-  description: '판 어디까지 · 컷 언제 · 릴리스 상황 · 판올림 · 체크리스트 · 남은 칸을 읽는다. 판 일정, 빨강 칸, 담당별 노랑, 최근 발행 런을 조회하는 읽기 전용 도구. 행정 업무는 coo_admin.',
-  parameters: { type: 'object', properties: { version: { type: 'string', description: '조회할 판. 생략하면 개발 판과 다음 판.' } }, required: [] },
+  description: '판 어디까지 · 컷 언제 · 릴리스 상황 · 판올림 · 체크리스트 · 남은 칸을 읽는다. 판 일정, 빨강 칸, 담당별 노랑, 최근 발행 런을 조회하는 읽기 전용 도구. 행정 업무는 coo_admin.\n'
+    + 'topic=status(기본): 개발·다음 판 현황과 발행 원장.\n'
+    + 'topic=features: 지정 판의 모든 피처·칸(끝난 칸 포함).\n'
+    + 'topic=cell: id 칸 하나의 상태·근거와 살핀 판.\n'
+    + 'topic=schedule: 발행 이후 판의 컷·착지·발행·동결 일정.\n'
+    + 'topic=ops: 도는 런·발행·늦은 스케줄·자리·열린 결정의 출처 있는 개관.\n'
+    + '발행·버전·피처·체크리스트·칸·컷·일정·운영 상태 질문은 Grep·ListDir·파일 검색보다 이 도구를 먼저 부른다 — 그 답은 파일이 아니라 원장에 있다.',
+  parameters: { type: 'object', properties: {
+    version: { type: 'string', description: '조회할 판. 생략하면 개발 판과 다음 판.' },
+    topic: { type: 'string', enum: ['status', 'features', 'cell', 'schedule', 'ops'], description: '읽을 대상(기본 status).' },
+    id: { type: 'string', description: 'topic=cell 때 찾을 칸 id(필수).' },
+  }, required: [] },
 };
 
 export const RELEASE_CHANGE_SPEC: LLMToolSpec = {
@@ -35,6 +49,9 @@ export interface ReleaseToolDeps {
   devVersion?: () => string;
   checklist?: (version: string) => Checklist;
   schedule?: (version: string) => ReleaseSchedule | null;
+  schedules?: () => ReleaseSchedule[];
+  publishedRecord?: (version: string) => unknown;
+  contextNow?: (options: { topic?: string }) => ContextNowAnswer;
   latestRun?: (graphId: string) => GraphRunState | null;
   confirm?: (options: ConfirmOpts) => Promise<ConfirmResult>;
   add?: typeof add;
@@ -61,18 +78,106 @@ function dDay(days: number): string {
   return days < 0 ? `D+${-days}` : days === 0 ? 'D-day' : `D-${days}`;
 }
 
+type Published = { version: string | null; publishedAt: string | null; state: 'published' | 'no-record' | 'unreadable' | 'unknown' };
+
+function readPublishedRecord(version: string): unknown {
+  return JSON.parse(readFileSync(join(releaseLedgerRoot(), 'release', version, 'release.json'), 'utf8'));
+}
+
+function publishedStatus(released: string, deps: ReleaseToolDeps): Published {
+  if (!released) return { version: null, publishedAt: null, state: 'unknown' };
+  try {
+    const raw: unknown = (deps.publishedRecord ?? readPublishedRecord)(released);
+    if (raw === undefined || raw === null) return { version: released, publishedAt: null, state: 'no-record' };
+    const record: unknown = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    if (record && typeof record === 'object' && 'version' in record && 'publishedAt' in record
+      && record.version === released && typeof record.publishedAt === 'string' && Number.isFinite(Date.parse(record.publishedAt))) {
+      return { version: released, publishedAt: record.publishedAt, state: 'published' };
+    }
+    throw new Error('release.json 의 version 또는 publishedAt 가 잘못됨');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') return { version: released, publishedAt: null, state: 'no-record' };
+    const reason = error instanceof Error ? error.message : String(error);
+    debug.log('release.tool', 'published-unreadable', { version: released, reason });
+    return { version: released, publishedAt: null, state: 'unreadable' };
+  }
+}
+
+function firstLine(text: string): string { return text.split(/\r?\n/, 1)[0] ?? ''; }
+
+function versionOrder(a: string, b: string): number {
+  const left = a.split('.').map(Number), right = b.split('.').map(Number);
+  return (left[0]! - right[0]!) || (left[1]! - right[1]!) || (left[2]! - right[2]!);
+}
+
+function cellView(item: ChecklistItem) {
+  return { id: item.id, title: firstLine(item.title), status: item.status,
+    owner: item.owner ?? null, priority: item.priority ?? null, evidence: item.evidence ? firstLine(item.evidence) : null };
+}
+
 export function dispatchReleaseStatus(args: Record<string, unknown>, deps: ReleaseToolDeps = {}): { text: string; structured: Record<string, unknown> } {
+  const topic = args.topic === undefined ? 'status' : args.topic;
+  if (typeof topic !== 'string' || !['status', 'features', 'cell', 'schedule', 'ops'].includes(topic)) throw new Error('topic 은 status, features, cell, schedule, ops 중 하나');
   const requested = args.version;
   if (requested !== undefined && (typeof requested !== 'string' || !requested.trim())) throw new Error('판 이름이 필요합니다');
-  const version = requested ? null : checklistDevVersion(deps.devVersion?.() ?? devVersion());
+  const checklist = deps.checklist ?? listChecklist;
+  if (topic === 'ops') {
+    const answer = (deps.contextNow ?? contextNow)({});
+    const kinds: ContextFact['kind'][] = ['run', 'release', 'schedule-late', 'seat', 'decision'];
+    const facts = answer.facts.filter(fact => kinds.includes(fact.kind));
+    debug.log('release.tool', 'status', { action: 'status', topic, version: requested ?? null });
+    return { text: facts.length ? facts.map(fact => JSON.stringify(fact)).join('\n') : '운영 개관: 관측된 사실 없음', structured: { facts } };
+  }
+  const dev = checklistDevVersion(deps.devVersion?.() ?? devVersion());
+  if (topic === 'features' || topic === 'cell' || topic === 'schedule') {
+    let result: { text: string; structured: Record<string, unknown> };
+    if (topic === 'features') {
+      const target = (requested as string | undefined) ?? dev;
+      validateVersion(target);
+      const data = checklist(target);
+      const counts = summarizeChecklist(data);
+      const items = data.items.slice(0, 60).map(({ id, title, status, owner, priority }) =>
+        ({ id, title: firstLine(title), status, owner: owner ?? null, priority: priority ?? null }));
+      const total = data.items.length;
+      result = { text: `${target} 판 피처 ${total}칸 · 초록 ${counts.green} · 노랑 ${counts.yellow} · 빨강 ${counts.red} · 끝 ${counts.done}\n${items.map(item => `${item.id} ${item.title} · ${item.status} · ${item.owner ?? '미배정'}`).join('\n')}${total > 60 ? `\n앞 60칸만 표시(전체 ${total}칸)` : ''}`,
+        structured: { version: target, items, counts: { green: counts.green, yellow: counts.yellow, red: counts.red, done: counts.done }, total, truncated: total > 60 } };
+    } else if (topic === 'cell') {
+      const id = requiredString(args, 'id');
+      const searched = requested ? [requested as string] : [...new Set([dev, nextVersion(dev), checklist(dev).released].filter(Boolean))];
+      let found: { version: string; item: ChecklistItem } | undefined;
+      const examined: string[] = [];
+      for (const v of searched) {
+        validateVersion(v);
+        examined.push(v);
+        const item = checklist(v).items.find(item => item.id === id);
+        if (item) { found = { version: v, item }; break; }
+      }
+      result = found
+        ? { text: `${found.version} · ${id} ${firstLine(found.item.title)} · ${found.item.status} · 담당 ${found.item.owner ?? '미배정'}${found.item.evidence ? ` · 근거 ${firstLine(found.item.evidence)}` : ''}`,
+          structured: { found: true, version: found.version, item: cellView(found.item) } }
+        : { text: `${id} · 살핀 판(${examined.join(', ')})에 없음`, structured: { found: false, searched: examined } };
+    } else {
+      const released = checklist(dev).released;
+      const schedules = (deps.schedules ?? listSchedules)().filter(row => !released || versionOrder(row.version, released) > 0)
+        .sort((a, b) => versionOrder(a.version, b.version));
+      result = { text: schedules.length ? schedules.map(formatSchedule).join('\n') : '살핀 판에 일정 없음',
+        structured: { schedules: schedules.map(row => ({ version: row.version, cutAt: row.cutAt, landBy: row.landBy,
+          publishAt: row.publishAt ?? null, freezeFrom: row.freezeFrom ?? null, freezeUntil: row.freezeUntil ?? null })) } };
+    }
+    debug.log('release.tool', 'status', { action: 'status', topic, version: requested ?? dev });
+    return result;
+  }
+  const version = requested ? null : dev;
   const versions = requested ? [requested as string] : [version!, nextVersion(version!)];
   const now = deps.now ?? new Date();
   const run = (deps.latestRun ?? latestGraphRun)('release-loop');
   const latest = run ? { status: run.status, lastNode: run.path.at(-1) ?? null, startedAt: run.startedAt ?? null } : null;
+  let devChecklist: Checklist | undefined;
   const entries = versions.map(v => {
     validateVersion(v);
     const schedule = (deps.schedule ?? getSchedule)(v);
     const data = (deps.checklist ?? listChecklist)(v);
+    if (v === dev) devChecklist = data;
     const summary = summarizeChecklist(data);
     const red = data.items.filter(item => item.status === 'red').map(({ id, title, owner }) => ({ id, title, owner: owner ?? '미배정' }));
     const yellowByOwner: Record<string, number> = {};
@@ -84,12 +189,12 @@ export function dispatchReleaseStatus(args: Record<string, unknown>, deps: Relea
     const landDaysLeft = schedule?.landBy ? daysLeft(schedule.landBy, now) : null;
     const cutHoursLeft = schedule ? Math.ceil((Date.parse(schedule.cutAt) - now.getTime()) / 3_600_000) : null;
     const landHoursLeft = schedule?.landBy ? Math.ceil((Date.parse(schedule.landBy) - now.getTime()) / 3_600_000) : null;
-    return { version: v, schedule: schedule ? { cutAt: schedule.cutAt, landBy: schedule.landBy, cutDaysLeft, landDaysLeft, cutHoursLeft, landHoursLeft } : null,
+    return { version: v, schedule: schedule ? { cutAt: schedule.cutAt, landBy: schedule.landBy, publishAt: schedule.publishAt ?? null, cutDaysLeft, landDaysLeft, cutHoursLeft, landHoursLeft } : null,
       counts: { green: summary.green, yellow: summary.yellow, red: summary.red, done: summary.done }, red, yellowByOwner };
   });
   const lines = entries.map(entry => {
     const schedule = entry.schedule;
-    return `${entry.version} · 컷 ${schedule ? formatKst(schedule.cutAt) : '미정'}${schedule?.landBy ? ` · 착지 마감 ${formatKst(schedule.landBy)}` : ' · 착지 마감 미정'}${schedule ? ` · 컷 ${dDay(schedule.cutDaysLeft!)} (${schedule.cutHoursLeft}시간)${schedule.landDaysLeft !== null ? ` · 착지 ${dDay(schedule.landDaysLeft)} (${schedule.landHoursLeft}시간)` : ''}` : ''}\n` +
+    return `${entry.version} · 컷 ${schedule ? formatKst(schedule.cutAt) : '미정'}${schedule?.landBy ? ` · 착지 마감 ${formatKst(schedule.landBy)}` : ' · 착지 마감 미정'}${schedule ? ` · 컷 ${dDay(schedule.cutDaysLeft!)} (${schedule.cutHoursLeft}시간)${schedule.landDaysLeft !== null ? ` · 착지 ${dDay(schedule.landDaysLeft)} (${schedule.landHoursLeft}시간)` : ''}` : ''}${schedule?.publishAt ? ` · 발행 ${formatKst(schedule.publishAt).split(' ')[1]} KST` : ''}\n` +
       `초록 ${entry.counts.green} · 노랑 ${entry.counts.yellow} · 빨강 ${entry.counts.red} · 끝 ${entry.counts.done}\n` +
       `빨강 칸: ${entry.red.length ? entry.red.map(item => `${item.id} ${item.title} (${item.owner})`).join(', ') : '없음'}\n` +
       `담당별 노랑: ${Object.keys(entry.yellowByOwner).length ? Object.entries(entry.yellowByOwner).map(([owner, count]) => `${owner} ${count}`).join(', ') : '없음'}`;
@@ -99,9 +204,13 @@ export function dispatchReleaseStatus(args: Record<string, unknown>, deps: Relea
     { kind: 'release-schedule', items: entries.map(entry => ({ title: `${entry.version} 컷`, due: entry.schedule ? kstDate(entry.schedule.cutAt) : null, daysLeft: entry.schedule?.cutDaysLeft ?? null, state: entry.schedule ? 'scheduled' : 'undecided', owner: 'release' })), meta: { versions: entries.map(entry => entry.version) } },
     { kind: 'release-checklist', items: entries.flatMap(entry => entry.red.map(item => ({ title: `${item.id} ${item.title}`, due: null, daysLeft: null, state: 'red', owner: item.owner }))), meta: { counts: entries.map(entry => ({ version: entry.version, ...entry.counts })) } },
   ];
-  const structured = { releases: entries, latestRun: latest };
-  debug.log('release.tool', 'status', { action: 'status', version: versions.join(',') });
-  return { text: `${lines.join('\n\n')}\n${cards.map(formatElanousCard).join('\n')}`, structured };
+  const published = publishedStatus((devChecklist ?? checklist(dev)).released, deps);
+  const publishedLine = published.state === 'published' ? `발행 판 ${published.version} · 발행 ${formatKst(published.publishedAt!)}`
+    : published.state === 'no-record' ? `발행 판 ${published.version} · 발행 기록 없음`
+    : published.state === 'unreadable' ? `발행 판 ${published.version} · 발행 기록 못 읽음` : '발행 판 모름';
+  const structured = { releases: entries, latestRun: latest, published };
+  debug.log('release.tool', 'status', { action: 'status', topic, version: versions.join(',') });
+  return { text: `${lines.join('\n\n')}\n${cards.map(formatElanousCard).join('\n')}\n${publishedLine}`, structured };
 }
 
 function requiredString(args: Record<string, unknown>, key: string): string {

package/src/domains/schedule-registry.ts

@@ -289,14 +289,17 @@ export function cronEntryId(cron: string, effectiveCommand: string): string {
   return createHash('sha1').update(cron + '|' + effectiveCommand).digest('hex').slice(0, 12);
 }
 
-/** ★ 관측성 래퍼 unwrap (RFC-scheduler-execution-observability·2026-07-15) — crontab 라인이
- *  `bun scripts/cron-run.ts --schedule-id <id> scripts/X.ts --a` 로 래핑돼도 id/name 파생은 안쪽 실제 target 기준으로.
- *  래퍼와 그 id 인자만 제거 → 래핑 전 원본과 동일 문자열 → id(sha1) 불변·마이그레이션 0.
- *  순수·멱등(비래핑 라인은 그대로 반환). */
+/** ★ 관측성 래퍼 unwrap (RFC-scheduler-execution-observability·2026-07-15) — hq-fence 한 겹을
+ *  먼저 벗긴 뒤 cron-run.ts 래퍼와 id 인자를 제거한다. id/name 파생은 안쪽 target 기준.
+ *  감싸지 않은 명령은 그대로 반환하며, 결과는 다시 unwrap 해도 같다. */
 export function unwrapCronCommand(command: string): string {
-  const shell = command.replace(/(?:\S*\/)?bun\s+(?:\S*\/)?cron-run\.ts\s+(?:--schedule-id\s+\S+\s+)?--shell\s+/, '');
-  if (shell !== command) return shell;
-  return command.replace(/(?:[^\s]*\/)?cron-run\.ts\s+(?:--schedule-id\s+\S+\s+)?/, '');
+  // 작은따옴표 인코딩('"'"' · '\'')만 복원한다. 닫힌 인용 뒤의 바깥 로그 리다이렉트는 버리고,
+  // 줄 끝 `# 주석` 은 감싸기 전 줄과 같은 꼴이 되도록 안쪽 명령 뒤에 그대로 붙인다.
+  const fence = /^(?:\S*\/)?hq-fence\s+(?:--role\s+[^\s'"]+(?:\s+--)?|[^\s'"]+)\s+'((?:[^']|'"'"'|'\\'')*)'(?:\s+(?:\d*>>?\s*\S+|\d+>&\d+))*(\s+#.*)?$/.exec(command);
+  const inner = fence ? fence[1]!.replaceAll(`'"'"'`, "'").replaceAll(`'\\''`, "'") + (fence[2] ?? '') : command;
+  const shell = inner.replace(/(?:\S*\/)?bun\s+(?:\S*\/)?cron-run\.ts\s+(?:--schedule-id\s+\S+\s+)?--shell\s+/, '');
+  if (shell !== inner) return shell;
+  return inner.replace(/(?:[^\s]*\/)?cron-run\.ts\s+(?:--schedule-id\s+\S+\s+)?/, '');
 }
 
 /** crontab 라인을 관측성 래퍼로 감싼다(P3) — `bun scripts/X.ts` → `bun scripts/cron-run.ts --schedule-id <id> scripts/X.ts`.

package/src/domains/schedule-runner.ts

@@ -26,6 +26,7 @@ import { openSchedulesDb, listSchedules, readCrontab, parseCronLine, scriptName,
 import { recordScheduledExecution } from './schedule-observability.js';
 import { prevScheduledFire } from './cron-match.js';
 import { resolveTimeZone } from '../time/format.js';
+import '../user-config.js'; // Register the saved timezone before selecting the firing and catch-up clock.
 import { debug } from '../debug/log.js';
 
 interface CronTaskLike { stop(): void }

package/src/elanous-config-dir.ts

@@ -37,7 +37,7 @@ function warnIfIgnoredEnv(resolved: string, source: 'flag' | 'state-dir' | 'defa
   if (env === undefined || normalizedDir(env) === normalizedDir(resolved)) return;
   console.error(`ELANOUS_CONFIG_DIR 는 읽지 않습니다 — 설정 폴더 = ${resolved} · 그 폴더를 쓰려면 --config-dir ${normalizedDir(env)}`);
   try {
-    const { debug } = require('./debug/log.js') as typeof import('./debug/log.js');
+    const { debug } = require('./debug/log.js') as { debug: { log: (category: string, event: string, data: Record<string, unknown>) => void } };
     debug.log('config.dir', 'env-ignored', { env, resolved, source });
   } catch { /* logging must not change config resolution */ }
 }
@@ -63,7 +63,7 @@ export function getElanousConfigDir(): string {
   //     두 축이 한 뿌리로 수렴한다. 로직을 여기 중복 구현하지 않는다.
   //     (`configDirFollowingStateDir` 은 §4d 계약을 문서화·테스트하는 순수 함수로 남는다 —
   //      실제 해석 경로는 이 리졸버 하나다.)
-  const { effectiveInstanceRoot } = require('./instance/resolve.js') as typeof import('./instance/resolve.js');
+  const { effectiveInstanceRoot } = require('./instance/resolve.js') as { effectiveInstanceRoot: () => string };
   const resolved = effectiveInstanceRoot();
   warnIfIgnoredEnv(resolved, process.env.ELANOUS_STATE_DIR?.trim() ? 'state-dir' : 'default');
   return resolved;

package/src/elanous-daemon.ts

@@ -33,7 +33,7 @@ import {
   type LockMeta,
 } from './telegram-lock.js';
 
-import { defaultUnixSocketPath } from './boot/acp-server.js';
+import { defaultUnixSocketPath } from './boot/acp-socket-path.js';
 
 export type ElanousDaemonLockMeta = LockMeta;
 export class ElanousDaemonLockError extends TelegramLockError {}
@@ -56,8 +56,8 @@ export function elanousDaemonLogPath(): string {
   return joinPath(elanousDaemonDir(), 'elanous.log');
 }
 
-/** Default unix socket path the daemon binds. Re-exported from
- *  `boot/acp-server.ts` so callers don't have to chase the source. */
+/** Default unix socket path the daemon binds. Resolved from
+ *  `boot/acp-socket-path.ts` without loading the ACP server. */
 export function elanousDaemonSocketPath(): string {
   return defaultUnixSocketPath();
 }

package/src/exec-requests/planner.ts

@@ -7,6 +7,7 @@ import { defaultGraphsDir } from '../self-implement/graph-templates.js';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import type { ExecAttachment } from './store.js';
 import { debug } from '../debug/log.js';
+import { peerEditRunGate } from '../nexus/api/graph-peer-edit.js';
 import { OUTPUT_KINDS, pickDefaultOutput, type OutputKind } from './default-outputs.js';
 
 export interface InstalledGraph {
@@ -105,6 +106,11 @@ async function coreAndMineGraphs(coreDir: string, mineDir: string): Promise<Inst
           const id = doc?.graph_id;
           if (typeof id !== 'string' || !/^[a-z0-9-]+$/.test(id) || seen.has(id)) continue;
           if (core && doc?.loop?.exec_request !== true) continue;
+          // W9c — a «mine» graph a peer changed is not runnable until the owner approves it (fail closed).
+          if (!core) {
+            const gate = peerEditRunGate(dir, id);
+            if (!gate.ok) { debug.log('exec-requests', 'skipped-peer-edit', { id, error: gate.error }); continue; }
+          }
           const inputs = doc?.loop?.inputs;
           const inputKeys = core && Array.isArray(inputs)
             ? inputs.filter((key): key is string => typeof key === 'string')

package/src/execution-loop/launch-gate.ts

@@ -22,7 +22,7 @@ export interface ActiveRunsForGoalDeps {
 /** Only a live process with an exact goal ID or verbatim authored ask is a duplicate. Incomplete observation is not absence. */
 export function activeRunsForGoal(goalId: string, deps: ActiveRunsForGoalDeps = {}): ActiveRunsForGoal {
   try {
-    const observation = (deps.queryRuns ?? (() => queryRunningRuns({ includeTest: true, caller: 'execution-loop.launch-gate', noCache: true })))();
+    const observation = (deps.queryRuns ?? (() => queryRunningRuns({ includeTest: true, caller: 'execution-loop.launch-gate' })))();
     const loadLedger = deps.loadLedger ?? loadRunLedger;
     const readGoalDocument = deps.readGoalDocument ?? ((path: string) => readFileSync(path, 'utf8'));
     let unknown = observation.completeness !== 'complete' || observation.pty.unreadable.length > 0;

package/src/expression/i18n/messages.en.ts

@@ -39,6 +39,10 @@ export const messagesEn: Messages = {
   rangeError: 'Value must be between {min} and {max}.',
   patternError: '"{value}" does not match the expected pattern.',
 
+  // Chat fallback
+  chatNoSynthesisLead: 'I could not finish the answer — the time to summarize ran out after {n} tool calls. Please ask a narrower question (for example, just one thing).',
+  chatFoldedInternalTail: '● Internal notes folded · {n} lines · press f to expand',
+
   // Async + status
   loading: 'Loading…',
   saving: 'Saving…',
@@ -76,6 +80,7 @@ export const messagesEn: Messages = {
   setupBanner: 'elanous — setup wizard',
   setupWritingTo: 'Writing to: {path}',
   setupComplete: 'Setup complete',
+  setupErrorReportNotice: 'If something breaks, elanous reports the error to our team automatically (error details, version and a random install ID — never your name or email). To turn it off: elanous config set errorReports.enabled false',
   setupRerunHint: 'Re-run: {cmd}',
 
   // Setup wizard — Step 1 (LLM provider)