hypomnema 1.6.2 → 1.7.0

package/scripts/query.mjs

@@ -18,8 +18,9 @@
 
 import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { join, relative, extname } from 'path';
-import { resolveHypoRoot, expandHome } from './lib/hypo-root.mjs';
+import { resolveHypoRootInfo, checkVaultOrExit, expandHome } from './lib/hypo-root.mjs';
 import { loadHypoIgnore, isScanIgnored } from './lib/hypo-ignore.mjs';
+import { currentDevice, scopeVisible, readVisibilityScope } from '../hooks/hypo-shared.mjs';
 
 // ── arg parsing ──────────────────────────────────────────────────────────────
 
@@ -31,7 +32,11 @@ function parseArgs(argv) {
     else if (arg.startsWith('--limit=')) args.limit = parseInt(arg.slice(8), 10) || 10;
     else if (arg === '--json') args.json = true;
   }
-  if (!args.hypoDir) args.hypoDir = resolveHypoRoot();
+  if (!args.hypoDir) {
+    const info = resolveHypoRootInfo();
+    args.hypoDir = info.root;
+    args.hypoDirSource = info.source;
+  }
   return args;
 }
 
@@ -95,12 +100,19 @@ if (!args.query) {
   process.exit(1);
 }
 
+// Only validate the auto-resolved path (env/marker/default). An explicit
+// --hypo-dir=<path> (tests, other tooling) is trusted as-is, valid or not.
+const vaultMissing = args.hypoDirSource
+  ? checkVaultOrExit(args.hypoDir, args.hypoDirSource)
+  : false;
+
 const terms = args.query.toLowerCase().split(/\s+/).filter(Boolean);
 const ignorePatterns = loadHypoIgnore(args.hypoDir);
 const scanDirs = ['pages', 'projects'].map((d) => join(args.hypoDir, d));
 const files = scanDirs.flatMap((d) => collectMdFiles(d, args.hypoDir, [], ignorePatterns));
 
 const results = [];
