hypomnema 1.3.1 → 1.3.3

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

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 /**
- * hypo-auto-minimal-crystallize.mjs — Stop hook (fix #27 PR-C, ADR 0022 Layer 3)
+ * hypo-auto-minimal-crystallize.mjs — Stop hook (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
+ * the current session did substantial work (mutation, or a high-volume
+ * read-only investigation — see step 3) but never produced a verified
  * session-close. Forces Claude to run minimal session-close before the
  * conversation context evaporates.
  *
@@ -11,8 +12,10 @@
  *
  *   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)
+ *   3. not a substantial session   → continue       (substantial-session gate)
+ *        substantial = ≥1 mutation tool_use, OR ≥5 read-only investigation
+ *        calls (Read/Grep/Glob/Bash) — 6a, so read-only review/debug sessions
+ *        are also nudged to close. Pure Q&A / incidental lookups still skip.
  *   4. no recent user close-intent → continue       (close-intent gate, see below)
  *   5. readSessionClosedMarker(session_id) valid
  *                                  → continue       (close already verified)
@@ -43,18 +46,19 @@ import { join } from 'path';
 import {
   HYPO_DIR,
   PKG_ROOT,
-  hasMutatingTranscriptActivity,
+  isSubstantialSession,
   readSessionClosedMarker,
   extractUserMessages,
   isClosePattern,
   isGateSkipped,
+  precompactGateStatus,
 } from './hypo-shared.mjs';
 
 function emitContinue() {
   console.log(JSON.stringify({ continue: true, suppressOutput: true }));
 }
 
-function emitBlock(sessionId, transcriptPath) {
+function emitBlock(sessionId, transcriptPath, gate = null) {
   // 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
@@ -64,12 +68,39 @@ function emitBlock(sessionId, transcriptPath) {
   // coherence: a marker written without lint would only let Stop pass for
   // /compact to immediately re-block on the same errors).
   const transcriptHint = transcriptPath ? ` --transcript-path=${transcriptPath}` : '';
-  const reason = `[WIKI_AUTOCLOSE] session-close 미완료 — /hypo:crystallize 실행으로 마무리 (session_id=${sessionId}${transcriptHint}).`;
+  const markCmd = `crystallize --mark-session-closed --session-id=${sessionId}${transcriptHint}`;
+  // The log-only escape hatch for a non-project (wiki/tooling-only)
+  // session. Offered ONLY as an explicit alternative when a close blocker is
+  // present — never as the default recovery, so a real project session is not
+  // taught to bypass the ADR 0043 close invariant (codex design Finding 3).
+  const logOnlyCmd = `crystallize --mark-session-closed --log-only --session-id=${sessionId}${transcriptHint}`;
+  // ADR 0047: refine the message with the read-only /compact gate result.
+  // - gate green → the close is compact-ready and ONLY the marker is missing
+  //   (the hand-edit close case: files Written + committed directly, bypassing
+  //   the marker writer). Say so precisely + give the one command, instead of
+  //   the generic "미완료" that reads as "you never closed".
+  // - gate has blockers → surface them so the user fixes the real issue first.
+  // - gate null (tooling error/unavailable) → generic message (fail-open).
+  let reason;
+  if (gate && gate.ok) {
+    reason = `[WIKI_AUTOCLOSE] close gate green — only the session-closed marker is missing. Run \`${markCmd}\` to finish (session_id=${sessionId}).`;
+  } else if (gate && gate.blockers && gate.blockers.length > 0) {
+    const blockers = gate.blockers.map((b) => b.reason).join('; ');
+    reason = `[WIKI_AUTOCLOSE] session-close incomplete — resolve: ${blockers}. Then run \`${markCmd}\` (session_id=${sessionId}).`;
+    // Only when a project-close blocker is what's holding the session: a
+    // non-project session has nothing to close, so offer log-only as the way out
+    // (Claude decides whether this session is project-scoped — no auto-attribution).
+    if (gate.blockers.some((b) => b.type === 'close')) {
+      reason += ` If this was a non-project (wiki/tooling-only) session with no project to close, run \`${logOnlyCmd}\` instead (log-only close, no project attribution).`;
+    }
+  } else {
+    reason = `[WIKI_AUTOCLOSE] session-close 미완료 — /hypo:crystallize 실행으로 마무리 (session_id=${sessionId}${transcriptHint}).`;
+  }
   console.log(
     JSON.stringify({
       decision: 'block',
       reason,
-      stopReason: 'session-close incomplete (fix #27 PR-C / ADR 0022 Layer 3)',
+      stopReason: 'session-close incomplete (ADR 0022 Layer 3)',
     }),
   );
 }
@@ -112,8 +143,10 @@ process.stdin.on('end', () => {
     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)) {
+    // 3. substantial-session gate. Pure Q&A / incidental-lookup sessions skip
+    // the block; mutating sessions AND high-volume read-only investigations
+    // (6a) pass through to the close-intent gate.
+    if (!isSubstantialSession(transcriptPath)) {
       emitContinue();
       return;
     }
@@ -141,7 +174,20 @@ process.stdin.on('end', () => {
       return;
     }
 
-    emitBlock(sessionId, transcriptPath);
+    // ADR 0047: read-only /compact gate (same precompactGateStatus the real
+    // PreCompact hook uses) sharpens the block message — distinguishes "close
+    // is compact-ready, only the marker is missing" from "there are real
+    // blockers". The hook NEVER writes the marker here (file-header invariant);
+    // this is read-only. Any error → null → emitBlock falls back to the generic
+    // message (fail-open).
+    let gate = null;
+    try {
+      gate = precompactGateStatus(HYPO_DIR, transcriptPath ? { transcriptPath } : {});
+    } catch {
+      gate = null;
+    }
+
+    emitBlock(sessionId, transcriptPath, gate);
   } catch (err) {
     // Fail-open on any unexpected error.
     process.stderr.write(`[hypo-auto-minimal-crystallize] error: ${err?.message ?? String(err)}\n`);

package/hooks/hypo-compact-guard.mjs

@@ -2,7 +2,7 @@
 /**
  * hypo-compact-guard.mjs — UserPromptSubmit hook
  *
- * Scope: detects "/compact" or "/clear" typed in chat only (ADR 0022 Layer 2, fix #25).
+ * Scope: detects "/compact" or "/clear" typed in chat only (ADR 0022 Layer 2).
  * The CLI built-in /compact does NOT fire UserPromptSubmit — use personal-wiki-check.mjs
  * (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.
@@ -42,14 +42,17 @@ process.stdin.on('end', () => {
     const gitStatus = hypoIsClean();
     const hotStatus = hotMdIsClean();
 
-    if (hasSession && gitStatus.clean && hotStatus.clean) {
+    // ADR 0056: block on uncommitted (real unsaved work); unpushed commits (ahead)
+    // are a soft, auto-synced state and must not block /compact or /clear — mirrors
+    // the precompactGateStatus demote so the chat-side gate stays consistent.
+    if (hasSession && !gitStatus.uncommitted && hotStatus.clean) {
       console.log(JSON.stringify({ continue: true, suppressOutput: true }));
       return;
     }
 
     const reasons = [
       !hasSession ? 'session log entry missing' : '',
-      !gitStatus.clean ? gitStatus.reason : '',
+      gitStatus.uncommitted ? gitStatus.reason : '',
       !hotStatus.clean ? hotStatus.reason : '',
     ].filter(Boolean);
 

package/hooks/hypo-cwd-change.mjs

@@ -137,7 +137,7 @@ process.stdin.on('end', () => {
       return;
     }
 
-    // MISS: cwd matches no project. fix #23 / ADR 0023 — offer to create one
+    // MISS: cwd matches no project. ADR 0023 — offer to create one
     // when the trigger conditions hold. Same nudge-only model as session-start.
     let suggestPrefix = '';
     if (shouldSuggestProjectCreation(newCwd, HYPO_DIR)) {

package/hooks/hypo-first-prompt.mjs

@@ -3,9 +3,9 @@
  * hypo-first-prompt.mjs — UserPromptSubmit hook
  *
  * Consumes the marker written by hypo-session-start.mjs (source omitted /
- * 'session-start') or hypo-cwd-change.mjs (source 'cwd-change', fix #13).
+ * 'session-start') or hypo-cwd-change.mjs (source 'cwd-change').
  * On the FIRST user prompt after the marker is written, FORCES a one-line
- * resume summary into the reply (fix #3 — the old "answer only if related"
+ * resume summary into the reply (the old "answer only if related"
  * conditional is removed; the line is injected unconditionally).
  *
  * hot.md / session-state.md content is NOT re-injected here — the upstream

package/hooks/hypo-hot-rebuild.mjs

@@ -12,7 +12,12 @@
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
-import { HYPO_DIR, computeSessionGrowth, formatGrowthMetrics } from './hypo-shared.mjs';
+import {
+  HYPO_DIR,
+  computeSessionGrowth,
+  formatGrowthMetrics,
+  deriveRootLogEntries,
+} from './hypo-shared.mjs';
 
 const HOT_PATH = join(HYPO_DIR, 'hot.md');
 const GROWTH_CACHE = join(HYPO_DIR, '.cache', 'last-session-growth.json');
@@ -107,6 +112,14 @@ try {
 } catch (err) {
   process.stderr.write(`[hypo-hot-rebuild] error: ${err?.message ?? String(err)}\n`);
 }
+// Auto-derive the root log.md session entry from each project's session-log
+// heading (runs AFTER rebuild() so root hot.md is already fresh and isn't itself
+// counted as the project's open gate problem). Best-effort: own try/catch.
+try {
+  deriveRootLogEntries(HYPO_DIR);
+} catch (err) {
+  process.stderr.write(`[hypo-hot-rebuild] log-derive error: ${err?.message ?? String(err)}\n`);
+}
 try {
   emitGrowth();
 } catch (err) {

package/hooks/hypo-personal-check.mjs

@@ -3,8 +3,8 @@
  * hypo-personal-check.mjs — PreCompact hook
  *
  * Hard gate before /compact. Blocks if:
- *   - the session-close memory files were not updated this session (fix #17:
- *     session-state.md, project hot.md, root hot.md, session-log, log.md)
+ *   - the session-close memory files were not updated this session
+ *     (session-state.md, project hot.md, root hot.md, session-log, log.md)
  *   - wiki git repo has uncommitted/unpushed changes
  *   - hot.md has forbidden structure
  *   - lint blockers exist
@@ -14,7 +14,7 @@
  *   2. HYPO_SKIP_GATE=1 in a recent *user-role* transcript message
  *      (assistant/tool output is excluded to prevent self-triggering from block reason text)
  *
- * NOTE: capacity bypass (wiki-context-critical.json ≥90%) was REMOVED by fix #26
+ * NOTE: capacity bypass (wiki-context-critical.json ≥90%) was REMOVED
  * (ADR 0022 amendment 2026-05-13). Spec §7.5: even at full context, minimal
  * session-close is mandatory — auto-bypass on capacity caused silent state loss.
  */
