elanous 0.2.22 → 0.2.24

package/src/domains/release-tool.ts

@@ -1,17 +1,33 @@
+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 { mergedPrsLast24h as countMergedPrsLast24h } from '../release-loop/placement.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).' },
+    action: { type: 'string', enum: ['schedule', 'blocked', 'landed'], description: '짧은 읽기 요약: 다음 컷 일정·막힌 칸·최근 24시간 병합 PR.' },
+    id: { type: 'string', description: 'topic=cell 때 찾을 칸 id(필수).' },
+  }, required: [] },
 };
 
 export const RELEASE_CHANGE_SPEC: LLMToolSpec = {
@@ -35,11 +51,15 @@ 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;
   move?: typeof move;
   setSchedule?: typeof setSchedule;
+  mergedPrsLast24h?: (now?: Date) => number;
 }
 
 function nextVersion(version: string): string {
@@ -61,18 +81,142 @@ 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 (args.action !== undefined) {
+    const action = args.action;
+    if (typeof action !== 'string' || !['schedule', 'blocked', 'landed'].includes(action)) {
+      throw new Error('action 은 schedule, blocked, landed 중 하나여야 합니다');
+    }
+    if (action === 'schedule') {
+      const released = checklist(dev).released;
+      const schedules = (deps.schedules ?? listSchedules)()
+        .filter(row => requested ? row.version === requested : !released || versionOrder(row.version, released) > 0)
+        .sort((a, b) => versionOrder(a.version, b.version));
+      const text = schedules.length ? `다음 컷 시각:\n${schedules.map(formatSchedule).join('\n')}` : '다음 컷 시각: 일정 없음';
+      debug.log('release.tool', 'status', { action, version: requested ?? dev });
+      return { text, 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 })) } };
+    }
+    if (action === 'blocked') {
+      const versions = requested ? [requested as string] : [dev, nextVersion(dev)];
+      const blocked = versions.flatMap(version => {
+        validateVersion(version);
+        return checklist(version).items
+          .filter(item => item.status === 'red' || (item.status === 'yellow' && item.disposition === 'block'))
+          .map(item => ({ version, id: item.id, title: firstLine(item.title), status: item.status, disposition: item.disposition ?? null, owner: item.owner ?? null }));
+      });
+      const text = blocked.length ? `막힌 칸 ${blocked.length}개:\n${blocked.map(item => `${item.version} · ${item.id} ${item.title} · ${item.status === 'red' ? '빨강' : '보류'}${item.owner ? ` · 담당 ${item.owner}` : ''}`).join('\n')}` : '막힌 칸 없음';
+      debug.log('release.tool', 'status', { action, version: requested ?? versions.join(',') });
+      return { text, structured: { blocked } };
+    }
+    const now = deps.now ?? new Date();
+    const merged = (deps.mergedPrsLast24h ?? countMergedPrsLast24h)(now);
+    debug.log('release.tool', 'status', { action, since: new Date(now.getTime() - 86_400_000).toISOString(), until: now.toISOString(), merged });
+    return { text: `어제 착지: 최근 24시간 병합 PR ${merged}건`, structured: {
+      mergedPrsLast24h: merged,
+      since: new Date(now.getTime() - 86_400_000).toISOString(),
+      until: now.toISOString(),
+    } };
+  }
+  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 +228,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 +243,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/error-report/report.ts

@@ -31,7 +31,7 @@ export interface ErrorReport {
   at: string; consent: true;
 }
 
