hypomnema 1.0.1 → 1.2.0

package/docs/ARCHITECTURE.md

@@ -53,7 +53,7 @@ hypomnema/
 │   ├── Home.md, Overview.md, hypo-automation.md, hypo-help.md
 │   ├── pages/_index.md
 │   └── projects/_template/
-├── tests/runner.mjs          ← no-dependency test runner (51 tests)
+├── tests/runner.mjs          ← no-dependency test runner
 ├── docs/                     ← ARCHITECTURE.md, CONTRIBUTING.md
 ├── .claude-plugin/plugin.json← plugin manifest
 └── package.json              ← npm metadata, no runtime deps
@@ -100,7 +100,7 @@ Hooks run automatically at Claude Code lifecycle events. They are deployed to `~
 | `UserPromptSubmit` | `hypo-first-prompt.mjs` → `hypo-lookup.mjs` → `hypo-compact-guard.mjs` |
 | `PreCompact` | `hypo-personal-check.mjs` |
 | `PostToolUse` (Write/Edit) | `hypo-auto-stage.mjs` |
-| `Stop` | `hypo-hot-rebuild.mjs` → `hypo-auto-commit.mjs` |
+| `Stop` | `hypo-hot-rebuild.mjs` → `hypo-session-record.mjs` → `hypo-auto-commit.mjs` |
 | `CwdChanged` | `hypo-cwd-change.mjs` |
 | `FileChanged` | `hypo-file-watch.mjs` |
 
@@ -113,9 +113,10 @@ Hooks run automatically at Claude Code lifecycle events. They are deployed to `~
 | `hypo-lookup` | BM25 search over the wiki on every prompt. **HIT** → inject top-3 page snippets (≤2000 chars each, with verify-by-date warnings). **MISS** → emit closest-slug signal that prompts Claude to research + `/hypo:ingest` |
 | `hypo-compact-guard` | Detect `/compact` invocations → enforce session-close checklist before allowing compact |
 | `hypo-personal-check` | PreCompact validation: lint blockers, uncommitted changes, missing session-log entries → block compact |
-| `hypo-auto-stage` | After Write/Edit on a wiki path, run `git add` (filtered by `.hypoignore`) |
-| `hypo-hot-rebuild` | At session stop, regenerate root `hot.md` from recent activity |
-| `hypo-auto-commit` | At session stop, commit staged changes + `git pull --rebase` + `git push` (silent fail on missing remote) |
+| `hypo-auto-stage` | After Write/Edit on a wiki path, run `git add` (skips paths matching `.hypoignore`) |
+| `hypo-hot-rebuild` | At session stop, regenerate root `hot.md` from recent activity; emit growth metrics + cache for next SessionStart |
+| `hypo-session-record` | At session stop, append `{session_id, transcript_path, recorded_at, cwd}` to `.cache/sessions/index.jsonl` (primary source for the observability audit) |
+| `hypo-auto-commit` | At session stop, filter changed paths through `.hypoignore`, commit non-ignored changes, `git pull --no-rebase` + `git push` (silent fail on missing remote) |
 | `hypo-cwd-change` | When working directory changes, re-resolve the active project and inject its `hot.md` |
 | `hypo-file-watch` | Notify on external wiki edits so the in-session view stays consistent |
 
@@ -289,8 +290,9 @@ SessionStart
   │     └─► hypo-cwd-change.mjs (re-inject project hot.md)
   │
   └─► Stop
