elanous 0.2.9 → 0.2.10

package/scripts/install.sh

@@ -11,7 +11,7 @@ set -euo pipefail
 
 usage() {
   cat <<'EOF'
-Usage: bash scripts/install.sh [--prefix PATH] [--source PATH.tgz|URL] [--no-modify-path] [--no-bootstrap-bun] [--no-setup] [--yes] [--allow-downgrade] [--help]
+Usage: bash scripts/install.sh [--prefix PATH] [--source PATH.tgz|URL] [--no-modify-path] [--no-bootstrap-bun] [--no-install-deps] [--no-setup] [--yes] [--allow-downgrade] [--help]
        curl -fsSL https://github.com/ElanvitalAI/elanous/releases/latest/download/install.sh | bash
 
 Install elanous without contacting a package registry.
@@ -23,6 +23,7 @@ Install elanous without contacting a package registry.
                       (or set $ELANOUS_INSTALL_SOURCE; without either, fetch the verified latest release)
   --no-modify-path    do not append the elanous PATH block to a shell startup file
   --no-bootstrap-bun  fail instead of installing bun with its official installer when bun is missing
+  --no-install-deps  do not install missing prerequisites with apt even when running as root
   --no-setup          do not start first-time setup in this window after installing (interactive terminals only)
   --yes               do not ask before updating an existing installation
   --allow-downgrade   allow installing a version older than the one already installed
@@ -38,6 +39,7 @@ PREFIX="${ELANOUS_INSTALL_PREFIX:-${XDG_DATA_HOME:-${HOME:?HOME is required}/.lo
 SOURCE="${ELANOUS_INSTALL_SOURCE:-}"
 MODIFY_PATH=1
 BOOTSTRAP_BUN=1
+INSTALL_DEPS=1
 RUN_SETUP=1
 ASSUME_YES=0
 ALLOW_DOWNGRADE=0
@@ -53,6 +55,7 @@ while [ "$#" -gt 0 ]; do
       SOURCE="$2"; shift 2 ;;
     --no-modify-path) MODIFY_PATH=0; shift ;;
     --no-bootstrap-bun) BOOTSTRAP_BUN=0; shift ;;
+    --no-install-deps) INSTALL_DEPS=0; shift ;;
     --no-setup) RUN_SETUP=0; shift ;;
     --yes|-y) ASSUME_YES=1; shift ;;
     --allow-downgrade) ALLOW_DOWNGRADE=1; shift ;;
