elanous 0.2.17 → 0.2.19

package/src/away/release-watch.ts

@@ -0,0 +1,255 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { deliver, inQuietHours, sendOutbound } from '../domains/outbound-alert.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { readReleaseRuns, type ReleaseRunNodeView, type ReleaseRunView } from '../nexus/api/ops-api.js';
+import { readPresence, type Presence } from './presence.js';
+
+/** AWAY-MODE-1 — 외출 중 발행 현황 공백 0. 발행 런 원장(`/v1/ops/release/runs` 와 같은 판정)을 직전에 본 것과 견주어
+ *  «새로 생긴 전이»만 텔레그램 한 통으로 보낸다. 같은 전이는 두 번 안 보낸다(보낸 뒤에만 기준을 옮긴다). */
+
+export const RELEASE_SCREEN_URL = 'https://op.elanous.ai/app/ops/release';
+/** 발행 중 이 간격 동안 새 전이가 없으면 «생존» 한 줄. */
+export const ALIVE_EVERY_MS = 60 * 60_000;
+/** 이보다 오래된 런은 따라가지 않는다 — 외출을 켠 순간 지난 판이 쏟아지지 않게. */
+export const FOLLOW_WINDOW_MS = 36 * 3600_000;
+
+export interface RunMark {
+  status: string;
+  /** 끝난(ok 가 정해진) 노드 수. */
+  ended: number;
+  /** 지금 도는 노드(있으면). */
+  running?: string;
+  /** 이 런에 대해 마지막으로 보낸 시각(ISO) — 생존 줄 간격의 기준. */
+  sentAt: string;
+}
+
+export interface WatchState { runs: Record<string, RunMark> }
+
+export interface WatchMessage { text: string; urgent: boolean }
+
+const BLOCKED = new Set(['failed', 'budget-exceeded', 'awaiting-approval']);
+
+const clean = (text: string, max: number): string => {
+  const one = text.replace(/[\r\n\t]+/g, ' ').replace(/\s+/g, ' ').trim();
+  return one.length > max ? `${one.slice(0, max - 1)}…` : one;
+};
+
+const label = (run: ReleaseRunView): string => run.version ?? run.runId.slice(0, 8);
+
+/** 그래프의 종결 자리표 — 노드가 아니라 끝을 표시한다(런 상태로 따로 말한다). */
+const TERMINAL = new Set(['done', 'failed']);
+
+function endedNodes(run: ReleaseRunView): ReleaseRunNodeView[] {
+  return run.nodes.filter((node) => node.ok !== null && !TERMINAL.has(node.nodeId));
+}
+
+function runningNode(run: ReleaseRunView): ReleaseRunNodeView | undefined {
+  return run.status === 'running' ? run.nodes.find((node) => node.ok === null) : undefined;
+}
+
+function minutesSince(iso: string | undefined, now: number): number | null {
+  if (!iso) return null;
+  const at = Date.parse(iso);
+  return Number.isFinite(at) ? Math.max(0, Math.round((now - at) / 60_000)) : null;
+}
+
+/** 노드 하나가 끝났을 때의 한 줄. 게이트는 도입 수·면제를 꼭 말한다(«통과»만으로는 면제를 못 읽는다). */
+export function nodeLine(node: ReleaseRunNodeView): string {
+  const mark = node.ok ? '✅' : '❌';
+  const facts = node.facts ?? {};
+  const parts: string[] = [`${mark} ${node.nodeId}`];
+  if (facts.introduced !== undefined) parts.push(`도입 ${facts.introduced}${facts.preexisting !== undefined ? ` · 기존 ${facts.preexisting}` : ''}`);
+  if (node.summary) parts.push(clean(node.summary, 120));
+  else if (facts.verdict) parts.push(facts.verdict);
+  let line = parts.join(' · ');
+  if (facts.waiver) line += `\n   ⚠️ 면제 적용: ${clean(facts.waiver, 140)}`;
+  return line;
+}
+
+function blockedLine(run: ReleaseRunView): string {
+  const last = endedNodes(run).at(-1);
+  const where = last ? `${last.nodeId}${last.ok === false ? ' 실패' : ''}` : '노드 기록 없음';
+  const why = last?.summary ? ` — ${clean(last.summary, 140)}` : '';
+  if (run.status === 'awaiting-approval') {
+    return `⏸ ${label(run)} 발행 승인 대기 · ${where}${why}\n   다음 수: 승인 권한자(OP·대표)가 승인해야 다음 노드로 간다`;
+  }
+  const kind = run.status === 'budget-exceeded' ? '예산 초과로 멈춤' : '막힘';
+  return `⛔ ${label(run)} 발행 ${kind} · ${where}${why}\n   다음 수: 담당 자리(TC·OP)가 재개 또는 면제를 판단한다 — 결정이 오면 이 채널로 알린다`;
+}
+
+/** 직전 표지와 지금 런을 견주어 보낼 줄을 만든다. 순수 함수 — 시험이 이것을 문다. */
+export function diffRun(prev: RunMark | undefined, run: ReleaseRunView, now: number): { lines: string[]; urgent: boolean; changed: boolean } {
+  const ended = endedNodes(run);
+  const running = runningNode(run);
+  const lines: string[] = [];
+  let urgent = false;
+  if (!prev) {
+    // 이미 끝난 판은 조용히 기준만 잡는다 — 외출을 켤 때 지난 판이 쏟아지지 않게.
+    if (run.status === 'done') return { lines, urgent, changed: true };
+    // 처음 보는 런 — 지난 노드를 다시 쏟지 않고 «지금 어디인가» 한 줄로 시작한다.
+    const total = run.path.filter((step) => !TERMINAL.has(step)).length || run.nodes.length;
+    const where = run.status === 'running'
+      ? `지금 ${running?.nodeId ?? '다음 노드 준비'}${running?.startedAt ? `(${minutesSince(running.startedAt, now)}분째)` : ''}`
+      : `상태 ${run.status}`;
+    lines.push(`📦 ${label(run)} 발행 따라가기 시작 · 끝난 노드 ${ended.length}${total ? `/${total}` : ''} · ${where}`);
+    if (BLOCKED.has(run.status)) { lines.push(blockedLine(run)); urgent = true; }
+    return { lines, urgent, changed: true };
+  }
+  for (const node of ended.slice(prev.ended)) {
+    lines.push(nodeLine(node));
+    if (node.ok === false) urgent = true;
+  }
+  if (running && running.nodeId !== prev.running && running.nodeId === 'gate') {
+    lines.push(`▶ gate 시작${running.startedAt ? ` · ${new Date(running.startedAt).toLocaleTimeString('ko-KR', { timeZone: 'Asia/Seoul', hour: '2-digit', minute: '2-digit', hour12: false })} KST` : ''}`);
+  }
+  if (run.status !== prev.status) {
+    if (run.status === 'done') {
+      const took = minutesSince(run.startedAt, now);
+      lines.push(`🎉 ${label(run)} 발행 완료 · 노드 ${ended.length}${took !== null ? ` · ${Math.floor(took / 60)}시간 ${took % 60}분` : ''}`);
+    } else if (BLOCKED.has(run.status)) {
+      lines.push(blockedLine(run));
+      urgent = true;
+    } else if (run.status === 'running' && BLOCKED.has(prev.status)) {
+      lines.push(`▶ ${label(run)} 발행 재개`);
+    }
+  }
+  if (!lines.length && run.status === 'running' && now - Date.parse(prev.sentAt) >= ALIVE_EVERY_MS) {
+    const mins = minutesSince(running?.startedAt, now);
+    lines.push(`💓 ${label(run)} 발행 진행 중 · 지금 ${running?.nodeId ?? '다음 노드 준비'}${mins !== null ? `(${mins}분째)` : ''} · 끝난 노드 ${ended.length}/${run.path.filter((step) => !TERMINAL.has(step)).length || ended.length}`);
+  }
+  const changed = lines.length > 0 || prev.ended !== ended.length || prev.status !== run.status || prev.running !== running?.nodeId;
+  return { lines, urgent, changed };
+}
+
+export function markOf(run: ReleaseRunView, sentAt: string): RunMark {
+  const running = runningNode(run);
+  return { status: run.status, ended: endedNodes(run).length, ...(running ? { running: running.nodeId } : {}), sentAt };
+}
+
+/** 따라갈 런 — 최근 36시간 안에 시작한 것만. 원장엔 «running» 인 채 버려진 옛 런이 있어 상태로 고르면 매시간 생존 줄이 샌다. */
+export function followedRuns(runs: ReleaseRunView[], now: number): ReleaseRunView[] {
+  return runs.filter((run) => now - Date.parse(run.startedAt) <= FOLLOW_WINDOW_MS);
+}
+
+export function composeMessage(lines: string[]): string {
+  return [...lines, `↗ ${RELEASE_SCREEN_URL}`].join('\n');
+}
+
+export function watchStatePath(root: string = effectiveInstanceRoot()): string {
+  return join(root, 'away', 'release-watch.json');
+}
+
+export function readWatchState(path: string = watchStatePath()): WatchState {
+  try {
+    const value: unknown = JSON.parse(readFileSync(path, 'utf8'));
+    const runs = value && typeof value === 'object' ? (value as { runs?: unknown }).runs : undefined;
+    return { runs: runs && typeof runs === 'object' ? runs as Record<string, RunMark> : {} };
+  } catch { return { runs: {} }; }
+}
+
+export function writeWatchState(state: WatchState, path: string = watchStatePath()): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(state)}\n`);
+  renameSync(tmp, path);
+}
+
+export interface TickDeps {
+  presence?: () => Presence;
+  runs?: () => ReleaseRunView[] | 'unavailable';
+  readState?: () => WatchState;
+  writeState?: (state: WatchState) => void;
+  /** 보통 줄 — 야간 무음이면 아침까지 보류된다. */
+  send?: (text: string) => boolean;
+  /** 막힘·실패 — 야간 무음을 뚫는다. */
+  sendUrgent?: (text: string) => boolean;
+  now?: () => number;
+}
+
+export type TickOutcome =
+  | { outcome: 'present' }
+  | { outcome: 'unavailable' }
+  | { outcome: 'quiet'; followed: number }
+  | { outcome: 'sent'; followed: number; lines: number; urgent: boolean }
+  | { outcome: 'send-failed'; followed: number; lines: number; urgent: boolean };
+
+export interface UrgentIo {
+  quiet: () => boolean;
+  outbound: (text: string, kind: string) => boolean;
+  deliver: (text: string, kind: string) => 'daemon' | 'direct' | false;
+}
+
+/** 막힘·실패 차선 — 야간 무음이면 보류 큐를 건너뛰고 바로 보낸다(`deliver`), 아니면 평소 길(`sendOutbound`). */
+export function makeUrgentSender(io: UrgentIo = { quiet: () => inQuietHours(), outbound: sendOutbound, deliver: (t, k) => deliver(t, k) }): (text: string) => boolean {
+  return (text) => io.quiet() ? io.deliver(text, 'ops-alert') !== false : io.outbound(text, 'ops-alert');
+}
+
+const defaultSendUrgent = makeUrgentSender();
+
+/** 한 번 본다. 자리에 있으면 아무것도 안 한다(기준도 지운다 — 다음 외출이 지난 일을 다시 보내지 않게). */
+export function releaseWatchTick(deps: TickDeps = {}): TickOutcome {
+  const presence = (deps.presence ?? readPresence)();
+  const writeState = deps.writeState ?? ((state: WatchState) => writeWatchState(state));
+  if (!presence.away) {
+    const state = (deps.readState ?? readWatchState)();
+    if (Object.keys(state.runs).length) writeState({ runs: {} });
+    return { outcome: 'present' };
+  }
+  const all = (deps.runs ?? (() => readReleaseRuns(null, undefined, { facts: true })))();
+  if (all === 'unavailable') {
+    try { debug.log('away.release-watch', 'runs-unavailable', {}); } catch { /* fail-open */ }
+    return { outcome: 'unavailable' };
+  }
+  const now = (deps.now ?? Date.now)();
+  const nowIso = new Date(now).toISOString();
+  const state = (deps.readState ?? readWatchState)();
+  const runs = followedRuns(all, now);
+  const lines: string[] = [];
+  let urgent = false;
+  const next: WatchState = { runs: {} };
+  let changed = false;
+  for (const run of [...runs].reverse()) {
+    const prev = state.runs[run.runId];
+    const diff = diffRun(prev, run, now);
+    lines.push(...diff.lines);
+    urgent ||= diff.urgent;
+    changed ||= diff.changed;
+    next.runs[run.runId] = diff.lines.length ? markOf(run, nowIso) : { ...markOf(run, prev?.sentAt ?? nowIso) };
+  }
+  if (Object.keys(state.runs).some((id) => !next.runs[id])) changed = true;
+  if (!lines.length) {
+    if (changed) writeState(next);
+    return { outcome: 'quiet', followed: runs.length };
+  }
+  const text = composeMessage(lines);
+  const ok = urgent ? (deps.sendUrgent ?? defaultSendUrgent)(text) : (deps.send ?? ((t: string) => sendOutbound(t, 'op-report')))(text);
+  try { debug.log('away.release-watch', ok ? 'sent' : 'send-failed', { followed: runs.length, lines: lines.length, urgent }); } catch { /* fail-open */ }
+  // 못 보냈으면 기준을 옮기지 않는다 — 다음 틱이 같은 줄을 다시 시도한다(중복 대신 누락을 막는 쪽).
+  if (ok) writeState(next);
+  return { outcome: ok ? 'sent' : 'send-failed', followed: runs.length, lines: lines.length, urgent };
+}
+
+/** /release · away status 가 쓰는 «지금» 요약 — 가장 최근 런 하나. */
+export function releaseNowText(runs: ReleaseRunView[] | 'unavailable', now: number = Date.now()): string {
+  if (runs === 'unavailable') return '발행 런 원장을 못 읽었다(권한·디스크) — 「없다」가 아니다';
+  const run = runs[0];
+  if (!run) return `발행 런 기록 없음\n↗ ${RELEASE_SCREEN_URL}`;
+  const ended = endedNodes(run);
+  const running = runningNode(run);
+  const total = run.path.filter((step) => !TERMINAL.has(step)).length || run.nodes.length;
+  const head = `📦 ${label(run)} · ${run.status} · 끝난 노드 ${ended.length}${total ? `/${total}` : ''}`;
+  const lines = [head];
+  if (running) {
+    const mins = minutesSince(running.startedAt, now);
+    lines.push(`지금: ${running.nodeId}${mins !== null ? ` (${mins}분째)` : ''}`);
+  }
+  const last = ended.at(-1);
+  if (last) lines.push(`마지막: ${nodeLine(last)}`);
+  if (BLOCKED.has(run.status)) lines.push(blockedLine(run));
+  const started = minutesSince(run.startedAt, now);
+  if (started !== null) lines.push(`시작 ${Math.floor(started / 60)}시간 ${started % 60}분 전`);
+  lines.push(`↗ ${RELEASE_SCREEN_URL}`);
+  return lines.join('\n');
+}

package/src/briefing/brief-items.ts

@@ -4,6 +4,7 @@ import { dirname, join } from 'node:path';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { debug } from '../debug/log.js';
 import { dateKey } from '../time/format.js';
+import { readRequirementFunnel, type RequirementFunnelResult } from '../intake-plane/requirement-funnel.js';
 
 export const BRIEF_DOMAINS = ['운영', '판', '흡수', '시장', '행정', '코나투스'] as const;
 export const BRIEF_PRIORITIES = ['P0', 'P1', 'P2'] as const;
@@ -41,6 +42,7 @@ export interface BriefItemsOptions {
   stateDir?: string;
   now?: () => Date;
   log?: (category: string, event: string, data?: unknown) => void;
+  requirementFunnel?: (now: Date) => RequirementFunnelResult;
 }
 
 export class BriefItemsInputError extends Error {
@@ -89,8 +91,15 @@ function needsDecision(item: BriefItem, today: string): boolean {
  * duplicate claims dropped (same normalized sentence, most urgent kept).
  */
 export function composeBriefMarkdown(items: readonly BriefItem[], slot: BriefSlot, now: Date): string {
+  return composeBriefPage(items, slot, now).markdown;
+}
+
+/** The ids are exactly the rows represented by the composed page, after deduplication. */
+export function composeBriefPage(items: readonly BriefItem[], slot: BriefSlot, now: Date): { markdown: string; ids: number[] } {
   const today = dateKey(now, { timeZone: KST });
-  const eligible = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now));
+  // A duplicate left out of a delivered page stays unsent in the ledger, but must not reappear on a later page.
+  const deliveredClaims = new Set(items.filter(item => item.sent_at !== null).map(item => normalizeClaim(item.text)));
+  const eligible = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now) && !deliveredClaims.has(normalizeClaim(item.text)));
   // Duplicate claims keep the copy that needs a decision today (P0 or due today), then the higher priority, then the earliest (ACP must-fix).
   const rank = (item: BriefItem) => [needsDecision(item, today) ? 0 : 1, BRIEF_PRIORITIES.indexOf(item.priority), item.id];
   const better = (a: BriefItem, b: BriefItem) => { const x = rank(a), y = rank(b); return x[0]! - y[0]! || x[1]! - y[1]! || x[2]! - y[2]!; };
@@ -117,7 +126,7 @@ export function composeBriefMarkdown(items: readonly BriefItem[], slot: BriefSlo
     for (const item of group.sort((a, b) => a.id - b.id)) lines.push(itemLine(item));
     lines.push('');
   }
-  return `${lines.join('\n').trimEnd()}\n`;
+  return { markdown: `${lines.join('\n').trimEnd()}\n`, ids: unique.map(item => item.id) };
 }
 
 function itemLine(item: BriefItem): string {
@@ -166,11 +175,13 @@ export class BriefItemsLedger {
   readonly path: string;
   private readonly now: () => Date;
   private readonly log: (category: string, event: string, data?: unknown) => void;
+  private readonly requirementFunnel: (now: Date) => RequirementFunnelResult;
 
   constructor(options: BriefItemsOptions = {}) {
     this.path = join(options.stateDir ?? elanousStateRoot(), 'briefing', 'items.sqlite');
     this.now = options.now ?? (() => new Date());
     this.log = options.log ?? ((category, event, data) => debug.log(category, event, data));
+    this.requirementFunnel = options.requirementFunnel ?? ((now) => readRequirementFunnel({ stateDir: options.stateDir, now }));
   }
 
   private using<T>(work: (db: Database) => T): T {
@@ -246,15 +257,81 @@ export class BriefItemsLedger {
 
   /**
    * Markdown for one slot. Reads only — never marks, rewrites, or sends an item.
-   * Items created at or after the slot instant are left out.
+   * Items created at or after the slot instant are left out. At 08:30 the
+   * requirement funnel contributes ephemeral lines without adding ledger rows.
    */
   compose(slot: string): string {
+    return this.composeWithIds(slot).markdown;
+  }
+
+  private itemsFromDb(db: Database): BriefItem[] {
+    return db.query('SELECT id, text, domain, priority, deadline, evidence, source, created_at, (SELECT MIN(sent_at) FROM sends WHERE sends.item_id = items.id) AS sent_at FROM items ORDER BY id').all() as BriefItem[];
+  }
+
+  private pageFromDb(db: Database, slot: BriefSlot): { markdown: string; ids: number[] } {
+    const items = this.itemsFromDb(db);
+    const now = this.now();
+    const morningCutoff = Date.parse(`${dateKey(now, { timeZone: KST })}T08:30:00+09:00`);
+    let funnelItems: BriefItem[] = [];
+    if (slot === '08:30' && now.getTime() >= morningCutoff) {
+      // A funnel failure must not take the morning brief down with it.
+      try {
+        const extra = this.requirementFunnel(new Date(morningCutoff - 1)).briefItems;
+        // Negative ids never collide with ledger rows and keep the funnel's own order (summary first).
+        funnelItems = extra.map((item, index): BriefItem => ({
+          id: index - extra.length, text: item.text, domain: item.domain, priority: item.priority, deadline: null,
+          evidence: item.evidence ?? null, source: item.source,
+          created_at: new Date(morningCutoff - 1).toISOString(), sent_at: null,
+        }));
+      } catch (error) {
+        this.log('briefing.items', 'requirement-funnel-failed', { slot, error: error instanceof Error ? error.message : String(error) });
+      }
+    }
+    const composed = composeBriefPage([...items, ...funnelItems], slot, now);
+    // Ephemeral funnel lines appear on the page but have no ledger row to mark sent.
+    const page = { markdown: composed.markdown, ids: composed.ids.filter(id => id > 0) };
+    const candidates = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now)).length;
+    this.log('briefing.items', 'composed', { slot, candidates, bytes: Buffer.byteLength(page.markdown) });
+    return page;
+  }
+
+  /** Read-only page and the exact ledger item ids printed on it (after deduplication). */
+  composeWithIds(slot: string): { markdown: string; ids: number[] } {
     if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
-    const items = this.list();
-    const markdown = composeBriefMarkdown(items, slot as BriefSlot, this.now());
-    const included = items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot as BriefSlot, this.now()));
-    this.log('briefing.items', 'composed', { slot, candidates: included.length, bytes: Buffer.byteLength(markdown) });
-    return markdown;
+    return this.using(db => this.pageFromDb(db, slot as BriefSlot));
+  }
+
+  /** Hold the ledger's SQLite writer lock from selecting unsent rows through delivery and marking.
+   * A failed delivery rolls back and releases the lock; the next sender can retry.
+   */
+  withSendLock<T>(slot: string, work: (page: { markdown: string; ids: number[] }, markSent: (ids: readonly number[], slot: BriefSlot) => number) => T): T {
+    if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
+    return this.using(db => {
+      db.exec('BEGIN IMMEDIATE');
+      try {
+        const page = this.pageFromDb(db, slot as BriefSlot);
+        const result = work(page, (ids, sentSlot) => {
+          if (sentSlot !== slot || ids.length !== page.ids.length || ids.some((id, index) => id !== page.ids[index])) {
+            throw new BriefItemsInputError('marked ids must match composed page');
+          }
+          return this.markSentInDb(db, ids, sentSlot);
+        });
+        db.exec('COMMIT');
+        return result;
+      } catch (cause) {
+        db.exec('ROLLBACK');
+        throw cause;
+      }
+    });
+  }
+
+  private markSentInDb(db: Database, ids: readonly number[], slot: BriefSlot): number {
+    const at = this.now().toISOString();
+    const insert = db.query('INSERT INTO sends (item_id, slot, sent_at) VALUES (?, ?, ?)');
+    let count = 0;
+    for (const id of ids) { insert.run(id, slot, at); count++; }
+    this.log('briefing.items', 'marked-sent', { slot, count });
+    return count;
   }
 
   /**
@@ -263,14 +340,6 @@ export class BriefItemsLedger {
    */
   markSent(ids: readonly number[], slot: BriefSlot): number {
     if (!(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
-    const at = this.now().toISOString();
-    const count = this.using(db => {
-      const insert = db.query('INSERT INTO sends (item_id, slot, sent_at) VALUES (?, ?, ?)');
-      let n = 0;
-      db.transaction(() => { for (const id of ids) { insert.run(id, slot, at); n++; } })();
-      return n;
-    });
-    this.log('briefing.items', 'marked-sent', { slot, count });
-    return count;
+    return this.using(db => db.transaction(() => this.markSentInDb(db, ids, slot))());
   }
 }

package/src/chat/index.ts

@@ -434,7 +434,7 @@ export interface SlashCommand {
 export const SLASH_COMMANDS: SlashCommand[] = [
   { name: 'help',  aliases: ['?'],         description: '명령과 키 보기' },
   { name: 'resume',    aliases: [],             description: '지난 대화 이어 가기 · /resume <id 앞자리>' },
-  { name: 'model',     aliases: ['m'],           description: '모델 바꾸기 — /model <codex|terra|sol|luna|opus|sonnet|grok> (list + current when no arg). OpenAI 는 Codex(Responses API)만. effort 는 /reasoning.', subcommands: ['codex', 'terra', 'sol', 'luna', 'opus', 'sonnet', 'grok'] },
+  { name: 'model',     aliases: ['m'],           description: '모델 바꾸기 — /model 빠름|보통|깊음 (코드명도 됨)', subcommands: ['빠름', '보통', '깊음', 'codex', 'terra', 'sol', 'luna', 'opus', 'sonnet', 'grok'] },
   { name: 'clear', aliases: ['cls'],       description: '대화 기록 지우기' },
   { name: 'status', aliases: ['st'], description: '지금 상태 — 모델 · 연결 · 계정' },
   { name: 'now', aliases: [], description: '현재 맥락과 출처 표 — /now [주제]' },
@@ -448,6 +448,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
   //   and the PWA `/design-check` panel. Listed (not baselined as hidden) on
   //   purpose: a surface nobody can discover is not a surface.
   { name: 'design',    aliases: ['design-check'], description: 'Design rulebooks this repository declares · /design [--declared] · /design pick [number|id] to choose a design direction', subcommands: ['--declared', 'pick'] },
+  { name: 'decide', aliases: ['dec'], description: '열린 결정 카드 보기·답하기 — /decide [번호] [선택지 키] [확인]' },
   { name: 'provider',  aliases: ['p'],          description: 'LLM providers — /provider (list) · next (cycle, also Alt+M / pill click) · use <name> · pick (visual picker) · reset', subcommands: ['next', 'use', 'pick', 'picker', 'menu', 'reset', 'list'] },
   { name: 'reasoning', aliases: ['r', 'think'],  description: 'Reasoning level (codex effort + summary, anthropic extended-thinking budget) — /reasoning [off|low|medium|high|xhigh] (cycle when no arg · xhigh 는 모델 상한이 xhigh 이상일 때만 wire 에 실린다, 아니면 high 로 깎인다)', subcommands: ['off', 'low', 'medium', 'high', 'xhigh'] },
   { name: 'local',     aliases: ['ll'],         description: 'Local OpenAI-compatible LLM — ping / models / test / use', subcommands: ['ping', 'models', 'test', 'use', 'status'] },

package/src/chat/short-question.ts

@@ -1,40 +1,3 @@
-// B1(UX · 0.2.7) — 짧은 «물음»은 도구 없이 빠른 경로로(첫 글자 ≤2초 · 내부 문서 `EVAL-bot-chat-vs-grok-2026-09-30`).
-// 허용 방식(골 ASK-bot-short-question-fast-path-b1b): 아래가 «모두» 참일 때만 fast — 하나라도 거짓이면 fast 아님(보수 쪽).
-//   ⓐ 한 줄 · 80자 이하 · 첨부 없음 ⓑ 인사이거나 «물음 꼴» ⓒ 요청·작업 표지 · 경로·URL·코드 꼴 · 실시간 낱말이 없다.
-// 거부 목록으로 변형을 다 막을 수는 없다 — 오분류 비용은 «확인해 볼까요?» 한 줄로 막힌다(도구가 안 실릴 뿐 대화는 이어진다).
-// 판정 표본 = src/chat/short-question.test.ts 의 고정 표 20개(⊕ 리뷰가 든 변형).
-
-export interface ShortQuestionContext {
-  hasAttachments?: boolean;
-}
-export interface ShortQuestionVerdict {
-  fast: boolean;
-  reason: string;
-}
-
-const GREETING = /^(?:안녕(?:하세요|하십니까)?|반가워(?:요)?|고마워(?:요)?|감사합니다|하이|hi|hello|hey|thanks|thank you)[!?.~\s]*$/i;
-// «한 줄로» 같은 짧은 꼬리를 떼고 본다.
-const TAIL = /\s*(?:한\s*줄로|짧게|간단히|briefly|in one line)[.!]?\s*$/i;
-const KO_QUESTION_END = /(?:\?|까|니|나요|냐|야|어때|뭐|몇|언제|어디|누구|왜|인가|일까)[?.!~]*$/;
-const EN_QUESTION = /^(?:what|why|how|who|where|when|which|is|are|does|do)\b.*\?$/i;
-const REQUEST_KO = /(?:해\s*줘|해\s*주세요|줘(?:요)?(?=[?.!\s]|$)|주세요|줄래|할래|볼래|줄\s*수\s*있|돌려|실행|고쳐|만들어\s*줘|찾아|검색|확인해|열어|보내|올려|지워|써\s*줘|작성해|요약해|정리해|분석해)/;
-const REQUEST_EN = /\b(?:please|can you|could you|would you|run|test|tests|fix|build|open|search|check|send|create|write|deploy|install|summarize)\b/i;
-const TASK = /(?:작업|파일|폴더|디렉터리|레포|저장소|커밋|브랜치|\bPR\b|코드|스크립트|테스트|빌드|배포|설치|설정|명령어|로그|버그|이슈)/i;
-const PATH_OR_CODE = /(?:https?:\/\/|www\.|[\w.-]+\/[\w./-]+|\.(?:ts|tsx|js|py|md|json|yaml|swift|kt)\b|[`{};=<>])/i;
-const LIVE = /(?:오늘\s*(?:날짜|며칠|무슨\s*요일)|지금\s*몇\s*시|최신|뉴스|속보|주가|시세|환율|날씨|today'?s|latest|news|stock|weather|right now)/i;
-
-export function classifyShortQuestion(text: string, ctx: ShortQuestionContext = {}): ShortQuestionVerdict {
-  const q = text.trim();
-  if (!q) return { fast: false, reason: 'empty' };
-  if (ctx.hasAttachments) return { fast: false, reason: 'attachment' };
-  if (/[\r\n\u2028\u2029]/.test(q)) return { fast: false, reason: 'multiline' };
-  if ([...q].length > 80) return { fast: false, reason: 'long' };
-  if (PATH_OR_CODE.test(q)) return { fast: false, reason: 'path-or-code' };
-  if (LIVE.test(q)) return { fast: false, reason: 'live' };
-  if (REQUEST_KO.test(q) || REQUEST_EN.test(q)) return { fast: false, reason: 'request' };
-  if (TASK.test(q)) return { fast: false, reason: 'task' };
-  if (GREETING.test(q)) return { fast: true, reason: 'greeting' };
-  const core = q.replace(TAIL, '').trim();
-  if (KO_QUESTION_END.test(core) || EN_QUESTION.test(core)) return { fast: true, reason: 'question' };
-  return { fast: false, reason: 'not-a-question' };
-}
+// The classifier lives in core-turn so the headless ACP path (core-turn-bridge) can use it without importing
+// chat code (tui-client-headless-guard). Existing chat callers keep this path.
+export * from '../core-turn/short-question.js';

package/src/cli/autopilot-cli.ts

@@ -6,7 +6,12 @@ import { writeStdoutJson } from './stdout-json.js';
 // runner. Spawns an ACP backend, opens a single session, runs the
 // AutopilotLoopDriver against the mission, prints agent deltas on
 // stdout + envelope/termination summary on stderr.
-export function registerAutopilotCommands(program: Command): void {
+export interface AutopilotCliDeps {
+  /** logs.db 싱크 등록(시험 주입). 기본 = `registerStandaloneLogSink`. `task-agent-action` 이 부른다. */
+  registerSink?: (surface: string) => Promise<unknown>;
+}
+
+export function registerAutopilotCommands(program: Command, cliDeps: AutopilotCliDeps = {}): void {
   // Explicit runtime entry for a selected action; the task chooser can invoke this entry.
   const autopilotCmd = program
     .command('autopilot')
@@ -14,18 +19,28 @@ export function registerAutopilotCommands(program: Command): void {
   autopilotCmd.command('task-agent-action <actionJson>')
     .description('Execute a selected task-agent action; defaults to shadow')
     .action(async (actionJson: string) => {
+      // 독립 프로세스 — 싱크를 붙이지 않으면 `task-agent`/`action` 관측이 logs.db 에 안 닿는다(fail-open).
+      const { registerTaskAgentSink } = await import('./tasks-cli.js');
+      await registerTaskAgentSink(cliDeps.registerSink);
       const { executeNextAction } = await import('../task-agent/actions.js');
       const { getUserConfig } = await import('../user-config.js');
       const { spawnSync } = await import('node:child_process');
-      const { readFileSync, writeFileSync, mkdirSync } = await import('node:fs');
+      const { writeFileSync, mkdirSync } = await import('node:fs');
+      // 상태 파일은 «없음»(ENOENT)만 빈 상태다 — 손상·해석 실패면 덮어쓰지 않고 멈춘다(사후 리뷰 must-fix · #24482).
+      const { readTaskAgentState, TaskAgentStateError } = await import('../task-agent/task-hand.js');
       const { join, dirname } = await import('node:path');
       const { debug } = await import('../debug/log.js');
       const { withFileLockSync } = await import('../storage/file-lock.js');
       const config = getUserConfig() as ReturnType<typeof getUserConfig> & { taskAgent?: { mode?: string } };
       const { effectiveInstanceRoot } = await import('../instance/resolve.js');
       const statePath = join(effectiveInstanceRoot(), 'task-agent-actions.json');
-      let state: { landingDay?: string; landingsToday?: number; failureCounts?: Record<string, number> } = {};
-      try { state = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first run */ }
+      type ActionState = { landingDay?: string; landingsToday?: number; failureCounts?: Record<string, number> };
+      let state: ActionState;
+      try { state = readTaskAgentState<ActionState>(statePath); } catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+        return;
+      }
       const action = JSON.parse(actionJson) as import('../task-agent/actions.js').NextAction;
       const deps: import('../task-agent/actions.js').ActionDeps = {
         ...state,
@@ -37,8 +52,7 @@ export function registerAutopilotCommands(program: Command): void {
         mode: config.taskAgent?.mode,
         // 하루 착지 칸은 상태 파일 잠금 안에서 확보·반환한다 — 두 CLI 프로세스가 같은 잔여 칸을 쓰지 않게.
         reserveLanding: (day, limit) => withFileLockSync(`${statePath}.lock`, () => {
-          let disk: typeof state = {};
-          try { disk = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first */ }
+          const disk = readTaskAgentState<ActionState>(statePath);
           const used = disk.landingDay === day ? disk.landingsToday ?? 0 : 0;
           if (used >= limit) return false;
           mkdirSync(dirname(statePath), { recursive: true });
@@ -47,8 +61,7 @@ export function registerAutopilotCommands(program: Command): void {
           return true;
         }),
         incrementFailure: (key) => withFileLockSync(`${statePath}.lock`, () => {
-          let disk: typeof state = {};
-          try { disk = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first */ }
+          const disk = readTaskAgentState<ActionState>(statePath);
           const counts = { ...(disk.failureCounts ?? {}) };
           counts[key] = (counts[key] ?? 0) + 1;
           mkdirSync(dirname(statePath), { recursive: true });
@@ -56,8 +69,7 @@ export function registerAutopilotCommands(program: Command): void {
           return counts[key]!;
         }),
         releaseLanding: (day) => withFileLockSync(`${statePath}.lock`, () => {
-          let disk: typeof state = {};
-          try { disk = JSON.parse(readFileSync(statePath, 'utf8')); } catch { return; }
+          const disk = readTaskAgentState<ActionState>(statePath);
           if (disk.landingDay !== day || !disk.landingsToday) return;
           writeFileSync(statePath, JSON.stringify({ ...disk, landingsToday: disk.landingsToday - 1 }));
           deps.landingsToday = disk.landingsToday - 1;
@@ -72,7 +84,14 @@ export function registerAutopilotCommands(program: Command): void {
           return { status: p.status ?? 1, stdout: p.stdout ?? '', stderr: p.stderr ?? '' };
         },
       };
-      const result = await executeNextAction(action, deps);
+      let result: string;
+      try { result = await executeNextAction(action, deps); } catch (error) {
+        // 잠금 안 읽기가 손상을 만나면 쓰지 않고 여기로 온다 — 실패로 끝낸다. 그 밖의 오류는 종전대로 올린다.
+        if (!(error instanceof TaskAgentStateError)) throw error;
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+        return;
+      }
       if (config.taskAgent?.mode === 'live') deps.saveState?.();
       process.stdout.write(`${result}\n`);
     });

package/src/cli/away-cli.ts

@@ -0,0 +1,68 @@
+import type { Command } from 'commander';
+import { readPresence, writePresence, type Presence } from '../away/presence.js';
+import { releaseNowText, releaseWatchTick, type TickDeps, type TickOutcome } from '../away/release-watch.js';
+import { sendOutbound } from '../domains/outbound-alert.js';
+import { readReleaseRuns } from '../nexus/api/ops-api.js';
+
+export interface AwayCliDeps {
+  read?: () => Presence;
+  write?: (away: boolean, by: string) => Presence;
+  tick?: (deps?: TickDeps) => TickOutcome;
+  now?: () => string;
+  send?: (text: string) => boolean;
+  output?: (line: string) => void;
+  setExitCode?: (code: number) => void;
+}
+
+/** AWAY-MODE-1 — `elanous away on|off|status|tick`. 켜고 끄는 순간 텔레그램에 한 줄을 보내 «받는 길이 산다»를 바로 본다. */
+export function registerAwayCommand(program: Command, deps: AwayCliDeps = {}): void {
+  const read = deps.read ?? (() => readPresence());
+  const write = deps.write ?? ((away: boolean, by: string) => writePresence(away, by));
+  const tick = deps.tick ?? releaseWatchTick;
+  const now = deps.now ?? (() => releaseNowText(readReleaseRuns(null, undefined, { facts: true })));
+  const send = deps.send ?? ((text: string) => sendOutbound(text, 'op-report'));
+  const output = deps.output ?? ((line: string) => console.log(line));
+  const setExitCode = deps.setExitCode ?? ((code: number) => { process.exitCode = code; });
+
+  const away = program.command('away').description('외출 모드 — 켜면 발행 현황을 텔레그램으로 따라간다(노드 전이 · 막힘 즉시 · 60분 생존 줄)');
+
+  away.command('on')
+    .description('외출 모드 켜기 — 지금 발행 현황 한 통을 보내고 그 뒤 전이를 따라간다')
+    .action(() => {
+      write(true, 'cli');
+      const ok = send(`🚶 외출 모드 켬 — 발행 현황을 여기로 보낸다(끄기: /away off)\n${now()}`);
+      const result = tick();
+      output(`외출 모드 켬 · 확인 한 통 ${ok ? '보냄' : '못 보냄'} · 첫 확인 ${result.outcome}`);
+      if (!ok) output('⚠️ 텔레그램 발송 실패 — elanous logs --category outbound.send 로 확인');
+      setExitCode(ok ? 0 : 1);
+    });
+
+  away.command('off')
+    .description('외출 모드 끄기')
+    .action(() => {
+      write(false, 'cli');
+      tick();
+      const ok = send('🏠 외출 모드 끔 — 발행 알림은 평소대로');
+      output(`외출 모드 끔 · 확인 한 통 ${ok ? '보냄' : '못 보냄'}`);
+      setExitCode(ok ? 0 : 1);
+    });
+
+  away.command('status')
+    .description('지금 외출 모드인가 ⊕ 발행 현황')
+    .option('--json', 'JSON 한 줄')
+    .action((opts: { json?: boolean }) => {
+      const presence = read();
+      if (opts.json) { output(JSON.stringify(presence)); return; }
+      output(`${presence.away ? '🚶 외출 중' : '🏠 자리에 있음'}${presence.since ? ` · ${presence.since}` : ''}${presence.by ? ` · ${presence.by}` : ''}`);
+      output(now());
+    });
+
+  away.command('tick')
+    .description('발행 현황을 한 번 보고 새 전이만 보낸다(주기 실행용 · 자리에 있으면 아무것도 안 함)')
+    .option('--json', 'JSON 한 줄')
+    .action((opts: { json?: boolean }) => {
+      const result = tick();
+      output(opts.json ? JSON.stringify(result) : `away tick: ${result.outcome}`);
+      setExitCode(result.outcome === 'send-failed' || result.outcome === 'unavailable' ? 1 : 0);
+    });
+}