+const device = currentDevice();
 
 for (const { path, rel } of files) {
   let content;
@@ -112,6 +124,7 @@ for (const { path, rel } of files) {
   const { score, excerpt } = scoreAndExcerpt(content, terms);
   if (score === 0) continue;
   const fm = parseFrontmatter(content);
+  if (!scopeVisible(readVisibilityScope(content), device)) continue;
   results.push({
     slug: rel.replace(/\.md$/, ''),
     title: fm.title || rel,
@@ -128,8 +141,16 @@ if (args.json) {
   console.log(JSON.stringify(top, null, 2));
 } else {
   if (top.length === 0) {
-    console.log(`No results for: ${args.query}`);
-    console.log(`→ 관련 페이지가 없습니다. 새 지식이 있다면 /hypo:ingest 로 추가해 보세요.`);
+    // vaultMissing: nothing was actually scanned (no HYPO_DIR / no vault
+    // found). Both "No results for: …" and the "관련 페이지가 없습니다" CTA would
+    // misreport real knowledge as absent, so suppress the whole no-results
+    // block. The stderr notice from checkVaultOrExit already told the user why
+    // this run found nothing, and it did not search a vault to invite them to
+    // /hypo:ingest into one that may already hold the answer.
+    if (!vaultMissing) {
+      console.log(`No results for: ${args.query}`);
+      console.log(`→ 관련 페이지가 없습니다. 새 지식이 있다면 /hypo:ingest 로 추가해 보세요.`);
+    }
   } else {
     console.log(`Found ${results.length} result(s) for "${args.query}" (showing ${top.length}):\n`);
     for (const r of top) {

package/scripts/resume.mjs

@@ -30,6 +30,7 @@ import { existsSync, readFileSync, readdirSync, statSync, realpathSync } from 'f
 import { join } from 'path';
 import { resolveHypoRoot, expandHome } from './lib/hypo-root.mjs';
 import { pickProjectByCwd, collectProjectWorkingDirs } from './lib/wd-match.mjs';
+import { currentDevice, scopeVisible, readVisibilityScope } from '../hooks/hypo-shared.mjs';
 
 // ── arg parsing ──────────────────────────────────────────────────────────────
 
@@ -189,16 +190,27 @@ function resolveActiveProject(hypoDir, cwd = null) {
 
 // ── read session state ────────────────────────────────────────────────────────
 
-function readSessionState(hypoDir, project) {
-  const ssPath = join(hypoDir, 'projects', project, 'session-state.md');
-  if (!existsSync(ssPath)) return null;
-  return readFileSync(ssPath, 'utf-8');
+// Visibility guard: same contract as hypo-file-watch / hypo-session-start /
+// hypo-cwd-change. A machine-scoped page (visibility_scope: machine:<owner>) is
+// not surfaced on any machine but its owner, and /hypo:resume feeds its stdout
+// straight into the model, so it is one of those injection paths.
+//
+// `hidden` is kept distinct from "file absent" on purpose: reporting a scoped-out
+// state file as "no session-state.md found" would read as a broken vault. The
+// caller says which one it was.
+function readVisible(path, device) {
+  if (!existsSync(path)) return { content: null, hidden: false };
+  const raw = readFileSync(path, 'utf-8');
+  if (!scopeVisible(readVisibilityScope(raw), device)) return { content: null, hidden: true };
+  return { content: raw, hidden: false };
 }
 
-function readHot(hypoDir, project) {
-  const hotPath = join(hypoDir, 'projects', project, 'hot.md');
-  if (!existsSync(hotPath)) return null;
-  return readFileSync(hotPath, 'utf-8');
+function readSessionState(hypoDir, project, device) {
+  return readVisible(join(hypoDir, 'projects', project, 'session-state.md'), device);
+}
+
+function readHot(hypoDir, project, device) {
+  return readVisible(join(hypoDir, 'projects', project, 'hot.md'), device);
 }
 
 // ── main ─────────────────────────────────────────────────────────────────────
@@ -212,13 +224,23 @@ if (!project) {
   process.exit(1);
 }
 
-const sessionState = readSessionState(args.hypoDir, project);
-if (!sessionState) {
-  console.error(`Error: no session-state.md found for project "${project}"`);
+const device = currentDevice();
+
+const state = readSessionState(args.hypoDir, project, device);
+if (!state.content) {
+  if (state.hidden) {
+    console.error(
+      `Error: session-state.md for "${project}" is scoped to another machine ` +
+        `(visibility_scope). Nothing to resume on this machine (${device}).`,
+    );
+  } else {
+    console.error(`Error: no session-state.md found for project "${project}"`);
+  }
   process.exit(1);
 }
+const sessionState = state.content;
 
-const hotContent = readHot(args.hypoDir, project);
+const hotContent = readHot(args.hypoDir, project, device).content;
 
 if (args.json) {
   console.log(JSON.stringify({ project, sessionState, hot: hotContent }, null, 2));

package/scripts/stats.mjs

@@ -15,8 +15,8 @@
 
 import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { join, extname } from 'path';
-import { resolveHypoRoot, expandHome } from './lib/hypo-root.mjs';
-import { loadHypoIgnore, isIgnored, isScanIgnored } from './lib/hypo-ignore.mjs';
+import { resolveHypoRootInfo, checkVaultOrExit, expandHome } from './lib/hypo-root.mjs';
+import { loadHypoIgnore, isScanIgnored } from './lib/hypo-ignore.mjs';
 
 // ── arg parsing ──────────────────────────────────────────────────────────────
 
@@ -26,7 +26,11 @@ function parseArgs(argv) {
     if (arg.startsWith('--hypo-dir=')) args.hypoDir = expandHome(arg.slice(11));
     else if (arg === '--json') args.json = true;
   }
-  if (!args.hypoDir) args.hypoDir = resolveHypoRoot();
+  if (!args.hypoDir) {
+    const info = resolveHypoRootInfo();
+    args.hypoDir = info.root;
+    args.hypoDirSource = info.source;
+  }
   return args;
 }
 
@@ -69,11 +73,15 @@ function parseFrontmatter(content) {
   return fm;
 }
 
-function listDirs(dir) {
+// hypoDir/ignorePatterns are optional so callers that don't need scan-ignore
+// filtering (none left in this file) still work unchanged.
+function listDirs(dir, hypoDir = '', ignorePatterns = []) {
   if (!existsSync(dir)) return [];
   return readdirSync(dir).filter((e) => {
     if (e.startsWith('.')) return false;
-    return statSync(join(dir, e)).isDirectory();
+    const full = join(dir, e);
+    if (hypoDir && isScanIgnored(full, hypoDir, ignorePatterns)) return false;
+    return statSync(full).isDirectory();
   });
 }
 
@@ -88,15 +96,24 @@ function getLastActivity(hypoDir) {
 // ── main ─────────────────────────────────────────────────────────────────────
 
 const args = parseArgs(process.argv);
+// Only validate the auto-resolved path (env/marker/default). An explicit
+// --hypo-dir=<path> (tests, other tooling) is trusted as-is, valid or not.
+if (args.hypoDirSource) checkVaultOrExit(args.hypoDir, args.hypoDirSource);
 
 const ignorePatterns = loadHypoIgnore(args.hypoDir);
 const pageFiles = collectMdFiles(join(args.hypoDir, 'pages'), [], args.hypoDir, ignorePatterns);
-const projects = listDirs(join(args.hypoDir, 'projects'));
+// isScanIgnored (via listDirs' hypoDir arg): a .hyposcanignore-listed project
+// dir drops out of the project count too, same rationale as sources below.
+const projects = listDirs(join(args.hypoDir, 'projects'), args.hypoDir, ignorePatterns);
+// isScanIgnored (not isIgnored): sources counted here feed a scan-aggregation
+// report, not the commit/hook privacy gate, so a .hyposcanignore-only match
+// should drop out of the count too. Privacy semantics are preserved — an
+// .hypoignore match is still excluded, isScanIgnored only ever widens that.
 const sources = existsSync(join(args.hypoDir, 'sources'))
   ? readdirSync(join(args.hypoDir, 'sources')).filter(
       (e) =>
         !e.startsWith('.') &&
-        !isIgnored(join(args.hypoDir, 'sources', e), args.hypoDir, ignorePatterns),
+        !isScanIgnored(join(args.hypoDir, 'sources', e), args.hypoDir, ignorePatterns),
     )
   : [];
 
@@ -127,7 +144,10 @@ let adrCount = 0;
 for (const p of projects) {
   const decisionsDir = join(args.hypoDir, 'projects', p, 'decisions');
   if (existsSync(decisionsDir)) {
-    adrCount += readdirSync(decisionsDir).filter((f) => f.endsWith('.md')).length;
+    adrCount += readdirSync(decisionsDir).filter(
+      (f) =>
+        f.endsWith('.md') && !isScanIgnored(join(decisionsDir, f), args.hypoDir, ignorePatterns),
+    ).length;
   }
 }
 

package/scripts/uninstall.mjs

@@ -39,6 +39,12 @@ import {
   CODEX_TYPES,
   readExtensionPkgStateNoMutate,
   parseExtKey,
+  parseSkillKey,
+  parseSkillShaValue,
+  isFlatShaValue,
+  emptyShaMap,
+  isContainedUnder,
+  hasSymlinkAncestor,
   buildHookCommand,
 } from './lib/extensions.mjs';
 
@@ -105,8 +111,8 @@ function removeCommands(apply, force) {
 // map empties out, drop the target key; when the whole `extensions` object empties,
 // drop it too. Other targets' records (e.g. codex map during a Claude-only uninstall)
 // are never touched.
-function stripExtensionsFromPkg(pkgPath, target, removedKeys, apply) {
-  if (!existsSync(pkgPath) || removedKeys.length === 0) return false;
+function stripExtensionsFromPkg(pkgPath, target, removedKeys, apply, rewrittenKeys = new Map()) {
+  if (!existsSync(pkgPath) || (removedKeys.length === 0 && rewrittenKeys.size === 0)) return false;
   let pkg;
   try {
     pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
@@ -126,6 +132,15 @@ function stripExtensionsFromPkg(pkgPath, target, removedKeys, apply) {
       changed = true;
     }
   }
+  // A partially-uninstalled skill keeps only the files it still owns. Leaving the
+  // removed paths in the map would let a later --force run delete whatever the user
+  // has since put back at those paths.
+  for (const [key, nested] of rewrittenKeys) {
+    if (key in perTarget) {
+      perTarget[key] = nested;
+      changed = true;
+    }
+  }
   if (Object.keys(perTarget).length === 0) {
     delete extensions[target];
     changed = true;
@@ -157,6 +172,46 @@ function stripExtensionsFromPkg(pkgPath, target, removedKeys, apply) {
 // file whose on-disk SHA differs from the recorded one is user-modified and
 // preserved unless --force-extensions; a symlink/non-regular target is always
 // preserved (force does not follow them, matching install/upgrade E3's guard).
+// Remove the directories a skill removal emptied, deepest first, and finally the
+// skill root itself. Anything still holding files (user-added, or copies we
+// refused to remove) is left standing — rmdir on a non-empty directory throws and
+// we swallow it, which is exactly the "never destroy what we don't own" behavior.
+//
+// Every rmdir is guarded by the same containment + symlink-ancestor walk the file
+// removals use. Without it, a corrupt `"skills/x": {}` record plus a symlinked
+// skill dir was enough to rmdir empty directories anywhere on disk: the record
+// granted no file ownership, yet the prune still ran (codex pre-commit BLOCKER).
+function pruneSkillDirs(skillsRoot, skillRoot) {
+  if (hasSymlinkAncestor(skillsRoot, skillRoot)) return;
+  const dirs = [];
+  const collect = (dir, depth) => {
+    if (depth > 16) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue; // isDirectory() is false for a symlink here
+      const full = join(dir, e.name);
+      collect(full, depth + 1);
+      dirs.push(full);
+    }
+  };
+  collect(skillRoot, 1);
+  dirs.push(skillRoot);
+  for (const dir of dirs) {
+    if (!isContainedUnder(skillsRoot, dir)) continue;
+    if (hasSymlinkAncestor(skillsRoot, dir)) continue;
+    try {
+      rmdirSync(dir);
+    } catch {
+      // not empty (or gone) — leave it
+    }
+  }
+}
+
 function removeExtensions(target, apply, force) {
   const targetRoot = target === 'codex' ? join(HOME, '.codex') : join(HOME, '.claude');
   const types = target === 'codex' ? CODEX_TYPES : EXT_TYPES;
@@ -167,11 +222,77 @@ function removeExtensions(target, apply, force) {
 
   const removed = [];
   const removedKeys = [];
+  // Skill keys that survive in reduced form: key → the nested map of files we still
+  // own after this run.
+  const rewrittenKeys = new Map();
   const skippedUserModified = [];
   const skippedNonRegular = [];
 
   for (const [key, recordedSHA] of Object.entries(recorded)) {
     if (!recordedSHA) continue; // no ownership baseline → nothing to remove
+
+    // A directory skill records one key (`skills/<name>`) whose value is a map of
+    // per-file SHAs. parseExtKey rejects that key by design (it demands the type's
+    // file extension), so without this branch every installed skill file would be
+    // silently stranded: owned on paper, unreachable by uninstall.
+    const skillKey = types.includes('skills') ? parseSkillKey(key) : null;
+    if (skillKey) {
+      const nested = parseSkillShaValue(recordedSHA);
+      // A corrupt value grants no ownership: remove nothing, and do NOT prune —
+      // pruning on an empty/invalid record is destructive power the record never
+      // earned.
+      if (!nested || Object.keys(nested).length === 0) continue;
+      const skillsRoot = join(targetRoot, 'skills');
+      const skillRoot = join(skillsRoot, skillKey.installDir);
+      // What the record must still claim after this run. A file we removed drops
+      // out; a file we preserved stays. Keeping a removed path in the record is not
+      // cosmetic: a later --force run deletes whatever now sits at that path,
+      // including a brand-new file the user created there (codex fix-verify BLOCKER).
+      const remaining = emptyShaMap();
+      let removedAny = false;
+      const preserve = (rel, sha, path, bucket) => {
+        remaining[rel] = sha;
+        bucket.push(path);
+      };
+      for (const [rel, sha] of Object.entries(nested)) {
+        const fullPath = join(skillRoot, ...rel.split('/'));
+        // Same containment + symlink-ancestor guard the sync path uses: a lexical
+        // check alone cannot see a symlinked directory in the middle of the path.
+        if (!isContainedUnder(skillRoot, fullPath) || hasSymlinkAncestor(skillsRoot, fullPath)) {
+          preserve(rel, sha, fullPath, skippedNonRegular);
+          continue;
+        }
+        if (!existsSync(fullPath)) continue; // already gone: the claim goes too
+        if (!isRegularFile(fullPath)) {
+          preserve(rel, sha, fullPath, skippedNonRegular);
+          continue;
+        }
+        const buf = readFileIfRegular(fullPath);
+        const fileSha = buf ? sha256(buf) : null;
+        if (fileSha === sha || force) {
+          if (apply) rmSync(fullPath);
+          removed.push(fullPath);
+          removedAny = true;
+        } else {
+          preserve(rel, sha, fullPath, skippedUserModified);
+        }
+      }
+      // Prune the directories we emptied, deepest first. A skill dir still holding
+      // user files (or files we refused to remove) is left in place.
+      if (apply && removedAny) pruneSkillDirs(skillsRoot, skillRoot);
+      // Retire the key outright only when nothing is left to claim. Otherwise rewrite
+      // it down to just the preserved files: dropping the whole key would disown them
+      // forever, and keeping the whole key would leave stale claims on paths we no
+      // longer own.
+      if (Object.keys(remaining).length === 0) removedKeys.push(key);
+      else rewrittenKeys.set(key, remaining);
+      continue;
+    }
+
+    // A flat key's value must be a plain hex SHA. Anything else (an object parked
+    // there by a corrupt pkg-json) grants no ownership — otherwise --force would
+    // remove the file on the strength of a value we never wrote.
+    if (!isFlatShaValue(recordedSHA)) continue;
     const parsed = parseExtKey(key, types);
     if (!parsed) continue; // untrusted / cross-target key → never join+rm
     const fullPath = join(targetRoot, parsed.type, parsed.installFile);
@@ -193,7 +314,7 @@ function removeExtensions(target, apply, force) {
       skippedUserModified.push(fullPath);
     }
   }
-  return { target, removed, removedKeys, skippedUserModified, skippedNonRegular };
+  return { target, removed, removedKeys, rewrittenKeys, skippedUserModified, skippedNonRegular };
 }
 
 // True iff `pkg.json` still holds extensions state for a target the current
@@ -478,6 +599,7 @@ let codexExtResult = {
   target: 'codex',
   removed: [],
   removedKeys: [],
+  rewrittenKeys: new Map(),
   skippedUserModified: [],
   skippedNonRegular: [],
 };
@@ -497,10 +619,23 @@ if (args.codex) {
   );
 }
 
-// Surgical per-target ext SHA strip — only for files we actually removed.
-stripExtensionsFromPkg(pkgJsonPath, 'claude', claudeExtResult.removedKeys, args.apply);
+// Surgical per-target ext SHA strip — only for files we actually removed. A skill
+// we uninstalled only partway is rewritten down to the files we still own.
+stripExtensionsFromPkg(
+  pkgJsonPath,
+  'claude',
+  claudeExtResult.removedKeys,
+  args.apply,
+  claudeExtResult.rewrittenKeys,
+);
 if (args.codex) {
-  stripExtensionsFromPkg(pkgJsonPath, 'codex', codexExtResult.removedKeys, args.apply);
+  stripExtensionsFromPkg(
+    pkgJsonPath,
+    'codex',
+    codexExtResult.removedKeys,
+    args.apply,
+    codexExtResult.rewrittenKeys,
+  );
 }
 
 // pkg.json metadata file removal — only when no user-tracked state remains.