@@ -91,8 +94,8 @@ if ! command -v bun >/dev/null 2>&1 && [ -x "${BUN_INSTALL:-$HOME/.bun}/bin/bun"
   export PATH="${BUN_INSTALL:-$HOME/.bun}/bin:$PATH"
 fi
 # Match doctor-distro.ts families when a required command is absent; do not source os-release as shell code.
-required_command_hint() {
-  local package="$1" id='' id_like='' version='' key value family='unknown' like
+required_command_family() {
+  local id='' id_like='' version='' key value family='unknown' like
   if [ "$(uname -s)" = 'Darwin' ]; then
     family='darwin'
   elif [ "$(uname -s)" = 'Linux' ] && [ -r "${ELANOUS_INSTALL_OS_RELEASE_FILE:-/etc/os-release}" ]; then
@@ -121,6 +124,12 @@ required_command_hint() {
       fi
     fi
   fi
+  printf '%s' "$family"
+}
+
+required_command_hint() {
+  local package="$1" family
+  family="$(required_command_family)"
   if [ "$package" = 'bun' ] && [ "$family" != 'unknown' ]; then
     echo '   curl -fsSL https://bun.sh/install | bash' >&2
     return
@@ -138,16 +147,33 @@ required_command_hint() {
 SUDO='sudo '
 [ "$(id -u 2>/dev/null)" = 0 ] && SUDO=''
 
-# 빠진 선행 명령을 «한 번에» 모아 한 줄로 댄다.
-# 🩸 09-25 베어 ubuntu:24.04 실측: unzip 으로 멈추고, 깔고 다시 돌리면 git 으로 또 멈췄다(세 판).
-# 패키지 매니저 권한은 사람 몫이라 대신 깔지 않는다. bun 은 여기서 세지 않는다(없으면 아래에서 공식 설치기로 깐다).
-MISSING=()
-if ! command -v bun >/dev/null 2>&1 && [ "$BOOTSTRAP_BUN" -eq 1 ]; then
-  command -v curl >/dev/null 2>&1 || MISSING+=(curl)
-  command -v unzip >/dev/null 2>&1 || MISSING+=(unzip)   # bun 공식 설치기가 쓴다
+# 빠진 선행 명령을 «한 번에» 모아 한 줄로 댄다. bun 은 여기서 세지 않는다(없으면 아래에서 공식 설치기로 깐다).
+missing_prerequisites() {
+  MISSING=()
+  if ! command -v bun >/dev/null 2>&1 && [ "$BOOTSTRAP_BUN" -eq 1 ]; then
+    command -v curl >/dev/null 2>&1 || MISSING+=(curl)
+    command -v unzip >/dev/null 2>&1 || MISSING+=(unzip)   # bun 공식 설치기가 쓴다
+  fi
+  command -v git >/dev/null 2>&1 || MISSING+=(git)
+}
+missing_prerequisites
+INSTALLED_DEPS=''
+DEPS_INSTALL_FAILED=0
+if [ "${#MISSING[@]}" -gt 0 ] && [ "$INSTALL_DEPS" -eq 1 ] && [ "$SUDO" = '' ] &&
+   command -v apt-get >/dev/null 2>&1 && [ "$(required_command_family)" = debian ]; then
+  DEPS_TO_INSTALL=("${MISSING[@]}")
+  # Fresh container images ship with empty package lists — refresh once, then install without prompts.
+  if DEBIAN_FRONTEND=noninteractive apt-get update -qq >&2 &&
+     DEBIAN_FRONTEND=noninteractive apt-get install -y -qq "${DEPS_TO_INSTALL[@]}" >&2; then
+    INSTALLED_DEPS="${DEPS_TO_INSTALL[*]}"
+    echo "installed: $INSTALLED_DEPS" >&2
+    missing_prerequisites
+  else
+    DEPS_INSTALL_FAILED=1
+    echo '⛔ 자동 설치 실패 — 아래를 직접 실행하라 (automatic install failed — run the command below yourself):' >&2
+  fi
 fi
-command -v git >/dev/null 2>&1 || MISSING+=(git)
-if [ "${#MISSING[@]}" -gt 0 ]; then
+if [ "${#MISSING[@]}" -gt 0 ] || [ "$DEPS_INSTALL_FAILED" -eq 1 ]; then
   echo "⛔ required command missing: ${MISSING[*]}. Install it, then rerun this script:" >&2
   required_command_hint "${MISSING[*]}"
   exit 127
@@ -429,6 +455,7 @@ if [ "$MODIFY_PATH" -eq 1 ] && [ -n "${LOGIN_STARTUP:-}" ] && ! grep -Fqx "$MARK
 fi
 
 echo "$(t "Installed elanous $VERSION at $PREFIX/bin/elanous" "elanous $VERSION 을(를) 설치했습니다: $PREFIX/bin/elanous")"
+[ -z "$INSTALLED_DEPS" ] || echo "installed: $INSTALLED_DEPS"
 
 # ── 다음 걸음 (2026-09-23 · Phase 3 「사람 손」) ─────────────────────────
 # ⛔ 설치가 끝나도 «무엇을 더 쳐야 하나»를 안 말하면, 빠뜨린 손이 나중에 «다른 원인의 얼굴»로 나타난다

package/scripts/lib/pwa-scenarios/scenarios.ts

@@ -79,6 +79,9 @@ export function createScenarios(): Scenario[] {
 export function createScenariosWithReplay(readReplay: typeof readTerminalReplay): Scenario[] {
   const marker = `pwa-scn-${randomBytes(8).toString('hex')}`;
   const t1bMarker = `pwa-scn-${randomBytes(8).toString('hex')}`;
+  const t5bFirst = `ELANOUS_T5B_${randomBytes(8).toString('hex')}`;
+  const t5bSecond = `ELANOUS_T5B_${randomBytes(8).toString('hex')}`;
+  const screenContains = (text: string): string => `(() => { const host = document.querySelector('[data-xterm-host]'); const term = host?.__elanousTerm; if (!term || !host.getClientRects().length) return false; const buffer = term.buffer.active; for (let row = buffer.viewportY; row < buffer.viewportY + term.rows; row++) if (buffer.getLine(row)?.translateToString().includes(${JSON.stringify(text)})) return true; return false; })()`;
   // C1 — the answer (n+1) never appears in the question, so finding it on the page means a model replied.
   const c1Base = 1000 + (randomBytes(2).readUInt16BE(0) % 8000);
   return [
@@ -149,6 +152,23 @@ export function createScenariosWithReplay(readReplay: typeof readTerminalReplay)
           return body.terminals.filter((row) => row.producer === 'web-registration' && row.id === ids.terminalId).length === 1;
         } }],
     },
+    {
+      id: 'T5b', surface: 'terminal', path: '/app/term/', title: 'terminal shows output on open and after reload',
+      steps: [
+        { kind: 'goto' }, { kind: 'waitFor', selector: terminal, timeoutMs: 20_000 },
+        { kind: 'waitFor', jsPredicate: `Array.from(document.querySelectorAll(${JSON.stringify(connected)})).some(node => node.textContent?.includes('ACP: 연결됨'))`, timeoutMs: 20_000 },
+        { kind: 'click', selector: terminal }, { kind: 'type', text: `echo ${t5bFirst}` }, { kind: 'press', key: 'Enter' },
+        { kind: 'waitFor', jsPredicate: screenContains(t5bFirst), timeoutMs: 20_000 },
+        { kind: 'goto' }, { kind: 'waitFor', selector: terminal, timeoutMs: 20_000 },
+        { kind: 'waitFor', jsPredicate: screenContains(t5bFirst), timeoutMs: 20_000 },
+        { kind: 'click', selector: terminal }, { kind: 'type', text: `echo ${t5bSecond}` }, { kind: 'press', key: 'Enter' },
+        { kind: 'waitFor', jsPredicate: screenContains(t5bSecond), timeoutMs: 20_000 },
+      ],
+      expect: [
+        { js: screenContains(t5bFirst), expected: 'first marker still visible after reload' },
+        { js: screenContains(t5bSecond), expected: 'new output visible after reload' },
+      ],
+    },
     {
       id: 'C1', surface: 'chat', path: '/app/chat/', title: 'first message streams a model reply', costly: true,
       steps: [{ kind: 'goto' }, { kind: 'waitFor', selector: chatInput, timeoutMs: 20_000 }, { kind: 'click', selector: chatInput }, { kind: 'type', text: `Reply with only the number that is one more than ${c1Base}.` }, { kind: 'press', key: 'Enter' }],

package/scripts/lib/tui-regress-checks.ts

@@ -0,0 +1,146 @@
+// V1 — TUI regression checks that UX measured by hand on 10-02 (U1a · U1b · MAT1c · ONB1), as data.
+// Each check says what to type and how to judge the rendered screen text. The verdicts are pure
+// (screen string → ok/reason) so they are unit-tested without a PTY; scripts/tui-regress.ts drives the PTY.
+
+export type Step =
+  | { kind: 'type'; text: string }
+  | { kind: 'key'; data: string }
+  | { kind: 'wait'; ms: number }
+  | { kind: 'snap'; as: string }
+  | { kind: 'erase'; count: number };
+
+export interface Verdict { ok: boolean; reason: string }
+
+export interface TuiCheck {
+  id: string;
+  title: string;
+  /** `tui.role` to set in the temp config before launch (owner when omitted). */
+  role?: 'owner' | 'contributor' | 'general';
+  steps: Step[];
+  judge: (snaps: Record<string, string>) => Verdict;
+}
+
+const CTRL_C = '\x03';
+const BACKSPACE = '\x7f';
+const HINT = /한 번 더 누르면 나갑니다/;
+
+const ok = (reason: string): Verdict => ({ ok: true, reason });
+const no = (reason: string): Verdict => ({ ok: false, reason });
+
+/** The input row: the last screen line that starts with the prompt marker. */
+export function inputRow(screen: string): string | undefined {
+  return screen.split('\n').filter((line) => line.trimStart().startsWith('❯')).at(-1);
+}
+
+/** Palette entries visible after typing a slash prefix (lines other than the input row that show `/name`). */
+export function paletteHas(screen: string, name: string): boolean {
+  const row = inputRow(screen);
+  return screen.split('\n').some((line) => line !== row && line.includes(`/${name}`));
+}
+
+export function judgeFirstScreen(screen: string): Verdict {
+  if (/Step 1/.test(screen)) return no('«Step 1» 마법사가 떴다');
+  if (!inputRow(screen)) return no('입력칸 «❯» 가 없다');
+  return ok('입력칸이 보이고 «Step 1» 이 없다');
+}
+
+export function judgeHintAppearsThenClears(armed: string, later: string): Verdict {
+  if (!HINT.test(armed)) return no('빈 입력 Ctrl+C 뒤 안내가 안 보인다');
+  if (HINT.test(later)) return no('2.6초 뒤에도 안내가 남아 있다');
+  return ok('안내가 떴다가 2초 뒤 사라졌다');
+}
+
+export function judgeCtrlCClearsText(typed: string, after: string, text: string): Verdict {
+  if (!(inputRow(typed) ?? '').includes(text)) return no('친 글이 입력칸에 안 보인다(준비 실패)');
+  if ((inputRow(after) ?? '').includes(text)) return no('Ctrl+C 뒤에도 글이 남아 있다');
+  if (HINT.test(after)) return no('글을 지우는 Ctrl+C 에 나가기 안내가 떴다');
+  return ok('글이 지워지고 안내는 없다');
+}
+
+export function judgePalette(screens: Record<string, string>, expectations: Record<string, boolean>): Verdict {
+  for (const [name, want] of Object.entries(expectations)) {
+    const screen = screens[name];
+    if (screen === undefined) return no(`/${name} 화면이 없다`);
+    if (paletteHas(screen, name) !== want) return no(`/${name} 가 팔레트에 ${want ? '없다' : '보인다'}`);
+  }
+  return ok(Object.entries(expectations).map(([n, w]) => `/${n} ${w ? '보임' : '숨김'}`).join(' · '));
+}
+
+/** U1b — the help is drawn (key section ⊕ a run of command rows) and the prompt survives below it.
+ *  Not «the whole grid fits»: an owner sees 60+ commands, which exceed a 50-row screen and scroll (PgUp). */
+export function judgeHelpShown(screen: string): Verdict {
+  const lines = screen.split('\n');
+  const commandRows = lines.filter((line) => /^\s+\/[a-z][a-z-]*/.test(line)).length;
+  if (!lines.some((line) => /^\s*Keys\s*$/.test(line))) return no('/help 의 Keys 절이 안 보인다');
+  if (commandRows < 10) return no(`명령 줄이 ${commandRows}개뿐이다`);
+  if (!inputRow(screen)) return no('도움말을 연 뒤 입력칸이 화면 밖으로 밀렸다');
+  return ok(`도움말이 그려졌다(명령 줄 ${commandRows} · Keys 절 · 입력칸 유지)`);
+}
+
+/** U1c2 — lines typed while a reply streams show up as «my» lines, in order, each above its own answer. */
+export function judgeQueuedEcho(screen: string): Verdict {
+  const lines = screen.split('\n');
+  const at = (re: RegExp, after = -1) => lines.findIndex((line, i) => i > after && re.test(line));
+  const u2 = at(/Q2MARK 라고만/);
+  if (u2 < 0) return no('줄 서 있던 «Q2MARK 라고만» 이 내 말로 안 보인다');
+  const a2 = lines.findIndex((line, i) => i > u2 && /Q2MARK/.test(line) && !/라고만/.test(line));
+  const u3 = at(/Q3MARK 라고만/, u2);
+  if (u3 < 0) return no('«Q3MARK 라고만» 이 내 말로 안 보인다(또는 순서가 뒤집혔다)');
+  const a3 = lines.findIndex((line, i) => i > u3 && /Q3MARK/.test(line) && !/라고만/.test(line));
+  if (!(a2 > u2 && u3 > a2 && a3 > u3)) return no(`순서가 내 말2(${u2}) → 답2(${a2}) → 내 말3(${u3}) → 답3(${a3}) 가 아니다`);
+  return ok('내 말2 → 답2 → 내 말3 → 답3');
+}
+
+const PALETTE_STEPS = (names: string[]): Step[] => names.flatMap((name) => [
+  { kind: 'type', text: `/${name.slice(0, 3)}` } as Step,
+  { kind: 'wait', ms: 800 } as Step,
+  { kind: 'snap', as: name } as Step,
+  { kind: 'erase', count: 4 } as Step,
+  { kind: 'wait', ms: 300 } as Step,
+]);
+
+export const TUI_REGRESS_CHECKS: TuiCheck[] = [
+  {
+    id: 'R1', title: '첫 화면 — 입력칸 · «Step 1» 0 (ONB1)',
+    steps: [{ kind: 'snap', as: 'boot' }],
+    judge: (s) => judgeFirstScreen(s.boot ?? ''),
+  },
+  {
+    id: 'R2', title: '빈 입력 Ctrl+C → 안내 → 2초 뒤 사라짐 (U1a · #22868)',
+    steps: [{ kind: 'key', data: CTRL_C }, { kind: 'wait', ms: 300 }, { kind: 'snap', as: 'armed' }, { kind: 'wait', ms: 2600 }, { kind: 'snap', as: 'later' }],
+    judge: (s) => judgeHintAppearsThenClears(s.armed ?? '', s.later ?? ''),
+  },
+  {
+    id: 'R3', title: '글 친 뒤 Ctrl+C → 입력 지움 · 안내 없음 (U1a)',
+    steps: [{ kind: 'type', text: 'regress-abc' }, { kind: 'wait', ms: 400 }, { kind: 'snap', as: 'typed' }, { kind: 'key', data: CTRL_C }, { kind: 'wait', ms: 400 }, { kind: 'snap', as: 'after' }],
+    judge: (s) => judgeCtrlCClearsText(s.typed ?? '', s.after ?? '', 'regress-abc'),
+  },
+  {
+    id: 'R4', title: 'owner 팔레트 — /directive · /help 보임 (MAT1c)',
+    steps: PALETTE_STEPS(['directive', 'help']),
+    judge: (s) => judgePalette(s, { directive: true, help: true }),
+  },
+  {
+    id: 'R5', title: 'general 팔레트 — /directive 숨김 · /help 보임 (MAT1c)',
+    role: 'general',
+    steps: PALETTE_STEPS(['directive', 'help']),
+    judge: (s) => judgePalette(s, { directive: false, help: true }),
+  },
+  {
+    id: 'R6', title: '/help 가 그려지고 입력칸이 남는다 (U1b · #22802)',
+    steps: [{ kind: 'type', text: '/help' }, { kind: 'key', data: '\r' }, { kind: 'wait', ms: 1500 }, { kind: 'snap', as: 'help' }],
+    judge: (s) => judgeHelpShown(s.help ?? ''),
+  },
+  {
+    id: 'R7', title: '답 오는 중 쳐 둔 두 줄이 내 말로 차례로 (U1c2 · #23026 · 실제 LLM 턴)',
+    steps: [
+      { kind: 'type', text: '1부터 25까지 숫자를 한 줄에 하나씩 써 줘. 도구는 쓰지 마.' }, { kind: 'key', data: '\r' }, { kind: 'wait', ms: 2500 },
+      { kind: 'type', text: 'Q2MARK 라고만 답해' }, { kind: 'key', data: '\r' }, { kind: 'wait', ms: 500 },
+      { kind: 'type', text: 'Q3MARK 라고만 답해' }, { kind: 'key', data: '\r' }, { kind: 'wait', ms: 60_000 },
+      { kind: 'snap', as: 'after' },
+    ],
+    judge: (s) => judgeQueuedEcho(s.after ?? ''),
+  },
+];
+
+export const ERASE = BACKSPACE;

package/scripts/memory-lifecycle-cycle.ts

@@ -79,7 +79,7 @@ async function main(): Promise<void> {
           if (proposals.length) {
             const body = proposals.map((p, i) => `${i + 1}. ${p.label} (강도 ${p.score.toFixed(2)})\n   ${p.rationale}`).join('\n\n');
             const msg = `💡 taste 제안 ${proposals.length}건 — 반복 관심에서 창발한 미션 후보입니다.\n(제안일 뿐 미션 생성 아님 · 승인/기각: \`/taste approve <테마>\` · \`/taste reject <테마>\`)\n\n${body}`;
-            try { sendOutbound(msg, 'report'); } catch (e) { log(`taste 제안 발송 오류: ${e instanceof Error ? e.message : String(e)}`); }
+            try { sendOutbound(msg, 'ops-report'); } catch (e) { log(`taste 제안 발송 오류: ${e instanceof Error ? e.message : String(e)}`); }
             log(`taste 제안 표면화: ${proposals.length}건`);
           }
         }
@@ -101,7 +101,7 @@ async function main(): Promise<void> {
     const changed = (report.recaps?.promoted ?? 0) + (report.consolidate?.consolidated ?? 0)
       + (report.archive?.archived ?? 0) + (report.prunedEvents ?? 0);
     if (changed > 0) {
-      try { sendOutbound(`🧠 기억 회고(새벽) — ${summary}`, 'report'); } catch (e) { log(`발송 오류: ${e instanceof Error ? e.message : String(e)}`); }
+      try { sendOutbound(`🧠 기억 회고(새벽) — ${summary}`, 'ops-report'); } catch (e) { log(`발송 오류: ${e instanceof Error ? e.message : String(e)}`); }
     }
 
     // 자율행동 회상 로깅(autopilot P0.2) — 회고 루프도 자율행동.

package/scripts/ops-now-probe.ts

@@ -0,0 +1,327 @@
+#!/usr/bin/env bun
+import { spawn } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { debug, redactSecrets } from '../src/debug/log.js';
+import { sendOutbound } from '../src/domains/outbound-alert.js';
+import { DecisionLedger } from '../src/decisions/decision-ledger.js';
+import { effectiveInstanceRoot, prodInstanceRoot, releaseLedgerRoot } from '../src/instance/resolve.js';
+import { listMemories } from '../src/memory.js';
+import { listSchedules, getSchedule } from '../src/release-loop/release-schedule.js';
+import { listChecklist, summarizeChecklist } from '../src/release-loop/checklist.js';
+import { getUserConfig } from '../src/user-config.js';
+import { registerStandaloneLogSink } from '../src/domains/standalone-log-sink.js';
+
+export type ProbeKind = 'cut' | 'green' | 'open';
+export type ProbeVerdict = 'match' | 'mismatch' | 'pending' | 'unmeasured';
+export interface ProbeRow {
+  ts: string;
+  question: string;
+  verdict: ProbeVerdict;
+  botValue: string | number | null;
+  ledgerValue: string | number | null;
+  opsNowUpdatedAt: string | null;
+  reason: string | null;
+  botReply: string | null;
+}
+export const STANDARD_QUESTIONS: ReadonlyArray<{ kind: ProbeKind; ask: (version: string) => string }> = [
+  { kind: 'cut', ask: (version) => `${version} 컷 언제야?` },
+  { kind: 'green', ask: (version) => `${version} 체크리스트 초록 몇 개야?` },
+  { kind: 'open', ask: () => '지금 미결 결정 몇 개야?' },
+];
+
+export interface ProbeDeps {
+  schedules?: () => Promise<Array<{ version: string; cutAt: string }>> | Array<{ version: string; cutAt: string }>;
+  published?: (version: string) => Promise<boolean> | boolean;
+  cut?: (version: string) => Promise<string | null> | string | null;
+  green?: (version: string) => Promise<number> | number;
+  open?: () => Promise<number> | number;
+  ask?: (question: string, model?: string) => Promise<string>;
+  send?: typeof sendOutbound;
+  memoryUpdatedAt?: () => string | null;
+  model?: () => string | undefined;
+  root?: string;
+  now?: () => Date;
+  print?: (line: string) => void;
+  observe?: (question: string, verdict: ProbeVerdict, reason: string | null) => void;
+}
+export interface ProbeOptions { version?: string; dryRun?: boolean; json?: boolean }
+
+function kstDate(date: Date): string {
+  return new Date(date.getTime() + 9 * 3_600_000).toISOString().slice(0, 10);
+}
+
+const CUT_ISO = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})(?!\d)/g;
+const CUT_LOCAL = /(?:(\d{4})\s*[년./-]\s*)?(\d{1,2})\s*(?:월|[./-])\s*(\d{1,2})\s*(?:일)?(?:\s*\([^)]*\))?(?:\s*(?:오전|오후|AM|PM))?\s*(\d{1,2})\s*(?:시\s*(\d{1,2})\s*분?|:\s*(\d{2}))(?!\d)\s*(?:KST|한국시간)?/gi;
+
+function cutValue(text: string): string | null {
+  const iso = new RegExp(CUT_ISO.source).exec(text)?.[0];
+  if (iso && Number.isFinite(Date.parse(iso))) return new Date(Date.parse(iso) + 9 * 3_600_000).toISOString().slice(0, 16);
+  const match = new RegExp(CUT_LOCAL.source, 'i').exec(text);
+  if (!match) return null;
+  const year = match[1] ? Number(match[1]) : null;
+  const month = Number(match[2]), day = Number(match[3]);
+  let hour = Number(match[4]);
+  const minute = Number(match[5] ?? match[6]);
+  if (/오후|PM/i.test(match[0]) && hour < 12) hour += 12;
+  if (/오전|AM/i.test(match[0]) && hour === 12) hour = 0;
+  if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 23 || minute > 59) return null;
+  return `${year ?? '????'}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}T${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
+}
+
+function normalizedCut(value: string, reference?: string): string | null {
+  const parsed = cutValue(value);
+  if (!parsed) return null;
+  if (parsed.startsWith('????-') && reference) return `${reference.slice(0, 4)}${parsed.slice(4)}`;
+  return parsed;
+}
+
+function ledgerCutValue(value: string): string | null {
+  const millis = Date.parse(value);
+  if (!Number.isFinite(millis)) return null;
+  return new Date(millis + 9 * 3_600_000).toISOString().slice(0, 16);
+}
+
+type ParsedValue<T> = { value: T | null; ambiguous: boolean };
+type Candidate<T> = { start: number; end: number; value: T };
+
+function selectClaim<T>(reply: string, candidates: Candidate<T>[]): ParsedValue<T> {
+  if (candidates.length === 1) {
+    const after = reply.slice(candidates[0]!.end);
+    if (/^\s*(?:개|건|KST|한국시간)?\s*(?:가|이|은|는)?\s*(?:아닙니다|아니다|아니에요|아님|아닌|말고)/i.test(after)) {
+      return { value: null, ambiguous: true };
+    }
+    return { value: candidates[0]!.value, ambiguous: false };
+  }
+  if (candidates.length === 2) {
+    const between = reply.slice(candidates[0]!.end, candidates[1]!.start);
+    // «57개가 아니라 50개» · «3개, 아니 4개» — the later value is the asserted one.
+    if (/^(?:\s*(?:개|건|KST|한국시간))?\s*(?:가|이|은|는)?\s*(?:아니라|아닌|말고|[,，]?\s*아니(?:요|고)?\s*[,，]?)\s*$/i.test(between)) {
+      return { value: candidates[1]!.value, ambiguous: false };
+    }
+  }
+  return { value: null, ambiguous: candidates.length > 1 };
+}
+
+const NEGATED_AFTER = /^\s*(?:개|건)?\s*(?:가|이|은|는)?\s*(?:아닙니다|아니다|아니에요|아님|아닌|말고)/i;
+// A number counts as the metric only when it carries a unit (개·건) or sits right after the label («초록은 57»).
+// Anything else (a version «0.2.10판», a date) is not a claim about the count — unmeasured, never a false drift.
+const DIRECT_AFTER_LABEL = /^\s*(?:은|는|이|가|도|:|=)?\s*(?:총|현재|지금|모두|전부)?\s*$/;
+
+function countValue(reply: string, kind: 'green' | 'open'): ParsedValue<number> {
+  const label = kind === 'green' ? /(?:초록|녹색|green|🟢)/i : /(?:미결\s*결정|열린\s*결정|open\s*decisions?|미결)/i;
+  const found = label.exec(reply);
+  if (!found) {
+    const bare = /^\s*(\d[\d,]*)\s*(?:개|건)?[.。!\s]*$/.exec(reply);
+    if (!bare) return { value: null, ambiguous: false };
+    const value = Number(bare[1]!.replaceAll(',', ''));
+    return Number.isSafeInteger(value) && value >= 0 ? { value, ambiguous: false } : { value: null, ambiguous: false };
+  }
+  const answer = reply.slice(found.index + found[0].length);
+  const candidates: Candidate<number>[] = [];
+  for (const match of answer.matchAll(/(?<![\d.])\d[\d,]*(?![\d.])/g)) {
+    const value = Number(match[0].replaceAll(',', ''));
+    if (!Number.isSafeInteger(value) || value < 0) continue;
+    const end = match.index + match[0].length;
+    const unit = /^\s*(?:개|건)/.test(answer.slice(end));
+    const direct = DIRECT_AFTER_LABEL.test(answer.slice(0, match.index));
+    if (unit || direct) candidates.push({ start: match.index, end, value });
+  }
+  if (candidates.length) return selectClaim(answer, candidates);
+  // Number before the label («57개가 초록», «57개 초록이 아닙니다») — keep the negation that follows the label.
+  const reverse = new RegExp(`(?<![\\d.])(\\d[\\d,]*)(?![\\d.])\\s*(?:개|건)?\\s*(?:가|이|의)?\\s*${label.source}`, 'i').exec(reply);
+  if (!reverse) return { value: null, ambiguous: false };
+  const tail = reply.slice(reverse.index + reverse[0].length);
+  if (NEGATED_AFTER.test(tail)) return { value: null, ambiguous: true };
+  const value = Number(reverse[1]!.replaceAll(',', ''));
+  return Number.isSafeInteger(value) && value >= 0 ? { value, ambiguous: false } : { value: null, ambiguous: false };
+}
+
+function replyValue(kind: ProbeKind, reply: string, ledger: string | number): ParsedValue<string | number> {
+  if (kind !== 'cut') return countValue(reply, kind);
+  const candidates: Candidate<string>[] = [];
+  for (const match of reply.matchAll(CUT_ISO)) {
+    const value = normalizedCut(match[0], String(ledger));
+    if (value) candidates.push({ start: match.index, end: match.index + match[0].length, value });
+  }
+  for (const match of reply.matchAll(CUT_LOCAL)) {
+    if (candidates.some((candidate) => match.index < candidate.end && match.index + match[0].length > candidate.start)) continue;
+    let value = normalizedCut(match[0], String(ledger));
+    const zone = /^\s*(UTC|GMT|Z\b|[A-Z]{2,4}T\b|[+-]\d{1,2}(?::?\d{2})?\b)\s*([+-]\d{1,2}(?::?\d{2})?)?/i.exec(reply.slice(match.index + match[0].length));
+    if (value && zone && !/KST/i.test(match[0])) {
+      // A written zone other than KST: UTC/GMT converts (+9h); any other zone or offset is not guessed — unmeasured.
+      if (/^(?:UTC|GMT|Z)$/i.test(zone[1]!) && !zone[2] && !value.startsWith('????')) {
+        const millis = Date.parse(`${value}:00Z`);
+        value = Number.isFinite(millis) ? new Date(millis + 9 * 3_600_000).toISOString().slice(0, 16) : null;
+      } else value = null;
+    }
+    if (value) candidates.push({ start: match.index, end: match.index + match[0].length + (zone && !/KST/i.test(match[0]) ? zone[0].length : 0), value });
+  }
+  candidates.sort((a, b) => a.start - b.start);
+  const valid = candidates.filter(({ value: parsed }) => {
+    const millis = Date.parse(`${parsed}:00Z`);
+    return Number.isFinite(millis) && new Date(millis).toISOString().slice(0, 16) === parsed;
+  });
+  return selectClaim(reply, valid);
+}
+
+function askBot(question: string, model?: string): Promise<string> {
+  const root = effectiveInstanceRoot();
+  return new Promise((resolve, reject) => {
+    const args = ['bin/elanous.mjs', ...(root === prodInstanceRoot() ? [] : [`--test=${root}`]), 'ask', question, '--json'];
+    const child = spawn('bun', args, {
+      cwd: join(import.meta.dir, '..'),
+      env: { ...process.env, ...(model ? { ELANOUS_LLM_MODEL: model } : {}) },
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    let out = '';
+    let tooLong = false;
+    let timedOut = false;
+    const timer = setTimeout(() => { timedOut = true; child.kill(); reject(new Error('timeout')); }, 90_000);
+    child.stdout.on('data', (chunk: Buffer) => {
+      out += chunk.toString();
+      if (out.length > 1024 * 1024) { tooLong = true; child.kill(); }
+    });
+    child.on('error', (error) => { clearTimeout(timer); reject(error); });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (timedOut) return reject(new Error('timeout'));
+      if (tooLong) return reject(new Error('bot-output-too-large'));
+      if (code !== 0) return reject(new Error('bot-error'));
+      try {
+        const result = JSON.parse(out) as { reply?: unknown; error?: unknown };
+        if (typeof result.reply !== 'string') throw new Error('bot-no-reply');
+        resolve(result.reply);
+      } catch { reject(new Error('bot-no-reply')); }
+    });
+  });
+}
+
+function isPublished(version: string, releaseRoot: string): boolean {
+  try {
+    const record = JSON.parse(readFileSync(join(releaseRoot, 'release', version, 'release.json'), 'utf8')) as { publishedAt?: unknown; version?: unknown };
+    return record.version === version && typeof record.publishedAt === 'string';
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+function ledgerOpen(): number { return new DecisionLedger().list({ status: 'open' }).length; }
+function memoryUpdatedAt(): string | null { return listMemories().find((entry) => entry.name === 'ops-now')?.updatedAt ?? null; }
+function probeModel(): string | undefined {
+  const config = getUserConfig().raw.opsNowProbe;
+  if (!config || typeof config !== 'object' || Array.isArray(config)) return undefined;
+  const model = (config as Record<string, unknown>).model;
+  return typeof model === 'string' && model.trim() ? model.trim() : undefined;
+}
+
+export async function runOpsNowProbe(options: ProbeOptions = {}, deps: ProbeDeps = {}): Promise<{ rows: ProbeRow[]; exitCode: number; alert: string | null }> {
+  const now = (deps.now ?? (() => new Date()))();
+  const root = deps.root ?? effectiveInstanceRoot();
+  const releaseRoot = releaseLedgerRoot();
+  let version = options.version;
+  if (!version) {
+    try {
+      if (!deps.schedules && !existsSync(join(releaseRoot, 'release', 'features.sqlite'))) throw new Error('ledger-unreadable');
+      const schedules = await (deps.schedules ?? (() => listSchedules(releaseRoot)))();
+      const ordered = schedules.filter((row) => Number.isFinite(Date.parse(row.cutAt)))
+        .sort((a, b) => Date.parse(a.cutAt) - Date.parse(b.cutAt));
+      for (const row of ordered) {
+        if (!await (deps.published ?? ((v) => isPublished(v, releaseRoot)))(row.version)) {
+          version = row.version;
+          break;
+        }
+      }
+    } catch { /* A missing version makes the two release questions unmeasured. */ }
+  }
+  const updatedAt = (() => { try { return (deps.memoryUpdatedAt ?? memoryUpdatedAt)(); } catch { return null; } })();
+  let model: string | undefined;
+  try { model = deps.model ? deps.model() : probeModel(); } catch { /* Use the ask path's configured model. */ }
+  const rows: ProbeRow[] = [];
+  for (const item of STANDARD_QUESTIONS) {
+    const question = item.ask(version ?? '(판 미상)');
+    let ledgerValue: string | number | null = null;
+    let reason: string | null = null;
+    try {
+      if (item.kind !== 'open' && !version) throw new Error('ledger-unreadable');
+      if (item.kind === 'green' && !deps.green && !existsSync(join(releaseRoot, 'release', 'features.sqlite')) && !existsSync(join(releaseRoot, 'release', version!, 'checklist.json'))) throw new Error('ledger-unreadable');
+      if (item.kind === 'open' && !deps.open && !existsSync(new DecisionLedger().path)) throw new Error('ledger-unreadable');
+      const value = item.kind === 'cut' ? await (deps.cut ?? ((v) => getSchedule(v, releaseRoot)?.cutAt ?? null))(version!)
+        : item.kind === 'green' ? await (deps.green ?? ((v) => summarizeChecklist(listChecklist(v)).green))(version!) : await (deps.open ?? ledgerOpen)();
+      if (item.kind === 'cut') ledgerValue = typeof value === 'string' ? ledgerCutValue(value) : null;
+      else ledgerValue = typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
+      if (ledgerValue === null) reason = 'ledger-unreadable';
+    } catch { reason = 'ledger-unreadable'; }
+    let reply: string | null = null;
+    let botValue: string | number | null = null;
+    try { reply = await (deps.ask ?? askBot)(question, model); }
+    catch (error) { if (!reason) reason = (error as Error).message === 'timeout' ? 'timeout' : 'bot-unresponsive'; }
+    let verdict: ProbeVerdict = 'unmeasured';
+    if (!reason) {
+      if (!reply?.trim()) reason = 'bot-unresponsive';
+      else if (/확인\s*(?:중|해\s*보겠|해\s*볼게|해\s*보도록|이\s*필요)|조회\s*중|살펴\s*보겠/.test(reply)) { verdict = 'pending'; reason = 'bot-pending'; }
+      else {
+        const parsed = replyValue(item.kind, reply, ledgerValue!);
+        botValue = parsed.value;
+        if (botValue === null) reason = parsed.ambiguous ? 'value-ambiguous' : 'value-unparseable';
+        else verdict = botValue === ledgerValue ? 'match' : 'mismatch';
+      }
+    }
+    const row: ProbeRow = { ts: now.toISOString(), question, verdict, botValue, ledgerValue, opsNowUpdatedAt: updatedAt,
+      reason, botReply: reply === null ? null : redactSecrets({ reply }).reply.slice(0, 200) };
+    rows.push(row);
+    debug.log('ops-now.probe', 'verdict', { question, verdict, reason });
+    deps.observe?.(question, verdict, reason);
+  }
+  const path = join(root, 'ops-now-probe', `${kstDate(now)}.jsonl`);
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, rows.map((row) => JSON.stringify(row)).join('\n') + '\n', { mode: 0o600 });
+  const mismatches = rows.filter((row) => row.verdict === 'mismatch');
+  const alert = mismatches.length ? `🚨 ops-now 봇 답 불일치 — ${mismatches.map((row) => `${row.question} 봇 ${row.botValue} / 원장 ${row.ledgerValue}`).join(' · ')} · ops-now updatedAt ${updatedAt ?? '미상'}` : null;
+  let alertDelivery: 'sent' | 'failed' | 'dry-run' | null = alert ? (options.dryRun ? 'dry-run' : 'failed') : null;
+  if (alert && !options.dryRun) {
+    try {
+      if (await (deps.send ?? sendOutbound)(alert, 'ops-alert')) alertDelivery = 'sent';
+    } catch {
+      // A throwing sender has the same undelivered outcome as a false return.
+    }
+    if (alertDelivery === 'failed') debug.log('ops-now.probe', 'alert-failed', { kind: 'ops-alert' });
+  }
+  const print = deps.print ?? console.log;
+  const warning = [
+    ...(rows.some((row) => row.verdict === 'unmeasured') ? ['⚠ 측정하지 못한 질문이 있습니다.'] : []),
+    ...(alertDelivery === 'failed' ? ['⚠ ops-alert 전송 실패'] : []),
+  ].join(' ') || null;
+  if (options.json) print(JSON.stringify({ version: version ?? null, rows, alert, alertDelivery, warning, wouldSend: Boolean(alert && options.dryRun), exitCode: mismatches.length ? 1 : 0 }));
+  else {
+    for (const row of rows) print(`${row.verdict} · ${row.question} · 봇 ${row.botValue ?? '-'} · 원장 ${row.ledgerValue ?? '-'}${row.reason ? ` · ${row.reason}` : ''}`);
+    if (warning) print(warning);
+    if (alert) {
+      if (alertDelivery === 'dry-run') print(`보냈을 것: ${alert}`);
+      else if (alertDelivery === 'sent') print(alert);
+    }
+  }
+  return { rows, exitCode: mismatches.length ? 1 : 0, alert };
+}
+
+export async function main(args: string[] = process.argv.slice(2)): Promise<number> {
+  let version: string | undefined;
+  let dryRun = false, json = false, once = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--once') once = true;
+    else if (arg === '--dry-run') dryRun = true;
+    else if (arg === '--json') json = true;
+    else if (arg === '--version' && args[i + 1] && !args[i + 1]!.startsWith('--')) version = args[++i];
+    else throw new Error(`알 수 없는 옵션: ${arg}`);
+  }
+  if (!once) throw new Error('--once 필요');
+  await registerStandaloneLogSink('ops-now-probe');
+  return (await runOpsNowProbe({ version, dryRun, json })).exitCode;
+}
+
+if (import.meta.main) {
+  try { process.exitCode = await main(); }
+  catch (error) { console.error(`ops-now-probe: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 2; }
+}