hypomnema 1.7.4 → 1.8.0

package/hooks/close-gate-store.mjs

@@ -367,10 +367,11 @@ export function readResolution(hypoDir, sessionId, rawTranscript) {
  * and a marker withheld by a commit failure could never be recovered
  * without a brand-new close phrase the user has no reason to type twice.
  * tests/close-hooks-gate.test.mjs's test C
- * ("crystallize.mjs:754 (runMarkSessionClosed) stays on isCloseGateOpen")
+ * ("runMarkSessionClosed stays on isCloseGateOpen")
  * pins exactly this: it withholds a marker via a real commit failure, fixes
  * the commit by hand with NO new close signal, and asserts the recovery run
- * still succeeds; swapping :754 to `closeGateStatus` turns that test red.
+ * still succeeds; swapping that call to `closeGateStatus` turns that test
+ * red.
  * As of this writing the two callers that gate a NEW request are
  * `verifyCloseAuthority` (crystallize.mjs, before any wiki byte is written)
  * and `hypo-close-guard.mjs`'s PreToolUse intercept (before a

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

@@ -69,6 +69,7 @@ import {
   hasPendingBackgroundWork,
   isCloseReconfirmDeclined,
   CLOSE_RECONFIRM_MARK,
+  resolveGateProjectOverride,
 } from './hypo-shared.mjs';
 
 function emitContinue() {
@@ -245,10 +246,19 @@ process.stdin.on('end', () => {
     let gate = null;
     const computeGate = () => {
       try {
+        // resolveGateProjectOverride (session-close-scope-boundary spec §2/§3): Stop
+        // gets no explicit project, only sessionCwd, same as PreCompact. Passed
+        // below as `attributionScope` (never `projectOverride`, which is the
+        // check-only diagnostic's key and would also disable the mine/foreign
+        // partition): this is what demotes a foreign project's dangling close to
+        // a notice instead of holding this session's Stop hostage on debt it
+        // never touched.
+        const attributionScope = resolveGateProjectOverride(HYPO_DIR, { sessionCwd });
         return precompactGateStatus(HYPO_DIR, {
           ...(transcriptPath ? { transcriptPath } : {}),
           ...(sessionCwd ? { sessionCwd } : {}),
           ...(sessionId ? { sessionId } : {}),
+          ...(attributionScope ? { attributionScope } : {}),
         });
       } catch {
         return null;

package/hooks/hypo-compact-guard.mjs

@@ -3,9 +3,11 @@
  * hypo-compact-guard.mjs — UserPromptSubmit hook
  *
  * Scope: detects "/compact" or "/clear" typed in chat only (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.
+ * The CLI built-in /compact does NOT fire UserPromptSubmit. The PreCompact hook
+ * (hypo-personal-check.mjs) covers that path, but it only REPORTS: since the
+ * session-close-scope-boundary change it never blocks /compact. /clear has no
+ * PreCompact event at all, so this hook is the only chat-side gate that can
+ * prompt session-close before a context wipe.
  *
  * Behavior: if session close is incomplete → instruct Claude to run session close
  * immediately before /compact or /clear.

package/hooks/hypo-cwd-change.mjs

@@ -110,6 +110,14 @@ process.stdin.on('end', () => {
 
     const ignorePatterns = loadHypoIgnore(HYPO_DIR);
 
+    // This injection is not a licensing surface for the observed-set gate
+    // (see base-store.mjs's recordObserved): a session's tracked
+    // `targets` are fixed at whichever project the OWNING SessionStart hit,
+    // and a cwd move can land here in a different project entirely, so
+    // recording an observation against this read could credit a path outside
+    // that fixed target set. Nothing here calls recordObserved; the guard
+    // stays exactly as conservative for a cwd-change injection as it was
+    // before the observed set existed.
     if (newHit) {
       const fromFile = readIfNotIgnored(newHit.hotPath, ignorePatterns);
       const content =

package/hooks/hypo-personal-check.mjs

@@ -2,21 +2,22 @@
 /**
  * hypo-personal-check.mjs — PreCompact hook
  *
- * Hard gate before /compact. Blocks if:
- *   - 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
- *
- * Bypass options (checked in order, per spec §7.5):
- *   1. HYPO_SKIP_GATE=1 env var
- *   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)
+ * NEVER blocks /compact (session-close-scope-boundary spec §1). It used to be
+ * a hard gate here, but /compact was the only hard path that "compact-ready"
+ * marker's invariant leaned on, and a hard block here meant every check
+ * `precompactGateStatus` runs (git-clean, hot.md structure, session-close
+ * files, scoped lint, W8 design-history, feedback projection) could hold
+ * /compact hostage on a project this session never touched. That is the
+ * scope-boundary bug this hook no longer causes. Session close is still
+ * enforced, just not HERE: the Stop hook (hypo-auto-minimal-crystallize.mjs)
+ * still blocks on close-intent + incomplete close, and `--mark-session-closed`
+ * still refuses the marker on a red gate. What follows is now advisory: an
+ * incomplete close surfaces as a systemMessage, never as decision:'block'.
  *
  * NOTE: capacity bypass (wiki-context-critical.json ≥90%) was REMOVED
- * (amendment 2026-05-13). Spec §7.5: even at full context, minimal
- * session-close is mandatory — auto-bypass on capacity caused silent state loss.
+ * (amendment 2026-05-13), and HYPO_SKIP_GATE is now moot for THIS hook since
+ * nothing here blocks — it is kept only so an incomplete-close systemMessage
+ * doesn't repeat the recommendation once bypassed.
  */
 
 import { spawnSync } from 'child_process';
@@ -32,6 +33,7 @@ import {
   isClosePattern,
   extractUserMessages,
   isUnderProjectDirs,
+  resolveGateProjectOverride,
 } from './hypo-shared.mjs';
 
 const WARNING_FILE = join(homedir(), '.claude', 'state', 'wiki-context-warning.json');
@@ -63,22 +65,18 @@ process.stdin.on('end', () => {
   //    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.
 
-  // ── Block 1.5: context warning (≥70%) — request session-compact before compact ──
+  // ── Context warning (≥70%) — advisory nudge toward session-compact, never a block ──
   if (existsSync(WARNING_FILE)) {
     try {
       unlinkSync(WARNING_FILE);
     } catch {}
     console.log(
       JSON.stringify({
-        decision: 'block',
-        reason: [
-          `[WIKI CHECK — BLOCKING] Context ≥70%: run /session-compact before compacting.`,
-          `STOP. Do NOT compact yet.`,
-          `1. If Skill tool is available: call it with skill="session-compact" immediately.`,
-          `2. If Skill tool is unavailable: perform the full session-close checklist from hypo-guide.md.`,
-          `After session close completes, compact will proceed normally.`,
-          ``,
-          `To skip: set HYPO_SKIP_GATE=1`,
+        continue: true,
+        systemMessage: [
+          `[WIKI CHECK] Context ≥70%: consider running /session-compact before compacting.`,
+          `1. If Skill tool is available: call it with skill="session-compact".`,
+          `2. If Skill tool is unavailable: perform the session-close checklist from hypo-guide.md.`,
         ].join('\n'),
       }),
     );
@@ -108,12 +106,23 @@ process.stdin.on('end', () => {
   // lint scope to this session's edited files; 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.
+  // resolveGateProjectOverride (session-close-scope-boundary spec §2/§3): PreCompact
+  // gets no explicit --project, only the payload's sessionCwd, so this resolves
+  // to the one project that cwd unambiguously owns (or null, which leaves the
+  // gate global). Passed below as `attributionScope`, never `projectOverride`:
+  // that key is the check-only diagnostic's and would also narrow
+  // sessionCloseGlobalStatus to this one project, turning off the mine/foreign
+  // partition that is what actually turns a foreign project's dangling close
+  // into a notice instead of debt this session gets blamed for in the message.
+  const attributionScope = resolveGateProjectOverride(HYPO_DIR, { sessionCwd });
+
   let gate;
   try {
     gate = precompactGateStatus(HYPO_DIR, {
       transcriptPath,
       ...(sessionId ? { sessionId } : {}),
       ...(sessionCwd ? { sessionCwd } : {}),
+      ...(attributionScope ? { attributionScope } : {}),
     });
   } catch (err) {
     // Defense-in-depth: precompactGateStatus fails open per-check, but if it ever
@@ -161,45 +170,100 @@ process.stdin.on('end', () => {
     }
   }
 
-  // Non-blocking heads-up about pre-existing lint / out-of-scope design-history
-  // debt in untouched files. Surfaced so it is visible but never blocks compact.
-  // Scoped to the close-target (today-active) projects: debt under one of their
-  // dirs stays listed by filename; debt elsewhere (other projects, shared pages,
-  // root files) folds into a count so the same untouched-file debt does not
-  // re-list its filenames on every compact. Non-file diagnostics (a fail-open
-  // "lint skipped" notice carries no path) are preserved verbatim, never folded.
-  const debtNotices = gate.notices.filter((n) => n.type === 'lint' || n.type === 'design-history');
-  const activeSlugs = (gate.close?.projects || []).map((p) => p.project).filter(Boolean);
-  const nonFileNotices = debtNotices.filter((n) => !n.file);
-  const fileNotices = debtNotices.filter((n) => n.file);
-  const inScopeNotices = fileNotices.filter((n) => isUnderProjectDirs(n.file, activeSlugs));
-  const otherDebtCount = fileNotices.length - inScopeNotices.length;
-  const listed = [
-    ...nonFileNotices.map((n) => n.reason),
-    ...new Set(inScopeNotices.map((n) => n.reason.replace(/ \([^)]*\)$/, ''))),
-  ];
-  let noticeText = '';
-  if (listed.length > 0) {
-    noticeText = `[WIKI CHECK] ${listed.length} pre-existing lint issue(s) in files this session did not touch (not blocking): ${listed
-      .slice(0, 5)
-      .join(', ')}${listed.length > 5 ? ', …' : ''} — clean up when convenient.`;
+  // Non-blocking heads-up, one line per notice TYPE (session-close-scope-boundary
+  // spec §4). gate.notices can carry any of seven types: git, git-sync,
+  // close-debt, close-cwd-unresolved, lint, design-history, feedback. Folding
+  // them all into one "pre-existing lint issue(s)" sentence (the old
+  // renderer) mislabeled git/git-sync/close-cwd-unresolved as lint debt and
+  // dropped close-cwd-unresolved plus most feedback notices outright: visible
+  // but lying about what kind of issue it was and what fixes it. A count that
+  // can grow unbounded (foreign git paths, close-debt projects) is capped and
+  // the rest folds into "+N more", mirroring the existing lint/design-history
+  // fold (a vault-wide lint sweep once produced 125 lines here).
+  const NOTICE_LIST_CAP = 5;
+  const foldNames = (items) =>
+    items.length > NOTICE_LIST_CAP
+      ? `${items.slice(0, NOTICE_LIST_CAP).join(', ')}, +${items.length - NOTICE_LIST_CAP} more`
+      : items.join(', ');
+  const byType = (t) => gate.notices.filter((n) => n.type === t);
+  const noticeLines = [];
+
+  // git: a dirty file outside this session's scope (§2b's structural demotion,
+  // or the trusted-transcript foreign-file demotion above it).
+  const foreignGit = byType('git');
+  if (foreignGit.length > 0) {
+    noticeLines.push(
+      `[WIKI CHECK] ${foreignGit.length} uncommitted file(s) outside this session's scope (not blocking): ${foldNames(foreignGit.map((n) => n.file || n.reason))}.`,
+    );
   }
-  if (otherDebtCount > 0) {
-    const fold = `+${otherDebtCount} pre-existing lint issue(s) elsewhere in the vault (other projects / shared pages, not blocking) — run \`/hypo:lint\` for the full list.`;
-    noticeText = noticeText ? `${noticeText}\n${fold}` : `[WIKI CHECK] ${fold}`;
+  // git-sync / close-cwd-unresolved: single-fact notices, their own `reason`
+  // is already the full sentence.
+  for (const n of byType('git-sync')) noticeLines.push(`[WIKI CHECK] ${n.reason}.`);
+  // close-cwd-unresolved's own `reason` (hypo-shared.mjs) names --project /
+  // --log-only, crystallize CLI flags with no PreCompact-hook equivalent, so
+  // it is not echoed here. This session's own sentence names the one thing a
+  // /compact-time reader can actually do about it: nothing, this is
+  // best-effort and non-blocking.
+  for (const n of byType('close-cwd-unresolved')) {
+    noticeLines.push(
+      `[WIKI CHECK] session cwd did not resolve to a unique project (not blocking): close attribution for this session is best-effort here.`,
+    );
   }
-  // A demoted close: some OTHER session left a project's close incomplete. It no
-  // longer blocks this compact, but it must still be SEEN — a notice list that the
-  // gate silently swallows (suppressOutput when nothing else surfaced) would turn the
-  // demotion into a disappearance, and nobody would ever fix the dangling close
-  // (codex design BLOCKER).
-  const closeDebt = gate.notices.filter((n) => n.type === 'close-debt');
+
+  // close-debt: some OTHER session left a project's close incomplete. It no
+  // longer blocks this compact, but it must still be SEEN: a notice list that
+  // the gate silently swallows (suppressOutput when nothing else surfaced)
+  // would turn the demotion into a disappearance, and nobody would ever fix
+  // the dangling close (codex design BLOCKER).
+  const closeDebt = byType('close-debt');
   if (closeDebt.length > 0) {
-    const line = `[WIKI CHECK] ${closeDebt.length} project(s) with an incomplete session close from another session (not blocking this compact): ${closeDebt
-      .map((n) => n.project)
-      .join(', ')} — each is fixed by that project's next close.`;
-    noticeText = noticeText ? `${noticeText}\n${line}` : line;
+    noticeLines.push(
+      `[WIKI CHECK] ${closeDebt.length} project(s) with an incomplete session close from another session (not blocking this compact): ${foldNames(closeDebt.map((n) => n.project))}, each fixed by that project's next close.`,
+    );
   }
+
+  // lint / design-history: pre-existing debt in files this session did not
+  // touch. Scoped to the close-target (today-active) projects: debt under one
+  // of their dirs stays listed by filename; debt elsewhere (other projects,
+  // shared pages, root files) folds into a count so the same untouched-file
+  // debt does not re-list its filenames on every compact. Non-file
+  // diagnostics (a fail-open "lint skipped" notice carries no path) are
+  // preserved verbatim, never folded. lint and design-history each get their
+  // own line now instead of sharing one "lint issue(s)" sentence.
+  const activeSlugs = (gate.close?.projects || []).map((p) => p.project).filter(Boolean);
+  for (const type of ['lint', 'design-history']) {
+    const debtNotices = byType(type);
+    const nonFileNotices = debtNotices.filter((n) => !n.file);
+    const fileNotices = debtNotices.filter((n) => n.file);
+    const inScopeNotices = fileNotices.filter((n) => isUnderProjectDirs(n.file, activeSlugs));
+    const otherDebtCount = fileNotices.length - inScopeNotices.length;
+    const listed = [
+      ...nonFileNotices.map((n) => n.reason),
+      ...new Set(inScopeNotices.map((n) => n.reason.replace(/ \([^)]*\)$/, ''))),
+    ];
+    if (listed.length > 0) {
+      noticeLines.push(
+        `[WIKI CHECK] ${listed.length} pre-existing ${type} issue(s) in files this session did not touch (not blocking): ${foldNames(listed)}. Clean up when convenient.`,
+      );
+    }
+    if (otherDebtCount > 0) {
+      noticeLines.push(
+        `[WIKI CHECK] +${otherDebtCount} pre-existing ${type} issue(s) elsewhere in the vault (other projects / shared pages, not blocking); run \`/hypo:lint\` for the full list.`,
+      );
+    }
+  }
+
+  // feedback: side-file I/O warnings (a projection target's per-slug sidecar is
+  // unreadable). A drift notice is skipped ONLY when this run actually healed
+  // it (feedbackHealed non-empty, reported once below): when gate.ok is
+  // false (another blocker fired), the self-heal above never runs at all, so
+  // the drift itself was never reported anywhere and must not be dropped here.
+  for (const n of byType('feedback')) {
+    if (feedbackHealed && /^feedback projection drift/.test(n.reason)) continue;
+    noticeLines.push(`[WIKI CHECK] ${n.reason}.`);
+  }
+
+  let noticeText = noticeLines.join('\n');
   // Surface the self-heal so a re-synced projection is not a silent mutation of
   // the user's MEMORY.md / CLAUDE.md (transparency).
   if (feedbackHealed) noticeText = noticeText ? `${noticeText}\n${feedbackHealed}` : feedbackHealed;
@@ -233,7 +297,7 @@ process.stdin.on('end', () => {
     return;
   }
 
-  // ── Block ──
+  // ── Advisory (never blocks — spec §1) ──
   // gate.blockers already carry per-type reasons in the canonical order
   // (git, hot, close, lint, design-history, feedback) — same strings as before
   // Now sourced from the shared gate instead of inline checks.
@@ -273,18 +337,14 @@ process.stdin.on('end', () => {
 
   console.log(
     JSON.stringify({
-      decision: 'block',
-      reason: [
-        `${closeIntentNote}[WIKI CHECK — BLOCKING] Session close incomplete. (${reasons.join(', ')})`,
-        `Run the checklist below in order, then retry /compact:`,
+      continue: true,
+      systemMessage: [
+        `${closeIntentNote}[WIKI CHECK] Session close incomplete. (${reasons.join(', ')})`,
+        `Recommended before /compact — run the checklist below:`,
         ``,
         checklistText,
         ...(noticeText ? ['', noticeText] : []),
-        ``,
-        `Trivial session? Bypass with HYPO_SKIP_GATE=1`,
       ].join('\n'),
-      continue: false,
-      stopReason: `Session close incomplete: ${reasons.join(', ')}`,
     }),
   );
 });

package/hooks/hypo-session-start.mjs

@@ -58,8 +58,15 @@ import {
   pkgRootNullAlreadyNotified,
   markPkgRootNullNotified,
   clearPkgRootNullNotified,
+  UPGRADE_APPLY_EITHER,
 } from './version-check.mjs';
-import { snapshotBase, overwriteTargets } from './base-store.mjs';
+import {
+  snapshotBase,
+  overwriteTargets,
+  beginObservedGeneration,
+  recordObserved,
+  hashContent,
+} from './base-store.mjs';
 import { listProposals } from './proposal-store.mjs';
 
 // Privacy guard: refuse to read+inject .hypoignore-matched
@@ -76,12 +83,18 @@ import { listProposals } from './proposal-store.mjs';
 // slicing first could cut the frontmatter off and silently fail open.
 // The root hot.md is a frontmatter-less pointer table, so it reads as '' and
 // passes (shared) unchanged.
+// Returns `{raw, shown}` rather than just the sliced string: the observed-set
+// record must hash the FULL bytes this call just read, not a fresh re-read at
+// record time, or a write that lands in the window between this read and the
+// record call would be credited to this session's observation without ever
+// having been shown to it. `shown` stays the maxChars-sliced display string
+// every existing caller already expects.
 function readIfNotIgnored(path, maxChars, patterns) {
   if (!path) return null;
   if (patterns.length > 0 && isIgnored(path, HYPO_DIR, patterns)) return null;
   const raw = readFileSync(path, 'utf-8');
   if (!scopeVisible(readVisibilityScope(raw), currentDevice())) return null;
-  return raw.slice(0, maxChars);
+  return { raw, shown: raw.slice(0, maxChars) };
 }
 
 // Scoped-out is not the same as absent. Both make readIfNotIgnored return null,
@@ -257,13 +270,24 @@ function buildPkgRootDriftNotice() {
     const cache = readCache(cachePath);
     if (pkgRootDriftAlreadyNotified(cache, key)) return '';
     markPkgRootDriftNotified(cachePath, key);
+    // status.cached is null both for a genuinely fresh install (never ran
+    // /hypo:init) AND for the channel-judgment-failure guard (init/upgrade
+    // positively decided to leave pkgRoot unset; see scripts/init.mjs's
+    // resolveDurableRoot). "run /hypo:upgrade and confirm the apply step" is a
+    // dead end in the second case: apply skips the same write until the
+    // registry itself is fixed. Point at that fix directly rather than send the
+    // user in a loop.
+    const recoveryLine = status.cached
+      ? '  → run `/hypo:upgrade` and confirm the apply step to bring hypo-pkg.json back in sync.'
+      : '  → if `/hypo:upgrade` keeps leaving this unwritten, the plugin channel itself cannot be ' +
+        'resolved: repair `~/.claude/plugins/installed_plugins.json` first (reinstall the plugin, or ' +
+        'run `/plugin marketplace update hypomnema` then `/reload-plugins`), then re-run `/hypo:upgrade`.';
     return (
       `[Hypomnema] Package metadata drift: hypo-pkg.json still points at ` +
       `\`${status.cached || '(none)'}\`, but the code actually running resolves to ` +
       `\`${status.self}\`.\n` +
       `  Hooks already resolved the correct root for this session — this is a ` +
-      `heads-up, not a blocker.\n` +
-      `  → run \`/hypo:upgrade --apply\` to bring hypo-pkg.json back in sync.`
+      `heads-up, not a blocker.\n${recoveryLine}`
     );
   } catch {
     return '';
@@ -301,9 +325,8 @@ function buildPkgRootNullNotice() {
       `[Hypomnema] Package root unresolved: this install's hooks cannot locate ` +
       `their own package, so PreCompact's lint/feedback checks are silently ` +
       `skipped this session.\n` +
-      `  → run \`hypomnema upgrade --apply\` to sync this install's hook copies ` +
-      `with the current package (the \`/hypo:upgrade --apply\` slash command does ` +
-      `the same thing, where slash commands were installed). \`/hypo:init\` will ` +
+      `  → run ${UPGRADE_APPLY_EITHER} to sync this install's hook copies ` +
+      `with the current package. \`/hypo:init\` will ` +
       `NOT fix this — it skips every hook file that already exists.\n` +
       `  → or run \`hypomnema doctor\` to see what's missing.`
     );
@@ -600,6 +623,12 @@ process.stdin.on('end', () => {
     // direct-write path.
     if (data.session_id) {
       snapshotBase(HYPO_DIR, data.session_id, overwriteTargets(hit ? hit.proj : null));
+      // Bumps the observed generation on EVERY SessionStart (first run and
+      // resume/compact alike), before the injections below record into it. A
+      // resume that ends up injecting nothing (ignored, scoped out, absent)
+      // still bumps, which is what lets a stale observation from an earlier
+      // resume expire instead of staying licensed for the rest of the session.
+      beginObservedGeneration(HYPO_DIR, data.session_id);
     }
 
     const ignorePatterns = loadHypoIgnore(HYPO_DIR);
@@ -617,8 +646,10 @@ process.stdin.on('end', () => {
       // marker is computed on raw content (staleMarkerForPath), then prepended
       // onto the sliced display content; a no-op when there is no verify_by_date.
       const TODAY = new Date().toISOString().slice(0, 10);
-      let hotContent = readIfNotIgnored(hit.hotPath, HOT_CHARS, ignorePatterns);
-      let stateContent = readIfNotIgnored(hit.statePath, STATE_CHARS, ignorePatterns);
+      const hotRead = readIfNotIgnored(hit.hotPath, HOT_CHARS, ignorePatterns);
+      const stateRead = readIfNotIgnored(hit.statePath, STATE_CHARS, ignorePatterns);
+      let hotContent = hotRead ? hotRead.shown : null;
+      let stateContent = stateRead ? stateRead.shown : null;
       const hotMarker = staleMarkerForPath(hit.hotPath, ignorePatterns, TODAY);
       const stateMarker = staleMarkerForPath(hit.statePath, ignorePatterns, TODAY);
       if (hotContent && hotMarker) hotContent = `${hotMarker}\n${hotContent}`;
@@ -647,6 +678,41 @@ process.stdin.on('end', () => {
             ),
           ),
         );
+        // Observed-set record: this is the actual injection point, so this is
+        // where "this session was SHOWN these bytes" becomes true. Recorded
+        // AFTER the marker write and the console.log above (fail-open
+        // ordering): if this throws, the model has already been shown the
+        // bytes above but no observed-entry lands, so the guard just fails
+        // safe into a park later, rather than the reverse — an entry on disk
+        // claiming an observation the injection never actually emitted.
+        // Gated on `hotContent`/`stateContent` (the same predicate that put
+        // each into `parts` above), not on `hotRead`/`stateRead` alone: an
+        // empty-but-not-ignored file makes `hotRead` a truthy `{raw:'',
+        // shown:''}`, and recording against that would create an observed
+        // entry for bytes the model was never actually shown a line of.
+        // Hash `.raw` (the full file this call just read), never a fresh
+        // `readFileSync` here — that would credit a write landing between the
+        // read above and this line to an observation that never happened.
+        if (data.session_id) {
+          if (hotContent) {
+            recordObserved(
+              HYPO_DIR,
+              data.session_id,
+              join('projects', hit.proj, 'hot.md'),
+              hashContent(hotRead.raw),
+              hotRead.raw.length > HOT_CHARS,
+            );
+          }
+          if (stateContent) {
+            recordObserved(
+              HYPO_DIR,
+              data.session_id,
+              join('projects', hit.proj, 'session-state.md'),
+              hashContent(stateRead.raw),
+              stateRead.raw.length > STATE_CHARS,
+            );
+          }
+        }
       } else {
         // A snapshot that exists but is scoped to another machine must not be
         // reported as "no snapshot yet": the model would treat a resumed project
@@ -701,7 +767,8 @@ process.stdin.on('end', () => {
       return;
     }
 
-    const globalContent = readIfNotIgnored(GLOBAL_HOT, HOT_CHARS, ignorePatterns);
+    const globalRead = readIfNotIgnored(GLOBAL_HOT, HOT_CHARS, ignorePatterns);
+    const globalContent = globalRead ? globalRead.shown : null;
     if (!globalContent) {
       // GLOBAL_HOT exists but is empty or .hypoignore'd — still surface any
       // pending notices (sync state, growth, AND the auto-project offer), which
@@ -722,6 +789,20 @@ process.stdin.on('end', () => {
         ),
       ),
     );
+    // Observed-set record: the MISS branch's root hot.md injection is the one
+    // place a project-less session observes anything at all. Recorded AFTER
+    // the console.log above — see the HIT branch's comment for why (fail-open
+    // ordering). Hashes `.raw`, not a fresh disk read, for the same reason
+    // given there.
+    if (data.session_id) {
+      recordObserved(
+        HYPO_DIR,
+        data.session_id,
+        'hot.md',
+        hashContent(globalRead.raw),
+        globalRead.raw.length > HOT_CHARS,
+      );
+    }
   } catch (err) {
     process.stderr.write(`[hypo-session-start] error: ${err?.message ?? String(err)}\n`);
     console.log(JSON.stringify(outExtra));