elanous 0.2.18 → 0.2.20

package/src/away/release-watch.ts

@@ -0,0 +1,272 @@
+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 { shardsLine } from '../release-loop/gate-shards.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;
+  /** GATE-LIVE-OBS — 마지막으로 본 잘림·실패 조각 수. 늘면 한 줄. */
+  shardsBad?: number;
+}
+
+const shardsBad = (run: ReleaseRunView): number | undefined => {
+  const counts = run.gateShards?.summary.counts;
+  return counts ? counts.timeout + counts.failed : undefined;
+};
+
+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` : ''}`);
+  }
+  const bad = shardsBad(run);
+  if (run.gateShards && bad !== undefined && bad > (prev.shardsBad ?? 0)) {
+    lines.push(`⚠️ gate 조각 잘림·실패 ${bad} · ${shardsLine(run.gateShards.summary)}`);
+  }
+  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}`
+      + (run.gateShards ? `\n   ${shardsLine(run.gateShards.summary)}` : ''));
+  }
+  const changed = lines.length > 0 || prev.ended !== ended.length || prev.status !== run.status || prev.running !== running?.nodeId
+    || (bad !== undefined && bad !== prev.shardsBad);
+  return { lines, urgent, changed };
+}
+
+export function markOf(run: ReleaseRunView, sentAt: string): RunMark {
+  const running = runningNode(run);
+  const bad = shardsBad(run);
+  return { status: run.status, ended: endedNodes(run).length, ...(running ? { running: running.nodeId } : {}), sentAt,
+    ...(bad !== undefined ? { shardsBad: bad } : {}) };
+}
+
+/** 따라갈 런 — 최근 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}분째)` : ''}`);
+    if (run.gateShards) lines.push(`   ${shardsLine(run.gateShards.summary)}`);
+  }
+  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);
+    });
+}