hypomnema 1.6.1 → 1.7.0

package/hooks/hypo-session-start.mjs

@@ -32,6 +32,9 @@ import {
   collectProjectWorkingDirs,
   buildVaultOrientation,
   staleMarkerFor,
+  currentDevice,
+  scopeVisible,
+  readVisibilityScope,
 } from './hypo-shared.mjs';
 import {
   defaultCachePath,
@@ -46,15 +49,45 @@ import {
   siblingAlreadyNotified,
   markSiblingNotified,
 } from './version-check.mjs';
+import { snapshotBase, overwriteTargets } from './base-store.mjs';
+import { listProposals } from './proposal-store.mjs';
 
 // Privacy guard: refuse to read+inject .hypoignore-matched
 // wiki files into additionalContext. Without this, a user who lists
 // `projects/private/hot.md` in .hypoignore would still see SECRET emit because
 // session-start reads hot/state paths directly.
+//
+// Visibility guard: a machine-scoped page (visibility_scope: machine:<owner>)
+// must not be injected on a machine other than its owner. hypo-file-watch
+// already filters these very files, so leaving session start unfiltered made the
+// SAME file behave differently depending on which path opened it: the user sets
+// the field, sees it honored on edit, and never learns that session start still
+// ships the body. Read the scope from the RAW content before the maxChars slice:
+// 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.
 function readIfNotIgnored(path, maxChars, patterns) {
   if (!path) return null;
   if (patterns.length > 0 && isIgnored(path, HYPO_DIR, patterns)) return null;
-  return readFileSync(path, 'utf-8').slice(0, maxChars);
+  const raw = readFileSync(path, 'utf-8');
+  if (!scopeVisible(readVisibilityScope(raw), currentDevice())) return null;
+  return raw.slice(0, maxChars);
+}
+
+// Scoped-out is not the same as absent. Both make readIfNotIgnored return null,
+// but telling the model "no snapshot yet / first session" when the snapshot merely
+// belongs to another machine is a lie it will act on. Returns false for an ignored
+// or missing file so only a real machine-scope hide reports true.
+// The caller may name the project and the fact, never the withheld body: a message
+// explaining the hide must not re-leak what it hid.
+function isScopedOut(path, patterns) {
+  try {
+    if (!path || !existsSync(path)) return false;
+    if (patterns.length > 0 && isIgnored(path, HYPO_DIR, patterns)) return false;
+    return !scopeVisible(readVisibilityScope(readFileSync(path, 'utf-8')), currentDevice());
+  } catch {
+    return false;
+  }
 }
 
 // Compute the STALE marker for a hot/state file from its RAW content (readIfNotIgnored
@@ -271,6 +304,24 @@ function syncStateNotice(pullOk) {
   }
   return `[WIKI: last sync failed: ${last.op || '?'} — ${last.error || 'unknown'}]`;
 }
+/**
+ * Surface the vault-wide count of parked write-proposals (T8). Routed
+ * exactly like syncStateNotice: the line joins the `notices` array (→
+ * additionalContext) and is also written to stderr, so both the model and the
+ * user's transcript see it. NOT a systemMessage banner (that channel is
+ * reserved for the update/sibling notices). Pure read (listProposals never
+ * mutates); best-effort so a store read failure never breaks SessionStart. '' when
+ * there are no pending proposals, so nothing surfaces on the empty path.
+ */
+function pendingProposalNotice() {
+  try {
+    const n = listProposals(HYPO_DIR).length;
+    if (n === 0) return '';
+    return `[WIKI: 대기 proposal ${n}건 (검토: hypomnema proposal list)]`;
+  } catch {
+    return '';
+  }
+}
 const GLOBAL_HOT = join(HYPO_DIR, 'hot.md');
 const HOT_CHARS = 2000;
 const STATE_CHARS = 2000;
