hypomnema 1.1.0 → 1.2.0

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

package/hooks/hypo-cwd-change.mjs

@@ -6,21 +6,41 @@
  * project hot.md. Skips if still within the same project subtree.
  */
 
-import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
-import { HYPO_DIR, buildOutput } from './hypo-shared.mjs';
+import {
+  HYPO_DIR,
+  buildOutput,
+  loadHypoIgnore,
+  isIgnored,
+  sessionMarkerPath,
+  shouldSuggestProjectCreation,
+  buildProjectSuggestionLine,
+  recordSuggestionCooldown,
+} from './hypo-shared.mjs';
 
 const PROJECTS_DIR = join(HYPO_DIR, 'projects');
-const GLOBAL_HOT   = join(HYPO_DIR, 'hot.md');
-const MAX_CHARS    = 3000;
+const GLOBAL_HOT = join(HYPO_DIR, 'hot.md');
+const MAX_CHARS = 3000;
+
+// Privacy guard: a .hypoignore-matched hot.md must not be
+// re-emitted into additionalContext on cwd change.
+function readIfNotIgnored(path, patterns) {
+  if (!path) return null;
+  if (patterns.length > 0 && isIgnored(path, HYPO_DIR, patterns)) return null;
+  return readFileSync(path, 'utf-8').slice(0, MAX_CHARS);
+}
 
 function parseFrontmatterField(content, key) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match) return null;
-  const line = match[1].split('\n').find(l => l.startsWith(`${key}:`));
+  const line = match[1].split('\n').find((l) => l.startsWith(`${key}:`));
   if (!line) return null;