-        ├─► hypo-hot-rebuild.mjs (regenerate root hot.md)
-        └─► hypo-auto-commit.mjs (commit + pull --rebase + push)
+        ├─► hypo-hot-rebuild.mjs (regenerate root hot.md + growth cache)
+        ├─► hypo-session-record.mjs (append .cache/sessions/index.jsonl)
+        └─► hypo-auto-commit.mjs (.hypoignore-filtered stage + commit + pull + push)
 ```
 
 ---
@@ -307,6 +309,78 @@ Promotion is intentionally manual to keep `<learned_behaviors>` curated. The pip
 
 ---
 
+## Observability (v1.1)
+
+v1.1 ships an **observability wedge** — the wiki measures whether it's actually being used per session, rather than claiming autonomy it can't yet deliver.
+
+### Data flow
+
+```
+Stop hook (hypo-session-record.mjs)
+    │  appends one JSONL entry per session
+    ▼
+<hypo-root>/.cache/sessions/index.jsonl   ← primary source
+    │
+    ▼
+scripts/session-audit.mjs                  ← per-session metrics + classification
+    │
+    ▼
+scripts/weekly-report.mjs                  ← aggregated weekly autonomy score
+    │
+    ▼
+journal/weekly/<YYYY-Www>.md               ← committed report (heuristic v0, spec §6.4 SoT)
+```
+
+### Transcript dual-source (ADR 0019)
+
+`session-audit.mjs` reads transcripts from two locations, in priority order:
+
+1. **Primary:** `<hypo-root>/.cache/sessions/index.jsonl` — written by the Stop hook `hypo-session-record.mjs`. Each line: `{ session_id, transcript_path, recorded_at, cwd }`.
+2. **Fallback:** `~/.claude/projects/<encoded>/*.jsonl` — scanned when the index is missing or empty (legacy / freshly-installed wikis).
+
+### Classification
+
+| Class | Rule |
+|---|---|
+| `staleness-skip` | `recorded_at` older than `--max-age-days` (default 30) |
+| `ingest-missed` | `urls >= 2` and `ingest_count == 0` |
+| `search-many`   | `search_count >= 5` (heavy retrieval; suggests missing synthesis) |
+| `search-0`      | `search_count == 0` |
+| `normal`        | otherwise |
+
+Counted tool names: `Grep`, `WebSearch`, `WebFetch`. Counted slash commands: `/hypo:query`, `/hypo:ingest`, `/hypo:feedback`. A single transcript record contributes to exactly one of (tool-use search OR text-based command search) — `computeMetrics` short-circuits after a tool-use match to prevent double counting.
+
+### Autonomy score (heuristic v0)
+
+`weekly-report.mjs` aggregates the week's results into a 0–100 score. The score is **clamped to `[0, 100]`** and skips `staleness-skip` sessions. Formula sketch (see `pages/observability/_index.md` for the formal definition):
+
+```
+numerator   = Σ min(search,3) + ingest*3 + feedback*2
+denominator = Σ 1   + (urls > 0 ? min(urls,5)*2 : 0)
+score       = clamp(round(num/den * 100), 0, 100)
+```
+
+The score is a **proxy, not ground truth**. The four-week baseline plan (capture v0 numbers, then revisit with LLM-judge classification before v2) is recorded in the same `_index.md`.
+
+### Privacy
+
+The observability pipeline reads but never republishes raw transcripts. Weekly reports only emit `session_id` plus aggregate counts — no transcript content, no URLs, no tool inputs. Transcripts themselves live under `~/.claude/projects/` or `.cache/sessions/` which `.hypoignore` already excludes from any sync.
+
+### Growth metrics (Lane B)
+
+A separate, lightweight counter — distinct from the audit pipeline — runs at every Stop / SessionStart pair:
+
+- **Stop** (`hypo-hot-rebuild.mjs`) computes `{ addedPages, updatedPages, newWikilinks }` by reading `git status --porcelain` plus a conditional `git diff HEAD --unified=0`, writes the result to `<hypo-root>/.cache/last-session-growth.json`, and echoes one line to stderr.
+- **SessionStart** (`hypo-session-start.mjs`) reads the cache and surfaces the same line in both stderr (cyan) and the LLM's `additionalContext` so user and model see the same "직전 세션" prefix.
+
+If `git status` shows no `.md` changes, the diff step is skipped — Stop hook fast path.
+
+### Citation convention
+
+The six writer-side skills (`crystallize`, `query`, `ingest`, `verify`, `graph`, `lint`) carry an identical footer instructing Claude to cite wiki pages inline as `[[page-slug]]`. The audit script counts these citations as a "wiki was actually consulted" signal in future iterations.
+
+---
+
 ## Privacy & exclusions
 
 `.hypoignore` is the **only** privacy mechanism. The v1.0 `personal / shared / public` mode matrix was deleted in v1.1 — every privacy decision turned out to be a per-path question, and a single ignore file handles per-path natively.
@@ -329,9 +403,9 @@ Default patterns: `*.pdf`, `*.zip`, `*.pem`, `*.env`, `*.key`, `*.crt`, `*creden
 | `upgrade.mjs` regression | ~10 (includes migration fixture) |
 | `lint.mjs` (fix / json / session-state) | ~10 |
 | Misc (`expandHome`, `resolveHypoRoot`, …) | ~remainder |
-| **Total** | **51 / 51 PASS** |
+| **Total** | Run `npm test` for the live count |
 
-Run with `npm test`. The runner uses only Node.js built-ins; tests create scoped temp dirs and clean up after themselves.
+Run with `npm test`. The runner uses only Node.js built-ins; tests create scoped temp dirs and clean up after themselves. The count above is a layout sketch — exact totals shift as lanes ship, so `npm test` is the source of truth.
 
 ---
 

package/docs/CONTRIBUTING.md

@@ -22,7 +22,7 @@ No build step. The package is plain ESM with **zero npm runtime dependencies**.
 git clone https://github.com/sk-lim19f/Hypomnema.git
 cd Hypomnema
 npm install   # installs dev tooling only — runtime deps are zero
-npm test      # 51/51 should pass
+npm test      # all tests should pass — exact count shifts as lanes ship
 npm run lint  # frontmatter + wikilink validation
 ```
 
@@ -120,7 +120,7 @@ If you need to share new logic, prefer extending an existing helper over adding
 
 ```bash
 npm test       # tests/runner.mjs — unit + smoke + contract tests
-npm run lint   # scripts/lint.mjs — frontmatter + wikilink validation
+npm run lint   # scripts/lint.mjs — frontmatter + wikilink validation + W8 (design-history stale vs session-log)
 ```
 
 The test runner uses only Node.js built-ins. Tests create scoped temp directories and clean up after themselves; you can run the suite without any environment setup.

package/hooks/hooks.json

@@ -11,6 +11,17 @@
         ]
       }
     ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/hypo-session-end.mjs",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
     "UserPromptSubmit": [
       {
         "hooks": [
@@ -60,6 +71,15 @@
             "timeout": 10
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/hypo-web-fetch-ingest.mjs",
+            "timeout": 10
+          }
+        ]
       }
     ],
     "Stop": [
@@ -72,6 +92,15 @@
           }
         ]
       },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/hypo-session-record.mjs",
+            "timeout": 10
+          }
+        ]
+      },
       {
         "hooks": [
           {
@@ -80,6 +109,15 @@
             "timeout": 60
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/hypo-auto-minimal-crystallize.mjs",
+            "timeout": 10
+          }
+        ]
       }
     ],
     "CwdChanged": [
@@ -105,5 +143,5 @@
       }
     ]
   },
-  "shared": ["hypo-shared.mjs"]
+  "shared": ["hypo-shared.mjs", "version-check.mjs", "version-check-fetch.mjs"]
 }

package/hooks/hypo-auto-commit.mjs

@@ -6,7 +6,8 @@
  */
 
 import { spawnSync } from 'child_process';
