elanous 0.2.22 → 0.2.23

package/src/display/coordinator.ts

@@ -252,6 +252,15 @@ export class DisplayCoordinator {
   private readonly regionMap: RegionMap;
   private readonly termSize: () => TermSize;
   private readonly invalidateRow: (row0: number) => void;
+  /** TUI-SLASH-FLICKER — true when the host wired a real row
+   *  invalidator, so a region move can be repaired by a plain diff
+   *  frame instead of a forced full-screen repaint. */
+  private readonly hasRowInvalidator: boolean;
+  /** TUI-SLASH-FLICKER — the previous flush invalidated overlay rows
+   *  (region moved / vanished); the next flush must re-emit the overlay
+   *  even when its bytes are unchanged, because the base rows under it
+   *  were just repainted. Replaces the old forceNext follow-up. */
+  private overlayRowsInvalidated = false;
 
   private surfaces = new Map<SurfaceId, DisplaySurface>();
   private focusNodes = new Map<SurfaceId, FocusNode>();
@@ -536,6 +545,7 @@ export class DisplayCoordinator {
     this.regionMap = opts.regionMap ?? new DefaultRegionMap();
     this.termSize = opts.termSize ?? (() => ({ rows: 24, cols: 80 }));
     this.invalidateRow = opts.invalidateRow ?? (() => { /* no-op default */ });
+    this.hasRowInvalidator = typeof opts.invalidateRow === 'function';
 
     // H1.6 · W1 → W2 bridge. Whenever LayerTree announces a layer
     // state change (bounds / opacity / parent / zIndex), inform the
@@ -2848,8 +2858,10 @@ export class DisplayCoordinator {
     // region invalidation (V4 cascade above) handles the actual
     // erase by marking rows dirty in the main frame buffer.
     let overlaySkippedThisFlush = false;
+    const overlayRowsInvalidated = this.overlayRowsInvalidated;
+    this.overlayRowsInvalidated = false;
     if (ansi.length > 0) {
-      if (request.force || ansi !== this.prevOverlayAnsi) {
+      if (request.force || overlayRowsInvalidated || ansi !== this.prevOverlayAnsi) {
         this.writeOverlay(ansi);
         this.prevOverlayAnsi = ansi;
         this.overlayWritesEmitted++;
@@ -2875,7 +2887,18 @@ export class DisplayCoordinator {
     }
     this.lastOverlayRegions = currentRegions;
     if (vanished && !request.force) {
-      this.forceNext = true;
+      // TUI-SLASH-FLICKER (2026-10-09) — the prior region rows were
+      // invalidated above, so the follow-up frame's row diff already
+      // repaints exactly those rows. Forcing it reached tui.ts::render
+      // as a full-screen erase (`\x1b[1;1H\x1b[J`) every time the slash
+      // picker's height changed while typing — whole-screen flicker.
+      // Keep the blanket force only when no row invalidator is wired.
+      if (this.hasRowInvalidator) {
+        this.markDirty('all');
+        this.overlayRowsInvalidated = true;
+      } else {
+        this.forceNext = true;
+      }
       this.requestFrame();
     }
   }

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

@@ -30,6 +30,7 @@ export interface CooAdminDeps {
   project?: string;
   now?: Date;
   dateEvidence?: CooDateEvidence;
+  briefing?: boolean;
 }
 
 /** Reads the configured Linear project without changing any Linear issue. */
@@ -58,6 +59,32 @@ export async function dispatchCooAdmin(_args: Record<string, unknown>, deps: Coo
       : 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 aDue = deadlineFor(a);
       const bDue = deadlineFor(b);

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/outbound-alert.ts

@@ -26,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. */
@@ -627,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';
@@ -704,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/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)

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

@@ -39,6 +39,10 @@ export const messagesJa: Messages = {
   rangeError: '値は {min} から {max} の範囲で指定してください。',
   patternError: '"{value}" は想定された形式と一致しません。',
 
+  // Chat fallback
+  chatNoSynthesisLead: '回答を最後まで書けませんでした — ツールを {n} 回使ううちに、まとめる時間が尽きました。質問を絞ってもう一度聞いてください(例: ひとつだけ)。',
+  chatFoldedInternalTail: '● 内部記録を折りたたみ · {n} 行 · f で展開',
+
   // Async + status
   loading: '読み込み中…',
   saving: '保存中…',
@@ -76,6 +80,7 @@ export const messagesJa: Messages = {
   setupBanner: 'elanous — セットアップウィザード',
   setupWritingTo: '保存先: {path}',
   setupComplete: 'セットアップ完了',
+  setupErrorReportNotice: '問題が起きると、elanous はエラーを運営チームに自動で報告します(エラー内容・バージョン・ランダムなインストール ID — 名前やメールは送りません)。オフにするには: elanous config set errorReports.enabled false',
   setupRerunHint: '再実行: {cmd}',
 
   // Setup wizard — Step 1 (LLM provider)

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

@@ -39,6 +39,10 @@ export const messagesKo: Messages = {
   rangeError: '값은 {min}에서 {max} 사이여야 합니다.',
   patternError: '"{value}"이(가) 예상 형식과 일치하지 않습니다.',
 
+  // Chat fallback
+  chatNoSynthesisLead: '답을 끝까지 쓰지 못했습니다 — 도구를 {n}번 쓰는 동안 정리할 시간이 끝났습니다. 질문을 좁혀 다시 물어 주세요(예: 무엇 하나만).',
+  chatFoldedInternalTail: '● 내부 기록 접힘 · {n}줄 · f 로 펼치기',
+
   // Async + status
   loading: '불러오는 중…',
   saving: '저장 중…',
@@ -76,6 +80,7 @@ export const messagesKo: Messages = {
   setupBanner: 'elanous — 셋업 마법사',
   setupWritingTo: '저장 경로: {path}',
   setupComplete: '셋업 완료',
+  setupErrorReportNotice: '오류가 나면 운영팀에 자동으로 알립니다(오류 내용·버전·무작위 설치 ID — 이름·메일 없이). 끄기: elanous config set errorReports.enabled false',
   setupRerunHint: '다시 실행: {cmd}',
 
   // Setup wizard — Step 1 (LLM provider)

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

@@ -39,6 +39,10 @@ export const messagesZh: Messages = {
   rangeError: '值必须在 {min} 到 {max} 之间。',
   patternError: '"{value}" 不符合预期格式。',
 
+  // Chat fallback
+  chatNoSynthesisLead: '未能写完回答 — 在使用工具 {n} 次之后，整理的时间已用完。请缩小问题范围后再问一次(例如：只问一件事)。',
+  chatFoldedInternalTail: '● 内部记录已折叠 · {n} 行 · 按 f 展开',
+
   // Async + status
   loading: '加载中…',
   saving: '保存中…',
@@ -76,6 +80,7 @@ export const messagesZh: Messages = {
   setupBanner: 'elanous — 设置向导',
   setupWritingTo: '保存到: {path}',
   setupComplete: '设置完成',
+  setupErrorReportNotice: '出错时，elanous 会自动向运营团队报告错误(错误内容、版本和随机安装 ID — 不包含姓名或邮箱)。关闭方法: elanous config set errorReports.enabled false',
   setupRerunHint: '重新运行: {cmd}',
 
   // Setup wizard — Step 1 (LLM provider)

package/src/expression/i18n/types.ts

@@ -50,6 +50,12 @@ export interface Messages {
   /** Template — supplies `{value}`. */
   patternError: string;
 
+  // ── Chat fallback ────────────────────────────────────────────────
+  /** Template — supplies `{n}`. Optional for older locale bundles. */
+  chatNoSynthesisLead?: string;
+  /** Template — supplies `{n}`. Optional for older locale bundles. */
+  chatFoldedInternalTail?: string;
+
   // ── Async + status ───────────────────────────────────────────────
   loading: string;
   saving: string;
@@ -100,6 +106,8 @@ export interface Messages {
   setupWritingTo: string;
   /** Banner shown after the wizard saves the config. */
   setupComplete: string;
+  /** First-run notice that error reports are on by default — what is sent and how to turn it off. Keep the command untranslated. Optional so older bundles fall back to English. */
+  setupErrorReportNotice?: string;
   /** Template — supplies `{cmd}` (typically `elanous setup`). */
   setupRerunHint: string;
 

package/src/github/pr-labels.ts

@@ -32,6 +32,7 @@ export const PR_LABELS = [
   { name: 'elanous:release-hold', axis: 'addon', color: 'D4C5F9', description: 'Exclude from release notes until verified in production', appliedBy: ['launcher', 'session', 'human'], sweep: { action: 'none' } },
   { name: 'elanous:idea-stale', axis: 'addon', color: 'FBCA04', description: 'Approval pending beyond the notification threshold', appliedBy: ['sweeper'], sweep: { action: 'notify', afterDays: IDEA_STALE_DAYS } },
   { name: 'elanous:needs-rebase', axis: 'addon', color: 'E99695', description: 'Approval blocked by conflicts or failing checks', appliedBy: ['sweeper'], sweep: { action: 'block-approval' } },
+  { name: 'elanous:harvestable', axis: 'addon', color: 'FBCA04', description: 'Pod terminal marked this PR for harvest', appliedBy: ['harness'], sweep: { action: 'close', afterHours: STALLED_DRAFT_HOURS } },
   { name: 'elanous:from-harness', axis: 'origin', color: 'C5DEF5', description: 'Launched from a harness goal', appliedBy: ['harness'], sweep: { action: 'none' } },
   { name: 'elanous:from-intake', axis: 'origin', color: 'C5DEF5', description: 'Launched from an absorbed idea', appliedBy: ['launcher'], sweep: { action: 'none' } },
   { name: 'elanous:from-linear', axis: 'origin', color: 'C5DEF5', description: 'Launched from a Linear task', appliedBy: ['launcher'], sweep: { action: 'none' } },