elanous 0.2.18 → 0.2.19

package/src/away/presence.ts

@@ -0,0 +1,40 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+
+/** AWAY-MODE-1 — 대표가 자리를 비웠나. 한 파일(`<instance>/presence.json`)이 정본이고 CLI·텔레그램 /away 가 같이 쓴다. */
+export interface Presence {
+  away: boolean;
+  /** 마지막으로 바꾼 시각(ISO). 한 번도 안 바꿨으면 없음. */
+  since?: string;
+  /** 누가 바꿨나 — cli · telegram · pwa. */
+  by?: string;
+}
+
+export function presencePath(root: string = effectiveInstanceRoot()): string {
+  return join(root, 'presence.json');
+}
+
+/** 못 읽으면 «자리에 있음»으로 읽는다 — 외출 알림은 켠 사람만 받는다. */
+export function readPresence(path: string = presencePath()): Presence {
+  try {
+    const value: unknown = JSON.parse(readFileSync(path, 'utf8'));
+    if (!value || typeof value !== 'object') return { away: false };
+    const rec = value as Partial<Presence>;
+    return {
+      away: rec.away === true,
+      ...(typeof rec.since === 'string' ? { since: rec.since } : {}),
+      ...(typeof rec.by === 'string' ? { by: rec.by } : {}),
+    };
+  } catch { return { away: false }; }
+}
+
+export function writePresence(away: boolean, by: string, opts: { path?: string; now?: Date } = {}): Presence {
+  const path = opts.path ?? presencePath();
+  const presence: Presence = { away, since: (opts.now ?? new Date()).toISOString(), by };
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(presence)}\n`);
+  renameSync(tmp, path);
+  return presence;
+}

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/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/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);
+    });
+}

package/src/cli/guardian-cli.ts

@@ -0,0 +1,49 @@
+import type { Command } from 'commander';
+import type { Database } from 'bun:sqlite';
+import type { GuardianPlan } from '../domains/guardian-tick.js';
+import { getUserConfig } from '../user-config.js';
+import { writeStdoutJson } from './stdout-json.js';
+
+// Domain modules (schedules.db · schedule-runner → node-cron) load lazily inside the actions,
+// so registering `guardian` adds no static dependency to the CLI boot path.
+async function guardianPlan(): Promise<{ db: Database; plan: GuardianPlan }> {
+  const { listSchedules, openSchedulesDb } = await import('../domains/schedule-registry.js');
+  const db = openSchedulesDb();
+  try {
+    return { db, plan: { jobs: listSchedules(db) } };
+  } catch (error) {
+    db.close();
+    throw error;
+  }
+}
+
+export function registerGuardianCommands(program: Command): void {
+  const guardian = program.command('guardian').description('크론 수호자 그림자 관측(기존 크론·알림 무변경)');
+  guardian.command('tick').description('현재 시각에 발화했을 잡을 관측(잡은 실행하지 않음)')
+    .action(async () => {
+      const { guardianTick } = await import('../domains/guardian-tick.js');
+      const { db, plan } = await guardianPlan();
+      try {
+        const cfg = getUserConfig();
+        // Live activation (and crontab retirement) is a separate operational change.
+        if (cfg.guardian?.mode === 'live') throw new Error('guardian live activation is outside GUARD-ONE-a');
+        const result = await guardianTick(new Date(), plan, { config: cfg });
+        await writeStdoutJson(JSON.stringify(result, null, 2) + '\n');
+      } finally { db.close(); }
+    });
+  guardian.command('compare').description('하루의 예정 발화와 기록된 실제 발화 비교')
+    .requiredOption('--day <YYYY-MM-DD>', '비교할 달력 날짜')
+    .option('--json', 'JSON 출력')
+    .action(async (opts: { day: string; json?: boolean }) => {
+      const { guardianShadowDay } = await import('../domains/guardian-tick.js');
+      const { db, plan } = await guardianPlan();
+      try {
+        const result = guardianShadowDay(opts.day, { db, plan });
+        if (opts.json) await writeStdoutJson(JSON.stringify(result, null, 2) + '\n');
+        else {
+          console.log(`guardian ${result.day}: ${result.same ? 'same' : 'diff'} (현재 레지스트리 cron·활성 기준 재계산 · alertsActual=null: 발송 수 미측정)`);
+          for (const row of result.jobs) console.log(`  ${row.job}: would=${row.would} actual=${row.actual} alertsActual=${row.alertsActual ?? '미측정'}`);
+        }
+      } finally { db.close(); }
+    });
+}

package/src/cli/intake-cli.ts

@@ -46,7 +46,8 @@ export async function runIntakeCandidatesCli(
   const limit = opts.limit === undefined ? undefined : parseCandidatesLimit(opts.limit);
   const directives = deps.directives ?? (async () => {
     const [{ Database }, { existsSync }, { directiveDbPath }] = await Promise.all([
-      import('bun:sqlite'), import('node:fs'), import('../directives/directive-index.js'),
+      // The directive index is excluded from the public export; load it at run time only (proact-meter · know-find pattern).
+      import('bun:sqlite'), import('node:fs'), import(['..', 'directives', 'directive-index.js'].join('/')) as Promise<{ directiveDbPath: () => string }>,
     ]);
     const path = directiveDbPath();
     if (!existsSync(path)) return [];
@@ -144,14 +145,15 @@ export async function runIntakeToTasksCli(
 
 /** `--telegram` 다이제스트. 렌즈는 digest 를 만들기 전에 돈다. 렌즈 실패는 보고를 막지 않는다. */
 export async function runIntakeDigestCli(
-  opts: { day?: string; json?: boolean; telegram?: boolean; vault?: string; note?: string },
+  opts: { day?: string; json?: boolean; telegram?: boolean; vault?: string; note?: string; seat?: string },
   deps: IntakeDigestCliDeps = {},
 ): Promise<{ sent?: boolean; empty?: boolean }> {
-  const { buildIntakeDigest, renderDigestMarkdown, renderDigestTelegram } = await import('../intake-plane/digest.js');
+  const { buildIntakeDigest, recordSeatBriefed, renderDigestMarkdown, renderDigestTelegram } = await import('../intake-plane/digest.js');
   const { effectiveInstanceRoot } = await import('../instance/resolve.js');
   const root = deps.root ?? effectiveInstanceRoot();
   const day = opts.day ?? new Date(Date.now() + 9 * 3600_000).toISOString().slice(0, 10);
-  if (opts.telegram) {
+  // A seat briefing ignores lens rows (digest drops them), so it does not pay for a lens pass over other seats' items.
+  if (opts.telegram && opts.seat === undefined) {
     const annotate = deps.annotateLens ?? (async (lensRoot, lensDay) => {
       const { annotateIntakeLens } = await import('../intake-plane/lens.js');
       return annotateIntakeLens(lensRoot, lensDay);
@@ -159,9 +161,10 @@ export async function runIntakeDigestCli(
     try { await annotate(root, day); }
     catch (error) { debug.log('intake.lens', 'annotate-failed', { day, reason: error instanceof Error ? error.message : String(error) }); }
   }
-  const d = (deps.buildDigest ?? buildIntakeDigest)(root, day);
+  const seat = opts.seat === undefined ? undefined : (await import('../intake-plane/intake-sources.js')).canonicalSeat(opts.seat);
+  const d = (deps.buildDigest ?? buildIntakeDigest)(root, day, undefined, undefined, seat);
   if (opts.telegram) {
-    if (!d.absorbed.length && !d.news?.length) { console.log(`텔레그램: ${day} 흡수 0 — 보내지 않음`); return { empty: true }; }
+    if (!seat && !d.absorbed.length && !d.news?.length) { console.log(`텔레그램: ${day} 흡수 0 — 보내지 않음`); return { empty: true }; }
     const text = renderDigestTelegram(d, { ...(opts.vault ? { vaultRoot: opts.vault } : {}), ...(opts.note ? { notePath: opts.note } : {}) });
     const sent = deps.sendTelegram
       ? await deps.sendTelegram(text)
@@ -171,6 +174,8 @@ export async function runIntakeDigestCli(
         return sendTelegramReport(getUserConfig(), text, { markdown: true, kind: 'intake' });
       })();
     debug.log('intake.digest', 'telegram', { day, absorbed: d.absorbed.length, goals: d.goals.length, sent });
+    if (seat && sent) recordSeatBriefed(root, seat, day, d.absorbed.map((entry) => entry.id));
+    if (seat === 'user') debug.log('watch.default', 'brief', { topics: (await import('../intake-plane/intake-sources.js')).listSources({ seat }, root).length, items: d.absorbed.length, sent });
     console.log(sent ? `텔레그램 보고 채널로 보냈다 (${day} · 흡수 ${d.absorbed.length} · 골 후보 ${d.goals.length})` : '텔레그램 보고 채널 설정이 없다(telegram.reportChannel) — 보내지 않음');
     if (!sent) process.exitCode = 3;
     return { sent };
@@ -397,9 +402,10 @@ export function registerIntakeCommands(program: Command, candidateDeps: IntakeCa
     .option('--day <YYYY-MM-DD>', 'KST 날짜 (기본 오늘)')
     .option('--json', '구조화 출력')
     .option('--telegram', '텔레그램 보고 채널(telegram.reportChannel)로 짧은 판을 보낸다')
+    .option('--seat <id>', '자리 id (user 아침 브리핑)')
     .option('--vault <root>', '옵시디언 볼트 뿌리 — 텔레그램 판에 노트 열기 주소를 싣는다')
     .option('--note <path>', '열기 주소가 가리킬 노트(그날 트렌드 노트)')
-    .action(async (opts: { day?: string; json?: boolean; telegram?: boolean; vault?: string; note?: string }) => {
+    .action(async (opts: { day?: string; json?: boolean; telegram?: boolean; vault?: string; note?: string; seat?: string }) => {
       await runIntakeDigestCli(opts);
     });
 

package/src/cli/log-event-names.ts

@@ -1564,6 +1564,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "visibility-failed",
   "visibility-noninteractive",
   "visibility-preflight",
+  "visible",
   "voice-mode-active",
   "warn",
   "watch-error",

package/src/cli/pod-cli.ts

@@ -71,7 +71,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
         const current = spec ? null : kubectl(['config', 'current-context']);
         const context = spec ?? (current?.status === 0 ? current.stdout.trim() : '');
         const members = context ? parsePodPool(context) : [];
-        const measure: PoolLeaseMeasure = members.length ? measurePoolLease(members, { kubectl, dns: (context) => (deps.dns ?? probePoolDns)(context, kubectl) }) : { members: [] };
+        const measure: PoolLeaseMeasure = members.length ? measurePoolLease(members, { kubectl, dns: (context) => (deps.dns ?? probePoolDns)(context, kubectl), measureUsage: true }) : { members: [] };
         let accounts: number | null = null;
         let accountReason: string | null = null;
         try { accounts = (deps.accounts ?? (() => listCodexAccountsInStore().length))(); }
@@ -96,6 +96,10 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
           }
           io.log(`실측 점유: ${measure.members.map((m) => `${m.context} ${m.running === null || m.pending === null ? '못 쟀다' : m.running + m.pending}/${m.capacity}`).join(' · ') || '?'}`);
           io.log(`권장 지금 ${decision.recommended ?? '?'} 개 더 (limitedBy=${decision.limitedBy ?? 'unknown'})${decision.reason ? ` · ${decision.reason}` : ''}`);
+          if (decision.admission) {
+            const g = (v: number | null) => v === null ? '?' : `${(v / 1024 ** 3).toFixed(1)}Gi`;
+            io.log(`골당 입장 ${g(decision.admission.admitBytes)} (실사용 표본 ${decision.admission.samples} · p95 ${g(decision.admission.p95Bytes)}${decision.admission.fallback ? ` · 폴백: ${decision.admission.fallback}` : ''})`);
+          }
           io.log(`예약(저작 중) ${host.reserved} · 대기 Job ${waitingJobs ?? '?'} · 실행 ${decision.running ?? '?'}`);
           io.log(`임대 없는 실행 ${decision.unleasedRunning ?? '?'}`);
           io.log(`capacity: ${decision.capacitySlots ?? '?'} 칸 (상한 ${members.reduce((sum, m) => sum + m.capacity, 0)} − Running ${decision.running ?? '?'} − Pending ${decision.pending ?? '?'}; 권장 수에서 건강한 멤버의 임대 없는 실행 차감)`);

package/src/cli/pty-drive-cli.ts

@@ -51,6 +51,18 @@ export interface TuiWorkdirDecision {
   readonly message?: string;
 }
 
+/** 「명시 격리」 판정 — `--test`(명시 플래그 층) 이거나 `--isolated-root` 를 줬을 때만 참.
+ *
+ * ⭐ 이 식은 «한 벌»이다 — `runPtyDriveInner`(거부)와 `src/index.ts` dev 의 자동 워크트리
+ *    판정(`decideAutoWorktree`)이 같이 쓴다. 둘이 갈리면 「자동으로 만들었어야 하는데 거부」나
+ *    「거부했어야 하는데 자동」이 조용히 생긴다. 3층(트리 파생)은 «명시»가 아니라서 빠진다. */
+export function isExplicitlyIsolated(
+  resolution: { readonly kind: string; readonly layer: string },
+  isolatedRoot?: string,
+): boolean {
+  return (resolution.kind === 'test' && resolution.layer === 'explicit-flag') || Boolean(isolatedRoot);
+}
+
 /** Reject the unsafe combination before a TUI child can inherit the caller's tree. */
 export function decideTuiWorkdir(isolated: boolean, cwd: string | undefined): TuiWorkdirDecision {
   const workdirProvided = Boolean(cwd?.trim());
@@ -62,7 +74,7 @@ export function decideTuiWorkdir(isolated: boolean, cwd: string | undefined): Tu
     // ⛔⭐ 거부 문면은 **무엇을 주면 되는지**까지 말한다(교차 세션 제안 · 2026-08-02).
     //    상대가 헤맨 이유가 *"어디에 config 를 쓰나"* 였다 — 실효 자리를 확인하는 한 줄을 함께 준다.
     ...(rejected
-      ? { message: '격리 우주에서는 작업 디렉토리를 명시해야 한다 — `--cwd <worktree-path>` 를 주십시오. '
+      ? { message: '격리 우주에서는 작업 디렉토리를 명시해야 한다 — `--worktree` 를 주거나 `--cwd <worktree-path>` 를 주십시오. '
           + '(안 주면 명령을 친 트리가 자식의 쓰기 허용 구역이 됩니다.) '
           + '지금 어느 우주인지는 `elanous where` 로 확인할 수 있습니다.' }
       : {}),
@@ -499,8 +511,7 @@ async function runPtyDriveInner(opts: PtyDriveOpts): Promise<{ exitCode: number
   const { effectiveInstanceRoot } = await import('../instance/resolve.js');
   const scopeRoot = effectiveInstanceRoot();
   const resolution = resolveCurrentInstance();
-  const explicitlyIsolated = (resolution.kind === 'test' && resolution.layer === 'explicit-flag')
-    || Boolean(opts.isolatedRoot);
+  const explicitlyIsolated = isExplicitlyIsolated(resolution, opts.isolatedRoot);
   const workdirDecision = decideTuiWorkdir(explicitlyIsolated, opts.cwd);
   debug.log('pty.drive', 'tui-workdir-decision', workdirDecision);
   if (workdirDecision.rejected) throw new Error(workdirDecision.message);