-import { HYPO_DIR } from './hypo-shared.mjs';
+import { HYPO_DIR, loadHypoIgnore, isIgnored, appendSyncFailure } from './hypo-shared.mjs';
+import { join } from 'path';
 
 function git(...args) {
   return spawnSync('git', ['-C', HYPO_DIR, ...args], { encoding: 'utf-8', timeout: 30000 });
@@ -17,7 +18,20 @@ function hasRemote() {
   return (r.stdout || '').trim().length > 0;
 }
 
-git('add', '-A');
+// `.hypoignore` is the project privacy boundary. `git add -A` ignores it, so
+// enumerate changed paths, drop ignored ones, then stage explicitly.
+const ignorePatterns = loadHypoIgnore(HYPO_DIR);
+const porcelain = git('status', '--porcelain', '-uall');
+const paths = [];
+for (const line of (porcelain.stdout || '').split('\n')) {
+  if (!line) continue;
+  const file = line.slice(3).replace(/^"|"$/g, '').split(' -> ').pop().trim();
+  if (!file) continue;
+  if (ignorePatterns.length > 0 && isIgnored(join(HYPO_DIR, file), HYPO_DIR, ignorePatterns))
+    continue;
+  paths.push(file);
+}
+if (paths.length > 0) git('add', '--', ...paths);
 const staged = git('diff', '--cached', '--name-only').stdout?.trim() || '';
 if (staged) {
   const today = new Date().toISOString().slice(0, 10);
@@ -29,8 +43,13 @@ if (staged) {
 }
 
 if (hasRemote()) {
-  git('pull', '--no-rebase', '-q');
-  git('push');
+  // fix #9: pull/push failures must not stop the session, but they can no
+  // longer be swallowed silently — record each to .cache/sync-state.json so
+  // session-start (#10) and doctor (#11) can surface them next session.
+  const pull = git('pull', '--no-rebase', '-q');
+  if (pull.status !== 0) appendSyncFailure(HYPO_DIR, 'pull', pull.stderr || pull.stdout);
+  const push = git('push');
+  if (push.status !== 0) appendSyncFailure(HYPO_DIR, 'push', push.stderr || push.stdout);
 }
 
 console.log(JSON.stringify({ continue: true, suppressOutput: true }));

package/hooks/hypo-auto-minimal-crystallize.mjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+/**
+ * hypo-auto-minimal-crystallize.mjs — Stop hook (fix #27 PR-C, ADR 0022 Layer 3)
+ *
+ * Last hook in the Stop chain: a final-line defense that blocks `Stop` when
+ * the current session performed mutation work but never produced a verified
+ * session-close. Forces Claude to run minimal session-close before the
+ * conversation context evaporates.
+ *
+ * Decision flow (see ADR 0022 amendment 2026-05-19 Q1+Q2 + 2nd amendment Q-close-gate):
+ *
+ *   1. stop_hook_active === true  → continue       (loop guard; PoC 2026-05-14)
+ *   2. wiki absent                 → continue       (fail-open)
+ *   3. transcript has zero Edit/Write/MultiEdit/NotebookEdit tool_use
+ *                                  → continue       (substantial-session gate)
+ *   4. no recent user close-intent → continue       (close-intent gate, see below)
+ *   5. readSessionClosedMarker(session_id) valid
+ *                                  → continue       (close already verified)
+ *   6. otherwise                   → decision:block
+ *
+ * Close-intent gate (added after PR-C dogfooding revealed every-turn block —
+ * codex 2-worker debate 2026-05-19, both REQUEST_CHANGES). Stop fires after
+ * EVERY assistant turn, not at session end; blocking on "mutation + no marker"
+ * alone nags the user on every turn of a long mutating session. ADR 0022's
+ * real intent is "block when the session is ENDING and close is incomplete".
+ * We approximate the end signal by reusing isClosePattern() over recent
+ * user-message text (the same low-false-positive signal PreCompact uses):
+ * only block when the user actually signalled wrap-up ("이만 마치자",
+ * "오늘 여기까지", "wrap up", "session close"). last_assistant_message is NOT
+ * used — "커밋했습니다"/"작업 완료" type phrases produce false positives.
+ *
+ * The hook NEVER writes the marker — even in the loop-guard branch. Writer
+ * authority lives in `scripts/crystallize.mjs` (`--apply-session-close
+ * --session-id=X` or standalone `--mark-session-closed --session-id=X`),
+ * which gates the write on sessionCloseFileStatus.ok. Doing the write here
+ * would let a Claude that ignored the block (did other work, hit Stop again)
+ * silently get a marker without performing the close — exactly the failure
+ * mode the per-session marker was introduced to prevent.
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+import {
+  HYPO_DIR,
+  PKG_ROOT,
+  hasMutatingTranscriptActivity,
+  readSessionClosedMarker,
+  extractUserMessages,
+  isClosePattern,
+  isGateSkipped,
+} from './hypo-shared.mjs';
+
+function emitContinue() {
+  console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+}
+
+function emitBlock(sessionId) {
+  // One-line, skill-first. /hypo:crystallize is the documented session-close
+  // alias; passing --session-id there writes the per-session marker that clears
+  // this block. CLI fallback + bypass live in commands/crystallize.md, not here
+  // — keep the Stop reason terse so the actionable instruction stands out.
+  const reason = `[WIKI_AUTOCLOSE] session-close 미완료 — /hypo:crystallize 실행으로 마무리 (session_id=${sessionId}).`;
+  console.log(
+    JSON.stringify({
+      decision: 'block',
+      reason,
+      stopReason: 'session-close incomplete (fix #27 PR-C / ADR 0022 Layer 3)',
+    }),
+  );
+}
+
+let raw = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => (raw += chunk));
+process.stdin.on('end', () => {
+  try {
+    let payload = {};
+    try {
+      payload = JSON.parse(raw) || {};
+    } catch (err) {
+      // Any malformed payload is fail-open — we never want a parse error to
+      // strand Claude in a blocked Stop with no recovery context.
+      process.stderr.write(
+        `[hypo-auto-minimal-crystallize] error: ${err?.message ?? String(err)}\n`,
+      );
+      emitContinue();
+      return;
+    }
+
+    // 1. loop guard. NEVER write marker here (see file header).
+    if (payload.stop_hook_active === true) {
+      emitContinue();
+      return;
+    }
+
+    if (isGateSkipped()) {
+      emitContinue();
+      return;
+    }
+
+    // 2. wiki absent → can't enforce anything meaningful.
+    if (!existsSync(HYPO_DIR)) {
+      emitContinue();
+      return;
+    }
+
+    const sessionId = payload.session_id || payload.sessionId || null;
+    const transcriptPath = payload.transcript_path || payload.transcriptPath || null;
+
+    // 3. substantial-session gate. Read-only / Q&A sessions skip the block.
+    if (!hasMutatingTranscriptActivity(transcriptPath)) {
+      emitContinue();
+      return;
+    }
+
+    // 4. close-intent gate. Stop fires every turn; only nudge when the user
+    // actually signalled session wrap-up. Without this, a long mutating
+    // session is blocked on every turn (PR-C dogfooding regression).
+    const userText = transcriptPath ? extractUserMessages(transcriptPath) : '';
+    if (!isClosePattern(userText)) {
+      emitContinue();
+      return;
+    }
+
+    // 5. close already verified for this session_id.
+    if (sessionId && readSessionClosedMarker(HYPO_DIR, sessionId)) {
+      emitContinue();
+      return;
+    }
+
+    // 6. block — but only when we have a session_id to address the recovery
+    // instruction to. Without one, the marker contract can't be honored, so
+    // failing-open is safer than blocking forever.
+    if (!sessionId) {
+      emitContinue();
+      return;
+    }
+
+    emitBlock(sessionId);
+  } catch (err) {
+    // Fail-open on any unexpected error.
+    process.stderr.write(`[hypo-auto-minimal-crystallize] error: ${err?.message ?? String(err)}\n`);
+    emitContinue();
+  }
+});

package/hooks/hypo-auto-stage.mjs

@@ -6,17 +6,18 @@
  */
 
 import { spawnSync } from 'child_process';
-import { HYPO_DIR } from './hypo-shared.mjs';
+import { HYPO_DIR, loadHypoIgnore, isIgnored } from './hypo-shared.mjs';
 
 let input = {};
 try {
-  const raw = await new Promise(r => {
+  const raw = await new Promise((r) => {
     let d = '';
-    process.stdin.on('data', c => d += c);
+    process.stdin.on('data', (c) => (d += c));
     process.stdin.on('end', () => r(d));
   });
   input = JSON.parse(raw);
-} catch {
+} catch (err) {
+  process.stderr.write(`[hypo-auto-stage] error: ${err?.message ?? String(err)}\n`);
   console.log(JSON.stringify({ continue: true, suppressOutput: true }));
   process.exit(0);
 }
@@ -24,7 +25,10 @@ try {
 const filePath = input.tool_input?.file_path ?? '';
 
 if (filePath.startsWith(HYPO_DIR + '/') || filePath === HYPO_DIR) {
-  spawnSync('git', ['-C', HYPO_DIR, 'add', filePath], { stdio: 'ignore' });
+  const patterns = loadHypoIgnore(HYPO_DIR);
+  if (patterns.length === 0 || !isIgnored(filePath, HYPO_DIR, patterns)) {
+    spawnSync('git', ['-C', HYPO_DIR, 'add', filePath], { stdio: 'ignore' });
+  }
 }
 
 console.log(JSON.stringify({ continue: true, suppressOutput: true }));

package/hooks/hypo-compact-guard.mjs

@@ -2,12 +2,13 @@
 /**
  * hypo-compact-guard.mjs — UserPromptSubmit hook
  *
- * Scope: detects "/compact" typed in chat only.
+ * Scope: detects "/compact" or "/clear" typed in chat only (ADR 0022 Layer 2, fix #25).
  * The CLI built-in /compact does NOT fire UserPromptSubmit — use personal-wiki-check.mjs
- * (PreCompact hook) as the hard gate for that path.
+ * (PreCompact hook) as the hard gate for that path. /clear has no PreCompact event, so
+ * this hook is the only chat-side gate that can prompt session-close before context wipe.
  *
  * Behavior: if session close is incomplete → instruct Claude to run session close
- * immediately before /compact.
+ * immediately before /compact or /clear.
  */
 
 import {
@@ -15,26 +16,31 @@ import {
   hypoIsClean,
   hotMdIsClean,
   readChecklist,
-  isCompactCommand,
+  isClearCommand,
+  isCompactOrClearCommand,
   isGateSkipped,
 } from './hypo-shared.mjs';
 
 let input = '';
 process.stdin.setEncoding('utf-8');
-process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('data', (chunk) => {
+  input += chunk;
+});
 process.stdin.on('end', () => {
   try {
-    const data   = JSON.parse(input);
+    const data = JSON.parse(input);
     const prompt = (data.prompt || '').trim();
 
-    if (!isCompactCommand(prompt) || isGateSkipped()) {
+    if (!isCompactOrClearCommand(prompt) || isGateSkipped()) {
       console.log(JSON.stringify({ continue: true, suppressOutput: true }));
       return;
     }
 
+    const detected = isClearCommand(prompt) ? '/clear' : '/compact';
+
     const hasSession = lastSubstantialOpIsSession();
-    const gitStatus  = hypoIsClean();
-    const hotStatus  = hotMdIsClean();
+    const gitStatus = hypoIsClean();
+    const hotStatus = hotMdIsClean();
 
     if (hasSession && gitStatus.clean && hotStatus.clean) {
       console.log(JSON.stringify({ continue: true, suppressOutput: true }));
@@ -42,30 +48,33 @@ process.stdin.on('end', () => {
     }
 
     const reasons = [
-      !hasSession      ? 'session log entry missing' : '',
+      !hasSession ? 'session log entry missing' : '',
       !gitStatus.clean ? gitStatus.reason : '',
       !hotStatus.clean ? hotStatus.reason : '',
     ].filter(Boolean);
 
-    const today     = new Date().toISOString().slice(0, 10);
+    const today = new Date().toISOString().slice(0, 10);
     const checklist = readChecklist(today);
-    const body      = checklist
+    const body = checklist
       ? `Checklist:\n${checklist}`
       : 'See hypo-guide.md for the session-close checklist.';
 
-    console.log(JSON.stringify({
-      continue: true,
-      additionalContext: [
-        `[WIKI_AUTOCLOSE] /compact detected — session close incomplete (${reasons.join(', ')}).`,
-        `Do NOT wait for user input. Run wiki session close NOW, then retry /compact.`,
-        ``,
-        body,
-        ``,
-        `To bypass: set HYPO_SKIP_GATE=1`,
-      ].join('\n'),
-    }));
-  } catch {
+    console.log(
+      JSON.stringify({
+        continue: true,
+        additionalContext: [
+          `[WIKI_AUTOCLOSE] ${detected} detected — session close incomplete (${reasons.join(', ')}).`,
+          `Do NOT wait for user input. Run wiki session close NOW, then retry ${detected}.`,
+          ``,
+          body,
+          ``,
+          `To bypass: set HYPO_SKIP_GATE=1`,
+        ].join('\n'),
+      }),
+    );
+  } catch (err) {
     // Fail-open: any parse/runtime error must not block the user's prompt.
+    process.stderr.write(`[hypo-compact-guard] error: ${err?.message ?? String(err)}\n`);
     console.log(JSON.stringify({ continue: true, suppressOutput: true }));
   }
 });