hypomnema 1.6.2 → 1.7.1

package/hooks/hypo-first-prompt.mjs

@@ -48,7 +48,17 @@ process.stdin.on('end', () => {
     }
 
     const hasSnapshot = marker.hasSnapshot ?? (marker.hotPath && existsSync(marker.hotPath));
-    const snapshotNote = hasSnapshot ? '' : ' (no snapshot yet — first session)';
+    // A snapshot withheld by visibility_scope is NOT an absent one. session-start
+    // stamps the marker so this hook can tell them apart: without it, a project
+    // resumed on a foreign machine is announced as a first session, and the model
+    // then has every reason to author a fresh hot.md over the one that exists on
+    // the owning machine. Never name the withheld contents, only the fact.
+    const scopedOut = marker.scopedOut === true;
+    const snapshotNote = hasSnapshot
+      ? ''
+      : scopedOut
+        ? ' (snapshot scoped to another machine)'
+        : ' (no snapshot yet — first session)';
     // 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';
@@ -63,11 +73,17 @@ process.stdin.on('end', () => {
     // first-ever session (codex v2 review 2026-05-26).
     const exampleLine = hasSnapshot
       ? `${verb} ${projSafe}: [one-line summary]. Continue with [next task]?`
-      : `${verb} ${projSafe}: no prior snapshot yet — first session. What would you like to start with?`;
+      : scopedOut
+        ? `${projSafe}: this project has a prior snapshot, but it is scoped to another machine and is not visible here. What would you like to work on?`
+        : `${verb} ${projSafe}: no prior snapshot yet — first session. What would you like to start with?`;
     const fillNote = hasSnapshot
       ? `Replace the bracketed placeholders using the [HOT] / [SESSION STATE] ` +
         `context already injected this session — do NOT emit the literal brackets.`
-      : `Use the line above verbatim — there is no prior snapshot to summarize.`;
+      : scopedOut
+        ? `Use the line above verbatim. The project has prior work; its snapshot ` +
+          `simply belongs to another machine, so treat it as an existing project ` +
+          `whose history you cannot see from here.`
+        : `Use the line above verbatim — there is no prior snapshot to summarize.`;
 
     console.log(
       JSON.stringify(

package/hooks/hypo-hot-rebuild.mjs

@@ -17,11 +17,31 @@ import {
   computeSessionGrowth,
   formatGrowthMetrics,
   deriveRootLogEntries,
+  recordTouchedPaths,
 } from './hypo-shared.mjs';
 
 const HOT_PATH = join(HYPO_DIR, 'hot.md');
 const GROWTH_CACHE = join(HYPO_DIR, '.cache', 'last-session-growth.json');
 
+// This Stop hook runs BEFORE hypo-auto-commit and can write hot.md
+// (rebuild) and log.md (deriveRootLogEntries), both hook-generated, not user
+// Write/Edit, so hypo-auto-stage never sees them. Read session_id off stdin so
+// whatever this hook writes still lands in the scoped commit's set; without
+// this, a scope built from Write/Edit alone would silently drop these files
+// from every session's auto-commit.
+let sessionId = null;
+try {
+  const raw = await new Promise((r) => {
+    let d = '';
+    process.stdin.on('data', (c) => (d += c));
+    process.stdin.on('end', () => r(d));
+  });
+  const payload = JSON.parse(raw || '{}') || {};
+  sessionId = payload.session_id || payload.sessionId || null;
+} catch {
+  sessionId = null;
+}
+
 function parseFrontmatter(content) {
   const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!m) return {};
@@ -52,12 +72,13 @@ function parsePointerRows(content) {
   return rows;
 }
 
+/** @returns {boolean} true when hot.md was actually rewritten. */
 function rebuild() {
-  if (!existsSync(HOT_PATH)) return;
+  if (!existsSync(HOT_PATH)) return false;
 
   const current = readFileSync(HOT_PATH, 'utf-8');
   const rows = parsePointerRows(current);
-  if (rows.length === 0) return;
+  if (rows.length === 0) return false;
 
   const today = new Date().toISOString().slice(0, 10);
 
@@ -93,7 +114,11 @@ ${tableRows}
 3. Read \`projects/<name>/hot.md\` for project background
 `;
 
-  if (canonical !== current) writeFileSync(HOT_PATH, canonical);
+  if (canonical !== current) {
+    writeFileSync(HOT_PATH, canonical);
+    return true;
+  }
+  return false;
 }
 
 function emitGrowth() {
@@ -107,16 +132,18 @@ function emitGrowth() {
   } catch {}
 }
 
+let hotWritten = false;
 try {
-  rebuild();
+  hotWritten = rebuild();
 } 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.
+let logEntriesAdded = 0;
 try {
-  deriveRootLogEntries(HYPO_DIR);
+  logEntriesAdded = deriveRootLogEntries(HYPO_DIR);
 } catch (err) {
   process.stderr.write(`[hypo-hot-rebuild] log-derive error: ${err?.message ?? String(err)}\n`);
 }
@@ -126,6 +153,17 @@ try {
   process.stderr.write(`[hypo-hot-rebuild] error: ${err?.message ?? String(err)}\n`);
 }
 
+// Feed this hook's own writes into the session's scoped auto-commit
+// set (see the sessionId comment above). No-op without a session_id.
+try {
+  const touched = [];
+  if (hotWritten) touched.push('hot.md');
+  if (logEntriesAdded > 0) touched.push('log.md');
+  if (touched.length > 0) recordTouchedPaths(HYPO_DIR, sessionId, touched);
+} catch (err) {
+  process.stderr.write(`[hypo-hot-rebuild] touched-paths error: ${err?.message ?? String(err)}\n`);
+}
+
 try {
   console.log(JSON.stringify({ continue: true, suppressOutput: true }));
 } catch {}

package/hooks/hypo-lookup.mjs

@@ -19,6 +19,9 @@ import {
   staleMarkerFor,
   pageUsageLoggingAllowed,
   recordLookupUsage,
+  currentDevice,
+  scopeVisible,
+  readVisibilityScope,
 } from './hypo-shared.mjs';
 
 const INDEX_PATH = join(HYPO_DIR, 'index.md');
@@ -32,7 +35,16 @@ function buildPageMap(dir, root = dir, map = {}, ignorePatterns = [], hypoDir =
   for (const entry of readdirSync(dir)) {
     const full = join(dir, entry);
     if (isIgnored(full, hypoDir, ignorePatterns)) continue;
-    if (statSync(full).isDirectory()) {
+    // Skip an entry we can't stat (dangling symlink, race, permission) instead
+    // of throwing: the map is now built before the miss branch too, so one bad
+    // entry must not sink the whole lookup into the silent outer catch.
+    let st;
+    try {
+      st = statSync(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) {
       buildPageMap(full, root, map, ignorePatterns, hypoDir);
     } else if (entry.endsWith('.md')) {
       const rel = full.slice(root.length + 1).replace(/\.md$/, '');
@@ -208,25 +220,6 @@ process.stdin.on('end', () => {
     const topScore = scored[0]?.score ?? 0;
     const matched = scored.filter((e) => e.score >= topScore * 0.5);
 
-    if (matched.length === 0) {
-      const topic = keywords.slice(0, 5).join(', ');
-      const closest = bm25Score(keywords, entries)
-        .map((e) => ({ ...e, score: e.score * typePrior(e.slug) }))
-        .sort((a, c) => c.score - a.score)
-        .slice(0, 3)
-        .map((e) => `[[${e.slug}]]`)
-        .join(', ');
-      console.log(
-        JSON.stringify(
-          buildOutput(`[WIKI LOOKUP: miss] "${topic}" — no match. Closest: ${closest || 'none'}`, {
-            continue: true,
-            suppressOutput: true,
-          }),
-        ),
-      );
-      return;
-    }
-
     const ignorePatterns = loadHypoIgnore(HYPO_DIR);
     const pageMap = {
       ...buildPageMap(
@@ -245,19 +238,81 @@ process.stdin.on('end', () => {
       ),
     };
 
+    // Single device snapshot for the whole prompt (currentDevice() itself stays
+    // uncached upstream so tests can override via HYPO_DEVICE; this hook only
+    // needs one read per lookup, not one per candidate).
+    const device = currentDevice();
+
+    // Resolve a slug to its on-disk path the same way the injection loop does.
+    const resolveSlugPath = (slug) =>
+      pageMap[slug] ?? pageMap[slug.replace(/^(pages|projects)\//, '')] ?? pageMap[basename(slug)];
+
+    // Read a page's raw content at most once per lookup: the visibility gate and
+    // the injection loop both need it, so memoize to avoid a double read.
+    const rawCache = new Map();
+    const readRaw = (path) => {
+      if (rawCache.has(path)) return rawCache.get(path);
+      let raw = null;
+      try {
+        raw = readFileSync(path, 'utf-8');
+      } catch {
+        raw = null;
+      }
+      rawCache.set(path, raw);
+      return raw;
+    };
+
+    // Visibility gate: MUST read raw content and go through readVisibilityScope
+    // (never a local frontmatter parser) so first-wins + comment-strip stay in
+    // step with the write side — a local last-wins/no-comment parser would miss
+    // `machine:devA # note` on devA itself. An unresolved/unreadable slug passes
+    // through (nothing to leak; the missing-file paths handle it downstream).
+    const isSlugVisible = (slug) => {
+      const path = resolveSlugPath(slug);
+      if (!path || !existsSync(path)) return true;
+      const raw = readRaw(path);
+      if (raw === null) return true;
+      return scopeVisible(readVisibilityScope(raw), device);
+    };
+
+    // Filter BEFORE the miss decision so a device that matches only machine-other
+    // pages takes the clean miss path (with closest VISIBLE suggestions), not the
+    // "index hit but files missing" branch. Hidden pages never reach injection,
+    // the empty-injection slug branch, or the "+N more" count — all read only
+    // visibleMatched, so no machine-other slug can leak through any path.
+    const visibleMatched = matched.filter((e) => isSlugVisible(e.slug));
+
+    if (visibleMatched.length === 0) {
+      const topic = keywords.slice(0, 5).join(', ');
+      const closest = bm25Score(keywords, entries)
+        .map((e) => ({ ...e, score: e.score * typePrior(e.slug) }))
+        .sort((a, c) => c.score - a.score)
+        .filter((e) => isSlugVisible(e.slug))
+        .slice(0, 3)
+        .map((e) => `[[${e.slug}]]`)
+        .join(', ');
+      console.log(
+        JSON.stringify(
+          buildOutput(`[WIKI LOOKUP: miss] "${topic}" — no match. Closest: ${closest || 'none'}`, {
+            continue: true,
+            suppressOutput: true,
+          }),
+        ),
+      );
+      return;
+    }
+
     // UTC to match doctor.mjs' overdue set (D1/D2). STALE is advisory, so a
     // one-day UTC/local skew never misleads.
     const TODAY = new Date().toISOString().slice(0, 10);
 
     const injected = [];
     const injectedSlugs = [];
-    for (const { slug } of matched.slice(0, MAX_HITS)) {
-      const path =
-        pageMap[slug] ??
-        pageMap[slug.replace(/^(pages|projects)\//, '')] ??
-        pageMap[basename(slug)];
+    for (const { slug } of visibleMatched.slice(0, MAX_HITS)) {
+      const path = resolveSlugPath(slug);
       if (path && existsSync(path)) {
-        const raw = readFileSync(path, 'utf-8');
+        const raw = readRaw(path);
+        if (raw === null) continue;
         // Compute the marker on raw (pre-slice) so a long body can't truncate
         // frontmatter out of reach. fail-open: a marker failure drops the marker,
         // never the page.
@@ -275,7 +330,7 @@ process.stdin.on('end', () => {
     }
 
     if (injected.length === 0) {
-      const slugs = matched
+      const slugs = visibleMatched
         .slice(0, MAX_HITS)
         .map((e) => e.slug)
         .join(', ');
@@ -297,9 +352,11 @@ process.stdin.on('end', () => {
       recordLookupUsage(HYPO_DIR, { sessionId, slugs: injectedSlugs });
     }
 
+    // visibleMatched (not matched): a hidden count would still name a "+N more"
+    // total that includes machine-other pages this device can never see.
     const overflow =
-      matched.length > MAX_HITS
-        ? `\n(+${matched.length - MAX_HITS} more matches — search wiki index for more)`
+      visibleMatched.length > MAX_HITS
+        ? `\n(+${visibleMatched.length - MAX_HITS} more matches — search wiki index for more)`
         : '';
 
     console.log(

package/hooks/hypo-personal-check.mjs

@@ -42,6 +42,7 @@ process.stdin.on('data', (chunk) => (raw += chunk));
 process.stdin.on('end', () => {
   let transcriptPath = null;
   let sessionId = null;
+  let sessionCwd = null;
   try {
     const input = JSON.parse(raw || '{}');
     transcriptPath = input.transcript_path ?? null;
@@ -49,6 +50,11 @@ process.stdin.on('end', () => {
     // 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;
+    // Authoritative session cwd for the session-cwd close check. This is the one
+    // verified cwd source (mirrors hypo-session-record); it lets /compact block a
+    // session whose own project close was never started, which the recency-based
+    // global status cannot see.
+    sessionCwd = input.cwd ?? null;
   } catch {
     /* fail-open */
   }
@@ -107,6 +113,7 @@ process.stdin.on('end', () => {
     gate = precompactGateStatus(HYPO_DIR, {
       transcriptPath,
       ...(sessionId ? { sessionId } : {}),
+      ...(sessionCwd ? { sessionCwd } : {}),
     });
   } catch (err) {
     // Defense-in-depth: precompactGateStatus fails open per-check, but if it ever
@@ -122,9 +129,11 @@ process.stdin.on('end', () => {
   // 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.
+  // race exits non-zero and blocks here. Each FILE it writes is atomic (tmp+
+  // rename, see feedback-sync's atomicWrite), so a mid-write fault can no longer
+  // truncate a target; what is still not atomic is the write ACROSS targets (one
+  // file can land before another fails), which the preflight narrows to genuine
+  // fs errors and no further.
   let feedbackHealed = '';
   if (gate.ok && gate.driftTargets.length > 0) {
     const feedbackPath = PKG_ROOT ? join(PKG_ROOT, 'scripts', 'feedback-sync.mjs') : null;
@@ -179,6 +188,18 @@ process.stdin.on('end', () => {
     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}`;
   }
+  // 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');
+  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;
+  }
   // 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;

package/hooks/hypo-session-record.mjs

@@ -12,8 +12,7 @@
 
 import { existsSync, mkdirSync, appendFileSync } from 'fs';
 import { dirname, join } from 'path';
-import { hostname } from 'os';
-import { HYPO_DIR } from './hypo-shared.mjs';
+import { HYPO_DIR, currentDevice } from './hypo-shared.mjs';
 
 const INDEX_PATH = join(HYPO_DIR, '.cache', 'sessions', 'index.jsonl');
 
@@ -54,7 +53,7 @@ process.stdin.on('end', () => {
       // machine identity for multi-machine audit. index.jsonl lives
       // under .cache/ (gitignored in a normal vault), so this is a LOCAL-only
       // per-session record — accurate for every session, no sync/privacy cost.
-      device: hostname() || 'unknown',
+      device: currentDevice(),
     };
     appendFileSync(INDEX_PATH, JSON.stringify(entry) + '\n');
   } catch (err) {