-  return line.slice(key.length + 1).trim().replace(/^['"]|['"]$/g, '');
+  return line
+    .slice(key.length + 1)
+    .trim()
+    .replace(/^['"]|['"]$/g, '');
 }
 
 function findProjectHot(cwd) {
@@ -30,7 +50,7 @@ function findProjectHot(cwd) {
     if (!statSync(projDir).isDirectory()) continue;
     const indexPath = join(projDir, 'index.md');
     if (!existsSync(indexPath)) continue;
-    const content    = readFileSync(indexPath, 'utf-8');
+    const content = readFileSync(indexPath, 'utf-8');
     const workingDir = parseFrontmatterField(content, 'working_dir');
     if (!workingDir) continue;
     const resolved = workingDir.startsWith('~/')
@@ -38,7 +58,13 @@ function findProjectHot(cwd) {
       : workingDir;
     if (cwd === resolved || cwd.startsWith(resolved + '/')) {
       const hotPath = join(projDir, 'hot.md');
-      return { proj, hotPath: existsSync(hotPath) ? hotPath : null, resolved };
+      const statePath = join(projDir, 'session-state.md');
+      return {
+        proj,
+        hotPath: existsSync(hotPath) ? hotPath : null,
+        statePath: existsSync(statePath) ? statePath : null,
+        resolved,
+      };
     }
   }
   return null;
@@ -46,14 +72,17 @@ function findProjectHot(cwd) {
 
 let raw = '';
 process.stdin.setEncoding('utf-8');
-process.stdin.on('data', chunk => raw += chunk);
+process.stdin.on('data', (chunk) => (raw += chunk));
 process.stdin.on('end', () => {
   try {
     let data = {};
-    try { data = JSON.parse(raw); } catch {}
+    try {
+      data = JSON.parse(raw);
+    } catch {}
 
     const newCwd = data.new_cwd || data.new_directory || data.cwd || process.cwd();
     const oldCwd = data.old_cwd || data.old_directory || data.previous_cwd || '';
+    const sessionId = data.session_id || 'default';
 
     // Skip re-injection if still in the same project
     const oldHit = oldCwd ? findProjectHot(oldCwd) : null;
@@ -64,28 +93,82 @@ process.stdin.on('end', () => {
       return;
     }
 
+    const ignorePatterns = loadHypoIgnore(HYPO_DIR);
+
     if (newHit) {
-      const content = newHit.hotPath
-        ? readFileSync(newHit.hotPath, 'utf-8').slice(0, MAX_CHARS)
-        : '(no hot.md yet — will be created at session close)';
-      console.log(JSON.stringify(
-        buildOutput(`[WIKI: cwd changed → project=${newHit.proj}]\n\n${content}`, { continue: true, suppressOutput: true })
-      ));
+      const fromFile = readIfNotIgnored(newHit.hotPath, ignorePatterns);
+      const content = fromFile ?? '(no hot.md yet — will be created at session close)';
+      // fix #13: arm the first-prompt marker so the NEXT user prompt re-triggers
+      // hypo-first-prompt, which forces a "Resuming <project>" summary line.
+      // Only arm when real hot content was actually injected — if hot.md is
+      // missing or .hypoignore'd (fromFile null), there is nothing for the LLM
+      // to summarize, so forcing "Resuming" would be empty noise (codex review).
+      if (fromFile) {
+        try {
+          writeFileSync(
+            sessionMarkerPath(sessionId),
+            JSON.stringify({
+              proj: newHit.proj,
+              hotPath: newHit.hotPath,
+              statePath: newHit.statePath,
+              hasSnapshot: true,
+              source: 'cwd-change',
+              ts: Date.now(),
+            }),
+          );
+        } catch (err) {
+          process.stderr.write(
+            `[hypo-cwd-change] marker write failed: ${err?.message ?? String(err)}\n`,
+          );
+        }
+      }
+      console.log(
+        JSON.stringify(
+          buildOutput(`[WIKI: cwd changed → project=${newHit.proj}]\n\n${content}`, {
+            continue: true,
+            suppressOutput: true,
+          }),
+        ),
+      );
       return;
     }
 
-    if (!existsSync(GLOBAL_HOT)) {
-      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
-      return;
+    // MISS: cwd matches no project. fix #23 / 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)) {
+      const suggestLine = buildProjectSuggestionLine(newCwd);
+      suggestPrefix = `${suggestLine}\n\n`;
+      recordSuggestionCooldown(HYPO_DIR, newCwd);
+      process.stderr.write(`\n\x1b[33m${suggestLine}\x1b[0m\n`);
     }
 
-    const globalContent = readFileSync(GLOBAL_HOT, 'utf-8').slice(0, MAX_CHARS);
-    console.log(JSON.stringify(
-      buildOutput(`[WIKI: cwd changed → no project match, injecting global hot]\n\n${globalContent}`, { continue: true, suppressOutput: true })
-    ));
+    const globalContent = existsSync(GLOBAL_HOT)
+      ? readIfNotIgnored(GLOBAL_HOT, ignorePatterns)
+      : null;
 
+    if (!globalContent) {
+      if (suggestPrefix) {
+        console.log(
+          JSON.stringify(
+            buildOutput(suggestPrefix.trimEnd(), { continue: true, suppressOutput: true }),
+          ),
+        );
+      } else {
+        console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      }
+      return;
+    }
+    console.log(
+      JSON.stringify(
+        buildOutput(
+          `${suggestPrefix}[WIKI: cwd changed → no project match, injecting global hot]\n\n${globalContent}`,
+          { continue: true, suppressOutput: true },
+        ),
+      ),
+    );
   } catch (err) {
-    process.stderr.write(`[wiki-cwd-change] error: ${err.message}\n`);
+    process.stderr.write(`[hypo-cwd-change] error: ${err?.message ?? String(err)}\n`);
     console.log(JSON.stringify({ continue: true, suppressOutput: true }));
   }
 });

package/hooks/hypo-file-watch.mjs

@@ -8,17 +8,19 @@
 
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
-import { HYPO_DIR } from './hypo-shared.mjs';
+import { HYPO_DIR, loadHypoIgnore, isIgnored } from './hypo-shared.mjs';
 
 const MAX_CHARS = 2000;
 
 let raw = '';
 process.stdin.setEncoding('utf-8');
-process.stdin.on('data', chunk => raw += chunk);
+process.stdin.on('data', (chunk) => (raw += chunk));
 process.stdin.on('end', () => {
   try {
     let data = {};
-    try { data = JSON.parse(raw); } catch {}
+    try {
+      data = JSON.parse(raw);
+    } catch {}
 
     const filePath = data.file_path || data.path || '';
 
@@ -27,6 +29,15 @@ process.stdin.on('end', () => {
       return;
     }
 
+    // Privacy guard: refuse to inject
+    // .hypoignore-matched paths. Without this, `.env*` or other secrets under
+    // HYPO_DIR are re-emitted as additionalContext to the Claude provider.
+    const patterns = loadHypoIgnore(HYPO_DIR);
+    if (patterns.length > 0 && isIgnored(filePath, HYPO_DIR, patterns)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
     if (!existsSync(filePath)) {
       console.log(JSON.stringify({ continue: true, suppressOutput: true }));
       return;
@@ -35,13 +46,15 @@ process.stdin.on('end', () => {
     const content = readFileSync(filePath, 'utf-8').slice(0, MAX_CHARS);
     const relPath = filePath.replace(HYPO_DIR + '/', '');
 
-    console.log(JSON.stringify({
-      continue: true,
-      suppressOutput: true,
-      additionalContext: `[WIKI FILE UPDATED: ${relPath}]\n\n${content}`,
-    }));
-
-  } catch {
+    console.log(
+      JSON.stringify({
+        continue: true,
+        suppressOutput: true,
+        additionalContext: `[WIKI FILE UPDATED: ${relPath}]\n\n${content}`,
+      }),
+    );
+  } catch (err) {
+    process.stderr.write(`[hypo-file-watch] error: ${err?.message ?? String(err)}\n`);
     console.log(JSON.stringify({ continue: true, suppressOutput: true }));
   }
 });

package/hooks/hypo-first-prompt.mjs

@@ -2,31 +2,33 @@
 /**
  * hypo-first-prompt.mjs — UserPromptSubmit hook
  *
- * Consumes the marker written by wiki-session-start.mjs.
- * On the FIRST user prompt of a new session, injects a lightweight decision
- * instruction so the LLM can decide whether to announce the resume context.
+ * Consumes the marker written by hypo-session-start.mjs (source omitted /
+ * 'session-start') or hypo-cwd-change.mjs (source 'cwd-change', fix #13).
+ * 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"
+ * conditional is removed; the line is injected unconditionally).
  *
- * hot.md content is NOT re-injected here — wiki-session-start.mjs already
- * injected it on SessionStart. Only the decision hint is added.
+ * hot.md / session-state.md content is NOT re-injected here — the upstream
+ * hook already placed it in additionalContext. This hook only forces the LLM
+ * to lead with the summary line drawn from that context.
  * Marker expires after 10 minutes.
  */
 
 import { readFileSync, unlinkSync, existsSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { buildOutput } from './hypo-shared.mjs';
+import { buildOutput, sessionMarkerPath } from './hypo-shared.mjs';
 
 const MARKER_TTL = 10 * 60 * 1000; // 10 min
 
 let raw = '';
 process.stdin.setEncoding('utf-8');
-process.stdin.on('data', chunk => raw += chunk);
+process.stdin.on('data', (chunk) => (raw += chunk));
 process.stdin.on('end', () => {
   try {
     let data = {};
-    try { data = JSON.parse(raw); } catch {}
-    const sessionId = data.session_id || 'default';
-    const MARKER_FILE = join(tmpdir(), `hypo-session-marker-${sessionId}.json`);
+    try {
+      data = JSON.parse(raw);
+    } catch {}
+    const MARKER_FILE = sessionMarkerPath(data.session_id);
 
     if (!existsSync(MARKER_FILE)) {
       console.log(JSON.stringify({ continue: true, suppressOutput: true }));
@@ -34,26 +36,38 @@ process.stdin.on('end', () => {
     }
 
     const marker = JSON.parse(readFileSync(MARKER_FILE, 'utf-8'));
-    const age    = Date.now() - (marker.ts || 0);
+    const age = Date.now() - (marker.ts || 0);
 
-    try { unlinkSync(MARKER_FILE); } catch {}
+    try {
+      unlinkSync(MARKER_FILE);
+    } catch {}
 
     if (age > MARKER_TTL) {
       console.log(JSON.stringify({ continue: true, suppressOutput: true }));
       return;
     }
 
-    const hasSnapshot  = marker.hasSnapshot ?? (marker.hotPath && existsSync(marker.hotPath));
+    const hasSnapshot = marker.hasSnapshot ?? (marker.hotPath && existsSync(marker.hotPath));
     const snapshotNote = hasSnapshot ? '' : ' (no snapshot yet — first session)';
+    // fix #13: a cwd-change re-trigger says "Resuming"; a fresh session start
+    // (default source) says "Previously working on".
+    const verb = marker.source === 'cwd-change' ? 'Resuming' : 'Previously working on';
 
-    console.log(JSON.stringify(
-      buildOutput(
-        `[WIKI SESSION START: project=${marker.proj}${snapshotNote}]\nDecision hint: if the first message relates to this project → answer first, then add one line "Previously working on ${marker.proj} — continue?" If unrelated / simple Q&A → answer only, no mention.`,
-        { continue: true, suppressOutput: true }
-      )
-    ));
-
-  } catch {
+    console.log(
+      JSON.stringify(
+        buildOutput(
+          `[WIKI SESSION START: project=${marker.proj}${snapshotNote}]\n` +
+            `Before addressing the user's message, lead your FIRST reply with exactly one line:\n` +
+            `"${verb} ${marker.proj}: <one-line summary>. Continue with <next task>?"\n` +
+            `Draw <one-line summary> and <next task> from the [HOT] / [SESSION STATE] ` +
+            `context already injected this session. Inject this line unconditionally — ` +
+            `even if the user's first message is unrelated or a simple question — then answer normally.`,
+          { continue: true, suppressOutput: true },
+        ),
+      ),
+    );
+  } catch (err) {
+    process.stderr.write(`[hypo-first-prompt] error: ${err?.message ?? String(err)}\n`);
     console.log(JSON.stringify({ continue: true, suppressOutput: true }));
   }
 });

package/hooks/hypo-hot-rebuild.mjs

@@ -14,8 +14,8 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { HYPO_DIR, computeSessionGrowth, formatGrowthMetrics } from './hypo-shared.mjs';
 
-const HOT_PATH         = join(HYPO_DIR, 'hot.md');
-const GROWTH_CACHE     = join(HYPO_DIR, '.cache', 'last-session-growth.json');
+const HOT_PATH = join(HYPO_DIR, 'hot.md');
+const GROWTH_CACHE = join(HYPO_DIR, '.cache', 'last-session-growth.json');
 
 function parseFrontmatter(content) {
   const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
@@ -56,10 +56,12 @@ function rebuild() {
 
   const today = new Date().toISOString().slice(0, 10);
 
-  const tableRows = rows.map(({ name, slug }) => {
-    const date = getProjectDate(slug) || today;
-    return `| ${name} | ${date} | [[projects/${slug}/hot]] |`;
-  }).join('\n');
+  const tableRows = rows
+    .map(({ name, slug }) => {
+      const date = getProjectDate(slug) || today;
+      return `| ${name} | ${date} | [[projects/${slug}/hot]] |`;
+    })
+    .join('\n');
 
   const canonical = `---
 title: Hot Cache — Pointer
@@ -92,7 +94,7 @@ ${tableRows}
 function emitGrowth() {
   if (!existsSync(HYPO_DIR)) return;
   const stats = computeSessionGrowth(HYPO_DIR);
-  const line  = formatGrowthMetrics('stop', stats);
+  const line = formatGrowthMetrics('stop', stats);
   if (line) process.stderr.write(`${line}\n`);
   try {
     mkdirSync(join(HYPO_DIR, '.cache'), { recursive: true });
@@ -100,7 +102,17 @@ function emitGrowth() {
   } catch {}
 }
 
-try { rebuild();     } catch {}
-try { emitGrowth();  } catch {}
+try {
+  rebuild();
+} catch (err) {
+  process.stderr.write(`[hypo-hot-rebuild] error: ${err?.message ?? String(err)}\n`);
+}
+try {
+  emitGrowth();
+} catch (err) {
+  process.stderr.write(`[hypo-hot-rebuild] error: ${err?.message ?? String(err)}\n`);
+}
 
-try { console.log(JSON.stringify({ continue: true, suppressOutput: true })); } catch {}
+try {
+  console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+} catch {}