hypomnema 1.1.0 → 1.2.1

package/commands/feedback.md

@@ -2,23 +2,34 @@
 description: Record an AI behavior correction or preference into the wiki
 ---
 
-You are running `/hypo:feedback`. Capture a behavior correction or preference into `pages/feedback/` for future sessions.
+You are running `/hypo:feedback`. Capture a behavior correction or preference into `pages/feedback/` — the **single source of truth** for learned behaviors (ADR 0031 / fix #37).
 
 ## What this does
 
-- Creates or updates `pages/feedback/<topic>.md` with a dated entry
+- Creates or updates `pages/feedback/<topic>.md` with a dated entry and full classification frontmatter
 - Appends a reference to `log.md`
-- Ensures the feedback is findable in future sessions
+- **Automatically refreshes the projection** into `MEMORY.md` and the user's CLAUDE.md `<learned_behaviors>` via `feedback-sync --write`
+
+> ⚠️ Do **not** hand-edit MEMORY.md or CLAUDE.md `<learned_behaviors>` for feedback. Those are one-way projections derived from the wiki page. Edit the wiki page; the projection follows.
 
 ---
 
 ## Step 1 — Gather feedback details
 
-If the user did not provide them, ask:
+If the user did not provide them, ask. The classification fields are required so the page can project correctly:
+
+1. **Topic** (slug): "What topic does this feedback apply to? (e.g. `response-length`, `commit-style`)"
+2. **Rule** (entry): "State the rule or correction in one or two sentences."
+3. **Reason**: "What incident or reasoning prompted this?"
+4. **Scope**: "Does this apply globally (all projects) or to this project only?" → `global` | `project:<project-id>` (project-id must exact-match the resolved id; see Step 3 note)
+5. **Tier**: "Is this a hard rule (L1) or a softer preference (L2)?" → `L1` | `L2`
+6. **Targets**: "Where should this project?" → `project-memory` (MEMORY.md) and/or `claude-learned` (global CLAUDE.md). Default `project-memory`.
+7. **Priority** (1–5, higher sorts first; default 3).
+8. **Sensitivity**: `public` (default) or `sanitized` (redacted secrets/paths). `private` is not allowed — the wiki is git-pushed.
 
-1. **Topic** (slug): "What topic does this feedback apply to? (e.g. `response-length`, `commit-style`, `code-comments`)"
-2. **Rule**: "State the rule or correction in one or two sentences."
-3. **Why** (optional): "What was the reason or incident that prompted this?"
+If **claude-learned** is among the targets, the page must be `scope: global` + `tier: L1`, and you must also collect:
+- **Global summary**: a one-line summary for the CLAUDE.md learned-behaviors entry.
+- Confirm **promote to global** (the page is only projected to CLAUDE.md when promoted).
 
 ---
 
@@ -30,38 +41,41 @@ To check for an existing topic, locate the Hypomnema package root and run:
 node <package-root>/scripts/feedback.mjs --list [--hypo-dir="<path>"]
 ```
 
-If a matching topic exists, confirm with the user whether to append to it or create a new one.
+If a matching topic exists, appending adds a dated entry and bumps `updated:` (classification frontmatter is preserved).
 
 ---
 
-## Step 3 — Write the feedback entry
-
-Compose the entry text. Format:
-
-```
-**Rule**: <one-line rule>
-
-**Why**: <reason or incident>
-
-**How to apply**: <when this kicks in>
-```
+## Step 3 — Write the feedback page
 
-Then run:
+Run with `--dry-run` first to preview the generated page, then without it to write. Pass every collected field:
 
 ```bash
 node <package-root>/scripts/feedback.mjs \
   --topic="<slug>" \
-  --entry="<formatted entry text>" \
+  --entry="<one-line rule>" \
+  --scope="global|project:<project-id>" \
+  --tier="L1|L2" \
+  --targets="project-memory[,claude-learned]" \
+  --priority=<1-5> \
+  --sensitivity="public|sanitized" \
+  --memory-summary="<one-line MEMORY.md summary>" \
+  --reason="<why this rule exists>" \
+  [--global-summary="<one-line CLAUDE.md summary>" --promote-to-global] \
+  [--source="session:<date>"] \
   [--hypo-dir="<path>"] \
   [--dry-run]
 ```
 
-Run with `--dry-run` first to preview, then without it to write.
+When `--targets` includes `claude-learned`, `--global-summary` and `--promote-to-global` are required (and `--scope=global --tier=L1`).
+
+> **`scope: project:<project-id>` 주의 (v1.2.0).** `<project-id>`는 `feedback-sync`가 resolve한 project-id와 정확히 일치해야 한다 (default: cwd의 `/`,`.` → `-` 치환; `--project-id=<id>` 로 override). 일치하지 않으면 그 페이지는 해당 project의 MEMORY로 projection되지 **않는다** (silent skip — lint error 아님). 다만 현재 lint scope regex(`^project:[a-z0-9][a-z0-9-]*$`)는 cwd-derived id 형식(`-Users-...`)을 거부하므로, **`project:*` scope를 사용하려면 slug-safe id로 `--project-id=<slug>`를 override해서 wiki 디렉터리도 그 id에 맞추는 운영 패턴이 필요하다**. resolved-id ↔ slug 정합화는 v1.3.0 트랙에서 다룸.
+
+On a real (non-dry-run) write, the script automatically runs `feedback-sync --write` to refresh MEMORY.md / CLAUDE.md. If that post-step reports drift it prints a one-line warning — the page is still saved; reconcile with `hypomnema feedback-sync --check`.
 
 ---
 
-## Step 4 — Confirm and cross-reference
+## Step 4 — Confirm
 
-After writing:
-- Tell the user: "Saved to `pages/feedback/<topic>.md`."
-- If this feedback should also update the project's `session-state.md` or the user's CLAUDE.md `<learned_behaviors>`, ask: "Should I also add this to your CLAUDE.md learned behaviors?"
+After writing, tell the user:
+- "Saved to `pages/feedback/<topic>.md` and refreshed the MEMORY/CLAUDE projection."
+- If the projection post-step warned (over-cap, conflict, unresolved project-id), surface that and suggest `hypomnema feedback-sync --check`.

package/commands/ingest.md

@@ -21,13 +21,33 @@ Ask the user:
 2. **Slug**: "What slug should this source have? (e.g. `openai-swarm-paper`, `team-retro-2026-04`)"
    - Default: derive from title or filename
 
-If a URL is provided, fetch the content. If a file path is provided, read it.
+Do **not** fetch the URL or read the file yet — the privacy guard in Step 2 must run first.
 
 ---
 
-## Step 2 — Check for orphaned sources
+## Step 2 — Privacy guard (`.hypoignore`)
 
-Locate the Hypomnema package root. Run the ingest helper to surface existing orphaned sources:
+Refuse to ingest secrets (`.env`, SSH keys, credentials) before they ever reach `sources/`. Locate the Hypomnema package root and run the guard for **both** the input path and the destination path:
+
+1. **If the source is a file path**, check it (use an absolute path):
+
+   ```bash
+   node <package-root>/scripts/ingest.mjs [--hypo-dir="<path>"] --check="<absolute-input-path>"
+   ```
+
+2. **Always** check the destination `sources/<slug>.<ext>`:
+
+   ```bash
+   node <package-root>/scripts/ingest.mjs [--hypo-dir="<path>"] --check="sources/<slug>.<ext>"
+   ```
+
+If either command exits non-zero, **stop**: surface the `Refused: ...` message to the user and do not fetch, read, or save the source. The slug check matters because a user could rename a `.env` to an innocuous slug — the destination must still be blocked.
+
+---
+
+## Step 3 — Check for orphaned sources
+
+Run the ingest helper to surface existing orphaned sources:
 
 ```bash
 node <package-root>/scripts/ingest.mjs [--hypo-dir="<path>"]
@@ -35,9 +55,11 @@ node <package-root>/scripts/ingest.mjs [--hypo-dir="<path>"]
 
 If there are orphaned sources already in `sources/`, ask: "There are N unprocessed sources — do you want to ingest one of those instead?"
 
+Once the guard has passed: if a URL is provided, fetch the content; if a file path is provided, read it.
+
 ---
 
-## Step 3 — Save raw source
+## Step 4 — Save raw source
 
 Save the raw content to `sources/<slug>.<ext>` (use `.md` for text, `.txt` for plain text, `.pdf` or original extension for documents).
 
@@ -45,13 +67,13 @@ Do **not** modify or summarize in the sources file — save it as-is.
 
 ---
 
-## Step 4 — Synthesize
+## Step 5 — Synthesize
 
 Read and synthesize the source:
 
 1. **Check index.md** — does a page on this topic already exist?
    - If yes: update the existing page (merge new information, mark `updated:` today)
-   - If no: create a new page in `pages/` with `type: source-summary` and `source: <slug>`
+   - If no: create a new page in `pages/` with `type: source-summary` and `sources: [<slug>]`
 
 2. **Frontmatter** for new pages:
    ```yaml
@@ -60,7 +82,7 @@ Read and synthesize the source:
    type: source-summary
    updated: YYYY-MM-DD
    tags: [<relevant tags>]
-   source: <slug>
+   sources: [<slug>]
    confidence: high | medium | low
    evidence_strength: direct
    ---
@@ -70,14 +92,14 @@ Read and synthesize the source:
 
 ---
 
-## Step 5 — Update index.md and log.md
+## Step 6 — Update index.md and log.md
 
 - Append a line to `index.md`: `- [[pages/<slug>]] — <one-line description>`
 - Append to `log.md`: `- YYYY-MM-DD ingest: [[pages/<slug>]] from sources/<slug>.<ext>`
 
 ---
 
-## Step 6 — Report
+## Step 7 — Report
 
 Show:
 - ✓ Saved source: `sources/<slug>.<ext>`

package/commands/upgrade.md

@@ -28,7 +28,7 @@ node <package-root>/scripts/upgrade.mjs [--hypo-dir="<path>"]
 
 Show the output verbatim.
 
-> **Note**: If a major SCHEMA bump is detected, this step generates a `MIGRATION-vX.Y.md` file in the Hypomnema root. This is a new informational file — no existing files are overwritten.
+> **Note**: A major SCHEMA bump is only **detected** in this step. The informational `MIGRATION-vX.Y.md` file is written later by `--apply` (Step 4) and only on a major bump. `SCHEMA.md` is never auto-overwritten.
 
 ---
 
@@ -38,7 +38,7 @@ Show the output verbatim.
 - `⚠` — minor update available (stale hook or missing settings entry)
 - `✗` — major version bump or missing hook files (action required)
 
-For a **major SCHEMA bump**: point the user to the generated `MIGRATION-vX.Y.md` file in their Hypomnema root and ask them to review it before applying.
+For a **major SCHEMA bump**: warn the user that `--apply` will additionally write a `MIGRATION-vX.Y.md` informational file in their Hypomnema root and that they must manually merge the SCHEMA diff after applying.
 
 ---
 

package/docs/ARCHITECTURE.md

@@ -328,7 +328,7 @@ scripts/session-audit.mjs                  ← per-session metrics + classificat
 scripts/weekly-report.mjs                  ← aggregated weekly autonomy score
     │
     ▼
-pages/observability/<YYYY-WW>.md           ← committed report (heuristic v0)
+journal/weekly/<YYYY-Www>.md               ← committed report (heuristic v0, spec §6.4 SoT)
 ```
 
 ### Transcript dual-source (ADR 0019)

package/docs/CONTRIBUTING.md

@@ -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": [
@@ -89,6 +109,15 @@
             "timeout": 60
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/hypo-auto-minimal-crystallize.mjs",
+            "timeout": 10
+          }
+        ]
       }
     ],
     "CwdChanged": [
@@ -114,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,7 @@
  */
 
 import { spawnSync } from 'child_process';
-import { HYPO_DIR, loadHypoIgnore, isIgnored } from './hypo-shared.mjs';
+import { HYPO_DIR, loadHypoIgnore, isIgnored, appendSyncFailure } from './hypo-shared.mjs';
 import { join } from 'path';
 
 function git(...args) {
@@ -27,7 +27,8 @@ 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;
+  if (ignorePatterns.length > 0 && isIgnored(join(HYPO_DIR, file), HYPO_DIR, ignorePatterns))
+    continue;
   paths.push(file);
 }
 if (paths.length > 0) git('add', '--', ...paths);
@@ -42,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

@@ -10,13 +10,14 @@ 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);
 }

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