hypomnema 1.10.1 → 1.10.2

package/hooks/hypo-auto-stage.mjs

@@ -6,7 +6,7 @@
  */
 
 import { spawnSync } from 'child_process';
-import { relative } from 'path';
+import { join } from 'path';
 import {
   HYPO_DIR,
   loadHypoIgnore,
@@ -17,6 +17,8 @@ import {
   readAutoStagedRecord,
   recordAutoStagedBlob,
   recordTouchedPaths,
+  vaultRelatives,
+  remainingSpawnTimeoutMs,
   vaultCommitLockTarget,
   withFileLock,
 } from './hypo-shared.mjs';
@@ -30,6 +32,20 @@ import { advanceBaseForWrite, hashContent } from './base-store.mjs';
 // guard at close. tool_name, not file_path, is the write signal.
 const WRITE_TOOLS = new Set(['Write', 'Edit', 'MultiEdit']);
 
+// One time budget for every wait in this hook. hooks.json gives the hook 10 seconds and kills it
+// after that, so waits that each ran to their own limit (vault lock, git, cache lock, session lock,
+// base lock: 5 seconds apiece) could be cut off before the failure flag was written. The evidence
+// comes first, in time as well as in budget: the ownership record (and, if it fails, the failure
+// flag) runs before anything else, the report keeps its own share, and the side work (staging, the
+// auto-staged cache, the base advance) uses only what the record left. A hook killed during the
+// side work has already left its record. Dropped side work is redone or harmless: Stop stages
+// again, a missing cache entry only means one more backup, a missing base advance parks the close
+// on a proposal (the safe direction).
+const AUTO_STAGE_BUDGET_MS = 8000;
+const REPORT_SHARE_MS = 1000; // kept for the output that must still be printed
+const deadline = { end: performance.now() + AUTO_STAGE_BUDGET_MS };
+const until = (shareMs) => ({ end: deadline.end - shareMs });
+
 let input = {};
 try {
   const raw = await new Promise((r) => {
@@ -44,75 +60,43 @@ try {
   process.exit(0);
 }
 
-const filePath = input.tool_input?.file_path ?? '';
+const givenPath = input.tool_input?.file_path ?? '';
+// Inside the vault by a path comparison on real paths, not a string prefix: a HYPO_DIR with a
+// trailing separator, or a vault reached through a symlink or a relative spelling, still counts.
+// A string test that misses leaves no touched-paths record and no failure flag for a write that
+// is really in the vault, and the close then does not see that uncommitted file as this session's.
+const rels = typeof givenPath === 'string' && givenPath ? vaultRelatives(HYPO_DIR, givenPath) : [];
+const rel = rels[0];
+// The same file spelled from HYPO_DIR, for every git and ignore call below.
+const filePath = rel === undefined ? givenPath : join(HYPO_DIR, rel);
 
-if (filePath.startsWith(HYPO_DIR + '/') || filePath === HYPO_DIR) {
+if (rel !== undefined) {
   const patterns = loadHypoIgnore(HYPO_DIR);
-  // Only a write stages: a Read of a vault file must not change the index.
-  if (
-    WRITE_TOOLS.has(input.tool_name) &&
-    (patterns.length === 0 || !isIgnored(filePath, HYPO_DIR, patterns))
-  ) {
-    // Under the vault commit lock, like every other writer of the index: the catch-up pre-step
-    // (clearGeneratedPathsBlockingPull) reads and releases the index while it holds that lock, and
-    // an add landing in between would stage bytes it is about to set aside. A lock that cannot be
-    // taken skips the add: the session's scoped auto-commit stages its own paths, so nothing is
-    // lost.
-    try {
-      withFileLock(
-        vaultCommitLockTarget(HYPO_DIR),
-        () => {
-          const rel = relative(HYPO_DIR, filePath);
-          // A merge in progress (open conflict, or a resolution waiting for its commit): staging
-          // now would change that resolution. The path is still in the session's touched set
-          // below, so Stop commits it once the merge is done.
-          if (
-            spawnSync('git', ['-C', HYPO_DIR, 'rev-parse', '-q', '--verify', 'MERGE_HEAD'], {
-              stdio: 'ignore',
-            }).status === 0
-          )
-            return;
-          // A version a person already staged for this path must reach the commit intact, so that
-          // it can be backed up there: `git add` would put the tool's bytes over it first. The
-          // path is left unstaged (it is still in the session's touched set below, so Stop commits
-          // it). A staged deletion (`git rm`) is skipped the same way: `git add` would turn it into a
-          // modification. With no answer from git about the index, skip too: Stop stages it either
-          // way.
-          const before = indexAndHeadBlobs(HYPO_DIR, rel);
-          if (
-            !before ||
-            isStagedDeletion(before.head, before.indexed) ||
-            (before.index &&
-              before.index !== before.head &&
-              !isAutoStagedBlob(readAutoStagedRecord(HYPO_DIR), rel, before.index, before.head))
-          )
-            return;
-          const add = spawnSync('git', ['-C', HYPO_DIR, 'add', filePath], { stdio: 'ignore' });
-          if (add.status !== 0) return;
-          // Record the blob this hook staged (and the HEAD blob it sat on), so the commit can tell
-          // it from one a person staged later and does not back up Claude's own write.
-          // Best-effort: with no record the commit saves the blob as it would for a person's.
-          const after = indexAndHeadBlobs(HYPO_DIR, rel);
-          if (after?.index) recordAutoStagedBlob(HYPO_DIR, rel, after.index, before.head);
-        },
-        { timeoutMs: Number(process.env.HYPO_VAULT_LOCK_TIMEOUT_MS) || 5000 },
-      );
-    } catch (err) {
-      process.stderr.write(
-        `[hypo-auto-stage] 볼트 잠금을 못 잡아 ${filePath} 의 git add 를 건너뛰었습니다 (${err?.code ?? err?.message})\n`,
-      );
-    }
-  }
-
+  // A pattern may name the symlink or the directory it points to, so every spelling is checked
+  // (hypo-file-watch does the same). Staging and recording use the real path, so an ignored alias
+  // would otherwise bring an ignored directory's content into the commit through its other name.
+  const ignoredSpellings =
+    patterns.length === 0
+      ? []
+      : rels.filter((r) => isIgnored(join(HYPO_DIR, r), HYPO_DIR, patterns));
   if (WRITE_TOOLS.has(input.tool_name)) {
-    const rel = relative(HYPO_DIR, filePath);
-
     // Accumulate this write into the session's scoped auto-commit
     // set, keyed by session_id (no-op without one; never a shared bucket).
     // hypo-auto-commit.mjs drains this at Stop instead of sweeping the whole
     // working tree, so another session's concurrent writes to this vault
     // never land in THIS session's commit.
-    const recorded = recordTouchedPaths(HYPO_DIR, input.session_id, rel);
+    // The record runs first, before staging: a hook killed while it stages (the harness timeout, a
+    // git that hangs) has then already recorded the write, and nothing staged is left unclaimed. It
+    // and a failure flag may use everything up to the report share; staging gets what is left.
+    // A path that is ignored only under another spelling is not recorded: the commit would
+    // check the real path alone and take it. One ignored under its real path is still recorded
+    // (the commit leaves it out and the close gate reports it).
+    const aliasOnlyIgnored = ignoredSpellings.length > 0 && !ignoredSpellings.includes(rel);
+    const recorded =
+      aliasOnlyIgnored ||
+      recordTouchedPaths(HYPO_DIR, input.session_id, rel, {
+        deadline: until(REPORT_SHARE_MS),
+      });
     if (!recorded) {
       // A lock-timeout or write failure here leaves the file just written
       // with nothing in ANY session's touched-paths set to bring it into an
@@ -126,6 +110,77 @@ if (filePath.startsWith(HYPO_DIR + '/') || filePath === HYPO_DIR) {
       );
     }
 
+    // A path ignored under any of its spellings is recorded (above) but never staged.
+    if (ignoredSpellings.length === 0) {
+      // Under the vault commit lock, like every other writer of the index: the catch-up pre-step
+      // (clearGeneratedPathsBlockingPull) reads and releases the index while it holds that lock, and
+      // an add landing in between would stage bytes it is about to set aside. A lock that cannot be
+      // taken skips the add: the session's scoped auto-commit stages its own paths, so nothing is
+      // lost. Every wait below is cut to what the record left of the hook budget; with no time left
+      // the add is skipped the same way.
+      const staging = until(REPORT_SHARE_MS);
+      const lockWaitMs = Math.min(
+        Number(process.env.HYPO_VAULT_LOCK_TIMEOUT_MS) || 5000,
+        remainingSpawnTimeoutMs(staging),
+      );
+      try {
+        if (lockWaitMs > 0)
+          withFileLock(
+            vaultCommitLockTarget(HYPO_DIR),
+            () => {
+              // A merge in progress (open conflict, or a resolution waiting for its commit): staging
+              // now would change that resolution. The path is already in the session's touched
+              // set, so Stop commits it once the merge is done. A check that got no answer in time
+              // is treated the same: staging on a guess could change the resolution.
+              const mergeTimeout = remainingSpawnTimeoutMs(staging);
+              if (mergeTimeout === 0) return;
+              const merging = spawnSync(
+                'git',
+                ['-C', HYPO_DIR, 'rev-parse', '-q', '--verify', 'MERGE_HEAD'],
+                { stdio: 'ignore', timeout: mergeTimeout },
+              );
+              if (merging.status === 0 || merging.error) return;
+              // A version a person already staged for this path must reach the commit intact, so that
+              // it can be backed up there: `git add` would put the tool's bytes over it first. The
+              // path is left unstaged (it is already in the session's touched set, so Stop commits
+              // it). A staged deletion (`git rm`) is skipped the same way: `git add` would turn it into a
+              // modification. With no answer from git about the index, skip too: Stop stages it either
+              // way.
+              const before = indexAndHeadBlobs(HYPO_DIR, rel, { deadline: staging });
+              if (
+                !before ||
+                isStagedDeletion(before.head, before.indexed) ||
+                (before.index &&
+                  before.index !== before.head &&
+                  !isAutoStagedBlob(readAutoStagedRecord(HYPO_DIR), rel, before.index, before.head))
+              )
+                return;
+              const addTimeout = remainingSpawnTimeoutMs(staging);
+              if (addTimeout === 0) return;
+              const add = spawnSync('git', ['-C', HYPO_DIR, 'add', filePath], {
+                stdio: 'ignore',
+                timeout: addTimeout,
+              });
+              if (add.status !== 0) return;
+              // Record the blob this hook staged (and the HEAD blob it sat on), so the commit can tell
+              // it from one a person staged later and does not back up Claude's own write.
+              // Best-effort: with no record the commit saves the blob as it would for a person's.
+              const after = indexAndHeadBlobs(HYPO_DIR, rel, { deadline: staging });
+              const cacheWaitMs = Math.min(5000, remainingSpawnTimeoutMs(staging));
+              if (after?.index && cacheWaitMs > 0)
+                recordAutoStagedBlob(HYPO_DIR, rel, after.index, before.head, {
+                  timeoutMs: cacheWaitMs,
+                });
+            },
+            { timeoutMs: lockWaitMs },
+          );
+      } catch (err) {
+        process.stderr.write(
+          `[hypo-auto-stage] 볼트 잠금을 못 잡아 ${filePath} 의 git add 를 건너뛰었습니다 (${err?.code ?? err?.message})\n`,
+        );
+      }
+    }
+
     // Write=proposal gate provenance: when this session's own write lands on one of
     // the overwrite targets it snapshotted at start, advance that target's base so
     // the close guard reads the change as "I wrote this", not "someone else did"
@@ -142,7 +197,12 @@ if (filePath.startsWith(HYPO_DIR + '/') || filePath === HYPO_DIR) {
         input.tool_name === 'Write' && typeof input.tool_input?.content === 'string'
           ? hashContent(input.tool_input.content)
           : null;
-      advanceBaseForWrite(HYPO_DIR, input.session_id, rel, filePath, known);
+      // Only what is left after the report share; none left skips the advance.
+      const baseWaitMs = remainingSpawnTimeoutMs(until(REPORT_SHARE_MS));
+      if (baseWaitMs > 0)
+        advanceBaseForWrite(HYPO_DIR, input.session_id, rel, filePath, known, {
+          timeoutMs: Math.min(5000, baseWaitMs),
+        });
     }
   }
 }

package/hooks/hypo-close-guard.mjs

@@ -49,9 +49,8 @@
  * before anything else runs.
  */
 
-import { realpathSync } from 'fs';
-import { basename, dirname, isAbsolute, join, relative, sep } from 'path';
-import { HYPO_DIR, isGateSkipped } from './hypo-shared.mjs';
+import { isAbsolute } from 'path';
+import { HYPO_DIR, isGateSkipped, vaultRelatives } from './hypo-shared.mjs';
 import { isGeneratedViewPath, isSessionEntryPath } from './session-entries.mjs';
 
 // Mirrors hypo-auto-stage.mjs's WRITE_TOOLS: the tools that replace file bytes.
@@ -61,39 +60,6 @@ const GENERATED_DENY =
   '생성 파일입니다. close payload의 summary/tracks로 기록하세요 (직접 쓰면 다음 close가 덮어씁니다).';
 const ENTRY_DENY = '원본 항목은 close apply만 만들고 고치지 않습니다.';
 
-// The vault-relative spellings of `filePath` that are inside `root`: the path as given and, when
-// the files exist, their real paths (a symlinked vault written through its real path). A string
-// prefix test is not used: a trailing separator on HYPO_DIR or a symlink would switch it off.
-function insideRelatives(root, filePath) {
-  const real = (p) => {
-    try {
-      return realpathSync(p);
-    } catch {
-      return null;
-    }
-  };
-  // The real path of the nearest ancestor that exists, with the segments below it put back: a file
-  // that does not exist yet, in a directory that does not either, still resolves. `dirname` reaches
-  // a fixed point at the filesystem root, which ends the walk (`null` when not even that resolves).
-  const realThroughAncestor = (p) => {
-    const rest = [];
-    for (let d = p; ; d = dirname(d)) {
-      const r = real(d);
-      if (r !== null) return join(r, ...rest);
-      if (dirname(d) === d) return null;
-      rest.unshift(basename(d));
-    }
-  };
-  const pairs = [[root, filePath]];
-  const realRoot = real(root);
-  const realFile = realThroughAncestor(filePath);
-  if (realRoot !== null && realFile !== null) pairs.push([realRoot, realFile]);
-  return pairs
-    .map(([r, f]) => relative(r, f))
-    .filter((rel) => rel !== '' && rel.split(sep)[0] !== '..' && !isAbsolute(rel))
-    .map((rel) => rel.replace(/\\/g, '/'));
-}
-
 let input = {};
 try {
   const raw = await new Promise((r) => {
@@ -120,7 +86,7 @@ try {
   const root = HYPO_DIR.replace(/[\\/]+$/, '') || HYPO_DIR;
   let rel = null;
   let reason = null;
-  for (const candidate of insideRelatives(root, filePath)) {
+  for (const candidate of vaultRelatives(root, filePath)) {
     const spellings = [candidate, candidate.toLowerCase()];
     reason = spellings.some(isGeneratedViewPath)
       ? GENERATED_DENY

package/hooks/hypo-compact-guard.mjs

@@ -16,12 +16,15 @@
  * This hook never calls precompactGateStatus: its own hooks.json timeout is
  * 10s and the gate's lint spawn alone budgets 30s, three times over. Instead
  * it re-checks only the cheap axes (session log, git, hot.md) directly, and
- * narrows the git axis with the SAME project-vs-foreign path rule the gate
- * uses (isForeignProjectFile / classifyForeignOnlyDirty in hypo-shared.mjs), so
- * a different project's dangling close file does not fire a false alarm here
- * either. Unlike the gate, this hook never passes transcriptTouched into that
- * rule: parsing the transcript is exactly the evidence spec §5 excludes to
- * stay inside the 10s budget, so only the cheap path-prefix axis runs here.
+ * narrows the git axis with a project-vs-foreign path rule
+ * (isForeignProjectFile / classifyForeignOnlyDirty in hypo-shared.mjs), so
+ * a different project's dangling close file does not fire a false alarm here.
+ * The gate no longer uses that rule: it judges the git axis by this session's
+ * touched-paths record, so the two now differ. The record is a per-session
+ * file under .cache/sessions, which this hook does not read, and it never
+ * parses the transcript either, to stay inside the 10s budget. Only the
+ * cheap path-prefix axis runs here. Moving this hook onto the record is a
+ * follow-up, not part of the gate change.
  */
 
 import {

package/hooks/hypo-file-watch.mjs

@@ -20,6 +20,7 @@ import {
   currentDevice,
   scopeVisible,
   readVisibilityScope,
+  vaultRelatives,
 } from './hypo-shared.mjs';
 
 const MAX_CHARS = 2000;
@@ -34,12 +35,20 @@ process.stdin.on('end', () => {
       data = JSON.parse(raw);
     } catch {}
 
-    const filePath = data.file_path || data.path || '';
+    const givenPath = data.file_path || data.path || '';
 
-    if (!filePath.startsWith(HYPO_DIR + '/') && filePath !== HYPO_DIR) {
+    // Inside the vault by a path comparison on real paths, not a string prefix: a HYPO_DIR with a
+    // trailing separator, or a vault reached through a symlink, still counts. Every check below
+    // then uses the file spelled from HYPO_DIR. The .hypoignore guard checks every spelling
+    // (a pattern may name the symlink or the directory it points to); the real-path one is read.
+    const rels =
+      typeof givenPath === 'string' && givenPath ? vaultRelatives(HYPO_DIR, givenPath) : [];
+    if (rels.length === 0) {
       console.log(JSON.stringify({ continue: true, suppressOutput: true }));
       return;
     }
+    const rel = rels[0];
+    const filePath = join(HYPO_DIR, rel);
 
     // Privacy guard: refuse to emit .hypoignore-matched paths. Without this,
     // `.env*` or other secrets under HYPO_DIR are re-emitted in this hook's
@@ -48,7 +57,7 @@ process.stdin.on('end', () => {
     // FileChanged actually appears on a given machine is unmeasured, so the
     // only safe assumption is that a matched path must never be put in it.
     const patterns = loadHypoIgnore(HYPO_DIR);
-    if (patterns.length > 0 && isIgnored(filePath, HYPO_DIR, patterns)) {
+    if (patterns.length > 0 && rels.some((r) => isIgnored(join(HYPO_DIR, r), HYPO_DIR, patterns))) {
       console.log(JSON.stringify({ continue: true, suppressOutput: true }));
       return;
     }
@@ -71,7 +80,7 @@ process.stdin.on('end', () => {
     }
 
     const content = fileRaw.slice(0, MAX_CHARS);
-    const relPath = filePath.replace(HYPO_DIR + '/', '');
+    const relPath = rel;
 
     // Built inline rather than through buildOutput(): the hook reference's
     // FileChanged section documents the same two fields as its CwdChanged
@@ -95,12 +104,11 @@ process.stdin.on('end', () => {
     // this package returns watchPaths to seed that list. The watch list is
     // session-global though, not scoped to this plugin: if another hook or
     // plugin seeds it, this matcher-less group fires on every watched file,
-    // not just wiki ones. The HYPO_DIR check above (`filePath.startsWith(HYPO_DIR
-    // + '/')`, a string-prefix test that does not resolve symlinks) still
-    // returns immediately for any path that does not start with HYPO_DIR, so
-    // a watch seeded elsewhere cannot point this hook at a path outside the
-    // wiki. A symlink living inside the wiki is a separate case: its path
-    // still starts with HYPO_DIR and passes the check above, but
+    // not just wiki ones. The vaultRelatives check above still returns
+    // immediately for any path that is not inside HYPO_DIR (as given or by its
+    // real path), so a watch seeded elsewhere cannot point this hook at a path
+    // outside the wiki. A symlink living inside the wiki is a separate case:
+    // its path is inside HYPO_DIR as given and passes the check above, but
     // readFileSync follows it, so whatever that link points to, inside the
     // wiki or not, is what actually gets emitted.
     console.log(