memgineering 0.25.3 → 0.27.0

package/dist/index.js

@@ -1325,8 +1325,8 @@ var init_exclude = __esm({
       [...ALWAYS_SKIP_DIRS].map((d) => fold(d))
     );
     ALWAYS_SKIP_SEGMENTS_FOLDED = ALWAYS_SKIP_SEGMENTS.map((s) => fold(s));
-    ALWAYS_SKIP_FILE = (basename4) => {
-      const b = fold(basename4);
+    ALWAYS_SKIP_FILE = (basename5) => {
+      const b = fold(basename5);
       return b.startsWith(".env") || b === ".ds_store" || b === ".memgdeny" || b === ".memgallow" || b === ".memgignore";
     };
     EMPTY_IGNORE_SET = { rules: [], unsupported: [] };
@@ -4971,9 +4971,112 @@ var init_version = __esm({
   }
 });
 
+// ../../packages/storage-adapter/src/local-file/atomic.ts
+import { rename as rename2, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+async function writeThenRename(abs, content) {
+  const tmp = `${abs}.${process.pid}.tmp`;
+  try {
+    await writeFile2(tmp, content, { encoding: "utf8", mode: 384 });
+    await rename2(tmp, abs);
+  } catch (err) {
+    await rm3(tmp, { force: true });
+    throw err;
+  }
+}
+var init_atomic = __esm({
+  "../../packages/storage-adapter/src/local-file/atomic.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/path-lock.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { readdir as readdir2, readFile as readFile3, stat, unlink, writeFile as writeFile3 } from "fs/promises";
+import { basename, dirname as dirname2, join as join5 } from "path";
+async function lockHolder(path) {
+  try {
+    const [info, token] = await Promise.all([stat(path), readFile3(path, "utf8")]);
+    return { token, ageMs: Date.now() - info.mtimeMs };
+  } catch {
+    return null;
+  }
+}
+async function unlinkIfStill(path, token) {
+  const now = await readFile3(path, "utf8").catch(() => null);
+  if (now === token) await unlink(path).catch(() => void 0);
+}
+async function takeOver(path, dead) {
+  const takeoverPath = `${path}.takeover`;
+  try {
+    await writeFile3(takeoverPath, "", { flag: "wx", mode: 384 });
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      const age = await stat(takeoverPath).then(
+        (info) => Date.now() - info.mtimeMs,
+        () => null
+      );
+      if (age !== null && age > STALE_LOCK_MS) await unlink(takeoverPath).catch(() => void 0);
+    }
+    return false;
+  }
+  try {
+    const held = await lockHolder(path);
+    if (held !== null && held.token === dead && held.ageMs > STALE_LOCK_MS) {
+      await unlink(path).catch(() => void 0);
+    }
+    return true;
+  } finally {
+    await unlink(takeoverPath).catch(() => void 0);
+  }
+}
+async function withPathLock(path, fn, waitMs = 0) {
+  const token = `${process.pid}-${randomUUID2()}`;
+  const deadline = Date.now() + waitMs;
+  for (let vanished = 0; ; ) {
+    try {
+      await writeFile3(path, token, { flag: "wx", mode: 384 });
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST") return null;
+    }
+    const held = await lockHolder(path);
+    if (held === null) {
+      vanished += 1;
+      if (vanished > 20) return null;
+      continue;
+    }
+    if (held.ageMs > STALE_LOCK_MS && await takeOver(path, held.token)) continue;
+    if (Date.now() >= deadline) return null;
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  try {
+    return await fn();
+  } finally {
+    await unlinkIfStill(path, token);
+  }
+}
+async function clearStaleTemps(path) {
+  const dir = dirname2(path);
+  const prefix = `${basename(path)}.`;
+  const names = await readdir2(dir).catch(() => []);
+  await Promise.all(
+    names.filter((n) => n.startsWith(prefix) && /\.\d+\.tmp$/.test(n)).map(async (n) => {
+      const age = await stat(join5(dir, n)).then((s) => Date.now() - s.mtimeMs).catch(() => 0);
+      if (age > STALE_LOCK_MS) await unlink(join5(dir, n)).catch(() => void 0);
+    })
+  );
+}
+var STALE_LOCK_MS;
+var init_path_lock = __esm({
+  "src/lib/path-lock.ts"() {
+    "use strict";
+    STALE_LOCK_MS = 3e4;
+  }
+});
+
 // src/lib/credentials.ts
-import { mkdir as mkdir3, readFile as readFile3, unlink, writeFile as writeFile2 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir3, readFile as readFile4, unlink as unlink2 } from "fs/promises";
+import { join as join6 } from "path";
 import { z as z6 } from "zod";
 function registryFromClaim(raw) {
   const parsed = RegistryCredentialsSchema.omit({ linked_at: true }).safeParse(raw);
@@ -4981,34 +5084,53 @@ function registryFromClaim(raw) {
   return { ...parsed.data, linked_at: (/* @__PURE__ */ new Date()).toISOString() };
 }
 function credentialsPath() {
-  return join5(brandHome(), "credentials.json");
+  return join6(brandHome(), "credentials.json");
 }
 async function readCredentials() {
   try {
     const parsed = CredentialsSchema.safeParse(
-      JSON.parse(await readFile3(credentialsPath(), "utf8"))
+      JSON.parse(await readFile4(credentialsPath(), "utf8"))
     );
     return parsed.success ? parsed.data : null;
   } catch {
     return null;
   }
 }
+async function underLock(change) {
+  const held = await withPathLock(
+    join6(brandHome(), "credentials.lock"),
+    async () => ({ result: await change() }),
+    LOCK_WAIT_MS
+  );
+  return held === null ? change() : held.result;
+}
+async function writeWhole(credentials) {
+  await clearStaleTemps(credentialsPath());
+  await writeThenRename(credentialsPath(), `${JSON.stringify(credentials, null, 2)}
+`);
+}
 async function saveCredentials(credentials) {
   await mkdir3(brandHome(), { recursive: true });
-  await unlink(credentialsPath()).catch(() => void 0);
-  await writeFile2(credentialsPath(), JSON.stringify(credentials, null, 2) + "\n", {
-    encoding: "utf8",
-    mode: 384
+  await underLock(() => writeWhole(credentials));
+}
+async function saveRotatedRegistry(sent, rotated) {
+  return underLock(async () => {
+    const stored = await readCredentials();
+    if (stored?.registry === void 0 || stored.registry.refresh_token !== sent) return false;
+    await writeWhole({ ...stored, registry: { ...stored.registry, ...rotated } });
+    return true;
   });
 }
 async function clearCredentials() {
-  await unlink(credentialsPath()).catch(() => void 0);
+  await underLock(() => unlink2(credentialsPath()).catch(() => void 0));
 }
-var RegistryCredentialsSchema, CredentialsSchema;
+var RegistryCredentialsSchema, CredentialsSchema, LOCK_WAIT_MS;
 var init_credentials = __esm({
   "src/lib/credentials.ts"() {
     "use strict";
+    init_atomic();
     init_brand();
+    init_path_lock();
     RegistryCredentialsSchema = z6.object({
       api_url: z6.string().min(1),
       refresh_token: z6.string().min(1),
@@ -5032,20 +5154,21 @@ var init_credentials = __esm({
        */
       registry: RegistryCredentialsSchema.optional().catch(void 0)
     });
+    LOCK_WAIT_MS = 2e3;
   }
 });
 
 // src/lib/pending-login.ts
-import { mkdir as mkdir4, readFile as readFile4, unlink as unlink2, writeFile as writeFile3 } from "fs/promises";
-import { join as join6 } from "path";
+import { mkdir as mkdir4, readFile as readFile5, unlink as unlink3, writeFile as writeFile4 } from "fs/promises";
+import { join as join7 } from "path";
 import { z as z7 } from "zod";
 function pendingLoginPath() {
-  return join6(brandHome(), "pending-login.json");
+  return join7(brandHome(), "pending-login.json");
 }
 async function readPendingLogin() {
   try {
     const parsed = PendingLoginSchema.safeParse(
-      JSON.parse(await readFile4(pendingLoginPath(), "utf8"))
+      JSON.parse(await readFile5(pendingLoginPath(), "utf8"))
     );
     return parsed.success ? parsed.data : null;
   } catch {
@@ -5054,14 +5177,14 @@ async function readPendingLogin() {
 }
 async function savePendingLogin(pending) {
   await mkdir4(brandHome(), { recursive: true });
-  await unlink2(pendingLoginPath()).catch(() => void 0);
-  await writeFile3(pendingLoginPath(), JSON.stringify(pending, null, 2) + "\n", {
+  await unlink3(pendingLoginPath()).catch(() => void 0);
+  await writeFile4(pendingLoginPath(), JSON.stringify(pending, null, 2) + "\n", {
     encoding: "utf8",
     mode: 384
   });
 }
 async function clearPendingLogin() {
-  await unlink2(pendingLoginPath()).catch(() => void 0);
+  await unlink3(pendingLoginPath()).catch(() => void 0);
 }
 function pendingExpired(pending, now = Date.now()) {
   return Math.floor(now / 1e3) >= pending.expires_at_epoch;
@@ -5329,27 +5452,9 @@ var init_api_client = __esm({
   }
 });
 
-// ../../packages/storage-adapter/src/local-file/atomic.ts
-import { rename as rename2, rm as rm3, writeFile as writeFile4 } from "fs/promises";
-async function writeThenRename(abs, content) {
-  const tmp = `${abs}.${process.pid}.tmp`;
-  try {
-    await writeFile4(tmp, content, { encoding: "utf8", mode: 384 });
-    await rename2(tmp, abs);
-  } catch (err) {
-    await rm3(tmp, { force: true });
-    throw err;
-  }
-}
-var init_atomic = __esm({
-  "../../packages/storage-adapter/src/local-file/atomic.ts"() {
-    "use strict";
-  }
-});
-
 // src/lib/config.ts
-import { mkdir as mkdir5, readFile as readFile5 } from "fs/promises";
-import { join as join7, resolve } from "path";
+import { mkdir as mkdir5, readFile as readFile6 } from "fs/promises";
+import { join as join8, resolve } from "path";
 import { z as z8 } from "zod";
 function withDefaultBrain(brain) {
   if (brain.default) return brain;
@@ -5357,11 +5462,11 @@ function withDefaultBrain(brain) {
   return oldest ? { ...brain, default: oldest.root } : brain;
 }
 function configPath() {
-  return join7(brandHome(), "config.json");
+  return join8(brandHome(), "config.json");
 }
 async function loadConfig() {
   try {
-    const parsed = ConfigSchema.safeParse(JSON.parse(await readFile5(configPath(), "utf8")));
+    const parsed = ConfigSchema.safeParse(JSON.parse(await readFile6(configPath(), "utf8")));
     return parsed.success ? parsed.data : EMPTY_CONFIG;
   } catch {
     return EMPTY_CONFIG;
@@ -5541,6 +5646,13 @@ var init_config = __esm({
          * Absent on a machine set up before it was recorded.
          */
         hook: z8.enum(["on", "off"]).optional().catch(void 0),
+        /**
+         * Which "left your hooks alone" notices the automatic hook refresh has
+         * already given, as `<file>:<reason>` — so a symlinked or unparseable
+         * settings file is mentioned once, not at the start of every session
+         * (lib/hook-refresh.ts, `refreshNotice`).
+         */
+        hookNoticesTold: z8.array(z8.string()).optional().catch(void 0),
         /**
          * Notes `setup --web` was asked to upload, not yet sent.
          *
@@ -5738,8 +5850,8 @@ var init_cloud_brain = __esm({
 });
 
 // ../../packages/storage-adapter/src/local-file/walk.ts
-import { lstat, readdir as readdir3, realpath } from "fs/promises";
-import { join as join9, relative, resolve as resolve2, sep } from "path";
+import { lstat, readdir as readdir4, realpath } from "fs/promises";
+import { join as join10, relative, resolve as resolve2, sep } from "path";
 async function walkVault(root, opts = {}) {
   const maxDepth = opts.maxDepth ?? DEFAULT_MAX_DEPTH;
   const rootAbs = resolve2(root);
@@ -5751,7 +5863,7 @@ async function walkVault(root, opts = {}) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = await readdir3(dirAbs, { withFileTypes: true });
+      entries = await readdir4(dirAbs, { withFileTypes: true });
     } catch {
       return;
     }
@@ -5768,7 +5880,7 @@ async function walkVault(root, opts = {}) {
         continue;
       }
       if (isDir) {
-        await visit(join9(dirAbs, entry.name), rel, depth + 1);
+        await visit(join10(dirAbs, entry.name), rel, depth + 1);
       } else if (entry.isFile()) {
         files2.push(rel);
       }
@@ -5799,7 +5911,7 @@ async function resolveRealInside(root, relPath, seenDirs) {
   const segments = relativeTo(rootAbs, abs).split("/");
   let cursor = rootAbs;
   for (const [i, segment] of segments.entries()) {
-    cursor = join9(cursor, segment);
+    cursor = join10(cursor, segment);
     const isLast = i === segments.length - 1;
     if (!isLast && seenDirs?.has(cursor)) continue;
     const st = await lstat(cursor);
@@ -5823,7 +5935,7 @@ var init_walk = __esm({
 });
 
 // ../../packages/storage-adapter/src/local-file/rules-file.ts
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 import { parse as parseYaml3 } from "yaml";
 function requireStringList(value, key2) {
   if (value === void 0 || value === null) return [];
@@ -5862,7 +5974,7 @@ function ignoreSetFrom(entries) {
 async function readRulesFile(root) {
   let raw;
   try {
-    raw = await readFile7(resolveInside(root, RULES_FILE), "utf8");
+    raw = await readFile8(resolveInside(root, RULES_FILE), "utf8");
   } catch (err) {
     if (err?.code === "ENOENT") return EMPTY_VAULT_RULES;
     throw new RulesFileError(
@@ -5968,7 +6080,7 @@ edit.
 
 // ../../packages/storage-adapter/src/local-file/adapter.ts
 import { createHash as createHash4 } from "crypto";
-import { lstat as lstat2, readFile as readFile8 } from "fs/promises";
+import { lstat as lstat2, readFile as readFile9 } from "fs/promises";
 var LocalFileReadAdapter;
 var init_adapter = __esm({
   "../../packages/storage-adapter/src/local-file/adapter.ts"() {
@@ -6088,7 +6200,7 @@ var init_adapter = __esm({
       /** Read `.memgdeny` / `.memgallow`. Missing is fine; unreadable is not. */
       static async readDenyFile(root, name) {
         try {
-          return parseDenyFile(await readFile8(resolveInside(root, name), "utf8"));
+          return parseDenyFile(await readFile9(resolveInside(root, name), "utf8"));
         } catch (err) {
           if (err?.code === "ENOENT") return EMPTY_DENY_LIST;
           throw err;
@@ -6107,7 +6219,7 @@ var init_adapter = __esm({
       static async readIgnoreFiles(root) {
         const load = async (name) => {
           try {
-            return parseIgnoreFile(await readFile8(resolveInside(root, name), "utf8"));
+            return parseIgnoreFile(await readFile9(resolveInside(root, name), "utf8"));
           } catch (err) {
             if (err?.code === "ENOENT") return EMPTY_IGNORE_SET;
             throw err;
@@ -6143,7 +6255,7 @@ var init_adapter = __esm({
         }
         const st = await lstat2(abs);
         if (!st.isFile()) throw new Error(`not a regular file: ${path}`);
-        const bytes = await readFile8(abs);
+        const bytes = await readFile9(abs);
         if (this.#protect) {
           let hits = secretContentHits(bytes.toString("utf8"));
           if (isExactlyListed(rel, this.#allow)) {
@@ -6251,8 +6363,8 @@ var init_adapter = __esm({
 });
 
 // src/lib/vault.ts
-import { readFile as readFile9, realpath as realpath2, stat } from "fs/promises";
-import { dirname as dirname2, isAbsolute, join as join10, resolve as resolve3 } from "path";
+import { readFile as readFile10, realpath as realpath2, stat as stat2 } from "fs/promises";
+import { dirname as dirname3, isAbsolute, join as join11, resolve as resolve3 } from "path";
 async function resolveBrain(explicit, cwd = process.cwd()) {
   const cfg = await loadConfig();
   const brains = cfg.brain.brains;
@@ -6317,7 +6429,7 @@ A folder marked (missing) is not on disk right now. If it is gone for good, \`me
 }
 async function liveBrains(brains) {
   const checked = await Promise.all(
-    brains.map(async (b) => (await stat(b.root).catch(() => null))?.isDirectory() ? b : null)
+    brains.map(async (b) => (await stat2(b.root).catch(() => null))?.isDirectory() ? b : null)
   );
   return checked.filter((b) => b !== null);
 }
@@ -6332,9 +6444,9 @@ function isInside(child, parent) {
 async function readPointer(cwd) {
   let dir = resolve3(cwd);
   for (; ; ) {
-    const candidate = join10(dir, BRAND.pointerFileName);
+    const candidate = join11(dir, BRAND.pointerFileName);
     try {
-      const raw = (await readFile9(candidate, "utf8")).trim();
+      const raw = (await readFile10(candidate, "utf8")).trim();
       const target = raw.split("\n")[0]?.trim();
       if (target) {
         return {
@@ -6344,7 +6456,7 @@ async function readPointer(cwd) {
       }
     } catch {
     }
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -6401,7 +6513,8 @@ function heldBack(scan) {
     byName,
     explicitly,
     byRule,
-    symlinked
+    symlinked,
+    otherSymlinks: scan.skippedSymlinks.filter((path) => !isNote(path))
   };
 }
 function heldBackJson(held, totalKey = "not_sent") {
@@ -6418,7 +6531,9 @@ function heldBackJson(held, totalKey = "not_sent") {
     // Present so a zero total can be read correctly. A non-empty list here means
     // the count above is a floor, not the answer — nothing inside these was
     // walked, so nobody knows how many notes they hold.
-    excluded_folders: held.folders
+    excluded_folders: held.folders,
+    // The same floor for links: a symlinked folder of notes was never walked.
+    skipped_other_symlinks: held.otherSymlinks
   };
 }
 function heldBackGroups(held) {
@@ -6444,11 +6559,14 @@ function describeHeldBack(held) {
     ),
     ...held.folders.map(
       (dir) => `${oneLine(dir, WIDTH.path)}/  \u2014 an excluded folder, whose contents were never walked`
+    ),
+    ...held.otherSymlinks.map(
+      (path) => `${oneLine(path, WIDTH.path)}  \u2014 a symlink, never followed; a folder behind it was never walked`
     )
   ];
 }
 function printHeldBack(held, wording) {
-  if (held.total === 0 && held.folders.length === 0) return;
+  if (held.total === 0 && held.folders.length === 0 && held.otherSymlinks.length === 0) return;
   const guessed = held.byName;
   const chosen = heldBackGroups(held).filter(({ label }) => label !== NAME_GUESS_LABEL);
   const chosenCount = chosen.reduce((n, g) => n + g.rows.length, 0);
@@ -6502,6 +6620,21 @@ ${chosenCount} note(s) are not in ${wording.where}, because your rules say so:`
       )
     );
   }
+  if (held.otherSymlinks.length > 0) {
+    printHuman(
+      c.gray(
+        `
+${held.otherSymlinks.length} symlink(s) were not followed, so nothing behind them is in ${wording.where} \u2014
+  a folder of notes behind one is not counted above:`
+      )
+    );
+    for (const path of held.otherSymlinks.slice(0, 10)) {
+      printHuman(c.gray(`    ${oneLine(path, WIDTH.path)}`));
+    }
+    if (held.otherSymlinks.length > 10) {
+      printHuman(c.gray(`    \u2026 and ${held.otherSymlinks.length - 10} more`));
+    }
+  }
 }
 var isNote, NAME_GUESS_LABEL;
 var init_held_back = __esm({
@@ -6530,8 +6663,8 @@ var init_index_build = __esm({
 });
 
 // src/commands/init.ts
-import { mkdir as mkdir9, readdir as readdir5, writeFile as writeFile7 } from "fs/promises";
-import { join as join15, resolve as resolve6 } from "path";
+import { mkdir as mkdir9, readdir as readdir6, writeFile as writeFile7 } from "fs/promises";
+import { join as join16, resolve as resolve6 } from "path";
 import { Command as Command4 } from "commander";
 function initCommand() {
   return new Command4("init").description("create a new brain, laid out and ready to write into").argument("<path>", "where the brain should live").option("--name <name>", "what to call it in the hub", "My brain").action(async (path, opts) => {
@@ -6566,7 +6699,7 @@ function initCommand() {
 }
 async function createBrain(path, name) {
   const root = resolve6(path);
-  const existing = await readdir5(root).catch(() => null);
+  const existing = await readdir6(root).catch(() => null);
   if (existing && existing.filter((e) => !e.startsWith(".")).length > 0) {
     throw memgError(
       "already_initialized",
@@ -6576,9 +6709,9 @@ async function createBrain(path, name) {
     );
   }
   await mkdir9(root, { recursive: true });
-  for (const dir of FOLDERS) await mkdir9(join15(root, dir), { recursive: true });
+  for (const dir of FOLDERS) await mkdir9(join16(root, dir), { recursive: true });
   for (const [file, content] of Object.entries(files(name))) {
-    await writeFile7(join15(root, file), content, "utf8");
+    await writeFile7(join16(root, file), content, "utf8");
   }
   const canonicalRoot2 = await canonicalize(root);
   const adapter = await LocalFileReadAdapter.openVault(canonicalRoot2);
@@ -6732,8 +6865,8 @@ var init_cloud_pointer = __esm({
 });
 
 // src/commands/link.ts
-import { readFile as readFile18 } from "fs/promises";
-import { join as join17 } from "path";
+import { readFile as readFile19 } from "fs/promises";
+import { join as join19 } from "path";
 import { Command as Command13 } from "commander";
 import prompts2 from "prompts";
 function sameBasename(all, entry) {
@@ -6937,7 +7070,7 @@ async function recordLink(adapter, observationsDir) {
 }
 async function refuseSilentRules(path, denied, excluded, unsupported) {
   const denyEntries = (await LocalFileReadAdapter.readDenyFile(path, ".memgdeny")).entries;
-  const rawDenyLines = await readFile18(join17(path, ".memgdeny"), "utf8").then(
+  const rawDenyLines = await readFile19(join19(path, ".memgdeny"), "utf8").then(
     (t) => t.split("\n").map((l) => l.trim()).filter((l) => l !== "" && !l.startsWith("#"))
   ).catch(() => []);
   const asWritten = (folded) => rawDenyLines.find(
@@ -7565,6 +7698,155 @@ var init_push = __esm({
   }
 });
 
+// src/lib/guard-shell.ts
+function guardHookCommand() {
+  return `/bin/sh -c '${GUARD_SHELL_SCRIPT}'`;
+}
+var GUARD_SHELL_SCRIPT;
+var init_guard_shell = __esm({
+  "src/lib/guard-shell.ts"() {
+    "use strict";
+    GUARD_SHELL_SCRIPT = [
+      'h="${MEMGINEERING_HOME-$HOME/.memgineering}"',
+      'f="$h/guard/fast"',
+      'c="$h/config.json"',
+      'k="$h/credentials.json"',
+      "g() { memgineering guard; exit 0; }",
+      '[ -f "$c" ] && [ -f "$k" ] && [ -d "$f" ] || g',
+      "p=$(cat)",
+      'go() { printf "%s\\n" "$p" | g; exit 0; }',
+      '[ -n "$p" ] || exit 0',
+      'q=\\"',
+      'case "$p" in */memory/* | *"$q"memory/* | *"\\\\/memory\\\\/"* | *"$q"memory\\\\/*) go ;; esac',
+      'w=${p%%"$q"*}',
+      'r=${p#"$w"}',
+      'case "$r" in "$q"session_id"$q"*) ;; *) go ;; esac',
+      'r=${r#"$q"session_id"$q"}',
+      "w=${r%%[![:space:]]*}",
+      'r=${r#"$w"}',
+      'case "$r" in :*) ;; *) go ;; esac',
+      "r=${r#:}",
+      "w=${r%%[![:space:]]*}",
+      'r=${r#"$w"}',
+      'case "$r" in "$q"*) ;; *) go ;; esac',
+      'r=${r#"$q"}',
+      's=${r%%"$q"*}',
+      'case "$s" in "" | *[!A-Za-z0-9-]*) go ;; esac',
+      'm=""',
+      'if [ -f "$f/$s" ]; then m="$f/$s"; else',
+      '  n=""',
+      '  for e in "$f/$s".empty.*; do',
+      '    [ -f "$e" ] || continue',
+      "    t=${e##*.}",
+      '    case "$t" in "" | *[!0-9]*) continue ;; esac',
+      '    [ -n "$n" ] || n=$(date +%s)',
+      '    if [ "$t" -gt "$n" ]; then m="$e"; break; fi',
+      "  done",
+      '  [ -n "$m" ] || go',
+      '  [ "$f/.rules-changed" -nt "$m" ] && go',
+      "fi",
+      '[ "$c" -nt "$m" ] && go',
+      '[ "$k" -nt "$m" ] && go',
+      "exit 0"
+    ].join("\n");
+  }
+});
+
+// src/lib/hook-refresh.ts
+import { chmod, lstat as lstat5, readFile as readFile25 } from "fs/promises";
+import { join as join25 } from "path";
+function moveShippedCommands(parsed, moves) {
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const settings = parsed;
+  const hooks = settings["hooks"];
+  if (hooks === void 0) return { next: settings, changed: 0 };
+  if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks)) return null;
+  let changed = 0;
+  const nextHooks = { ...hooks };
+  for (const move of moves) {
+    const groups = nextHooks[move.event];
+    if (!Array.isArray(groups)) continue;
+    nextHooks[move.event] = groups.map((group) => {
+      const entries = group?.hooks;
+      if (!Array.isArray(entries)) return group;
+      let touched = false;
+      const nextEntries = entries.map((entry) => {
+        const command = entry?.command;
+        if (typeof command !== "string" || command === move.to || !move.from.includes(command)) {
+          return entry;
+        }
+        touched = true;
+        changed += 1;
+        return { ...entry, command: move.to };
+      });
+      return touched ? { ...group, hooks: nextEntries } : group;
+    });
+  }
+  return { next: changed === 0 ? settings : { ...settings, hooks: nextHooks }, changed };
+}
+function withHookFileLock(fn, waitMs = 0) {
+  return withPathLock(join25(brandHome(), "hook-files.lock"), fn, waitMs);
+}
+async function readSettings(path) {
+  const raw = await readFile25(path, "utf8").catch(() => null);
+  if (raw === null) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function refreshHookFile(path, moves) {
+  const info = await lstat5(path).catch(() => null);
+  if (info === null) return "missing";
+  if (info.isSymbolicLink()) return "symlink";
+  await clearStaleTemps(path);
+  const first = moveShippedCommands(await readSettings(path), moves);
+  if (first === null) return "refused";
+  if (first.changed === 0) return "unchanged";
+  const outcome = await withHookFileLock(async () => {
+    const again = moveShippedCommands(await readSettings(path), moves);
+    if (again === null) return "refused";
+    if (again.changed === 0) return "unchanged";
+    await writeThenRename(path, `${JSON.stringify(again.next, null, 2)}
+`);
+    await chmod(path, info.mode & 4095).catch(() => void 0);
+    return "changed";
+  });
+  return outcome ?? "busy";
+}
+function refreshNotice(report3, told) {
+  const lines2 = [];
+  if (report3.changed.length > 0) {
+    lines2.push(
+      `memgineering brought its own hooks up to this version in ${report3.changed.join(", ")} \u2014 the before-edit check now answers an already-served session without starting node.`
+    );
+    if (report3.changed.some((p) => /[/\\]\.codex[/\\]hooks\.json$/.test(p))) {
+      lines2.push(
+        "Codex will ask to review the changed hook the next time it starts: trust it (press `t`) \u2014 until then neither memgineering hook runs in Codex."
+      );
+    }
+  }
+  const nowTold = [...told];
+  for (const skip of report3.skipped) {
+    const key2 = `${skip.path}:${skip.why}`;
+    if (nowTold.includes(key2)) continue;
+    nowTold.push(key2);
+    lines2.push(
+      skip.why === "symlink" ? `memgineering left its hooks in ${skip.path} as they are: the file is a link, and rewriting it would replace the link. \`memgineering setup\` updates them when you want it to.` : `memgineering left its hooks in ${skip.path} as they are: the file does not parse as JSON. Fix it, then \`memgineering setup\` updates them.`
+    );
+  }
+  return { text: lines2.length === 0 ? null : lines2.join("\n"), told: nowTold };
+}
+var init_hook_refresh = __esm({
+  "src/lib/hook-refresh.ts"() {
+    "use strict";
+    init_atomic();
+    init_brand();
+    init_path_lock();
+  }
+});
+
 // src/commands/setup-brain.ts
 function migration(localBrains) {
   return ` They also keep ${localBrains} brain(s) in folders on this machine. Offer moving those notes to the account instead of starting empty: \`memgineering push --brain <name>\` uploads a folder into a hosted brain and points here (nothing local is deleted), then \`memgineering reindex\` makes the moved notes searchable by meaning. The memgineering-setup skill has the migration steps.`;
@@ -7899,38 +8181,38 @@ var init_setup_signin = __esm({
 });
 
 // src/lib/next-step.ts
-import { mkdir as mkdir15, readFile as readFile24, writeFile as writeFile13 } from "fs/promises";
-import { join as join23 } from "path";
+import { mkdir as mkdir16, readFile as readFile26, writeFile as writeFile14 } from "fs/promises";
+import { join as join26 } from "path";
 function isSetUp(cfg) {
   return Object.keys(cfg.system.installed).length > 0;
 }
 function connectedMarker(at) {
-  return join23(brandHome(), `setup-connected-shown-${at.replace(/[^0-9A-Za-z]/g, "")}`);
+  return join26(brandHome(), `setup-connected-shown-${at.replace(/[^0-9A-Za-z]/g, "")}`);
 }
 async function connectedNoticeShown(at) {
-  return readFile24(connectedMarker(at), "utf8").then(
+  return readFile26(connectedMarker(at), "utf8").then(
     () => true,
     () => false
   );
 }
 async function markConnectedNoticeShown(at) {
   try {
-    await mkdir15(brandHome(), { recursive: true });
-    await writeFile13(connectedMarker(at), `${(/* @__PURE__ */ new Date()).toISOString()}
+    await mkdir16(brandHome(), { recursive: true });
+    await writeFile14(connectedMarker(at), `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   } catch {
   }
 }
 async function claimFullSetupNotice() {
-  const marker = join23(brandHome(), "setup-notice-shown");
+  const marker = join26(brandHome(), "setup-notice-shown");
   try {
-    await readFile24(marker, "utf8");
+    await readFile26(marker, "utf8");
     return false;
   } catch {
   }
   try {
-    await mkdir15(brandHome(), { recursive: true });
-    await writeFile13(marker, `${(/* @__PURE__ */ new Date()).toISOString()}
+    await mkdir16(brandHome(), { recursive: true });
+    await writeFile14(marker, `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   } catch {
   }
@@ -8096,12 +8378,12 @@ Synced instead? \`memgineering login\`, then \`memgineering create <name>\`.`;
 // src/lib/provenance.ts
 import { execFile, spawn as spawn2 } from "child_process";
 import { realpath as realpath3 } from "fs/promises";
-import { dirname as dirname8, join as join24, resolve as resolve14 } from "path";
+import { dirname as dirname9, join as join27, resolve as resolve14 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { promisify } from "util";
 async function detectProvenance(selfPath, opts = {}) {
   const entry = selfPath ?? fileURLToPath2(import.meta.url);
-  const selfDir = await realpath3(dirname8(entry)).catch(() => dirname8(entry));
+  const selfDir = await realpath3(dirname9(entry)).catch(() => dirname9(entry));
   if (/[\\/]_npx[\\/]|[\\/]\.npm[\\/]_cacache[\\/]/.test(selfDir)) {
     return {
       kind: "npx",
@@ -8219,7 +8501,7 @@ function isInside2(child, parent) {
 }
 async function unreachableByName(selfPath) {
   const entry = selfPath ?? fileURLToPath2(import.meta.url);
-  const selfDir = await realpath3(dirname8(entry)).catch(() => dirname8(entry));
+  const selfDir = await realpath3(dirname9(entry)).catch(() => dirname9(entry));
   if (!/[\\/](node_modules|_npx|_cacache)[\\/]/.test(`${selfDir}/`)) return null;
   const p = await detectProvenance(entry);
   return p.kind === "local" || p.kind === "npx" ? p.reason : null;
@@ -8234,7 +8516,7 @@ var init_provenance = __esm({
         kind: "npm",
         bin: "npm",
         prefixArgs: ["prefix", "-g"],
-        moduleRoot: (prefix) => process.platform === "win32" ? join24(prefix, "node_modules") : join24(prefix, "lib", "node_modules"),
+        moduleRoot: (prefix) => process.platform === "win32" ? join27(prefix, "node_modules") : join27(prefix, "lib", "node_modules"),
         install: "npm i -g memgineering@latest"
       },
       {
@@ -8271,9 +8553,9 @@ __export(setup_cloud_exports, {
 });
 import { spawn as spawn3 } from "child_process";
 import { realpathSync as realpathSync2 } from "fs";
-import { readdir as readdir7, stat as stat6 } from "fs/promises";
+import { readdir as readdir9, stat as stat8 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename3, dirname as dirname9, join as join25, resolve as resolve15, sep as sep4 } from "path";
+import { basename as basename4, dirname as dirname10, join as join28, resolve as resolve15, sep as sep4 } from "path";
 async function report2(setupToken, state, detail, code) {
   try {
     await apiRequest({
@@ -8291,16 +8573,16 @@ async function report2(setupToken, state, detail, code) {
 }
 async function folderCandidates() {
   const home = homedir5();
-  const roots = ["Documents", "notes", "Notes", "Obsidian", "vault"].map((d) => join25(home, d));
+  const roots = ["Documents", "notes", "Notes", "Obsidian", "vault"].map((d) => join28(home, d));
   const found = [];
   const countNotes = async (dir) => {
     let count = 0;
-    const entries = await readdir7(dir, { withFileTypes: true }).catch(() => []);
+    const entries = await readdir9(dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
       if (entry.isFile() && /\.(md|markdown)$/i.test(entry.name)) count += 1;
       else if (entry.isDirectory()) {
-        const inner = await readdir7(join25(dir, entry.name)).catch(() => []);
+        const inner = await readdir9(join28(dir, entry.name)).catch(() => []);
         count += inner.filter((n) => /\.(md|markdown)$/i.test(n)).length;
       }
       if (count > 999) break;
@@ -8308,7 +8590,7 @@ async function folderCandidates() {
     return count;
   };
   for (const root of roots) {
-    const info = await stat6(root).catch(() => null);
+    const info = await stat8(root).catch(() => null);
     if (!info?.isDirectory()) continue;
     const notes = await countNotes(root);
     if (notes > 0) found.push({ path: root, note_count: notes });
@@ -8643,9 +8925,9 @@ function insideFolder(target, folder) {
       realpathSync2(existing);
       break;
     } catch {
-      const parent = dirname9(existing);
+      const parent = dirname10(existing);
       if (parent === existing) break;
-      rest.unshift(basename3(existing));
+      rest.unshift(basename4(existing));
       existing = parent;
     }
   }
@@ -8692,14 +8974,14 @@ var init_setup_cloud = __esm({
 
 // src/commands/setup.ts
 import { createHash as createHash9 } from "crypto";
-import { access as access2, mkdir as mkdir16, readFile as readFile25 } from "fs/promises";
-import { dirname as dirname10, join as join26 } from "path";
+import { access as access2, mkdir as mkdir17, readFile as readFile27 } from "fs/promises";
+import { dirname as dirname11, join as join29 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { Command as Command40 } from "commander";
+import { Command as Command38 } from "commander";
 import prompts5 from "prompts";
 import { homedir as homedir6 } from "os";
 function setupCommand() {
-  return new Command40("setup").description("install into your agents, and point at a brain (--dry-run to only report)").option("--agent", "non-interactive: take every answer from flags").option("--human", "interactive: choose from a list").option("--web", "open a screen in the browser and answer it there").option("--print-url", "with --web: print the URL instead of opening a browser").option(
+  return new Command38("setup").description("install into your agents, and point at a brain (--dry-run to only report)").option("--agent", "non-interactive: take every answer from flags").option("--human", "interactive: choose from a list").option("--web", "open a screen in the browser and answer it there").option("--print-url", "with --web: print the URL instead of opening a browser").option(
     "--wait",
     "with --web: block until the screen is finished, even with nobody watching the terminal"
   ).option(
@@ -9060,7 +9342,7 @@ async function applySetup(choice, dryRun) {
   }
   async function write2() {
     for (const tool of choice.tools) {
-      const hubPath = join26(agentHome(), tool.hubFile);
+      const hubPath = join29(agentHome(), tool.hubFile);
       const written = await injectBlock(
         hubPath,
         hub + tailFor(tool, choice.hook),
@@ -9075,8 +9357,8 @@ async function applySetup(choice, dryRun) {
       });
       if (!dryRun && written.after !== null) mark(hubPath, written.after);
       for (const skill of BRAND.subSkills) {
-        const content = await loadAsset(join26(skill, "SKILL.md"));
-        const path = join26(agentHome(), tool.skillsDir, skill, "SKILL.md");
+        const content = await loadAsset(join29(skill, "SKILL.md"));
+        const path = join29(agentHome(), tool.skillsDir, skill, "SKILL.md");
         const out = await writeIfDifferent(path, content, dryRun);
         results.push({
           tool: tool.label,
@@ -9092,7 +9374,14 @@ async function applySetup(choice, dryRun) {
         results.push({
           tool: tool.label,
           what: hook.what,
-          result: choice.hook ? await installHook(hook, tool, dryRun) : await removeHook(hook, tool, dryRun)
+          // Under the lock every writer of these files takes, so a session
+          // starting meanwhile cannot refresh the same file under this write.
+          // A lock nobody gives up within five seconds is a crashed holder or
+          // a stuck one; the write goes ahead rather than leaving setup hung.
+          result: await (async () => {
+            const write3 = () => choice.hook ? installHook(hook, tool, dryRun) : removeHook(hook, tool, dryRun);
+            return await withHookFileLock(write3, 5e3) ?? write3();
+          })()
         });
       }
     }
@@ -9159,7 +9448,7 @@ async function hooksArmed(tools) {
   const capable = tools.filter((t) => t.hooks && t.hooksFile);
   if (capable.length === 0) return void 0;
   for (const tool of capable) {
-    const raw = await readFile25(join26(agentHome(), ...(tool.hooksFile ?? "").split("/")), "utf8").catch(
+    const raw = await readFile27(join29(agentHome(), ...(tool.hooksFile ?? "").split("/")), "utf8").catch(
       () => ""
     );
     if (hooksFor([tool]).some((spec) => raw.includes(spec.signature))) return "on";
@@ -9199,7 +9488,7 @@ async function detectTools() {
   const home = agentHome();
   const found = [];
   for (const tool of TOOLS) {
-    if (await exists2(join26(home, tool.dir))) found.push(tool);
+    if (await exists2(join29(home, tool.dir))) found.push(tool);
   }
   return found;
 }
@@ -9299,10 +9588,10 @@ async function injectBlock(filePath, content, dryRun, weWroteThis) {
   const block = `${BRAND.hubMarkerStart}
 ${content.trimEnd()}
 ${BRAND.hubMarkerEnd}`;
-  const existing = await readFile25(filePath, "utf8").catch(() => null);
+  const existing = await readFile27(filePath, "utf8").catch(() => null);
   if (existing === null) {
     if (!dryRun) {
-      await mkdir16(dirname10(filePath), { recursive: true });
+      await mkdir17(dirname11(filePath), { recursive: true });
       await writeThenRename(filePath, `${block}
 `);
     }
@@ -9342,23 +9631,56 @@ function looksLikeOurGuide(text) {
   return text.includes("memgineering recall") && text.includes("memgineering remember");
 }
 async function writeIfDifferent(filePath, content, dryRun) {
-  const existing = await readFile25(filePath, "utf8").catch(() => null);
+  const existing = await readFile27(filePath, "utf8").catch(() => null);
   const after = fingerprint(content);
   if (existing === content) return { outcome: "unchanged", before: existing, after };
   if (!dryRun) {
-    await mkdir16(dirname10(filePath), { recursive: true });
+    await mkdir17(dirname11(filePath), { recursive: true });
     await writeThenRename(filePath, content);
   }
   return { outcome: existing === null ? "injected" : "updated", before: existing, after };
 }
+function guardCommandFor(platform2) {
+  return platform2 === "win32" ? "memgineering guard || true" : guardHookCommand();
+}
+async function refreshOwnHookCommands() {
+  const moves = HOOKS.filter((h) => h.event !== "Stop").map((h) => ({
+    event: h.event,
+    from: SHIPPED_HOOK_COMMANDS[h.event],
+    to: h.command
+  }));
+  const changed = [];
+  const skipped = [];
+  for (const tool of TOOLS.filter((t) => t.hooks && t.hooksFile && DEFAULT_HOOK_TOOLS.includes(t.id))) {
+    const path = join29(agentHome(), ...(tool.hooksFile ?? "").split("/"));
+    const outcome = await refreshHookFile(path, moves);
+    if (outcome === "changed") changed.push(path);
+    else if (outcome === "symlink" || outcome === "refused") skipped.push({ path, why: outcome });
+  }
+  return { changed, skipped };
+}
+async function refreshOwnHooksAndTell(say) {
+  try {
+    const report3 = await refreshOwnHookCommands();
+    if (report3.changed.length === 0 && report3.skipped.length === 0) return;
+    const cfg = await loadConfig();
+    const told = cfg.system.hookNoticesTold ?? [];
+    const { text, told: nowTold } = refreshNotice(report3, told);
+    if (nowTold.length !== told.length) {
+      await saveConfig({ ...cfg, system: { ...cfg.system, hookNoticesTold: nowTold } });
+    }
+    if (text !== null) say(text);
+  } catch {
+  }
+}
 function hooksFor(tools) {
   return HOOKS.filter(
     (h) => tools.some((t) => t.hooks && (h.tools ?? DEFAULT_HOOK_TOOLS).includes(t.id))
   );
 }
 async function installHook(spec, tool, dryRun) {
-  const settingsPath = join26(agentHome(), ...(tool.hooksFile ?? "").split("/"));
-  const raw = await readFile25(settingsPath, "utf8").catch(() => null);
+  const settingsPath = join29(agentHome(), ...(tool.hooksFile ?? "").split("/"));
+  const raw = await readFile27(settingsPath, "utf8").catch(() => null);
   let settings = {};
   if (raw !== null) {
     try {
@@ -9400,15 +9722,15 @@ async function installHook(spec, tool, dryRun) {
   }
   const next = { ...settings, hooks: { ...hooks, [spec.event]: existingGroups } };
   if (!dryRun) {
-    await mkdir16(dirname10(settingsPath), { recursive: true });
+    await mkdir17(dirname11(settingsPath), { recursive: true });
     await writeThenRename(settingsPath, `${JSON.stringify(next, null, 2)}
 `);
   }
   return raw === null ? "injected" : "updated";
 }
 async function removeHook(spec, tool, dryRun) {
-  const settingsPath = join26(agentHome(), ...(tool.hooksFile ?? "").split("/"));
-  const raw = await readFile25(settingsPath, "utf8").catch(() => null);
+  const settingsPath = join29(agentHome(), ...(tool.hooksFile ?? "").split("/"));
+  const raw = await readFile27(settingsPath, "utf8").catch(() => null);
   if (raw === null) return "unchanged";
   let parsed;
   try {
@@ -9432,7 +9754,7 @@ async function removeHook(spec, tool, dryRun) {
   return "removed";
 }
 async function loadAsset(relPath) {
-  const raw = await readFile25(join26(await assetRoot(), relPath), "utf8");
+  const raw = await readFile27(join29(await assetRoot(), relPath), "utf8");
   if (relPath === BRAND.hubFileName && raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 4);
     if (end !== -1) return raw.slice(end + 4).trimStart();
@@ -9440,14 +9762,14 @@ async function loadAsset(relPath) {
   return raw;
 }
 async function assetRoot() {
-  const here = dirname10(fileURLToPath3(import.meta.url));
-  const bundled = join26(here, "..", "assets");
-  if (await exists2(join26(bundled, BRAND.hubFileName))) return bundled;
+  const here = dirname11(fileURLToPath3(import.meta.url));
+  const bundled = join29(here, "..", "assets");
+  if (await exists2(join29(bundled, BRAND.hubFileName))) return bundled;
   let dir = here;
   for (; ; ) {
-    const candidate = join26(dir, "packages", "skills");
-    if (await exists2(join26(candidate, BRAND.hubFileName))) return candidate;
-    const parent = dirname10(dir);
+    const candidate = join29(dir, "packages", "skills");
+    if (await exists2(join29(candidate, BRAND.hubFileName))) return candidate;
+    const parent = dirname11(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -9465,13 +9787,15 @@ async function exists2(path) {
     return false;
   }
 }
-var TOOLS, HOSTED_CONNECTOR_URL, SUPPORTED_LIST, REFUSAL_HINT, DUPLICATE_HINT, HOOK_TIMEOUT_S, DEFAULT_HOOK_TOOLS, HOOK_WHAT, HOOKS;
+var TOOLS, HOSTED_CONNECTOR_URL, SUPPORTED_LIST, REFUSAL_HINT, DUPLICATE_HINT, HOOK_TIMEOUT_S, DEFAULT_HOOK_TOOLS, HOOK_WHAT, HOOKS, SHIPPED_HOOK_COMMANDS;
 var init_setup = __esm({
   "src/commands/setup.ts"() {
     "use strict";
     init_atomic();
     init_brand();
     init_deadline();
+    init_guard_shell();
+    init_hook_refresh();
     init_errors();
     init_setup_brain();
     init_setup_signin();
@@ -9599,7 +9923,7 @@ For a guide: put ${BRAND.hubMarkerStart} and ${BRAND.hubMarkerEnd} back around t
           // here would mean a session that reads and answers never hears a rule.
           codex: "apply_patch|Bash"
         },
-        command: "memgineering guard || true",
+        command: guardCommandFor(process.platform),
         signature: "memgineering guard"
       },
       {
@@ -9625,6 +9949,13 @@ For a guide: put ${BRAND.hubMarkerStart} and ${BRAND.hubMarkerEnd} back around t
         tools: ["grok"]
       }
     ];
+    SHIPPED_HOOK_COMMANDS = {
+      SessionStart: [
+        "memgineering resurface --limit 5 || true",
+        `memgineering resurface --limit 5 --deadline ${HOOK_DEADLINE_MS} || true`
+      ],
+      PreToolUse: ["memgineering guard || true"]
+    };
   }
 });
 
@@ -9956,6 +10287,21 @@ var ReportReasonSchema = z10.enum(["spam", "harmful", "incorrect", "copyright",
 
 // ../../packages/contracts/src/errors.ts
 import { z as z11 } from "zod";
+
+// ../../packages/contracts/src/refresh-race.ts
+var REFRESH_RACE_FLAG = "refresh_rotated_by_another_request";
+function isRefreshRace(body) {
+  if (typeof body !== "object" || body === null) return false;
+  const error = body.error;
+  if (typeof error !== "object" || error === null) return false;
+  const { code, flags } = error;
+  if (code !== "not_authenticated" || !Array.isArray(flags)) return false;
+  return flags.some(
+    (flag2) => typeof flag2 === "object" && flag2 !== null && flag2.code === REFRESH_RACE_FLAG
+  );
+}
+
+// ../../packages/contracts/src/errors.ts
 var ErrorCodeSchema = z11.enum([
   "generic_failure",
   // 1
@@ -10905,16 +11251,33 @@ var PublishPackageRequestSchema = z19.object({
    */
   content: z19.string().min(50).max(1e5),
   /**
-   * Inline overrides for frontmatter fields. Merged into parsed frontmatter
-   * server-side; existing frontmatter wins if both present.
+   * Optional, and refused when it disagrees. core-api stores the title,
+   * description and type it reads from the frontmatter of `content`, which must
+   * carry all three (the title may come from `name:`). A value here that
+   * differs from the frontmatter's, compared trimmed, is refused as
+   * `usage_error` (HTTP 400) with a hint naming the frontmatter key; absent
+   * means no claim. A `type` the registry cannot publish at all (`scoped-rule`,
+   * `mdc-rule`, `plugin`) names no key to write: its hint says the type cannot
+   * be published yet and to drop `--type`. `kordis push` ≤0.15.2 sends
+   * `--type` here, and writes `type: skill` into the frontmatter of a SKILL.md
+   * or *.skill.md file, a folder or a .skill bundle that names no type — so
+   * `--type hook` on one is refused, where until 2026-10 it published a skill.
+   * Later versions send no `type`: they write `--type` into the frontmatter.
    */
   title: z19.string().min(1).max(200).optional(),
   description: z19.string().min(1).max(2048).optional(),
   type: HarnessTypeSchema.optional(),
+  /**
+   * A new package is published under this slug instead of the one derived from
+   * the frontmatter title. An update keeps the slug of the package it updates:
+   * a slug here that differs from the target's is refused (`usage_error`).
+   */
   slug: SlugSchema.optional(),
   /**
-   * When updating, the target full_slug. Omitted for new packages (server
-   * derives slug from title or accepts inline `slug`).
+   * When updating, the target full_slug; its presence is what makes a publish
+   * an update (`PUT /api/packages/:u/:s` sets it from the path). Omitted for a
+   * new package, whose slug is `slug` or else derived from the frontmatter
+   * title — never derived on an update.
    */
   target_full_slug: FullSlugSchema.optional(),
   /**
@@ -10922,6 +11285,12 @@ var PublishPackageRequestSchema = z19.object({
    */
   bump: z19.enum(["patch", "minor", "major"]).optional(),
   changelog: z19.string().max(2e3).optional(),
+  /**
+   * Refused when non-empty (`usage_error`): a package's dependencies are read
+   * from its frontmatter's `depends:` and `recommends:` lists only. Kept in the
+   * schema so the server sees them to refuse them — this object is non-strict,
+   * and an unlisted key would be stripped without a word.
+   */
   depends: z19.array(z19.string()).optional(),
   recommends: z19.array(z19.string()).optional(),
   /**
@@ -11395,6 +11764,120 @@ var AdminTelemetrySummaryResponseSchema = z22.object({
   daily: z22.array(TelemetryDailyBucketSchema)
 });
 
+// ../../packages/contracts/src/review-patterns.ts
+var STAGE_1_REJECT_PATTERNS = [
+  {
+    code: "curl_pipe_shell",
+    pattern: /\bcurl\s+[^|;]+\s*\|\s*(?:(?:sudo|doas)\s+)?(?:-E\s+|[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*(?:sh|bash|zsh|ksh|dash|csh|tcsh|fish)\b/i,
+    hint: "Replace `curl \u2026 | bash` with a verifiable install path: download the script to a file, show the user `cat` of it for inspection, then `bash <file>` only after confirmation."
+  },
+  {
+    code: "wget_pipe_shell",
+    pattern: /\bwget\s+[^|;]+\s*\|\s*(?:(?:sudo|doas)\s+)?(?:-E\s+|[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*(?:sh|bash|zsh|ksh|dash|csh|tcsh|fish)\b/i,
+    hint: "Replace `wget \u2026 | bash` with a verifiable install path: download the script to a file, show the user `cat` of it for inspection, then `bash <file>` only after confirmation."
+  },
+  {
+    code: "shell_process_substitution",
+    pattern: /(?:bash|sh|zsh)\s*<\(\s*(?:curl|wget)\b/i,
+    hint: "Replace `bash <(curl \u2026)` with a verifiable install path: download the script to a file, show the user `cat` of it for inspection, then `bash <file>` only after confirmation."
+  },
+  {
+    code: "eval_atob",
+    pattern: /\beval\s*\(\s*atob\b/i,
+    hint: "Encoded eval (`eval(atob(...))`) is a hallmark of obfuscated payloads. Move the logic into plain code the reader can audit."
+  },
+  {
+    code: "eval_buffer_from",
+    pattern: /\beval\s*\(\s*Buffer\.from\b/i,
+    hint: "Encoded eval (`eval(Buffer.from(...))`) is a hallmark of obfuscated payloads. Move the logic into plain code the reader can audit."
+  },
+  {
+    code: "aws_access_key",
+    pattern: /\b(?:AKIA|ASIA|AGPA)[0-9A-Z]{16}\b/,
+    hint: "Remove the AWS access key from the body. Reference credentials via env var (`AWS_ACCESS_KEY_ID`); rotate the leaked key immediately if it was real."
+  },
+  {
+    code: "private_key_block",
+    pattern: /-----BEGIN\s+(?:[A-Z0-9]+\s+)?PRIVATE\s+KEY(?:\s+BLOCK)?-----/,
+    hint: "Remove the private key block from the body. Reference keys via env var or a secret manager; rotate the leaked key immediately if it was real."
+  },
+  {
+    code: "google_api_key",
+    pattern: /\bAIza[0-9A-Za-z_-]{35}\b/,
+    hint: "Remove the Google API key from the body. Reference credentials via env var; rotate the leaked key immediately if it was real."
+  },
+  {
+    code: "slack_token",
+    pattern: /\b(?:xox[abpors]|xapp|xoxe)-[0-9a-zA-Z-]{10,}\b/,
+    hint: "Remove the Slack token from the body. Reference tokens via env var; revoke the leaked token immediately if it was real."
+  },
+  {
+    code: "github_token",
+    pattern: /\b(?:gh[pousr]_[A-Za-z0-9_]{36,}|github_pat_[A-Za-z0-9_]{60,})\b/,
+    hint: "Remove the GitHub token from the body. Reference tokens via env var; revoke the leaked token immediately if it was real."
+  }
+];
+var STAGE_1_5_AUP_PATTERNS = [
+  {
+    // Stolen-card / bank-credential trafficking storefronts. Anchored to the
+    // trafficking jargon that only appears in carding markets, not in the
+    // defensive "how to detect carding" literature. `dumps` is also an
+    // ordinary developer verb — "this hook dumps vendor files", "dumps store
+    // state", "dumps market data to CSV" all matched the shared noun list —
+    // so after `dumps` only sale framing (`shop`, `for sale`) counts, while
+    // `cvv` and `fullz` keep the full list. Narrowed when comments started
+    // running this table (2026-10-14).
+    code: "aup_stolen_financial_data_market",
+    pattern: /\b(?:cvv|fullz)\s+(?:shop|store|for\s+sale|market|vendor)\b|\bdumps\s+(?:shop|for\s+sale)\b|\bdumps?\s+with\s+pin\b|\bsell(?:ing)?\s+(?:cvv|fullz|dumps)\b/i,
+    hint: "This reads as a storefront for trafficking stolen financial data, which violates the Kordis AUP. If the package is about DETECTING or DEFENDING against card fraud, reword it so it does not read as an offer to buy/sell stolen data."
+  },
+  {
+    // DDoS-for-hire (booter/stresser) services sold on a subscription.
+    code: "aup_ddos_for_hire",
+    pattern: /\b(?:booter|stresser)\s+(?:service|panel|subscription)\b|\b(?:ddos|dstat)\s+for\s+hire\b|\bhire\s+(?:a\s+)?(?:booter|stresser|ddos)\b/i,
+    hint: "This reads as a DDoS-for-hire (booter/stresser) service, which violates the Kordis AUP. Load-testing tooling is fine \u2014 describe it as testing infrastructure you own/are authorized to test, not a for-hire attack service."
+  },
+  {
+    // Malware/stealer/ransomware sold or distributed as a product ("builder
+    // for sale", "buy our stealer"). A skill that DEFENDS against these, or a
+    // malware-analysis skill, does not use buy/sell framing.
+    code: "aup_malware_sale",
+    pattern: /\b(?:ransomware|stealer|infostealer|rat|keylogger|botnet)\s+(?:builder|kit|panel|source)\s+(?:for\s+sale|for\s+rent)\b|\b(?:buy|sell(?:ing)?|rent)\s+(?:our\s+)?(?:ransomware|stealer|infostealer|botnet)\b/i,
+    hint: "This reads as an offer to sell/rent malware, which violates the Kordis AUP. Malware ANALYSIS and DEFENSE content is welcome \u2014 reword so it does not read as distributing a weaponized build."
+  },
+  {
+    // Child sexual abuse material. Unlike the rest of this table this entry is
+    // NOT anchored to solicitation: it matches the spelled-out phrases ("child
+    // porn", "child pornography", "child sexual abuse material") wherever they
+    // appear, child-safety and moderation education included. Only the
+    // acronym "CSAM" on its own does not match ("how platforms detect CSAM
+    // for NCMEC reporting" passes). Kept this broad on purpose (2026-10-14):
+    // comments have no Stage-2 review after this table, so a miss costs more
+    // than a false positive.
+    code: "aup_csam",
+    pattern: /\bchild\s+(?:porn(?:ography)?|sexual\s+abuse\s+material)\b/i,
+    hint: "This reads as solicitation or distribution of child sexual abuse material, which is illegal and violates the Kordis AUP. This is a terminal, non-appealable rejection."
+  },
+  {
+    // Drug / untraceable-weapon brokering with explicit no-id / untraceable /
+    // dark-web fulfillment language — not a bare mention of a substance or
+    // firearm topic (e.g. harm-reduction or policy content does not use this
+    // buy/sell + untraceable-fulfillment framing together).
+    code: "aup_drug_weapon_brokering",
+    pattern: /\b(?:buy|sell(?:ing)?)\b[\s\S]{0,40}\b(?:cocaine|heroin|fentanyl|methamphetamine|untraceable firearms?|untraceable guns?)\b[\s\S]{0,40}\b(?:no id|untraceable|worldwide shipping|dark ?web)\b/i,
+    hint: "This reads as brokering illegal drugs or untraceable weapons for sale, which violates the Kordis AUP. If the package is about DETECTING or REPORTING such activity, reword it so it does not read as an offer to buy/sell."
+  },
+  {
+    // A directive to dox or swat a specific, named/tagged target — not a
+    // bare mention of doxxing/swatting as a topic (e.g. "how to protect
+    // yourself from doxxing" does not match).
+    code: "aup_targeted_harassment_directive",
+    pattern: /\b(?:dox|swat)\s+(?:this (?:guy|girl|person|user)|him|her|@[\w.]+)\b/i,
+    hint: "This reads as a directive to dox or swat a specific target, which violates the Kordis AUP. Remove the targeted-harassment instruction."
+  }
+];
+var DETERMINISTIC_REJECT_PATTERNS = [...STAGE_1_REJECT_PATTERNS, ...STAGE_1_5_AUP_PATTERNS];
+
 // ../../packages/api-client/src/errors.ts
 function httpStatusToCode(status) {
   if (status === 401) return "not_authenticated";
@@ -11931,7 +12414,7 @@ Wait ${err.retryAfter}s before trying again.` : "";
 
 // src/commands/base-write.ts
 init_errors();
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 import { resolve as resolve4 } from "path";
 import { Command as Command2 } from "commander";
 
@@ -11941,8 +12424,8 @@ init_brand();
 init_errors();
 init_ui();
 import { createHash as createHash3 } from "crypto";
-import { appendFile, mkdir as mkdir6, readFile as readFile6, readdir as readdir2, rm as rm4, writeFile as writeFile5 } from "fs/promises";
-import { join as join8 } from "path";
+import { appendFile, mkdir as mkdir6, readFile as readFile7, readdir as readdir3, rm as rm4, writeFile as writeFile5 } from "fs/promises";
+import { join as join9 } from "path";
 import { z as z23 } from "zod";
 
 // src/lib/ids.ts
@@ -12165,20 +12648,20 @@ function sanitizeRationale(raw) {
   return capped2;
 }
 function ledgerDir(vaultRoot) {
-  return join8(vaultRoot, BRAND.vaultLedgerDir, "ledger");
+  return join9(vaultRoot, BRAND.vaultLedgerDir, "ledger");
 }
 function ledgerFile(vaultRoot, ts) {
-  return join8(ledgerDir(vaultRoot), `ops-${ts.slice(0, 7)}.jsonl`);
+  return join9(ledgerDir(vaultRoot), `ops-${ts.slice(0, 7)}.jsonl`);
 }
 function hashContent(content) {
   return createHash3("sha256").update(content, "utf8").digest("hex");
 }
 function stateDirFor(vaultRoot) {
   const hash = createHash3("sha256").update(vaultRoot).digest("hex").slice(0, 16);
-  return join8(brandHome(), "state", hash);
+  return join9(brandHome(), "state", hash);
 }
 function snapshotDir(vaultRoot) {
-  return join8(stateDirFor(vaultRoot), "undo");
+  return join9(stateDirFor(vaultRoot), "undo");
 }
 async function appendOp(vaultRoot, op) {
   const ts = (op.now ?? /* @__PURE__ */ new Date()).toISOString();
@@ -12200,7 +12683,7 @@ async function appendOp(vaultRoot, op) {
   if (op.snapshotBefore != null) {
     const dir = snapshotDir(vaultRoot);
     await mkdir6(dir, { recursive: true });
-    await writeFile5(join8(dir, `${record.op_id}.txt`), op.snapshotBefore, {
+    await writeFile5(join9(dir, `${record.op_id}.txt`), op.snapshotBefore, {
       encoding: "utf8",
       mode: 384
     });
@@ -12212,7 +12695,7 @@ async function appendOp(vaultRoot, op) {
 }
 async function readSnapshot(vaultRoot, opId) {
   try {
-    return await readFile6(join8(snapshotDir(vaultRoot), `${opId}.txt`), "utf8");
+    return await readFile7(join9(snapshotDir(vaultRoot), `${opId}.txt`), "utf8");
   } catch {
     return null;
   }
@@ -12220,14 +12703,14 @@ async function readSnapshot(vaultRoot, opId) {
 async function readOps(vaultRoot) {
   let files2;
   try {
-    files2 = (await readdir2(ledgerDir(vaultRoot))).filter((f) => /^ops-\d{4}-\d{2}\.jsonl$/.test(f)).sort();
+    files2 = (await readdir3(ledgerDir(vaultRoot))).filter((f) => /^ops-\d{4}-\d{2}\.jsonl$/.test(f)).sort();
   } catch {
     return { ops: [], skipped: 0 };
   }
   const ops = [];
   let skipped = 0;
   for (const file of files2) {
-    const raw = await readFile6(join8(ledgerDir(vaultRoot), file), "utf8");
+    const raw = await readFile7(join9(ledgerDir(vaultRoot), file), "utf8");
     for (const line of raw.split("\n")) {
       if (line.trim() === "") continue;
       try {
@@ -12523,7 +13006,7 @@ async function readBody(source) {
       process.stdin.on("error", reject);
     });
   }
-  return readFile10(source, "utf8").catch(() => source);
+  return readFile11(source, "utf8").catch(() => source);
 }
 
 // src/commands/brain-admin.ts
@@ -12536,8 +13019,8 @@ init_errors();
 init_cloud_brain();
 init_config();
 init_held_back();
-import { readFile as readFile11, rm as rm5 } from "fs/promises";
-import { join as join11 } from "path";
+import { readFile as readFile12, rm as rm5 } from "fs/promises";
+import { join as join12 } from "path";
 import { Command as Command3 } from "commander";
 init_vault();
 init_ui();
@@ -12755,7 +13238,7 @@ function syncRulesCommand() {
   return new Command3("sync-rules").description("copy this brain\u2019s read/index exclusions into a file that follows you").option("--vault <path>", "which brain").action(async (opts) => {
     const { brain } = await resolveBrain(opts.vault);
     const root = brain.root;
-    const existingRaw = await readFile11(join11(root, RULES_FILE), "utf8").catch(() => void 0);
+    const existingRaw = await readFile12(join12(root, RULES_FILE), "utf8").catch(() => void 0);
     const current = await readRulesFile(root);
     const [dotDeny, dotIgnore] = await Promise.all([
       readLines(root, ".memgdeny"),
@@ -12783,7 +13266,7 @@ function syncRulesCommand() {
       });
       return;
     }
-    await writeThenRename(join11(root, RULES_FILE), next);
+    await writeThenRename(join12(root, RULES_FILE), next);
     const after = await readRulesFile(root);
     const lost = [
       ...neverRead.filter((e) => !after.raw.never_read.includes(e)),
@@ -12816,7 +13299,7 @@ function syncRulesCommand() {
   });
 }
 async function readLines(root, name) {
-  const raw = await readFile11(join11(root, name), "utf8").catch(() => "");
+  const raw = await readFile12(join12(root, name), "utf8").catch(() => "");
   return raw.split("\n").map((l) => l.replace(/\r$/, "").trim()).filter((l) => l !== "" && !l.startsWith("#"));
 }
 async function stopReadingHosted(path) {
@@ -13026,11 +13509,11 @@ init_index_build();
 
 // src/lib/lock.ts
 init_errors();
-import { mkdir as mkdir7, readFile as readFile12, rm as rm6, writeFile as writeFile6 } from "fs/promises";
-import { join as join12 } from "path";
+import { mkdir as mkdir7, readFile as readFile13, rm as rm6, writeFile as writeFile6 } from "fs/promises";
+import { join as join13 } from "path";
 var STALE_MS = 6e4;
 function lockPath(vaultRoot) {
-  return join12(stateDirFor(vaultRoot), "write.lock");
+  return join13(stateDirFor(vaultRoot), "write.lock");
 }
 function holderIsGone(pid) {
   try {
@@ -13073,7 +13556,7 @@ async function withFileLock(path, dir, fn) {
 }
 async function readLock(path) {
   try {
-    const parsed = JSON.parse(await readFile12(path, "utf8"));
+    const parsed = JSON.parse(await readFile13(path, "utf8"));
     if (typeof parsed.pid === "number" && typeof parsed.at === "string") {
       return { pid: parsed.pid, at: parsed.at };
     }
@@ -13092,15 +13575,15 @@ init_errors();
 import { Command as Command5 } from "commander";
 
 // src/lib/events.ts
-import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile14, readdir as readdir4 } from "fs/promises";
-import { join as join14 } from "path";
+import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile15, readdir as readdir5 } from "fs/promises";
+import { join as join15 } from "path";
 import { z as z24 } from "zod";
 
 // src/lib/project.ts
 init_config();
 init_vault();
-import { readFile as readFile13, stat as stat2 } from "fs/promises";
-import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join13, resolve as resolve5 } from "path";
+import { readFile as readFile14, stat as stat3 } from "fs/promises";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute2, join as join14, resolve as resolve5 } from "path";
 async function projectOf(cwd = process.cwd()) {
   const here = await canonicalize(resolve5(cwd));
   const repo = await findRepository(here);
@@ -13131,37 +13614,37 @@ async function boundName(key2) {
   return cfg.projects.bindings.find((b) => resolve5(b.dir) === key2)?.name ?? null;
 }
 async function derivedName(repo) {
-  const url = await originUrl(join13(repo.commonDir, "config"));
+  const url = await originUrl(join14(repo.commonDir, "config"));
   const fromRemote = url === null ? null : ownerRepo(url);
   if (fromRemote !== null) return { name: fromRemote, via: "remote" };
-  const folder = basename(repo.root);
+  const folder = basename2(repo.root);
   return folder === "" ? { name: null, via: "none" } : { name: folder, via: "dirname" };
 }
 async function findRepository(from) {
   let dir = from;
   for (; ; ) {
-    const found = await readGitLink(join13(dir, ".git"), dir);
+    const found = await readGitLink(join14(dir, ".git"), dir);
     if (found !== null) return found;
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 async function readGitLink(dot, dir) {
-  const info = await stat2(dot).catch(() => null);
+  const info = await stat3(dot).catch(() => null);
   if (info === null) return null;
   if (info.isDirectory()) return { root: dir, commonDir: dot };
-  const raw = await readFile13(dot, "utf8").catch(() => null);
+  const raw = await readFile14(dot, "utf8").catch(() => null);
   const pointed = raw === null ? null : /^gitdir:\s*(.+)$/m.exec(raw)?.[1]?.trim();
   if (pointed === null || pointed === void 0 || pointed === "") return null;
   const gitDir = isAbsolute2(pointed) ? resolve5(pointed) : resolve5(dir, pointed);
-  const common = (await readFile13(join13(gitDir, "commondir"), "utf8").catch(() => null))?.trim();
+  const common = (await readFile14(join14(gitDir, "commondir"), "utf8").catch(() => null))?.trim();
   const commonDir = common === void 0 || common === "" ? gitDir : isAbsolute2(common) ? resolve5(common) : resolve5(gitDir, common);
-  const root = basename(commonDir) === ".git" ? await canonicalize(dirname3(commonDir)) : dir;
+  const root = basename2(commonDir) === ".git" ? await canonicalize(dirname4(commonDir)) : dir;
   return { root, commonDir };
 }
 async function originUrl(configPath2) {
-  const text = await readFile13(configPath2, "utf8").catch(() => null);
+  const text = await readFile14(configPath2, "utf8").catch(() => null);
   if (text === null) return null;
   let inOrigin = false;
   let url = null;
@@ -13263,7 +13746,7 @@ var EventSchema = z24.object({
   opened_id: z24.string().nullable().default(null)
 });
 function eventsFile(stateDir, ts) {
-  return join14(stateDir, `events-${ts.slice(0, 7)}.jsonl`);
+  return join15(stateDir, `events-${ts.slice(0, 7)}.jsonl`);
 }
 function ledgerStateDir(target) {
   return target.kind === "cloud" ? stateDirFor(`cloud:${target.brainId}`) : stateDirFor(target.brain.root);
@@ -13307,13 +13790,13 @@ async function readEvents(vaultRoot) {
 async function readEventsAt(stateDir) {
   let files2;
   try {
-    files2 = (await readdir4(stateDir)).filter((f) => /^events-\d{4}-\d{2}\.jsonl$/.test(f)).sort();
+    files2 = (await readdir5(stateDir)).filter((f) => /^events-\d{4}-\d{2}\.jsonl$/.test(f)).sort();
   } catch {
     return [];
   }
   const events = [];
   for (const file of files2) {
-    const raw = await readFile14(join14(stateDir, file), "utf8");
+    const raw = await readFile15(join15(stateDir, file), "utf8");
     for (const line of raw.split("\n")) {
       if (line.trim() === "") continue;
       try {
@@ -13761,8 +14244,8 @@ init_exclude();
 init_adapter();
 init_walk();
 import { createHash as createHash5 } from "crypto";
-import { link, lstat as lstat3, mkdir as mkdir10, readFile as readFile15, rm as rm7, writeFile as writeFile8 } from "fs/promises";
-import { dirname as dirname4, join as join16, resolve as resolve7 } from "path";
+import { link, lstat as lstat3, mkdir as mkdir10, readFile as readFile16, rm as rm7, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname5, join as join17, resolve as resolve7 } from "path";
 var LocalFileCasAdapter = class _LocalFileCasAdapter {
   tier = 1;
   #read;
@@ -13853,7 +14336,7 @@ var LocalFileCasAdapter = class _LocalFileCasAdapter {
     }
     const gate = await this.#gateExisting(path, content);
     if (!gate.ok) throw gate.error;
-    const current = await readFile15(gate.abs);
+    const current = await readFile16(gate.abs);
     const currentHash = createHash5("sha256").update(current).digest("hex");
     if (currentHash !== opts.baseRevision.contentHash) {
       const st = await lstat3(gate.abs);
@@ -13877,7 +14360,7 @@ var LocalFileCasAdapter = class _LocalFileCasAdapter {
   async create(path, content) {
     const gate = await this.#gateNew(path, content);
     if (!gate.ok) throw gate.error;
-    await mkdir10(dirname4(gate.abs), { recursive: true });
+    await mkdir10(dirname5(gate.abs), { recursive: true });
     const tmp = `${gate.abs}.${process.pid}.tmp`;
     try {
       await writeFile8(tmp, content, { encoding: "utf8", mode: 384 });
@@ -13888,7 +14371,7 @@ var LocalFileCasAdapter = class _LocalFileCasAdapter {
         if (st.isSymbolicLink()) {
           throw new Error(`refusing to follow a symlink inside the vault: ${path}`);
         }
-        const existing = await readFile15(gate.abs);
+        const existing = await readFile16(gate.abs);
         return {
           ok: false,
           reason: "revision_conflict",
@@ -13946,8 +14429,8 @@ var LocalFileCasAdapter = class _LocalFileCasAdapter {
       return { ok: false, error: err };
     }
     const rel = relativeTo(this.#root, abs);
-    const refusal = this.#refuse(rel, path, content);
-    return refusal ? { ok: false, error: refusal } : { ok: true, abs, rel };
+    const refusal2 = this.#refuse(rel, path, content);
+    return refusal2 ? { ok: false, error: refusal2 } : { ok: true, abs, rel };
   }
   /**
    * Gates for a path that must NOT already exist.
@@ -13972,7 +14455,7 @@ var LocalFileCasAdapter = class _LocalFileCasAdapter {
     }
     let cursor = resolve7(this.#root);
     for (const segment of rel.split("/").slice(0, -1)) {
-      cursor = join16(cursor, segment);
+      cursor = join17(cursor, segment);
       try {
         const st = await lstat3(cursor);
         if (st.isSymbolicLink()) {
@@ -13986,8 +14469,8 @@ var LocalFileCasAdapter = class _LocalFileCasAdapter {
         return { ok: false, error: err };
       }
     }
-    const refusal = this.#refuse(rel, path, content);
-    return refusal ? { ok: false, error: refusal } : { ok: true, abs, rel };
+    const refusal2 = this.#refuse(rel, path, content);
+    return refusal2 ? { ok: false, error: refusal2 } : { ok: true, abs, rel };
   }
   /**
    * The rules, applied to a write. Returns the refusal or null.
@@ -14057,7 +14540,7 @@ init_ui();
 
 // src/commands/revise.ts
 init_src();
-import { readFile as readFile16 } from "fs/promises";
+import { readFile as readFile17 } from "fs/promises";
 import { Command as Command7 } from "commander";
 init_errors();
 init_index_build();
@@ -14072,6 +14555,69 @@ init_errors();
 init_index_build();
 init_cloud_brain();
 init_vault();
+
+// src/lib/guard-fast.ts
+init_brand();
+import { randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir11, readdir as readdir7, rename as rename4, stat as stat4, unlink as unlink4, utimes, writeFile as writeFile9 } from "fs/promises";
+import { join as join18 } from "path";
+var fastDir = () => join18(brandHome(), "guard", "fast");
+var EMPTY_TTL_S = 120;
+var SESSION_ID = /^[A-Za-z0-9-]{1,128}$/;
+var EMPTY_MARK = /^(.+)\.empty\.(\d+)$/;
+var RULES_CHANGED = ".rules-changed";
+var TMP_PREFIX = ".tmp-";
+async function place(name, asOfMs) {
+  await mkdir11(fastDir(), { recursive: true, mode: 448 });
+  const tmp = join18(fastDir(), `${TMP_PREFIX}${process.pid}-${randomUUID3()}`);
+  try {
+    await writeFile9(tmp, "", { mode: 384 });
+    const dated = (asOfMs - 1e3) / 1e3;
+    await utimes(tmp, dated, dated);
+    await rename4(tmp, join18(fastDir(), name));
+  } catch (err) {
+    await unlink4(tmp).catch(() => void 0);
+    throw err;
+  }
+}
+async function markServed(sessionId, asOfMs) {
+  if (!SESSION_ID.test(sessionId)) return;
+  await place(sessionId, asOfMs).catch(() => void 0);
+}
+async function markEmpty(sessionId, asOfMs) {
+  if (!SESSION_ID.test(sessionId)) return;
+  const until = Math.floor(asOfMs / 1e3) + EMPTY_TTL_S;
+  await place(`${sessionId}.empty.${until}`, asOfMs).catch(() => void 0);
+  await unlink4(join18(fastDir(), sessionId)).catch(() => void 0);
+}
+async function forgetEmptyChecks() {
+  await mkdir11(fastDir(), { recursive: true, mode: 448 }).then(() => writeFile9(join18(fastDir(), RULES_CHANGED), "", { mode: 384 })).catch(() => void 0);
+  const names = await readdir7(fastDir()).catch(() => []);
+  await Promise.all(
+    names.filter((name) => EMPTY_MARK.test(name)).map((name) => unlink4(join18(fastDir(), name)).catch(() => void 0))
+  );
+}
+var SERVED_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var TMP_TTL_MS = 60 * 1e3;
+async function pruneFast(nowMs = Date.now()) {
+  const names = await readdir7(fastDir()).catch(() => []);
+  const nowS = Math.floor(nowMs / 1e3);
+  await Promise.all(
+    names.map(async (name) => {
+      const path = join18(fastDir(), name);
+      const empty = EMPTY_MARK.exec(name);
+      if (empty) {
+        if (Number(empty[2]) <= nowS) await unlink4(path).catch(() => void 0);
+        return;
+      }
+      const info = await stat4(path).catch(() => null);
+      const ttl = name.startsWith(TMP_PREFIX) ? TMP_TTL_MS : SERVED_TTL_MS;
+      if (info && nowMs - info.mtimeMs > ttl) await unlink4(path).catch(() => void 0);
+    })
+  );
+}
+
+// src/commands/remember.ts
 init_ui();
 function rememberCommand() {
   const said = { scope: false, noScope: false };
@@ -14145,6 +14691,7 @@ function rememberCommand() {
         const kindLanded = kind === void 0 || written.kind === kind;
         const boundaryLanded = neverStore.length === 0 || Array.isArray(written.never_store) && neverStore.every((term) => written.never_store?.includes(term) === true);
         const overrideLanded = opts.overrideBoundary === void 0 || "boundary_override" in written;
+        if (binding) await forgetEmptyChecks();
         printDual({
           json: {
             id: written.id,
@@ -14779,6 +15326,7 @@ async function reviseHosted(where, ref, opts, added) {
       }
     }
   }
+  if (opts.rule === true) await forgetEmptyChecks();
   printDual({
     json: {
       brain: where.name,
@@ -15022,7 +15570,7 @@ async function readInput(source) {
     process.stdin.on("data", (chunk) => buf += chunk);
     process.stdin.on("end", () => resolve17(buf));
     process.stdin.on("error", reject);
-  }) : await readFile16(source, "utf8").catch(() => source);
+  }) : await readFile17(source, "utf8").catch(() => source);
   try {
     return JSON.parse(raw);
   } catch {
@@ -16522,7 +17070,7 @@ async function deleteCloudBrain(args) {
 
 // src/commands/curation.ts
 init_src();
-import { stat as stat3 } from "fs/promises";
+import { stat as stat5 } from "fs/promises";
 import { resolve as resolve8 } from "path";
 import { Command as Command14 } from "commander";
 
@@ -16531,12 +17079,12 @@ init_atomic();
 init_exclude();
 init_walk();
 import { createHash as createHash6 } from "crypto";
-import { readFile as readFile17 } from "fs/promises";
+import { readFile as readFile18 } from "fs/promises";
 var FILE = ".memgignore";
 var hashOf = (content) => createHash6("sha256").update(Buffer.from(content, "utf8")).digest("hex");
 async function readIgnoreFileState(root) {
   try {
-    const content = await readFile17(resolveInside(root, FILE), "utf8");
+    const content = await readFile18(resolveInside(root, FILE), "utf8");
     return { content, exists: true, hash: hashOf(content) };
   } catch (err) {
     if (err?.code === "ENOENT") {
@@ -16838,7 +17386,7 @@ async function mustMatchAFile(root, adapter, path) {
   const wanted = path.normalize("NFC").replace(/^\/+/, "");
   const absolute = resolve8(root, wanted);
   if (isInside(absolute, root)) {
-    const found = await stat3(absolute).catch(() => null);
+    const found = await stat5(absolute).catch(() => null);
     if (found?.isFile()) return wanted;
   }
   const hits = sameBasename(await adapter.list(""), path);
@@ -17412,8 +17960,8 @@ function ago(iso, now) {
 init_brand();
 init_config();
 import { createHash as createHash7 } from "crypto";
-import { mkdir as mkdir11, readdir as readdir6, stat as stat4, unlink as unlink3, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute3, join as join18, resolve as resolve9 } from "path";
+import { mkdir as mkdir12, readdir as readdir8, stat as stat6, unlink as unlink5, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname6, isAbsolute as isAbsolute3, join as join20, resolve as resolve9 } from "path";
 import { Command as Command17 } from "commander";
 
 // src/lib/rules.ts
@@ -17484,6 +18032,7 @@ function renderRuleGroups(rules, project) {
 init_src();
 init_deadline();
 init_cloud_brain();
+init_vault();
 function guardCommand() {
   return new Command17("guard").description("hook entry \u2014 show the user\u2019s rules before the first edit of a session").option("--context-dir <path>", "where the work is happening, when stdin does not say").option("--at <event>", "pre-tool-use | stop", "pre-tool-use").action(async (opts) => {
     try {
@@ -17515,7 +18064,7 @@ async function runGuard(payload, contextDirFlag) {
   if (!FILE_TOOLS.has(toolName)) return null;
   const filePath = fileFrom(payload);
   const cwd = typeof payload.cwd === "string" ? payload.cwd : process.cwd();
-  const contextDir = contextDirFlag ?? (filePath === null ? cwd : dirname5(resolve9(cwd, filePath)));
+  const contextDir = contextDirFlag ?? (filePath === null ? cwd : dirname6(resolve9(cwd, filePath)));
   const sessionId = typeof payload.session_id === "string" ? payload.session_id : null;
   if (sessionId === null) return null;
   const misdelivered = await misdeliveryNotice(toolName, filePath, sessionId);
@@ -17548,22 +18097,35 @@ async function runStopGuard(payload, contextDirFlag) {
   });
 }
 async function claimRules(sessionId, contextDir) {
+  const asOf = Date.now();
   const where = await resolveTarget({}).catch(() => null);
   if (where?.kind === "cloud") {
-    if (!await claimSession(sessionId, where.brainId)) return null;
+    if (!await claimSession(sessionId, where.brainId)) {
+      if (await claimExists(sessionId, where.brainId)) await markServed(sessionId, asOf);
+      return null;
+    }
     const hosted = await hostedRuleLines(where, contextDir).catch(() => null);
     if (hosted !== null) {
-      if (hosted.lines.length > 0) return { lines: hosted.lines, total: hosted.total };
+      if (hosted.lines.length > 0) {
+        await markServed(sessionId, asOf);
+        return { lines: hosted.lines, total: hosted.total };
+      }
       await releaseSession(sessionId, where.brainId);
+      await markEmpty(sessionId, asOf);
       return null;
     }
     await releaseSession(sessionId, where.brainId);
   }
+  const named = await resolveBrain(void 0, contextDir).catch(() => null);
+  if (named === null) return null;
+  const root = named.brain.root;
+  if (!await claimSession(sessionId, root)) return null;
   const collected = await collectRules(void 0, contextDir).catch(() => null);
-  if (collected === null) return null;
+  if (collected === null || collected.rules.length === 0) {
+    await releaseSession(sessionId, root);
+    return null;
+  }
   const { brainRoot, rules, total } = collected;
-  if (rules.length === 0) return null;
-  if (!await claimSession(sessionId, brainRoot)) return null;
   await recordEvent(brainRoot, {
     verb: "guard",
     contextDir,
@@ -17619,7 +18181,7 @@ async function readPayload() {
     return null;
   }
 }
-var guardDir = () => join18(brandHome(), "guard");
+var guardDir = () => join20(brandHome(), "guard");
 var WRITE_TOOLS = /* @__PURE__ */ new Set([
   "Write",
   "Edit",
@@ -17640,7 +18202,7 @@ async function misdeliveryNotice(toolName, filePath, sessionId) {
   return 'This file is this harness\u2019s own memory \u2014 no other tool the user works with will ever read it. Durable facts about the user belong in their brain, which every tool shares: memgineering remember "<the fact>" --reason "<why>" (add --rule if they stated a standing rule). Write it there instead, or in addition.';
 }
 function markerFor(sessionId, brain) {
-  return join18(
+  return join20(
     guardDir(),
     `${createHash7("sha256").update(`${sessionId}\0${brain}`).digest("hex").slice(0, 32)}`
   );
@@ -17648,8 +18210,8 @@ function markerFor(sessionId, brain) {
 async function claimSession(sessionId, brain) {
   const marker = markerFor(sessionId, brain);
   try {
-    await mkdir11(guardDir(), { recursive: true, mode: 448 });
-    await writeFile9(marker, "", { flag: "wx", mode: 384 });
+    await mkdir12(guardDir(), { recursive: true, mode: 448 });
+    await writeFile10(marker, "", { flag: "wx", mode: 384 });
   } catch {
     return false;
   }
@@ -17657,19 +18219,23 @@ async function claimSession(sessionId, brain) {
   return true;
 }
 async function releaseSession(sessionId, brain) {
-  await unlink3(markerFor(sessionId, brain)).catch(() => void 0);
+  await unlink5(markerFor(sessionId, brain)).catch(() => void 0);
+}
+async function claimExists(sessionId, brain) {
+  return stat6(markerFor(sessionId, brain)).then(() => true).catch(() => false);
 }
 var MARKER_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 async function pruneOldMarkers() {
   try {
     const dir = guardDir();
     const now = Date.now();
-    for (const name of await readdir6(dir)) {
-      const path = join18(dir, name);
+    for (const name of await readdir8(dir)) {
+      const path = join20(dir, name);
       if (!isAbsolute3(path)) continue;
-      const info = await stat4(path).catch(() => null);
-      if (info && now - info.mtimeMs > MARKER_TTL_MS) await unlink3(path).catch(() => void 0);
+      const info = await stat6(path).catch(() => null);
+      if (info && now - info.mtimeMs > MARKER_TTL_MS) await unlink5(path).catch(() => void 0);
     }
+    await pruneFast(now);
   } catch {
   }
 }
@@ -17711,7 +18277,7 @@ init_link();
 // src/commands/log.ts
 init_src();
 init_walk();
-import { lstat as lstat4, readFile as readFile19 } from "fs/promises";
+import { lstat as lstat4, readFile as readFile20 } from "fs/promises";
 import { Command as Command19 } from "commander";
 init_errors();
 init_cloud_brain();
@@ -18277,7 +18843,7 @@ async function readOrNull(root, path) {
   if (absolute === null) return null;
   const info = await lstat4(absolute).catch(() => null);
   if (!info || !info.isFile()) return null;
-  return readFile19(absolute, "utf8").catch(() => null);
+  return readFile20(absolute, "utf8").catch(() => null);
 }
 
 // src/commands/project.ts
@@ -18413,37 +18979,142 @@ init_api_client();
 init_credentials();
 init_config();
 init_pending_login();
-init_ui();
 import { Command as Command22 } from "commander";
-function logoutCommand() {
-  return new Command22("logout").description("sign out of your account \u2014 the pointer and your notes stay").option("--all", "revoke every token on the account, not just this machine\u2019s").option(
-    "--local",
-    "forget the token here without telling the server \u2014 only for a server you cannot reach"
-  ).action(async (opts) => {
-    const base2 = apiUrl();
-    const credentials = await readCredentials();
-    await clearPendingLogin();
-    await clearSetupFollowUps();
-    if (!credentials) {
-      printDual({
-        json: { signed_out: true, was_signed_in: false, api_url: base2 },
-        human: () => printHuman("Not signed in \u2014 nothing to do.")
-      });
-      return;
-    }
-    if (opts.local) {
-      await clearCredentials();
-      printDual({
-        json: { signed_out: true, revoked_on_server: false, api_url: credentials.api_url },
-        human: () => {
-          printHuman("Forgotten here.");
-          printHuman(
-            c.yellow(
-              "  The token was NOT revoked \u2014 it still works for anyone holding a copy.\n  Run `memgineering logout --all` once the server is reachable."
-            )
-          );
-        }
-      });
+
+// src/lib/registry-session.ts
+init_errors();
+init_credentials();
+init_version();
+function registryApiUrl(stored) {
+  const override = process.env["KORDIS_API_URL"];
+  return override !== void 0 && override !== "" ? override : stored;
+}
+async function requireRegistryCredentials() {
+  const credentials = await readCredentials();
+  const registry = credentials?.registry;
+  if (!registry) {
+    throw memgError(
+      "not_linked",
+      "this machine holds no registry identity",
+      credentials === null ? "Nothing was sent. Sign in with `memgineering login` \u2014 it links the registry identity at the same time, so one sign-in covers both." : "Nothing was sent. This machine is signed in to a brain, and the registry half of that sign-in is missing \u2014 which is what a credential file written before federation looks like. Run `memgineering login` again; it links the registry identity too."
+    );
+  }
+  return registry;
+}
+var RACE_WAIT_MS = 2e3;
+var RACE_POLL_MS = 50;
+function lostRace(err) {
+  return err instanceof KordisApiError && err.status === 401 && isRefreshRace({ error: { code: err.code, flags: err.flags } });
+}
+async function newerRegistry(sent) {
+  const deadline = Date.now() + RACE_WAIT_MS;
+  for (; ; ) {
+    const registry = (await readCredentials())?.registry;
+    if (registry !== void 0 && registry.refresh_token !== sent) return registry;
+    if (Date.now() >= deadline) return null;
+    await new Promise((resolve17) => setTimeout(resolve17, RACE_POLL_MS));
+  }
+}
+async function refreshRegistrySession(stored, opts = {}) {
+  const attempt = async (registry) => {
+    const baseUrl = (opts.apiUrlOf ?? ((r) => registryApiUrl(r.api_url)))(registry);
+    const anonymous = new KordisClient({
+      baseUrl,
+      userAgent: `memgineering/${VERSION}`,
+      ...opts.fetchImpl ? { fetch: opts.fetchImpl } : {},
+      ...opts.requestTimeoutMs === void 0 ? {} : { requestTimeoutMs: opts.requestTimeoutMs }
+    });
+    return { registry, baseUrl, tokens: await anonymous.refreshSession(registry.refresh_token) };
+  };
+  try {
+    return await attempt(stored);
+  } catch (err) {
+    if (!lostRace(err)) throw err;
+    const newer = await newerRegistry(stored.refresh_token);
+    if (newer === null) throw err;
+    return attempt(newer);
+  }
+}
+function refusal(err) {
+  if (lostRace(err)) {
+    return memgError(
+      "not_authenticated",
+      err.message,
+      "This machine's registry sign-in was refreshed by another request at the same moment, so this command could not use it. Run this command again."
+    );
+  }
+  const busyOrUnreachable = err instanceof KordisNetworkError || err instanceof KordisApiError && (err.status === 429 || err.status >= 500);
+  return (busyOrUnreachable ? adaptRegistryError(err) : null) ?? memgError(
+    "not_linked",
+    `the registry refused this machine's stored sign-in: ${err instanceof Error ? err.message : String(err)}`,
+    "Nothing was sent. The link between this brain and your registry account has expired or been revoked. `memgineering login` re-links both."
+  );
+}
+async function openRegistrySession(fetchImpl) {
+  const stored = await requireRegistryCredentials();
+  let refreshed;
+  try {
+    refreshed = await refreshRegistrySession(stored, fetchImpl ? { fetchImpl } : {});
+  } catch (err) {
+    throw refusal(err);
+  }
+  const { registry, baseUrl, tokens } = refreshed;
+  const credentialsRotated = await persistRotatedRefresh(
+    registry,
+    tokens.refresh_token,
+    tokens.session_id
+  );
+  const client = new KordisClient({
+    baseUrl,
+    userAgent: `memgineering/${VERSION}`,
+    getAccessToken: () => tokens.access_token,
+    ...fetchImpl ? { fetch: fetchImpl } : {}
+  });
+  return { client, username: registry.username, apiUrl: baseUrl, credentialsRotated };
+}
+async function persistRotatedRefresh(sent, refreshToken, sessionId) {
+  if (refreshToken === sent.refresh_token && sessionId === sent.session_id) return false;
+  try {
+    return await saveRotatedRegistry(sent.refresh_token, {
+      refresh_token: refreshToken,
+      session_id: sessionId
+    });
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/logout.ts
+init_ui();
+function logoutCommand() {
+  return new Command22("logout").description("sign out of your account \u2014 the pointer and your notes stay").option("--all", "revoke every token on the account, not just this machine\u2019s").option(
+    "--local",
+    "forget the token here without telling the server \u2014 only for a server you cannot reach"
+  ).action(async (opts) => {
+    const base2 = apiUrl();
+    const credentials = await readCredentials();
+    await clearPendingLogin();
+    await clearSetupFollowUps();
+    if (!credentials) {
+      printDual({
+        json: { signed_out: true, was_signed_in: false, api_url: base2 },
+        human: () => printHuman("Not signed in \u2014 nothing to do.")
+      });
+      return;
+    }
+    if (opts.local) {
+      await clearCredentials();
+      printDual({
+        json: { signed_out: true, revoked_on_server: false, api_url: credentials.api_url },
+        human: () => {
+          printHuman("Forgotten here.");
+          printHuman(
+            c.yellow(
+              "  The token was NOT revoked \u2014 it still works for anyone holding a copy.\n  Run `memgineering logout --all` once the server is reachable."
+            )
+          );
+        }
+      });
       return;
     }
     let revoked = null;
@@ -18484,12 +19155,13 @@ function logoutCommand() {
         }) : err;
       }
     }
-    const registryRevoked = await revokeRegistrySession(credentials.registry);
+    const registry = (await readCredentials())?.registry ?? credentials.registry;
+    const registryRevoked = await revokeRegistrySession(registry);
     await clearCredentials();
     printDual({
       json: {
         signed_out: true,
-        registry: credentials.registry === void 0 ? "not-linked" : registryRevoked ? "revoked" : "revoke-failed-expires-on-its-own",
+        registry: registry === void 0 ? "not-linked" : registryRevoked ? "revoked" : "revoke-failed-expires-on-its-own",
         revoked_on_server: true,
         revoked,
         all: opts.all === true,
@@ -18514,18 +19186,16 @@ function logoutCommand() {
 async function revokeRegistrySession(reg) {
   if (!reg) return false;
   try {
-    const refreshed = await fetch(`${reg.api_url}/auth/sessions/refresh`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ refresh_token: reg.refresh_token }),
-      signal: AbortSignal.timeout(3e3)
+    const { registry, tokens } = await refreshRegistrySession(reg, {
+      apiUrlOf: (r) => r.api_url,
+      requestTimeoutMs: 3e3
     });
-    if (!refreshed.ok) return false;
-    const pair = await refreshed.json();
-    if (typeof pair.access_token !== "string" || typeof pair.session_id !== "string") return false;
-    const del = await fetch(`${reg.api_url}/auth/sessions/${pair.session_id}`, {
+    if (typeof tokens.access_token !== "string" || typeof tokens.session_id !== "string") {
+      return false;
+    }
+    const del = await fetch(`${registry.api_url}/auth/sessions/${tokens.session_id}`, {
       method: "DELETE",
-      headers: { authorization: `Bearer ${pair.access_token}` },
+      headers: { authorization: `Bearer ${tokens.access_token}` },
       signal: AbortSignal.timeout(3e3)
     });
     return del.ok;
@@ -18687,8 +19357,8 @@ init_api_client();
 init_config();
 init_cloud_brain();
 init_ui();
-import { mkdir as mkdir12, readFile as readFile20, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname6, isAbsolute as isAbsolute4, join as join19, resolve as resolve11, sep as sep2 } from "path";
+import { mkdir as mkdir13, readFile as readFile21, writeFile as writeFile11 } from "fs/promises";
+import { dirname as dirname7, isAbsolute as isAbsolute4, join as join21, resolve as resolve11, sep as sep2 } from "path";
 import { Command as Command24 } from "commander";
 function pullCommand() {
   return new Command24("pull").description("download your hosted brain to a folder on this machine").argument("[destination]", "folder to write into (created if missing)").option("--brain <name>", "which hosted brain to download").option("--dry-run", "say what would be written and write nothing").action(async (destination, opts) => {
@@ -18756,8 +19426,8 @@ function pullCommand() {
           already.push(note.path);
           continue;
         }
-        await mkdir12(dirname6(file), { recursive: true });
-        await writeFile10(file, note.content ?? "", "utf8");
+        await mkdir13(dirname7(file), { recursive: true });
+        await writeFile11(file, note.content ?? "", "utf8");
         written.push(note.path);
         if (note.excluded === true) excluded.push(note.path);
       }
@@ -18871,7 +19541,7 @@ function safeJoin(root, relative3) {
       "Nothing was written for it. This should not happen \u2014 please report it."
     );
   }
-  const full = resolve11(join19(root, relative3));
+  const full = resolve11(join21(root, relative3));
   if (full !== root && !full.startsWith(root + sep2)) {
     throw memgError(
       "server_refused",
@@ -18883,7 +19553,7 @@ function safeJoin(root, relative3) {
 }
 async function exists(file) {
   try {
-    await readFile20(file);
+    await readFile21(file);
     return true;
   } catch {
     return false;
@@ -19032,72 +19702,6 @@ ${body}`;
 init_cloud_brain();
 init_index_build();
 
-// src/lib/registry-session.ts
-init_errors();
-init_credentials();
-init_version();
-function registryApiUrl(stored) {
-  const override = process.env["KORDIS_API_URL"];
-  return override !== void 0 && override !== "" ? override : stored;
-}
-async function requireRegistryCredentials() {
-  const credentials = await readCredentials();
-  const registry = credentials?.registry;
-  if (!registry) {
-    throw memgError(
-      "not_linked",
-      "this machine holds no registry identity",
-      credentials === null ? "Nothing was sent. Sign in with `memgineering login` \u2014 it links the registry identity at the same time, so one sign-in covers both." : "Nothing was sent. This machine is signed in to a brain, and the registry half of that sign-in is missing \u2014 which is what a credential file written before federation looks like. Run `memgineering login` again; it links the registry identity too."
-    );
-  }
-  return registry;
-}
-async function openRegistrySession(fetchImpl) {
-  const registry = await requireRegistryCredentials();
-  const baseUrl = registryApiUrl(registry.api_url);
-  const anonymous = new KordisClient({
-    baseUrl,
-    userAgent: `memgineering/${VERSION}`,
-    ...fetchImpl ? { fetch: fetchImpl } : {}
-  });
-  let tokens;
-  try {
-    tokens = await anonymous.refreshSession(registry.refresh_token);
-  } catch (err) {
-    throw memgError(
-      "not_linked",
-      `the registry refused this machine's stored sign-in: ${err instanceof Error ? err.message : String(err)}`,
-      "Nothing was sent. The link between this brain and your registry account has expired or been revoked. `memgineering login` re-links both."
-    );
-  }
-  const credentialsRotated = await persistRotatedRefresh(
-    registry,
-    tokens.refresh_token,
-    tokens.session_id
-  );
-  const client = new KordisClient({
-    baseUrl,
-    userAgent: `memgineering/${VERSION}`,
-    getAccessToken: () => tokens.access_token,
-    ...fetchImpl ? { fetch: fetchImpl } : {}
-  });
-  return { client, username: registry.username, apiUrl: baseUrl, credentialsRotated };
-}
-async function persistRotatedRefresh(registry, refreshToken, sessionId) {
-  if (refreshToken === registry.refresh_token && sessionId === registry.session_id) return false;
-  try {
-    const credentials = await readCredentials();
-    if (!credentials?.registry) return false;
-    await saveCredentials({
-      ...credentials,
-      registry: { ...credentials.registry, refresh_token: refreshToken, session_id: sessionId }
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // src/lib/publish-version.ts
 import semver from "semver";
 
@@ -19793,9 +20397,9 @@ init_errors();
 init_credentials();
 
 // src/lib/untrusted-fence.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 function makeUntrustedSentinel() {
-  return `KORDIS-UNTRUSTED-${randomUUID2()}`;
+  return `KORDIS-UNTRUSTED-${randomUUID4()}`;
 }
 function fenceUntrusted(sentinel, text) {
   const neutralized = text.replace(/KORDIS-UNTRUSTED-/g, "KORDIS-UNTRUSTED\u200B-");
@@ -20290,8 +20894,8 @@ init_errors();
 
 // src/lib/harness-context.ts
 init_brand();
-import { access, readFile as readFile21 } from "fs/promises";
-import { join as join20 } from "path";
+import { access, readFile as readFile22 } from "fs/promises";
+import { join as join22 } from "path";
 var PER_FILE_CAP = 16 * 1024;
 var TOTAL_CAP = 48 * 1024;
 var TRUNCATION_RESERVE = 64;
@@ -20336,13 +20940,13 @@ function extractHeadings(content) {
 }
 async function readHarnessContext(cwd = process.cwd(), home = agentHome()) {
   const candidates = [
-    { path: join20(cwd, "CLAUDE.md"), display: "CLAUDE.md", scope: "project" },
-    { path: join20(cwd, "AGENTS.md"), display: "AGENTS.md", scope: "project" },
-    { path: join20(cwd, "GEMINI.md"), display: "GEMINI.md", scope: "project" },
-    { path: join20(cwd, ".claude", "CLAUDE.md"), display: ".claude/CLAUDE.md", scope: "project" },
-    { path: join20(home, ".claude", "CLAUDE.md"), display: "~/.claude/CLAUDE.md", scope: "global" },
-    { path: join20(home, ".codex", "AGENTS.md"), display: "~/.codex/AGENTS.md", scope: "global" },
-    { path: join20(home, ".gemini", "GEMINI.md"), display: "~/.gemini/GEMINI.md", scope: "global" }
+    { path: join22(cwd, "CLAUDE.md"), display: "CLAUDE.md", scope: "project" },
+    { path: join22(cwd, "AGENTS.md"), display: "AGENTS.md", scope: "project" },
+    { path: join22(cwd, "GEMINI.md"), display: "GEMINI.md", scope: "project" },
+    { path: join22(cwd, ".claude", "CLAUDE.md"), display: ".claude/CLAUDE.md", scope: "project" },
+    { path: join22(home, ".claude", "CLAUDE.md"), display: "~/.claude/CLAUDE.md", scope: "global" },
+    { path: join22(home, ".codex", "AGENTS.md"), display: "~/.codex/AGENTS.md", scope: "global" },
+    { path: join22(home, ".gemini", "GEMINI.md"), display: "~/.gemini/GEMINI.md", scope: "global" }
   ];
   const files2 = [];
   let totalBytes = 0;
@@ -20350,7 +20954,7 @@ async function readHarnessContext(cwd = process.cwd(), home = agentHome()) {
     if (!await pathExists(cand.path)) continue;
     let raw;
     try {
-      raw = await readFile21(cand.path, "utf8");
+      raw = await readFile22(cand.path, "utf8");
     } catch {
       continue;
     }
@@ -20747,8 +21351,8 @@ function parseLimit2(raw) {
 import { Command as Command30 } from "commander";
 import prompts3 from "prompts";
 import { existsSync, lstatSync, realpathSync } from "fs";
-import { mkdir as mkdir14, readFile as readFile23, stat as stat5, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname7, join as join22, resolve as resolve12, sep as sep3 } from "path";
+import { mkdir as mkdir15, readFile as readFile24, stat as stat7, writeFile as writeFile13 } from "fs/promises";
+import { dirname as dirname8, join as join24, resolve as resolve12, sep as sep3 } from "path";
 
 // ../../packages/translators/src/skill/identity.ts
 function buildSkillFile(input, outputPath) {
@@ -21323,80 +21927,31 @@ function getTranslator(type, format) {
   return fn;
 }
 
-// src/commands/registry/pull.ts
-init_errors();
-init_ui();
-
-// src/lib/lockfile.ts
-init_brand();
-import { copyFile, mkdir as mkdir13, readFile as readFile22, writeFile as writeFile11, constants as fsConstants } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { join as join21 } from "path";
-function effectiveRange(entry) {
-  return entry.requestedRange ?? `^${entry.version}`;
-}
-function lockfilePath() {
-  return join21(brandHome(), "installed.json");
-}
-function kordisLockfilePath() {
-  return join21(process.env["KORDIS_HOME"] ?? join21(homedir4(), ".kordis"), "installed.json");
-}
-function lockfileDisplayPath() {
-  const path = lockfilePath();
-  const home = process.env["HOME"];
-  return home !== void 0 && home !== "" && path.startsWith(home) ? "~" + path.slice(home.length) : path;
-}
-async function migrateFromKordis() {
-  const source = kordisLockfilePath();
-  const destination = lockfilePath();
-  try {
-    await mkdir13(brandHome(), { recursive: true });
-    await copyFile(source, destination, fsConstants.COPYFILE_EXCL);
-  } catch {
-    return;
-  }
-  try {
-    const raw = await readFile22(destination, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed.migratedFrom === void 0) {
-      parsed.migratedFrom = source;
-      await writeLockfile(parsed);
-    }
-  } catch {
-  }
-}
-async function readLockfile() {
-  try {
-    return JSON.parse(await readFile22(lockfilePath(), "utf8"));
-  } catch {
-    await migrateFromKordis();
+// ../../packages/translators/src/merge-emitted-file.ts
+import tomlLib2 from "@iarna/toml";
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
+var MergeRefusal = class extends Error {
+  code;
+  reason;
+  constructor(reason) {
+    super(refusalMessage(reason));
+    this.name = "MergeRefusal";
+    this.code = reason.kind === "prototype_key" ? "unsafe_package_config" : "merge_refused";
+    this.reason = reason;
   }
-  try {
-    return JSON.parse(await readFile22(lockfilePath(), "utf8"));
-  } catch {
-    return { packages: {} };
+};
+function refusalMessage(reason) {
+  switch (reason.kind) {
+    case "prototype_key":
+      return `refusing to merge config fragment \u2014 prototype-polluting key "${reason.key}" at ${reason.path}`;
+    case "malformed_file":
+      return `refusing to merge into "${reason.targetPath}" \u2014 existing file is not valid ${reason.format.toUpperCase()}: ${reason.parseError}`;
+    case "non_object_root":
+      return `refusing to merge into "${reason.targetPath}" \u2014 existing ${reason.format.toUpperCase()} root is not an object`;
+    case "dangling_marker":
+      return `refusing to merge \u2014 found a "kordis:${reason.fullSlug}" start marker with no matching end marker`;
   }
 }
-async function writeLockfile(lf) {
-  await mkdir13(brandHome(), { recursive: true });
-  await writeFile11(lockfilePath(), JSON.stringify(lf, null, 2) + "\n", {
-    encoding: "utf8",
-    mode: 384
-  });
-}
-async function recordInstalled(fullSlug, entry) {
-  const home = brandHome();
-  await withFileLock(join21(home, "installed.lock"), home, async () => {
-    const lf = await readLockfile();
-    lf.packages[fullSlug] = entry;
-    await writeLockfile(lf);
-  });
-}
-
-// src/lib/merge-emitted-file.ts
-init_errors();
-import tomlLib2 from "@iarna/toml";
-import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 function isPlainObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -21421,11 +21976,7 @@ function assertNoProtoKeys(value, path) {
   if (!isPlainObject(value)) return;
   for (const [k, v] of Object.entries(value)) {
     if (PROTO_KEYS.has(k)) {
-      throw memgError(
-        "unsafe_package_config",
-        `refusing to merge config fragment \u2014 prototype-polluting key "${k}" at ${[...path, k].join(".")}`,
-        "Nothing was written. The package emits a config key named __proto__, constructor or prototype, which no legitimate tool config needs. Do not install it, and tell the author if you did not publish it."
-      );
+      throw new MergeRefusal({ kind: "prototype_key", key: k, path: [...path, k].join(".") });
     }
     assertNoProtoKeys(v, [...path, k]);
   }
@@ -21434,12 +21985,15 @@ function isOwnedServerLeaf(path) {
   return path.length === 2 && (path[0] === "mcpServers" || path[0] === "mcp_servers");
 }
 function deepMergeFragment(existing, fragment, path = []) {
-  if (path.length === 0) assertNoProtoKeys(fragment, []);
+  assertNoProtoKeys(fragment, path);
+  return mergeAt(existing, fragment, path);
+}
+function mergeAt(existing, fragment, path) {
   if (isOwnedServerLeaf(path)) return fragment;
   if (isPlainObject(existing) && isPlainObject(fragment)) {
     const out = { ...existing };
     for (const [k, v] of Object.entries(fragment)) {
-      out[k] = deepMergeFragment(existing[k], v, [...path, k]);
+      out[k] = mergeAt(existing[k], v, [...path, k]);
     }
     return out;
   }
@@ -21482,18 +22036,15 @@ function mergeStructuredFile(existingRaw, fragmentRaw, format, targetPath) {
   try {
     existing = parseStructured(existingRaw, format);
   } catch (err) {
-    throw memgError(
-      "merge_refused",
-      `refusing to merge into "${targetPath}" \u2014 existing file is not valid ${format.toUpperCase()}: ${err.message}`,
-      `Nothing was written. Fix or move aside the malformed ${targetPath}, then run the install again. It is not overwritten blind because it may hold configuration from other tools and other packages.`
-    );
+    throw new MergeRefusal({
+      kind: "malformed_file",
+      targetPath,
+      format,
+      parseError: err.message
+    });
   }
   if (!isPlainObject(existing) && isPlainObject(fragment)) {
-    throw memgError(
-      "merge_refused",
-      `refusing to merge into "${targetPath}" \u2014 existing ${format.toUpperCase()} root is not an object`,
-      `Nothing was written. ${targetPath} parses, but its top level is not an object, so a config fragment cannot be merged into it. Fix its shape or move it aside, then run the install again.`
-    );
+    throw new MergeRefusal({ kind: "non_object_root", targetPath, format });
   }
   const merged = deepMergeFragment(existing, fragment);
   return stringifyStructured(merged, format);
@@ -21515,15 +22066,100 @@ function mergeFencedFile(existingRaw, fullSlug, block) {
     return existingRaw.slice(0, startMatch.index) + trimmedBlock + existingRaw.slice(spanEnd);
   }
   if (startMatch && endIdx === -1) {
-    throw memgError(
-      "merge_refused",
-      `refusing to merge \u2014 found a "kordis:${fullSlug}" start marker with no matching end marker`,
-      `Nothing was written. The file has a dangling <!-- kordis:${fullSlug}:\u2026:start --> marker. Delete that line, or restore its <!-- kordis:${fullSlug}:end --> line, then run the install again.`
-    );
+    throw new MergeRefusal({ kind: "dangling_marker", fullSlug });
   }
   return existingRaw.trimEnd() + "\n\n" + trimmedBlock + "\n";
 }
 
+// src/commands/registry/pull.ts
+init_errors();
+init_ui();
+
+// src/lib/lockfile.ts
+init_brand();
+import { copyFile, mkdir as mkdir14, readFile as readFile23, writeFile as writeFile12, constants as fsConstants } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join23 } from "path";
+function effectiveRange(entry) {
+  return entry.requestedRange ?? `^${entry.version}`;
+}
+function lockfilePath() {
+  return join23(brandHome(), "installed.json");
+}
+function kordisLockfilePath() {
+  return join23(process.env["KORDIS_HOME"] ?? join23(homedir4(), ".kordis"), "installed.json");
+}
+function lockfileDisplayPath() {
+  const path = lockfilePath();
+  const home = process.env["HOME"];
+  return home !== void 0 && home !== "" && path.startsWith(home) ? "~" + path.slice(home.length) : path;
+}
+async function migrateFromKordis() {
+  const source = kordisLockfilePath();
+  const destination = lockfilePath();
+  try {
+    await mkdir14(brandHome(), { recursive: true });
+    await copyFile(source, destination, fsConstants.COPYFILE_EXCL);
+  } catch {
+    return;
+  }
+  try {
+    const raw = await readFile23(destination, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.migratedFrom === void 0) {
+      parsed.migratedFrom = source;
+      await writeLockfile(parsed);
+    }
+  } catch {
+  }
+}
+async function readLockfile() {
+  try {
+    return JSON.parse(await readFile23(lockfilePath(), "utf8"));
+  } catch {
+    await migrateFromKordis();
+  }
+  try {
+    return JSON.parse(await readFile23(lockfilePath(), "utf8"));
+  } catch {
+    return { packages: {} };
+  }
+}
+async function writeLockfile(lf) {
+  await mkdir14(brandHome(), { recursive: true });
+  await writeFile12(lockfilePath(), JSON.stringify(lf, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+async function recordInstalled(fullSlug, entry) {
+  const home = brandHome();
+  await withFileLock(join23(home, "installed.lock"), home, async () => {
+    const lf = await readLockfile();
+    lf.packages[fullSlug] = entry;
+    await writeLockfile(lf);
+  });
+}
+
+// src/lib/merge-refusal.ts
+init_errors();
+function adaptMergeRefusal(err) {
+  if (!(err instanceof MergeRefusal)) return null;
+  return memgError(err.code, err.message, mergeRefusalHint(err.reason));
+}
+function mergeRefusalHint(reason) {
+  switch (reason.kind) {
+    case "prototype_key":
+      return "Nothing was written. The package emits a config key named __proto__, constructor or prototype, which no legitimate tool config needs. Do not install it, and tell the author if you did not publish it.";
+    case "malformed_file":
+      return `Nothing was written. Fix or move aside the malformed ${reason.targetPath}, then run the install again. It is not overwritten blind because it may hold configuration from other tools and other packages.`;
+    case "non_object_root":
+      return `Nothing was written. ${reason.targetPath} parses, but its top level is not an object, so a config fragment cannot be merged into it. Fix its shape or move it aside, then run the install again.`;
+    case "dangling_marker":
+      return `Nothing was written. The file has a dangling <!-- kordis:${reason.fullSlug}:\u2026:start --> marker. Delete that line, or restore its <!-- kordis:${reason.fullSlug}:end --> line, then run the install again.`;
+  }
+}
+
 // src/commands/registry/pull.ts
 async function requireExecutableApproval(pkg, fullSlug, files2, approve2) {
   if (!pkg.capabilities.executable) return;
@@ -21654,7 +22290,7 @@ async function doPullInstall(fullSlug, tool, installRoot, opts = {}) {
   );
   for (const f of translated.files) {
     const abs = safeInstallPath(installRoot, f.path);
-    await mkdir14(dirname7(abs), { recursive: true });
+    await mkdir15(dirname8(abs), { recursive: true });
     await applyEmittedFile(abs, f, fullSlug, notes);
     written.push(abs);
   }
@@ -21810,7 +22446,7 @@ var TOOL_MARKERS = [
 async function detectTool(root) {
   for (const [path, tool] of TOOL_MARKERS) {
     try {
-      await stat5(join22(root, path));
+      await stat7(join24(root, path));
       return tool;
     } catch {
     }
@@ -21826,7 +22462,7 @@ function safeInstallPath(installRoot, relPath) {
       "Nothing was written. The package emits an absolute file path. Tell the author to publish it with relative paths only; if you did not publish it, treat it as an attempt to write outside your project."
     );
   }
-  const abs = join22(installRoot, relPath);
+  const abs = join24(installRoot, relPath);
   const resolvedRoot = resolve12(installRoot);
   const resolvedAbs = resolve12(abs);
   if (resolvedAbs !== resolvedRoot && !resolvedAbs.startsWith(resolvedRoot + sep3)) {
@@ -21842,9 +22478,9 @@ function safeInstallPath(installRoot, relPath) {
   } catch {
     return abs;
   }
-  let ancestor = dirname7(resolvedAbs);
+  let ancestor = dirname8(resolvedAbs);
   while (!existsSync(ancestor)) {
-    const parent = dirname7(ancestor);
+    const parent = dirname8(ancestor);
     if (parent === ancestor) break;
     ancestor = parent;
   }
@@ -21880,9 +22516,9 @@ function safeInstallPath(installRoot, relPath) {
 }
 async function writeEmittedFile(abs, content, encoding) {
   if (encoding === "base64") {
-    await writeFile12(abs, Buffer.from(content, "base64"));
+    await writeFile13(abs, Buffer.from(content, "base64"));
   } else {
-    await writeFile12(abs, content, "utf8");
+    await writeFile13(abs, content, "utf8");
   }
 }
 async function applyEmittedFile(abs, f, fullSlug, notes) {
@@ -21892,21 +22528,32 @@ async function applyEmittedFile(abs, f, fullSlug, notes) {
   }
   let existingRaw = null;
   try {
-    existingRaw = await readFile23(abs, "utf8");
+    existingRaw = await readFile24(abs, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
   if (f.format === "json" || f.format === "yaml" || f.format === "toml") {
-    const merged = mergeStructuredFile(existingRaw, f.content, f.format, abs);
+    let merged;
+    try {
+      merged = mergeStructuredFile(existingRaw, f.content, f.format, abs);
+    } catch (err) {
+      throw adaptMergeRefusal(err) ?? err;
+    }
     if (existingRaw !== null && existingRaw.trim() !== "") {
       notes?.push(
         `merged into ${f.path} \u2014 comments/formatting in the existing file are not preserved`
       );
     }
-    await writeFile12(abs, merged, "utf8");
+    await writeFile13(abs, merged, "utf8");
     return;
   }
-  await writeFile12(abs, mergeFencedFile(existingRaw, fullSlug, f.content), "utf8");
+  let fenced;
+  try {
+    fenced = mergeFencedFile(existingRaw, fullSlug, f.content);
+  } catch (err) {
+    throw adaptMergeRefusal(err) ?? err;
+  }
+  await writeFile13(abs, fenced, "utf8");
 }
 
 // src/commands/registry/update.ts
@@ -22409,12 +23056,14 @@ init_push();
 
 // src/commands/recall.ts
 init_src();
+init_exclude();
 init_config();
 import { Command as Command37 } from "commander";
-import { basename as basename2, resolve as resolve13 } from "path";
+import { basename as basename3, resolve as resolve13 } from "path";
 init_index_build();
 init_cloud_brain();
 init_errors();
+init_held_back();
 init_vault();
 init_ui();
 function recallCommand() {
@@ -22439,6 +23088,10 @@ function recallCommand() {
       let unsearchedBrains = [];
       let unsearchedLocal = [];
       let searchedLocalName = null;
+      let nothingToSearch = null;
+      let alsoLeftOut = null;
+      let namedIsPointer = false;
+      let serverHint;
       let isScaffolding;
       let templatesWithheld = 0;
       let spread = null;
@@ -22485,8 +23138,19 @@ function recallCommand() {
         }));
         spread = isScopeSpread(answered.scope_spread) ? answered.scope_spread : null;
         templatesWithheld = Number.isInteger(answered.templates_withheld) && (answered.templates_withheld ?? 0) > 0 ? answered.templates_withheld : 0;
-        if (rows.length === 0) {
-          unsearchedBrains = await listCloudBrains(cloud.token, cloud.apiUrl, { retries: 0 }).then((all) => all.filter((b) => b.id !== cloud.brainId)).catch(() => []);
+        if (rows.every(({ card }) => unfilledIds.has(card.id))) {
+          const listed = await listCloudBrains(cloud.token, cloud.apiUrl, { retries: 0 }).catch(
+            () => []
+          );
+          unsearchedBrains = listed.filter((b) => b.id !== cloud.brainId);
+          if (listed.find((b) => b.id === cloud.brainId)?.note_count === 0) {
+            nothingToSearch = { kind: "no_notes" };
+          }
+          if (opts.brain !== void 0) {
+            const pointer = await hostedPointer().catch(() => null);
+            namedIsPointer = pointer !== null && pointer.id === cloud.brainId && (pointer.signedIn || pointer.signInPending);
+          }
+          serverHint = typeof answered.hint === "string" && answered.hint.trim() !== "" ? answered.hint : void 0;
         }
         isScaffolding = (card) => unfilledIds.has(card.id);
         reasons = /* @__PURE__ */ new Map();
@@ -22528,7 +23192,11 @@ function recallCommand() {
         );
         isScaffolding = (card) => scaffolding.has(byId.get(card.id)?.path ?? "");
         const sides = new Set(local.conflicts.flatMap((conflict) => conflict.between));
-        const capped2 = capTemplates(local.memory_cards, isScaffolding, (card) => sides.has(card.id));
+        const capped2 = capTemplates(
+          local.memory_cards,
+          isScaffolding,
+          (card) => sides.has(card.id)
+        );
         templatesWithheld = capped2.withheld.length;
         result = { ...local, memory_cards: capped2.kept };
         entries = built.entries;
@@ -22541,8 +23209,16 @@ function recallCommand() {
             built.entries.map((e) => declaredScope(e.memory))
           );
         }
-        if (result.memory_cards.length === 0) {
-          searchedLocalName = basename2(resolve13(brain.root));
+        if (result.memory_cards.every((card) => isScaffolding(card))) {
+          const leftOut = await adapter.scan().then((scan) => leftOutOf(heldBack(scan), built.denied)).catch(() => void 0);
+          if (built.entries.length === 0) {
+            if (leftOut !== void 0) {
+              nothingToSearch = leftOut === null ? { kind: "no_notes" } : { kind: "all_left_out", leftOut };
+            }
+          } else {
+            alsoLeftOut = leftOut ?? null;
+          }
+          searchedLocalName = basename3(resolve13(brain.root));
           unsearchedLocal = await loadConfig().then(
             (cfg) => cfg.brain.brains.filter((other) => resolve13(other.root) !== resolve13(brain.root)).map((other) => ({ root: other.root }))
           ).catch(() => []);
@@ -22570,6 +23246,32 @@ function recallCommand() {
         );
         reasons = result.conflicts.length > 0 ? await conflictReasons(brain.root, result.conflicts, byId) : /* @__PURE__ */ new Map();
       }
+      const reachedSomethingWritten = rows.some(({ card }) => !isScaffolding(card));
+      const otherScript = reachedSomethingWritten ? null : entries ? unreachableScript(query, entries) : null;
+      const advice = !reachedSomethingWritten ? emptyRecallAdvice({
+        query,
+        depth,
+        scoped: Boolean(opts.scope),
+        chosenWith: {
+          ...opts.brain === void 0 || namedIsPointer ? {} : { brain: answeredBy ?? opts.brain },
+          ...opts.local === true ? { local: true } : {},
+          ...opts.vault === void 0 ? {} : { vault: opts.vault }
+        },
+        nothingToSearch,
+        alsoLeftOut,
+        otherScript,
+        unsearched: unsearchedBrains.length > 0 ? {
+          searched: answeredBy ?? "",
+          flag: "--brain",
+          others: unsearchedBrains.map((other) => other.name)
+        } : unsearchedLocal.length > 0 ? {
+          searched: searchedLocalName ?? "",
+          flag: "--vault",
+          others: unsearchedLocal.map((other) => other.root)
+        } : null,
+        semanticHint: semantic.state === "skipped" ? semantic.hint : void 0,
+        serverHint
+      }) : null;
       printDual({
         json: {
           query,
@@ -22608,20 +23310,29 @@ function recallCommand() {
           // Counted, never silent: these matched and were left off because
           // they are still exactly what `init` wrote.
           ...templatesWithheld > 0 ? { templates_withheld: templatesWithheld } : {},
-          ...spread === null ? {} : { scope_spread: spread }
+          ...spread === null ? {} : { scope_spread: spread },
+          // Only when nothing the person wrote came back — no card, or only
+          // untouched templates: the one next step the footer would have led
+          // with. An agent reading `cards: []` alone cannot tell an empty
+          // brain from a missed word from an unread brain, and one reading
+          // template cards alone took them for the whole brain.
+          ...advice === null ? {} : { hint: advice.hint }
         },
         human: () => {
           const brainHeading = answeredBy === null ? "" : ` \u2014 ${oneLine(answeredBy, WIDTH.title)}`;
-          const reachedSomethingWritten = rows.some(({ card }) => !isScaffolding(card));
-          const otherScript = reachedSomethingWritten ? null : entries ? unreachableScript(query, entries) : null;
-          const sayWhy = () => {
+          const sayWhy = (notice2) => {
             printHuman(
-              c.yellow(
-                `\u26A0 This brain's notes are mostly written in ${otherScript}, and this query is not.`
-              ) + c.gray(
+              c.yellow(`\u26A0 ${notice2.headline}`) + c.gray(`
+${notice2.lines.map((line) => `  ${line}`).join("\n")}
+`)
+            );
+          };
+          const sayOtherBrains = (otherBrains) => {
+            printHuman(
+              c.yellow(`\u26A0 ${otherBrains.headline}`) + c.gray(
                 `
-  Search matches text, not meaning, so no rewording in another language will reach them.
-  Ask again in ${otherScript}, or run \`memgineering resurface\` to see what is here.
+${otherBrains.commands.map((cmd) => `  ${cmd}`).join("\n")}
+  ${otherBrains.safe}
 `
               )
             );
@@ -22634,60 +23345,18 @@ function recallCommand() {
 `)
             );
           };
-          if (rows.length === 0) {
+          if (advice !== null && rows.length === 0) {
             printHuman(`## recall: ${query}${brainHeading}
 `);
             printHuman("_Nothing matched._\n");
             sayDegraded();
-            if (otherScript) {
-              sayWhy();
+            if (advice.leftOut !== null) sayWhy(advice.leftOut);
+            if (advice.otherScript !== null) {
+              sayWhy(advice.otherScript);
               return;
             }
-            if (unsearchedBrains.length > 0) {
-              printHuman(
-                c.yellow(
-                  `\u26A0 Only \`${oneLine(answeredBy ?? "", WIDTH.title)}\` was searched \u2014 this account has ${unsearchedBrains.length + 1} brains.`
-                ) + c.gray(
-                  `
-${unsearchedBrains.map(
-                    (brain) => `  memgineering recall ${JSON.stringify(query)} --brain ${JSON.stringify(brain.name)}`
-                  ).join(
-                    "\n"
-                  )}
-  Safe to run \u2014 reading another brain does not change which one this machine points at.
-`
-                )
-              );
-            }
-            if (unsearchedLocal.length > 0) {
-              printHuman(
-                c.yellow(
-                  `\u26A0 Only \`${oneLine(searchedLocalName ?? "", WIDTH.title)}\` was searched \u2014 ${unsearchedLocal.length + 1} brains are linked on this machine.`
-                ) + c.gray(
-                  `
-${unsearchedLocal.map(
-                    (other) => `  memgineering recall ${JSON.stringify(query)} --vault ${JSON.stringify(other.root)}`
-                  ).join(
-                    "\n"
-                  )}
-  Safe to run \u2014 reading another brain does not change which one this folder points at.
-`
-                )
-              );
-            }
-            printHuman(
-              c.gray(
-                // "Within this brain" is load-bearing when the warning above
-                // has just said another brain went unsearched. The enumeration
-                // reads as the whole surface — a recheck tester called this
-                // the last line on screen and a false all-clear, sitting below
-                // the one line that says otherwise.
-                (depth === "exact" ? "Within this brain, `--depth exact` searches the card only \u2014 titles, aliases, entities, summaries and scope \u2014 try `--depth standard` to search note bodies too, or fewer words" : "Within this brain, titles, aliases, summaries and note bodies are all searched \u2014 try fewer or broader words") + // Only when the reader actually passed one. Telling somebody
-                // to drop an argument they never supplied cost one tester a
-                // whole command to `--help` to find out it was not their bug.
-                (opts.scope ? ", or drop --scope." : ".")
-              )
-            );
+            if (advice.otherBrains !== null) sayOtherBrains(advice.otherBrains);
+            if (advice.withinThisBrain !== null) printHuman(c.gray(advice.withinThisBrain));
             return;
           }
           printHuman(`## recall: ${query}${brainHeading}  (${rows.length} cards)
@@ -22699,6 +23368,10 @@ ${unsearchedLocal.map(
                 "\n  Every card below is still the template `init` wrote \u2014 nobody has answered\n  these yet, so none of them is evidence of anything.\n  `memgineering onboard` prints what to ask to fill them in.\n"
               )
             );
+            if (advice !== null && advice.leftOut !== null) sayWhy(advice.leftOut);
+            if (advice !== null && advice.otherScript === null && advice.otherBrains !== null) {
+              sayOtherBrains(advice.otherBrains);
+            }
           }
           const templateCount = rows.filter(({ card }) => isScaffolding(card)).length;
           if (reachedSomethingWritten && templateCount > 0) {
@@ -22728,7 +23401,7 @@ ${unsearchedLocal.map(
               )
             );
           }
-          if (otherScript) sayWhy();
+          if (otherScript) sayWhy(otherScriptNotice(otherScript));
           const glossOn = rows.findIndex(
             ({ card }) => card.confidence === "stated" && !isScaffolding(card)
           );
@@ -22896,6 +23569,114 @@ function ago2(days) {
   if (days < 365) return `${Math.floor(days / 30)} months ago`;
   return `${Math.floor(days / 365)} years ago`;
 }
+function emptyRecallAdvice(facts) {
+  const otherScript = facts.otherScript === null ? null : otherScriptNotice(facts.otherScript);
+  const otherBrains = facts.unsearched === null || facts.unsearched.others.length === 0 ? null : unsearchedNotice(facts.query, facts.unsearched);
+  const nothing = facts.nothingToSearch;
+  const leftOut = nothing?.kind === "all_left_out" ? leftOutNotice(nothing.leftOut, facts.chosenWith, "all") : facts.alsoLeftOut === null || notesIn(facts.alsoLeftOut) === 0 ? null : leftOutNotice(facts.alsoLeftOut, facts.chosenWith, "some");
+  const within = (
+    // "Within this brain" is load-bearing when the warning above it has just
+    // said another brain went unsearched. The enumeration reads as the whole
+    // surface — a recheck tester called this the last line on screen and a
+    // false all-clear, sitting below the one line that says otherwise. Below
+    // a count of held-back notes it would be the same false all-clear.
+    (leftOut === null ? "Within this brain" : "Within the rest of this brain") + (facts.depth === "exact" ? ", `--depth exact` searches the card only \u2014 titles, aliases, entities, summaries and scope \u2014 try `--depth standard` to search note bodies too, or fewer words" : ", titles, aliases, summaries and note bodies are all searched \u2014 try fewer or broader words") + // Only when the reader actually passed one. Telling somebody to drop an
+    // argument they never supplied cost one tester a whole command to `--help`
+    // to find out it was not their bug.
+    (facts.scoped ? ", or drop --scope." : ".")
+  );
+  const hint = (() => {
+    if (nothing !== null) return nothingToSearchHint(nothing, facts.chosenWith);
+    const next = (() => {
+      if (otherScript !== null) return [otherScript.headline, ...otherScript.lines].join(" ");
+      if (otherBrains !== null) {
+        const runnable = otherBrains.commands.map((cmd) => `\`${cmd}\``).join(", ");
+        return `${otherBrains.headline} To search ${otherBrains.commands.length === 1 ? "the other one" : "the others"}: ${runnable}. ${otherBrains.safe}`;
+      }
+      if (facts.semanticHint !== void 0) {
+        return `Meaning was not searched \u2014 words only: ${facts.semanticHint}`;
+      }
+      if (facts.serverHint !== void 0) return facts.serverHint;
+      return within;
+    })();
+    return leftOut === null ? next : `${noticeText(leftOut)} ${next}`;
+  })();
+  return {
+    hint,
+    leftOut,
+    otherScript,
+    otherBrains,
+    // Nothing was searched, so no wording reaches anything.
+    withinThisBrain: nothing?.kind === "all_left_out" ? null : within
+  };
+}
+function noticeText(notice2) {
+  return [notice2.headline, ...notice2.lines].join(" ");
+}
+function otherScriptNotice(script) {
+  return {
+    headline: `This brain's notes are mostly written in ${script}, and this query is not.`,
+    lines: [
+      "Search matches text, not meaning, so no rewording in another language will reach them.",
+      `Ask again in ${script}, or run \`memgineering resurface\` to see what is here.`
+    ]
+  };
+}
+function unsearchedNotice(query, unsearched) {
+  const total = unsearched.others.length + 1;
+  const hosted = unsearched.flag === "--brain";
+  return {
+    headline: `Only \`${oneLine(unsearched.searched, WIDTH.title)}\` was searched \u2014 ${hosted ? `this account has ${total} brains` : `${total} brains are linked on this machine`}.`,
+    commands: unsearched.others.map(
+      (other) => `memgineering recall ${JSON.stringify(query)} ${unsearched.flag} ${JSON.stringify(other)}`
+    ),
+    safe: `Safe to run \u2014 reading another brain does not change which one this ${hosted ? "machine" : "folder"} points at.`
+  };
+}
+function nothingToSearchHint(nothing, chosenWith) {
+  return nothing.kind === "no_notes" ? emptyBrainHint(chosenWith) : noticeText(leftOutNotice(nothing.leftOut, chosenWith, "all"));
+}
+function folderFlags(chosenWith) {
+  return (chosenWith.local === true ? " --local" : "") + (chosenWith.vault === void 0 ? "" : ` --vault ${JSON.stringify(chosenWith.vault)}`);
+}
+function emptyBrainHint(chosenWith) {
+  if (chosenWith.brain !== void 0) {
+    return `This brain has no notes yet. \`memgineering remember\` writes to the brain this machine points at, not to this one \u2014 \`memgineering use --brain ${JSON.stringify(chosenWith.brain)}\` points it here first, if this is where the user wants the note.`;
+  }
+  return `This brain has no notes yet; \`memgineering remember "<what to keep>" --reason "<why>"${folderFlags(chosenWith)}\` writes the first one.`;
+}
+function leftOutNotice(leftOut, chosenWith, share) {
+  const notes = (n) => `${n} note${n === 1 ? "" : "s"}`;
+  const parts = [
+    leftOut.byRule > 0 ? `${notes(leftOut.byRule)} excluded by your rules` : null,
+    leftOut.listed > 0 ? `${notes(leftOut.listed)} listed in .memgdeny` : null,
+    leftOut.byName > 0 ? `${notes(leftOut.byName)} held back because the name looks private` : null,
+    leftOut.byContent > 0 ? `${notes(leftOut.byContent)} refused because the content looks like a credential` : null,
+    leftOut.symlinked > 0 ? `${notes(leftOut.symlinked)} behind a symlink, which is never followed` : null,
+    leftOut.otherSymlinks > 0 ? `${leftOut.otherSymlinks} other symlink${leftOut.otherSymlinks === 1 ? "" : "s"}, never followed, so a folder behind one was not looked inside` : null,
+    leftOut.folders > 0 ? `${leftOut.folders} excluded folder${leftOut.folders === 1 ? "" : "s"}, not looked inside` : null
+  ].filter((part) => part !== null);
+  return {
+    headline: `${share === "all" ? "Nothing in this brain could be searched" : "Not every note in this brain was searched"}: ${parts.join(", ")}.`,
+    lines: [`\`memgineering reindex${folderFlags(chosenWith)}\` names each one and why.`]
+  };
+}
+function notesIn(leftOut) {
+  return leftOut.byRule + leftOut.listed + leftOut.byName + leftOut.byContent + leftOut.symlinked;
+}
+function leftOutOf(held, denied) {
+  const refused = (reason) => denied.filter((d) => d.reason === reason).length;
+  const leftOut = {
+    byRule: held.byRule.filter((path) => !isExcluded(path, false)).length + refused("excluded"),
+    listed: held.explicitly.length + refused("explicit"),
+    byName: held.byName.length + refused("name"),
+    byContent: refused("content"),
+    symlinked: held.symlinked.length,
+    otherSymlinks: held.otherSymlinks.filter((path) => !isExcluded(path, false)).length,
+    folders: held.folders.filter((dir) => !isExcluded(dir, true)).length
+  };
+  return Object.values(leftOut).some((n) => n > 0) ? leftOut : null;
+}
 function unreachableScript(query, entries) {
   const queryScripts = scriptsIn(query);
   if (queryScripts.size === 0) return null;
@@ -22957,15 +23738,17 @@ function isScopeSpread(value) {
 }
 
 // src/commands/resurface.ts
+init_setup();
+init_ui();
 init_deadline();
 init_src();
-import { Command as Command38 } from "commander";
+import { Command as Command39 } from "commander";
 init_index_build();
 init_cloud_brain();
 init_vault();
 init_ui();
 function resurfaceCommand() {
-  return new Command38("resurface").description("what is worth having in view right now, without being asked").option("--context-dir <path>", "where the work is happening (default: cwd)").option("--limit <n>", "how many cards", (v) => parseInt(v, 10), 5).option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
+  return new Command39("resurface").description("what is worth having in view right now, without being asked").option("--context-dir <path>", "where the work is happening (default: cwd)").option("--limit <n>", "how many cards", (v) => parseInt(v, 10), 5).option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
     "--brain <name>",
     "read one existing hosted brain by name or id, without changing the pointer"
   ).option(
@@ -22976,6 +23759,11 @@ function resurfaceCommand() {
     async (opts) => {
       const bounded = (work) => opts.deadline !== void 0 && Number.isFinite(opts.deadline) ? withDeadline(opts.deadline, work) : work();
       await bounded(async () => {
+        await refreshOwnHooksAndTell(
+          (text) => (isJsonMode() ? process.stderr : process.stdout).write(`${text}
+
+`)
+        );
         const contextDir = opts.contextDir ?? process.cwd();
         const where = await resolveTarget({
           ...opts.brain === void 0 ? {} : { brain: opts.brain },
@@ -23187,11 +23975,11 @@ rank by project yet, so that is not one of the signals above.`
 }
 
 // src/commands/rules.ts
-import { Command as Command39 } from "commander";
+import { Command as Command40 } from "commander";
 init_cloud_brain();
 init_ui();
 function rulesCommand() {
-  return new Command39("rules").description("the user\u2019s standing decisions \u2014 what binds you here").option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
+  return new Command40("rules").description("the user\u2019s standing decisions \u2014 what binds you here").option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
     "--brain <name>",
     "read one existing hosted brain by name or id, without changing the pointer"
   ).action(async (opts) => {
@@ -23358,16 +24146,16 @@ init_next_step();
 init_provenance();
 import { spawn as spawn4 } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
-import { mkdir as mkdir18, open, readFile as readFile27, rename as rename4, rm as rm8, stat as stat7, unlink as unlink4, writeFile as writeFile15 } from "fs/promises";
-import { join as join28 } from "path";
+import { mkdir as mkdir19, open, readFile as readFile29, rename as rename5, rm as rm8, stat as stat9, unlink as unlink6, writeFile as writeFile16 } from "fs/promises";
+import { join as join31 } from "path";
 import { Command as Command41 } from "commander";
 
 // src/lib/update-check.ts
 init_atomic();
 init_brand();
 import { execFile as execFile2 } from "child_process";
-import { mkdir as mkdir17, readFile as readFile26, writeFile as writeFile14 } from "fs/promises";
-import { join as join27 } from "path";
+import { mkdir as mkdir18, readFile as readFile28, writeFile as writeFile15 } from "fs/promises";
+import { join as join30 } from "path";
 import { promisify as promisify2 } from "util";
 import semver4 from "semver";
 import { z as z33 } from "zod";
@@ -23448,11 +24236,11 @@ var UpdateStateSchema = z33.object({
   message: z33.string().nullable()
 });
 function statePath() {
-  return join27(brandHome(), "update-state.json");
+  return join30(brandHome(), "update-state.json");
 }
 async function readUpdateState() {
   try {
-    const parsed = UpdateStateSchema.safeParse(JSON.parse(await readFile26(statePath(), "utf8")));
+    const parsed = UpdateStateSchema.safeParse(JSON.parse(await readFile28(statePath(), "utf8")));
     return parsed.success ? parsed.data : null;
   } catch {
     return null;
@@ -23460,7 +24248,7 @@ async function readUpdateState() {
 }
 async function writeUpdateState(state) {
   try {
-    await mkdir17(brandHome(), { recursive: true });
+    await mkdir18(brandHome(), { recursive: true });
     await writeThenRename(statePath(), `${JSON.stringify(state, null, 2)}
 `);
   } catch {
@@ -23572,7 +24360,7 @@ async function runUpdate(opts, inherited) {
   }
   const held = await holdUpdateSlot(inherited);
   if (held === null && await blockedBy() === "stuck") {
-    const lock = join28(brandHome(), RECLAIM_LOCK);
+    const lock = join31(brandHome(), RECLAIM_LOCK);
     const hint = `A previous update did not finish, and clearing what it left is blocked by ${lock}. If no memgineering update is running, delete that folder and run \`memgineering update\` again.`;
     printDual({
       json: { ...status, provenance: provenance.kind, updated: false, reason: "update_claim_stuck", hint },
@@ -23687,14 +24475,14 @@ function newClaimToken() {
 }
 async function claimOwner() {
   try {
-    return (await readFile27(join28(brandHome(), "update-running"), "utf8")).trim() || null;
+    return (await readFile29(join31(brandHome(), "update-running"), "utf8")).trim() || null;
   } catch {
     return null;
   }
 }
 async function releaseUpdateSlot(token) {
   if (await claimOwner() !== token) return;
-  await unlink4(join28(brandHome(), "update-running")).catch(() => void 0);
+  await unlink6(join31(brandHome(), "update-running")).catch(() => void 0);
 }
 async function holdUpdateSlot(inherited) {
   if (inherited !== void 0 && await claimOwner() === inherited) return inherited;
@@ -23706,9 +24494,9 @@ async function holdUpdateSlot(inherited) {
 var HOOK_VERBS = /* @__PURE__ */ new Set(["guard", "resurface"]);
 var UPDATE_CLAIM_MS = 15 * 6e4;
 async function claimUpdateSlot(token = newClaimToken(), hooks = {}) {
-  const path = join28(brandHome(), "update-running");
+  const path = join31(brandHome(), "update-running");
   try {
-    await mkdir18(brandHome(), { recursive: true });
+    await mkdir19(brandHome(), { recursive: true });
     const handle = await open(path, "wx");
     await handle.writeFile(`${token}
 `);
@@ -23718,12 +24506,12 @@ async function claimUpdateSlot(token = newClaimToken(), hooks = {}) {
     if (err?.code !== "EEXIST") return false;
   }
   try {
-    if (Date.now() - (await stat7(path)).mtimeMs >= UPDATE_CLAIM_MS) {
+    if (Date.now() - (await stat9(path)).mtimeMs >= UPDATE_CLAIM_MS) {
       await hooks.afterObserve?.();
       await withReclaimLock(async () => {
-        if (Date.now() - (await stat7(path)).mtimeMs < UPDATE_CLAIM_MS) return;
+        if (Date.now() - (await stat9(path)).mtimeMs < UPDATE_CLAIM_MS) return;
         await hooks.afterRecheck?.();
-        await unlink4(path);
+        await unlink6(path);
       });
     }
   } catch {
@@ -23734,13 +24522,13 @@ var RECLAIM_LOCK = "update-running.reclaim";
 var RECLAIM_LOCK_MAX_MS = 10 * 6e4;
 async function withReclaimLock(fn) {
   const home = brandHome();
-  const lock = join28(home, RECLAIM_LOCK);
-  const staging = join28(home, `${RECLAIM_LOCK}.${process.pid}.${randomBytes2(4).toString("hex")}`);
-  await mkdir18(staging, { recursive: true });
-  await writeFile15(join28(staging, "owner"), `${process.pid} ${Date.now()}
+  const lock = join31(home, RECLAIM_LOCK);
+  const staging = join31(home, `${RECLAIM_LOCK}.${process.pid}.${randomBytes2(4).toString("hex")}`);
+  await mkdir19(staging, { recursive: true });
+  await writeFile16(join31(staging, "owner"), `${process.pid} ${Date.now()}
 `);
   try {
-    await rename4(staging, lock);
+    await rename5(staging, lock);
   } catch {
     await rm8(staging, { recursive: true, force: true }).catch(() => void 0);
     await breakAbandonedLock(lock);
@@ -23750,18 +24538,18 @@ async function withReclaimLock(fn) {
     return await fn();
   } finally {
     const aside = `${lock}.done.${randomBytes2(4).toString("hex")}`;
-    await rename4(lock, aside).then(() => rm8(aside, { recursive: true, force: true })).catch(() => void 0);
+    await rename5(lock, aside).then(() => rm8(aside, { recursive: true, force: true })).catch(() => void 0);
   }
 }
 async function breakAbandonedLock(lock) {
   try {
-    const seen = (await readFile27(join28(lock, "owner"), "utf8")).trim();
+    const seen = (await readFile29(join31(lock, "owner"), "utf8")).trim();
     if (!lockAbandoned(seen)) return;
     const aside = `${lock}.dead.${randomBytes2(4).toString("hex")}`;
-    await rename4(lock, aside);
-    const moved = (await readFile27(join28(aside, "owner"), "utf8").catch(() => "")).trim();
+    await rename5(lock, aside);
+    const moved = (await readFile29(join31(aside, "owner"), "utf8").catch(() => "")).trim();
     if (moved !== seen) {
-      await rename4(aside, lock).catch(() => void 0);
+      await rename5(aside, lock).catch(() => void 0);
       return;
     }
     await rm8(aside, { recursive: true, force: true });
@@ -23783,9 +24571,9 @@ function lockAbandoned(owner, now = Date.now()) {
 }
 async function blockedBy() {
   try {
-    const old = Date.now() - (await stat7(join28(brandHome(), "update-running"))).mtimeMs >= UPDATE_CLAIM_MS;
+    const old = Date.now() - (await stat9(join31(brandHome(), "update-running"))).mtimeMs >= UPDATE_CLAIM_MS;
     if (old) {
-      await stat7(join28(brandHome(), RECLAIM_LOCK));
+      await stat9(join31(brandHome(), RECLAIM_LOCK));
       return "stuck";
     }
   } catch {
@@ -23817,8 +24605,8 @@ function reportBelowMinimum(below) {
 
 // src/commands/undo.ts
 init_src();
-import { readFile as readFile28, rm as rm9 } from "fs/promises";
-import { join as join29 } from "path";
+import { readFile as readFile30, rm as rm9 } from "fs/promises";
+import { join as join32 } from "path";
 import { Command as Command42 } from "commander";
 init_atomic();
 init_errors();
@@ -23915,8 +24703,8 @@ ${matches.slice(0, 8).map((id) => `  ${id}`).join("\n")}${matches.length > 8 ? "
         );
       }
       const record = await withWriteLock(brain.root, async () => {
-        const absolute = join29(brain.root, target.target);
-        const current = await readFile28(absolute, "utf8").catch(() => null);
+        const absolute = join32(brain.root, target.target);
+        const current = await readFile30(absolute, "utf8").catch(() => null);
         const actualHash = current === null ? null : hashContent(current);
         if (actualHash !== target.hash_after) {
           throw memgError(
@@ -23978,7 +24766,7 @@ function minutesSince(iso) {
   return Math.max(0, Math.floor((Date.now() - at) / 6e4));
 }
 async function reverse(brain, op, current) {
-  const absolute = join29(brain.root, op.target);
+  const absolute = join32(brain.root, op.target);
   if (op.verb === "remember") {
     if (current === null) {
       throw memgError(
@@ -24035,7 +24823,7 @@ async function conflictHint(vaultRoot, op) {
 Read what it says now, then decide what should stay.`;
   const snapshot = await readSnapshot(vaultRoot, op.op_id);
   return snapshot === null ? base2 : `${base2}
-The text from before that change is still on this machine: ${join29(snapshotDir(vaultRoot), `${op.op_id}.txt`)}`;
+The text from before that change is still on this machine: ${join32(snapshotDir(vaultRoot), `${op.op_id}.txt`)}`;
 }
 
 // src/commands/brains.ts
@@ -24720,6 +25508,10 @@ async function run3(argv) {
   });
   await program.parseAsync(cleaned);
   if (ran !== "update") await backgroundUpdateNotice(ran === void 0 ? {} : { verb: ran });
+  if (ran !== void 0 && !["guard", "resurface", "setup"].includes(ran)) {
+    await refreshOwnHooksAndTell((text) => process.stderr.write(`${text}
+`));
+  }
 }
 async function handleError(err) {
   const failure = adaptRegistryError(err) ?? err;