@@ -346,6 +397,7 @@ process.stdin.on('end', () => {
 
     const pullOk = gitPull(HYPO_DIR);
     const syncLine = syncStateNotice(pullOk);
+    const proposalLine = pendingProposalNotice();
     const growthLine = readLastGrowthLine();
     // On source='clear', surface the dying
     // session's identity that hypo-session-end stashed so Claude can recover
@@ -364,11 +416,17 @@ process.stdin.on('end', () => {
     // 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(
-      Boolean,
-    );
+    const notices = [
+      syncLine,
+      proposalLine,
+      growthLine,
+      clearRecoveryLine,
+      updateLine,
+      siblingLine,
+    ].filter(Boolean);
     let noticePrefix = notices.length ? `${notices.join('\n\n')}\n\n` : '';
     if (syncLine) process.stderr.write(`\n\x1b[33m${syncLine}\x1b[0m\n`);
+    if (proposalLine) process.stderr.write(`\n\x1b[33m${proposalLine}\x1b[0m\n`);
     if (growthLine) process.stderr.write(`\n\x1b[36m${growthLine}\x1b[0m\n`);
     if (clearRecoveryLine)
       process.stderr.write(`\n\x1b[33m${clearRecoveryLine.split('\n')[0]}\x1b[0m\n`);
@@ -379,6 +437,18 @@ process.stdin.on('end', () => {
     const MARKER_FILE = sessionMarkerPath(sessionId);
     const hit = findProjectFiles(cwd);
 
+    // Observed-base snapshot for the write=proposal gate. Deliberately AFTER gitPull: the base must
+    // describe the tree this session actually starts from, remote merges
+    // included, or the first close would raise a proposal against content the
+    // session never had a chance to conflict with. Once per session
+    // (existence-check inside snapshotBase), so resume and compact leave it
+    // alone. `data.session_id` is used raw rather than the 'default' fallback
+    // above. A session with no id has no base and closes down the legacy
+    // direct-write path.
+    if (data.session_id) {
+      snapshotBase(HYPO_DIR, data.session_id, overwriteTargets(hit ? hit.proj : null));
+    }
+
     const ignorePatterns = loadHypoIgnore(HYPO_DIR);
 
     // When cwd is a project working_dir that is NOT the vault itself, tell the
@@ -425,17 +495,29 @@ process.stdin.on('end', () => {
           ),
         );
       } 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
+        // as a first session. Say which it is, and say nothing of the contents.
+        const scopedOut =
+          isScopedOut(hit.hotPath, ignorePatterns) || isScopedOut(hit.statePath, ignorePatterns);
+        const reason = scopedOut ? 'snapshot scoped to another machine' : 'no snapshot yet';
         process.stderr.write(
-          `\n\x1b[36m[Hypomnema]\x1b[0m project: \x1b[1m${hit.proj}\x1b[0m (no snapshot yet)\n\n`,
+          `\n\x1b[36m[Hypomnema]\x1b[0m project: \x1b[1m${hit.proj}\x1b[0m (${reason})\n\n`,
         );
+        // Carry the reason into the marker, not just this hook's output.
+        // hypo-first-prompt derives its resume line from the marker alone, so a
+        // marker that says only `hotPath: null` makes the NEXT prompt announce
+        // "first session" for a project that merely belongs to another machine.
+        // That lie is what invites the model to author a fresh hot.md over one
+        // that already exists elsewhere.
         writeFileSync(
           MARKER_FILE,
-          JSON.stringify({ proj: hit.proj, hotPath: null, ts: Date.now() }),
+          JSON.stringify({ proj: hit.proj, hotPath: null, scopedOut, ts: Date.now() }),
         );
         console.log(
           JSON.stringify(
             buildOutput(
-              `${noticePrefix}${hitPrefix}[WIKI HOT CACHE: project=${sanitizeProjForPrompt(hit.proj)}, no snapshot yet]`,
+              `${noticePrefix}${hitPrefix}[WIKI HOT CACHE: project=${sanitizeProjForPrompt(hit.proj)}, ${reason}]`,
               outExtra,
             ),
           ),