@@ -26,16 +26,11 @@ import { homedir } from 'os';
 import {
   HYPO_DIR,
   PKG_ROOT,
-  hypoIsClean,
-  hotMdIsClean,
-  sessionCloseFileStatus,
+  precompactGateStatus,
   readChecklist,
   isGateSkipped,
   isClosePattern,
   extractUserMessages,
-  extractTouchedWikiFiles,
-  closeFileTargets,
-  partitionLintScope,
 } from './hypo-shared.mjs';
 
 const WARNING_FILE = join(homedir(), '.claude', 'state', 'wiki-context-warning.json');
@@ -45,14 +40,19 @@ process.stdin.setEncoding('utf-8');
 process.stdin.on('data', (chunk) => (raw += chunk));
 process.stdin.on('end', () => {
   let transcriptPath = null;
+  let sessionId = null;
   try {
     const input = JSON.parse(raw || '{}');
     transcriptPath = input.transcript_path ?? null;
+    // A log-only marker for this session activates log-only gate
+    // semantics (no project attribution) so /compact does not block a closed
+    // non-project session on the active/phantom project's files.
+    sessionId = input.session_id ?? input.sessionId ?? null;
   } catch {
     /* fail-open */
   }
 
-  // ── Capacity bypass (≥90%) REMOVED — fix #26, ADR 0022 amendment 2026-05-13.
+  // ── Capacity bypass (≥90%) REMOVED — ADR 0022 amendment 2026-05-13.
   //    Even at full context, minimal session-close is mandatory (spec §7.5).
   //    Bypass paths are now only: HYPO_SKIP_GATE env / HYPO_SKIP_GATE in transcript.
 
@@ -93,164 +93,82 @@ process.stdin.on('end', () => {
   // ── Heavy checks ──
   const today = new Date().toISOString().slice(0, 10);
 
-  const gitStatus = hypoIsClean();
-  const hotStatus = hotMdIsClean();
-  // strict session-close (steps 1~6 of the 11-step crystallize
-  // checklist). closeFiles gates the 5 mandatory files (steps 1-4 + log.md);
-  // open-questions.md (step 5) is conditional ("변경 시") and intentionally
-  // ungated — see hypo-shared.mjs sessionCloseFileStatus and spec §5.2.7.
-  const closeFiles = sessionCloseFileStatus(HYPO_DIR);
-  const closeFilesReason = closeFiles.ok
-    ? ''
-    : `memory files not updated this session: ${[
-        ...closeFiles.missing.map((f) => `${f} (missing)`),
-        ...closeFiles.stale.map((f) => `${f} (stale)`),
-      ].join(', ')}`;
+  // The full PreCompact gate decision, single-sourced (ADR 0046). The SAME
+  // function backs `crystallize --check-session-close`, so a green self-check
+  // there means this hook will not block. precompactGateStatus runs git-clean +
+  // hot.md structure + session-close files (ADR 0043 global invariant) + scoped
+  // lint + W8 design-history + feedback projection. The transcript widens the
+  // lint scope to this session's edited files (ADR 0041); without one the scope
+  // is the mandatory close files. Read-only: pure feedback drift comes back as
+  // gate.driftTargets, a self-heal effect requirement we run as --write below.
+  let gate;
+  try {
+    gate = precompactGateStatus(HYPO_DIR, {
+      transcriptPath,
+      ...(sessionId ? { sessionId } : {}),
+    });
+  } catch (err) {
+    // Defense-in-depth: precompactGateStatus fails open per-check, but if it ever
+    // throws, never crash the PreCompact hook — fail open (continue) so a tooling
+    // fault can't wedge /compact.
+    process.stderr.write(`[hypo-personal-check] error: ${err?.message ?? String(err)}\n`);
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+    return;
+  }
 
-  const lintPath = PKG_ROOT ? join(PKG_ROOT, 'scripts', 'lint.mjs') : null;
-  let lintBlockers = [];
-  let lintW8 = [];
-  let lintNotices = []; // pre-existing debt in files this session did not touch
-  let lintSkipped = false;
-  if (!lintPath || !existsSync(lintPath)) {
-    lintSkipped = true;
-  } else {
-    try {
-      const r = spawnSync('node', [lintPath, '--json'], {
-        encoding: 'utf-8',
-        cwd: HYPO_DIR,
-        timeout: 30000,
+  // Self-heal pure feedback projection drift (ADR 0045): the one mutation the
+  // read-only gate leaves to the caller. Fails CLOSED — if the --write errors we
+  // turn the (otherwise non-blocking) drift into a blocker, since real drift is
+  // confirmed and silently passing it would defeat the gate. --write only applies
+  // when no target conflicts/over-caps (code===0 across ALL targets), so a late
+  // race exits non-zero and blocks here. It is semantic-preflight atomic but not
+  // filesystem-atomic (concurrent edit / mid-write I/O fault is best-effort) —
+  // pre-existing engine behavior, not introduced by the self-heal.
+  let feedbackHealed = '';
+  if (gate.ok && gate.driftTargets.length > 0) {
+    const feedbackPath = PKG_ROOT ? join(PKG_ROOT, 'scripts', 'feedback-sync.mjs') : null;
+    const w = feedbackPath
+      ? spawnSync(
+          process.execPath,
+          [
+            feedbackPath,
+            '--write',
+            '--no-input',
+            `--hypo-dir=${HYPO_DIR}`,
+            `--claude-home=${join(homedir(), '.claude')}`,
+          ],
+          { encoding: 'utf-8', timeout: 30000 },
+        )
+      : { status: 1 };
+    if (w.error || w.status === null || w.status !== 0) {
+      gate.ok = false;
+      gate.blockers.push({
+        type: 'feedback',
+        reason: `feedback projection drift (${gate.driftTargets.join(', ')}) — auto-sync failed; run \`hypomnema feedback-sync --write\` manually`,
       });
-      const parsed = JSON.parse(r.stdout || '{}');
-      const allErrors = parsed.errors || [];
-      const allW8 = (parsed.warns || []).filter((w) => w.id === 'W8');
-      // Bug B: judge this session on the files IT touched, not the whole vault.
-      // A readable transcript lets us scope (edited files ∪ mandatory close
-      // files); a missing/unreadable transcript falls back to the conservative
-      // global gate (never weaker than before).
-      const haveTranscript = !!(transcriptPath && existsSync(transcriptPath));
-      if (haveTranscript) {
-        const scope = new Set([
-          ...extractTouchedWikiFiles(transcriptPath, HYPO_DIR),
-          ...closeFileTargets(HYPO_DIR),
-        ]);
-        const part = partitionLintScope(allErrors, scope);
-        lintBlockers = part.blocking;
-        lintNotices = part.notice;
-        // W8 (design-history stale) is the CURRENT project's close
-        // responsibility, not cross-project debt — block on the active
-        // project's, surface others' as notices.
-        if (closeFiles.project) {
-          const mine = `projects/${closeFiles.project}/design-history.md`;
-          lintW8 = allW8.filter((w) => w.file === mine);
-          lintNotices.push(...allW8.filter((w) => w.file !== mine));
-        } else {
-          lintW8 = allW8;
-        }
-      } else {
-        lintBlockers = allErrors;
-        lintW8 = allW8;
-      }
-    } catch (err) {
-      /* fail-open */
-      process.stderr.write(`[hypo-personal-check] error: ${err?.message ?? String(err)}\n`);
+    } else {
+      feedbackHealed = `[WIKI CHECK] feedback projection re-synced (${gate.driftTargets.join(', ')}); MEMORY.md body may be unchanged — drift was in the managed block / side-files.`;
     }
   }
 
-  const lintOk = lintBlockers.length === 0;
-  const designHistoryOk = lintW8.length === 0;
-  // Non-blocking heads-up about pre-existing lint debt in untouched files (other
-  // projects / shared pages). Surfaced so it is visible but never blocks compact.
-  const noticeText =
-    lintNotices.length > 0
-      ? `[WIKI CHECK] ${lintNotices.length} pre-existing lint issue(s) in files this session did not touch (not blocking): ${[
-          ...new Set(lintNotices.map((b) => b.file)),
+  // Non-blocking heads-up about pre-existing lint / out-of-scope design-history
+  // debt in untouched files (other projects / shared pages). Surfaced so it is
+  // visible but never blocks compact. (Mirrors the pre-ADR-0046 inline behavior,
+  // which lumped out-of-scope W8 into the same lint-notice list.)
+  const debtNotices = gate.notices.filter((n) => n.type === 'lint' || n.type === 'design-history');
+  let noticeText =
+    debtNotices.length > 0
+      ? `[WIKI CHECK] ${debtNotices.length} pre-existing lint issue(s) in files this session did not touch (not blocking): ${[
+          ...new Set(debtNotices.map((n) => n.reason.replace(/ \([^)]*\)$/, ''))),
         ]
           .slice(0, 5)
-          .join(', ')}${lintNotices.length > 5 ? ', …' : ''} — clean up when convenient.`
+          .join(', ')}${debtNotices.length > 5 ? ', …' : ''} — clean up when convenient.`
       : '';
+  // Surface the self-heal so a re-synced projection is not a silent mutation of
+  // the user's MEMORY.md / CLAUDE.md (ADR 0045 transparency).
+  if (feedbackHealed) noticeText = noticeText ? `${noticeText}\n${feedbackHealed}` : feedbackHealed;
 
-  // ── fix #37 Phase C: feedback projection drift (ADR 0031) ──
-  // Single blocking gate invariant (spec §7.5): integrate into THIS hook, never
-  // add a separate PreCompact hook. `feedback-sync --check --strict` reports
-  // projection drift (wiki feedback SoT vs MEMORY / CLAUDE.md learned-behaviors
-  // projection). `--no-input` keeps this non-TTY hook from ever blocking on a
-  // prompt, and the engine's skip-MEMORY warning is *soft* (never escalated by
-  // --strict) so a fresh / external user whose ~/.claude/projects/<id> dir does
-  // not exist yet is never gated (contract §5 step 4). Fail-open on any spawn
-  // error, exactly like the lint check above.
-  const feedbackPath = PKG_ROOT ? join(PKG_ROOT, 'scripts', 'feedback-sync.mjs') : null;
-  let feedbackOk = true;
-  let feedbackReason = '';
-  let feedbackSkipped = false;
-  if (!feedbackPath || !existsSync(feedbackPath)) {
-    feedbackSkipped = true;
-  } else {
-    try {
-      const r = spawnSync(
-        process.execPath,
-        [
-          feedbackPath,
-          '--check',
-          '--strict',
-          '--no-input',
-          '--json',
-          `--hypo-dir=${HYPO_DIR}`,
-          `--claude-home=${join(homedir(), '.claude')}`,
-        ],
-        { encoding: 'utf-8', timeout: 30000 },
-      );
-      if (r.error || r.status === null) {
-        feedbackSkipped = true; // spawn failure → fail-open (never block on tooling)
-      } else if (r.status !== 0) {
-        // exit≠0 alone is ambiguous. A *missing* target file (e.g. a system
-        // whose ~/.claude/CLAUDE.md was never created) reports buildError +
-        // exit 1, which is benign — there is nothing to gate. Decide from the
-        // JSON report's per-target state instead of the raw exit code: block
-        // ONLY when some target has a genuine, actionable issue (drift,
-        // conflict, over-cap, or a malformed managed region). buildError is
-        // never actionable here, so any mix that lacks a real issue fails open
-        // — including memory:clean + claude:buildError, where the prior
-        // `every(buildError)` predicate wrongly blocked that case. Mirrors
-        // doctor's buildError→warn (non-fatal) handling.
-        let report = null;
-        try {
-          report = JSON.parse(r.stdout || '');
-        } catch {
-          /* unparseable → fail-open below */
-        }
-        const targets = report ? Object.values(report.targets || {}) : [];
-        const conflicted = targets.some(
-          (t) =>
-            t.intruder || t.unpaired || t.outOfContainer || (t.conflicts && t.conflicts.length),
-        );
-        const overCap = targets.some((t) => t.overCap);
-        const drifted = targets.some((t) => t.dirty);
-        if (!report || !(conflicted || overCap || drifted)) {
-          feedbackSkipped = true; // missing target / pure warning / unparseable → fail-open
-        } else {
-          feedbackOk = false;
-          feedbackReason = conflicted
-            ? 'feedback projection conflict (manual edit) — run `hypomnema feedback-sync --import-target-change --from=<memory|claude>`'
-            : overCap
-              ? 'feedback projection over cap — demote/archive feedback pages'
-              : 'feedback projection drift — run `hypomnema feedback-sync --write`';
-        }
-      }
-    } catch (err) {
-      feedbackSkipped = true;
-      process.stderr.write(`[hypo-personal-check] error: ${err?.message ?? String(err)}\n`);
-    }
-  }
-
-  if (
-    gitStatus.clean &&
-    hotStatus.clean &&
-    lintOk &&
-    designHistoryOk &&
-    closeFiles.ok &&
-    feedbackOk
-  ) {
+  if (gate.ok) {
     console.log(
       JSON.stringify(
         noticeText
@@ -264,13 +182,9 @@ process.stdin.on('end', () => {
   // ── Bypass 3: HYPO_SKIP_GATE ──
   if (isGateSkipped()) {
     const skipped = [
-      !gitStatus.clean ? gitStatus.reason : '',
-      !hotStatus.clean ? hotStatus.reason : '',
-      !closeFiles.ok ? closeFilesReason : '',
-      !designHistoryOk ? `design-history stale (${lintW8.length})` : '',
-      !feedbackOk ? feedbackReason : '',
-      lintSkipped ? 'lint skipped (hypo-pkg.json missing)' : '',
-      feedbackSkipped ? 'feedback-sync skipped (hypo-pkg.json missing)' : '',
+      ...gate.blockers.map((b) => b.reason),
+      gate.skipped.lint ? 'lint skipped (hypo-pkg.json missing)' : '',
+      gate.skipped.feedback ? 'feedback-sync skipped (hypo-pkg.json missing)' : '',
     ]
       .filter(Boolean)
       .join(', ');
@@ -284,18 +198,12 @@ process.stdin.on('end', () => {
   }
 
   // ── Block ──
+  // gate.blockers already carry per-type reasons in the canonical order
+  // (git, hot, close, lint, design-history, feedback) — same strings as before
+  // ADR 0046, now sourced from the shared gate instead of inline checks.
   const reasons = [
-    !gitStatus.clean ? gitStatus.reason : '',
-    !hotStatus.clean ? hotStatus.reason : '',
-    !closeFiles.ok ? closeFilesReason : '',
-    !lintOk
-      ? `lint blockers: ${[...new Set(lintBlockers.map((b) => b.id || b.file))].join(', ')}`
-      : '',
-    !designHistoryOk
-      ? `design-history stale: ${lintW8.map((w) => w.file.split('/')[1]).join(', ')}`
-      : '',
-    !feedbackOk ? feedbackReason : '',
-    lintSkipped ? 'lint skipped (run `hypomnema init` to enable lint gate)' : '',
+    ...gate.blockers.map((b) => b.reason),
+    gate.skipped.lint ? 'lint skipped (run `hypomnema init` to enable lint gate)' : '',
   ].filter(Boolean);
 
   const checklist = readChecklist(today);
@@ -304,11 +212,13 @@ process.stdin.on('end', () => {
     [
       `  [ ] 0. Read SCHEMA.md + hypo-guide.md (required before wiki work)`,
       `  [ ] 1. PRD       — create projects/<name>/prd.md if missing`,
-      `  [ ] 2. ADR       — decide yes/no on 5 types; if all N, note "no ADR — reason: <why>"`,
+      `  [ ] 2. ADR       — decide yes/no on 5 types. Design change → append to projects/<name>/design-history.md.`,
+      `           If none, note the literal marker "ADR 없음 — reason: <why>" in the session-log entry`,
+      `           (machine-readable; suppresses the W8 design-history gate for no-design sessions).`,
       `  [ ] 3. Ingest    — if new external knowledge, save to sources/ and ingest`,
       `  [ ] 4. Pages     — extract new concepts/patterns to pages/`,
       `  [ ] 5. Synthesis — if 3+ cross-page analysis results, save to pages/syntheses/`,
-      `  [ ] 6. session-log — append to projects/<name>/session-log/YYYY-MM.md`,
+      `  [ ] 6. session-log — append to projects/<name>/session-log/YYYY-MM-DD.md (daily shard)`,
       `  [ ] 7. index.md  — update Projects section if needed`,
       `  [ ] 8. log.md    — append ## [${today}] session | <project-name>`,
       `  [ ] 9. hot.md    — update projects/<name>/hot.md (no exceptions)`,
@@ -317,6 +227,8 @@ process.stdin.on('end', () => {
       `  [ ] 12. lint — run scripts/lint.mjs; fix errors in files YOU touched`,
       `           (other projects' / shared-page debt is reported as non-blocking notice)`,
       `  [ ] 13. git commit & push`,
+      `  [ ] 14. verify — run \`crystallize.mjs --check-session-close\`; only declare`,
+      `           the session closed once it prints "Compact-ready" (= this gate passes).`,
     ].join('\n');
 
   const closeIntentNote = hasCloseIntent

package/hooks/hypo-pre-commit.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * hypo-pre-commit.mjs — wiki git pre-commit hook worker (§6.8 fix #24)
+ * hypo-pre-commit.mjs — wiki git pre-commit hook worker (§6.8)
  *
  * Blocks staged files that match .hypoignore patterns.
  * Installed by `hypo init` to <wiki>/.git/hooks/pre-commit.

package/hooks/hypo-session-end.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * hypo-session-end.mjs — SessionEnd hook (fix #25 PR-A2, ADR 0022 Layer 2)
+ * hypo-session-end.mjs — SessionEnd hook (ADR 0022 Layer 2)
  *
  * `/clear` cannot be blocked: it never fires UserPromptSubmit (Stage 0 PoC,
  * 2026-05-14). The only intervention point is the SessionEnd(reason='clear')

package/hooks/hypo-session-start.mjs

@@ -176,7 +176,7 @@ function readLastGrowthLine() {
 }
 
 /**
- * fix #25 PR-A2 (ADR 0022 amendment 2026-05-14): if the prior session ended
+ * ADR 0022 amendment 2026-05-14: if the prior session ended
  * via `/clear`, hypo-session-end stashed its identity in `.cache/clear-marker.json`.
  * Read it (with 7-day stale guard), unlink it (one-shot), and return a
  * `[WIKI_AUTOCLOSE]` recovery line for additionalContext + stderr.
@@ -212,8 +212,8 @@ function gitPull(dir) {
 }
 
 /**
- * fix #10: surface unresolved sync failures recorded by a prior session's
- * Stop hook (fix #9). The entry is cleared only once this session's pull has
+ * Surface unresolved sync failures recorded by a prior session's
+ * Stop hook. The entry is cleared only once this session's pull has
  * succeeded AND there is no unpushed commit left behind by a failed push
  * (`[ahead N]`).
  *
@@ -323,7 +323,7 @@ let raw = '';
 process.stdin.setEncoding('utf-8');
 process.stdin.on('data', (chunk) => (raw += chunk));
 process.stdin.on('end', () => {
-  // ISSUE-5: declared before the try so every emit branch — including the outer
+  // Declared before the try so every emit branch — including the outer
   // catch — carries the same `systemMessage` (the user-visible update/sibling
   // banner). Reassigned once below after the notices are computed.
   let outExtra = { continue: true, suppressOutput: true };
@@ -343,14 +343,14 @@ process.stdin.on('end', () => {
     const clearRecoveryLine = buildClearRecoveryLine(data.source);
     const updateLine = buildUpdateNotice();
     const siblingLine = buildSiblingNotice();
-    // ISSUE-5: the update + stale-sibling banners must reach the USER. On a
+    // The update + stale-sibling banners must reach the USER. On a
     // SessionStart hook that exits 0, stderr is invisible in the normal TUI
     // (only shown on exit 2 / --verbose) and additionalContext is model-only —
     // `systemMessage` is the documented user-visible channel. Route those two
     // banners there. They ALSO stay in noticePrefix → additionalContext below,
     // so the model and the user start the session looking at the same state.
     // (The other stderr notices — sync/growth/clear/suggest — are intentionally
-    // transcript/--verbose only and out of ISSUE-5's scope.)
+    // transcript/--verbose only and out of this banner's scope.)
     const userMessage = [updateLine, siblingLine].filter(Boolean).join('\n\n');
     if (userMessage) outExtra = { ...outExtra, systemMessage: userMessage };
     const notices = [syncLine, growthLine, clearRecoveryLine, updateLine, siblingLine].filter(
@@ -417,7 +417,7 @@ process.stdin.on('end', () => {
       return;
     }
 
-    // MISS: cwd matches no project. fix #23 / ADR 0023 — offer to create one
+    // MISS: cwd matches no project. ADR 0023 — offer to create one
     // when the ADR trigger conditions hold (git repo + project marker + no
     // cooldown + not previously declined). The actual scaffold is the LLM's
     // job on a "Y" reply (scripts/lib/project-create.mjs); the hook only nudges.