-export interface ErrorReportSettings { enabled: boolean; identity: boolean; email?: string; telegramUser?: string }
+export interface ErrorReportSettings { enabled: boolean; identity: boolean; consented?: boolean; email?: string; telegramUser?: string }
 
 export interface ErrorReportDeps {
   configDir?: () => string;
@@ -100,10 +100,18 @@ export function buildErrorReport(input: ErrorReportInput, ctx: { installId: stri
   return report;
 }
 
+/** First-run notice: says what is actually sent — identity fields go along only when errorReports.identity is on. */
+export function errorReportNoticeLine(config: { identity?: boolean; email?: string; telegramUser?: string } | undefined): string {
+  const fields = [config?.email ? '이메일' : '', config?.telegramUser ? '텔레그램 사용자' : ''].filter(Boolean).join('·');
+  // Mirrors buildErrorReport: a field goes along only when identity is on AND the field is set.
+  const who = config?.identity === true && fields ? `진단과 함께 설정된 신원(${fields})을` : '익명 진단을';
+  return `오류 보고 안내: 오류 발생 시 ${who} 운영팀에 전송합니다. 끄려면 \`elanous config set errorReports.enabled false\`.`;
+}
+
 function defaultSettings(): ErrorReportSettings {
   try {
     const er = getUserConfig().errorReports;
-    return { enabled: er?.enabled !== false, identity: er?.identity === true, ...(er?.email ? { email: er.email } : {}), ...(er?.telegramUser ? { telegramUser: er.telegramUser } : {}) };
+    return { enabled: er?.enabled !== false, consented: er?.noticeShown === true, identity: er?.identity === true, ...(er?.email ? { email: er.email } : {}), ...(er?.telegramUser ? { telegramUser: er.telegramUser } : {}) };
   } catch { return { enabled: false, identity: false }; }
 }
 
@@ -137,10 +145,17 @@ export async function reportError(input: ErrorReportInput, deps: ErrorReportDeps
     if (!settings.enabled) return { sent: false, reason: 'disabled' };
     const now = (deps.now ?? Date.now)();
     const key = `${input.code}\u0000${input.message.slice(0, 200)}`;
+    const configDir = (deps.configDir ?? getElanousConfigDir)();
+    if (settings.consented !== true) {
+      const report = buildErrorReport(input, {
+        installId: installId(configDir), settings, nexus: { alive: false }, at: new Date(now).toISOString(),
+      });
+      keepPending(report, configDir, deps);
+      return { sent: false, reason: 'awaiting-notice' };
+    }
     const previous = lastSent.get(key);
     if (previous !== undefined && now - previous < SAME_ERROR_GAP_MS) return { sent: false, reason: 'recently-sent' };
     lastSent.set(key, now);
-    const configDir = (deps.configDir ?? getElanousConfigDir)();
     const report = buildErrorReport(input, {
       installId: installId(configDir), settings, nexus: await (deps.nexusMeta ?? defaultNexusMeta)(), at: new Date(now).toISOString(),
     });
@@ -186,7 +201,9 @@ function keepPending(report: ErrorReport, configDir: string, deps: ErrorReportDe
 export async function retryPendingErrorReport(deps: ErrorReportDeps = {}): Promise<ReportOutcome> {
   try {
     if (!(deps.enabledByEnvironment ?? defaultEnabledByEnvironment)()) return { sent: false, reason: 'environment' };
-    if (!(deps.settings ?? defaultSettings)().enabled) return { sent: false, reason: 'disabled' };
+    const settings = (deps.settings ?? defaultSettings)();
+    if (!settings.enabled) return { sent: false, reason: 'disabled' };
+    if (settings.consented !== true) return { sent: false, reason: 'awaiting-notice' };
     const configDir = (deps.configDir ?? getElanousConfigDir)();
     const file = pendingFile(configDir);
     if (!existsSync(file)) return { sent: false, reason: 'none' };

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,8 @@ 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:bench', axis: 'addon', color: 'C5DEF5', description: 'Bench arm output: never landed or swept; the owner harvests the winner onto main', appliedBy: ['harness'], sweep: { action: 'none' } },
+  { 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' } },

package/src/graph-runner/graph-cli.ts

@@ -155,11 +155,16 @@ export function registerGraphCommands(program: Command, runsDeps: { root?: strin
     .description('Advance one graph run, resuming a pending decision or starting only when requested')
     .option('--start', 'Start a new run when the graph is idle')
     .option('--schedule', 'Subscribe graph YAML triggers.schedule to the workflow scheduler and tick on each fire')
+    .option('--webhook', 'Subscribe graph YAML triggers.webhook to the workflow webhook router and tick on each request')
+    .option('--port <n>', 'Port for --webhook to listen on (default: any free port)')
     .option('--input <json>', 'JSON object passed to a newly started run')
     .option('--json', 'Print the tick result as JSON')
-    .action(async (file: string, opts: { start?: boolean; schedule?: boolean; input?: string; json?: boolean }) => {
+    .action(async (file: string, opts: { start?: boolean; schedule?: boolean; webhook?: boolean; port?: string; input?: string; json?: boolean }) => {
       try {
         if (opts.schedule && (opts.start || opts.input !== undefined || opts.json)) throw new Error('--schedule cannot be combined with --start, --input or --json');
+        if (opts.webhook && (opts.schedule || opts.start || opts.input !== undefined || opts.json)) throw new Error('--webhook cannot be combined with --schedule, --start, --input or --json');
+        if (opts.port !== undefined && !opts.webhook) throw new Error('--port requires --webhook');
+        if (opts.port !== undefined && (!/^\d+$/.test(opts.port) || Number(opts.port) > 65535)) throw new Error('--port must be an integer from 0 to 65535');
         if (opts.input !== undefined && !opts.start) throw new Error('--input requires --start');
         let input: Record<string, unknown> | undefined;
         if (opts.input !== undefined) {
@@ -171,6 +176,42 @@ export function registerGraphCommands(program: Command, runsDeps: { root?: strin
         }
         await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('graph');
         const { graphTick } = await import('./graph-tick.js');
+        if (opts.webhook) {
+          const { createWebhookSource } = await import('../workflow-runtime/triggers/webhook-source.js');
+          const graphFile = resolve(file);
+          const source = createWebhookSource();
+          // The CLI tick callback is the graph counterpart of the workflow webhook router's onEmit.
+          source.subscribeGraph(graphFile, async () => {
+            try {
+              const { notifyGraphEvents } = await import('./graph-notify.js');
+              const result = await graphTick(graphFile, { startIfIdle: true, deps: { notify: async () => { await notifyGraphEvents(); } } });
+              if (result.status === 'refused') return { ok: false, error: `refused: ${result.reason}` };
+              if (result.status === 'failed') return { ok: false, runId: result.runId, error: 'failed' };
+              return result.runId ? { ok: true, runId: result.runId } : { ok: false, error: `no run (${result.action})` };
+            } catch (error) {
+              debug.log('graph.runner', 'webhook-tick-failed', { file: graphFile, error: error instanceof Error ? error.message : String(error) });
+              return { ok: false, error: error instanceof Error ? error.message : String(error) };
+            }
+          });
+          if (!source.subscriptions().length) throw new Error('graph triggers.webhook is missing');
+          await source.start();
+          const server = Bun.serve({
+            hostname: '127.0.0.1',
+            port: opts.port === undefined ? 0 : Number(opts.port),
+            fetch: async (request) => {
+              const response = await source.dispatch({
+                method: request.method, path: new URL(request.url).pathname,
+                headers: Object.fromEntries(request.headers), body: await request.text(),
+              });
+              return response ? new Response(response.body, { status: response.status, headers: response.headers }) : new Response('webhook source not started', { status: 503 });
+            },
+          });
+          console.log(`graph webhook: ${source.subscriptions().length} active on http://127.0.0.1:${server.port}`);
+          const shutdown = () => { void server.stop(true).then(() => source.stop()).then(() => { process.exitCode = 0; }); };
+          process.once('SIGINT', shutdown);
+          process.once('SIGTERM', shutdown);
+          return;
+        }
         if (opts.schedule) {
           const { createScheduleSource } = await import('../workflow-runtime/triggers/schedule-source.js');
           const graphFile = resolve(file);