memgineering 0.3.0 → 0.4.1

package/dist/index.js

@@ -2624,6 +2624,11 @@ var init_atomic = __esm({
 import { mkdir as mkdir3, readFile as readFile5 } from "fs/promises";
 import { join as join5, resolve as resolve2 } from "path";
 import { z as z6 } from "zod";
+function withDefaultBrain(brain) {
+  if (brain.default) return brain;
+  const oldest = [...brain.brains].sort((a, b) => a.linkedAt.localeCompare(b.linkedAt))[0];
+  return oldest ? { ...brain, default: oldest.root } : brain;
+}
 function configPath() {
   return join5(brandHome(), "config.json");
 }
@@ -2666,7 +2671,22 @@ var init_config = __esm({
     });
     ConfigSchema = z6.object({
       brain: z6.object({
-        brains: z6.array(BrainSchema).default([])
+        brains: z6.array(BrainSchema).default([]),
+        /**
+         * The brain to use when nothing else says which — root path, or absent.
+         *
+         * Exists because linking a second brain used to break the first one
+         * everywhere. `resolveBrain` answered "1 brain linked" with that brain and
+         * "more than 1" with a refusal, so a scratch folder linked for an
+         * afternoon made every command in every directory ambiguous — including
+         * for other tools on the same machine, which is how a Gemini session lost
+         * a preference its user had just asked it to remember.
+         *
+         * Set by the first `link` or `init` and never moved on its own. A default
+         * that followed the newest link would have pointed at the scratch folder,
+         * which is the failure with the sign flipped.
+         */
+        default: z6.string().min(1).optional()
       }).default({ brains: [] }),
       system: z6.object({
         /** Self-update: `on` by default, decided at setup. */
@@ -2712,6 +2732,13 @@ async function resolveBrain(explicit, cwd = process.cwd()) {
   const containing = brains.filter((b) => isInside(cwd, b.root)).sort((a, b) => b.root.length - a.root.length)[0];
   if (containing) return { brain: containing, via: "cwd" };
   if (brains.length === 1) return { brain: brains[0], via: "only" };
+  const preferred = cfg.brain.default;
+  if (preferred) {
+    const known = brains.find((b) => b.root === preferred);
+    if (known && (await liveBrains([known])).length === 1) {
+      return { brain: known, via: "default" };
+    }
+  }
   const present = await liveBrains(brains);
   if (present.length === 1) return { brain: present[0], via: "only" };
   if (brains.length === 0) {
@@ -2726,7 +2753,10 @@ async function resolveBrain(explicit, cwd = process.cwd()) {
   throw memgError(
     "ambiguous_vault",
     `${present.length} of ${brains.length} linked brains are reachable, so this is ambiguous`,
-    `Pick one with --vault <path>, or bind this folder to one with \`memgineering use <path>\`.
+    `Set the one you actually use, once, and this stops happening everywhere:
+  memgineering use --default ${present[0]?.root ?? "<path>"}
+
+Or answer just for this run with --vault <path>, or bind this folder with \`memgineering use <path>\`.
 ${listed}${missing.length > 0 ? `
 A folder marked (missing) is not on disk right now. If it is gone for good, \`memgineering unlink ${missing[0]?.root}\` stops it getting in the way.` : ""}`
   );
@@ -2820,10 +2850,205 @@ var init_index_build = __esm({
   }
 });
 
+// src/commands/init.ts
+import { mkdir as mkdir8, readdir as readdir5, writeFile as writeFile6 } from "fs/promises";
+import { join as join12, resolve as resolve5 } from "path";
+import { Command as Command3 } from "commander";
+function initCommand() {
+  return new Command3("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) => {
+    const { root: canonicalRoot2, indexed } = await createBrain(path, opts.name);
+    printDual({
+      json: {
+        brain: canonicalRoot2,
+        folders: FOLDERS,
+        files: Object.keys(files(opts.name)),
+        observations_dir: OBSERVATIONS_DIR,
+        indexed
+      },
+      human: () => {
+        printHuman(`Created a brain at \`${canonicalRoot2}\`.
+`);
+        printHuman(`- \`01_BASE/\` \u2014 five files your agent reads first`);
+        printHuman(`- \`${OBSERVATIONS_DIR}/\` \u2014 where \`remember\` writes`);
+        printHuman(`- nine more folders, ready when you need them
+`);
+        printHuman(c.gray("The five base files are empty templates.\n"));
+        printHuman(
+          c.gray(
+            "AGENT: offer to fill them in now, in conversation \u2014 one question at a time,\nstarting with who they are and how they want you to work. Do not make them\ntype into a file. `memgineering-memory` has the questions and how to write\nthe answers back.\n"
+          )
+        );
+        printHuman(`If it does not offer, ask it: **"set up my memory"** / **"\uB0B4 \uC815\uBCF4 \uCC44\uC6CC\uC918"**`);
+        printHuman(c.gray("Or run `memgineering onboard` \u2014 it prints what to ask.\n"));
+        printHuman(c.gray('Then: `memgineering remember "<something worth keeping>"`'));
+      }
+    });
+  });
+}
+async function createBrain(path, name) {
+  const root = resolve5(path);
+  const existing = await readdir5(root).catch(() => null);
+  if (existing && existing.filter((e) => !e.startsWith(".")).length > 0) {
+    throw memgError(
+      "already_initialized",
+      `${root} already has files in it`,
+      `\`init\` is for a fresh folder. To use notes you already have, read them as they are:
+  memgineering link ${path}`
+    );
+  }
+  await mkdir8(root, { recursive: true });
+  for (const dir of FOLDERS) await mkdir8(join12(root, dir), { recursive: true });
+  for (const [file, content] of Object.entries(files(name))) {
+    await writeFile6(join12(root, file), content, "utf8");
+  }
+  const canonicalRoot2 = await canonicalize(root);
+  const adapter = await LocalFileReadAdapter.openVault(canonicalRoot2);
+  const built = await openIndex(adapter, canonicalRoot2);
+  const cfg = await loadConfig();
+  const brains = cfg.brain.brains.filter((b) => b.root !== canonicalRoot2);
+  brains.push({
+    root: canonicalRoot2,
+    linkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    observationsDir: OBSERVATIONS_DIR
+  });
+  await saveConfig({ ...cfg, brain: withDefaultBrain({ ...cfg.brain, brains }) });
+  return { root: canonicalRoot2, indexed: built.entries.length };
+}
+function files(name) {
+  const base = (id, title, summary, body) => [
+    "---",
+    "memgineering:",
+    `  id: ${id}`,
+    `  title: ${title}`,
+    `  summary: ${summary}`,
+    "  scope: base",
+    "---",
+    "",
+    `# ${title}`,
+    "",
+    body,
+    ""
+  ].join("\n");
+  return {
+    "00_HUB/HUB.md": [
+      "---",
+      "memgineering:",
+      "  id: hub",
+      `  title: ${name}`,
+      "  summary: Where to look for what, in this brain.",
+      "---",
+      "",
+      `# ${name}`,
+      "",
+      "This file says where things are. It holds no content of its own \u2014",
+      "when it starts explaining something instead of pointing at it, that",
+      "explanation belongs in a note.",
+      "",
+      "## Read first",
+      "",
+      "- `01_BASE/CRITICAL_FACTS.md` \u2014 the handful of things that must never be wrong",
+      "- `01_BASE/BOUNDARIES.md` \u2014 what not to do without asking",
+      "",
+      "## Where things go",
+      "",
+      "| Folder | What lives here |",
+      "| --- | --- |",
+      "| `10_ENTITIES/` | People, projects, systems \u2014 one note each |",
+      "| `20_TIMELINE/` | What happened, when. `observations/` is written by the agent |",
+      "| `30_ACTIONS/` | Open work and decisions waiting on something |",
+      "| `40_KNOWLEDGE/` | Conclusions worth keeping: how things work, why they were decided |",
+      "| `50_SKILLS/` | Procedures \u2014 the steps for doing a thing again |",
+      "| `60_TEMPLATES/` | Shapes for notes you write often |",
+      "| `70_SOURCES/` | Where something came from: links, papers, transcripts |",
+      "| `80_SHAREABLE/` | Notes you would be willing to publish |",
+      "| `90_ARCHIVE/` | Kept, but no longer current |",
+      ""
+    ].join("\n"),
+    "01_BASE/CRITICAL_FACTS.md": base(
+      "critical-facts",
+      "Critical facts",
+      "The few things that must never be wrong.",
+      [
+        "Keep this short enough to read every session. Anything that can be",
+        "looked up when needed belongs in a note instead.",
+        "",
+        "- "
+      ].join("\n")
+    ),
+    "01_BASE/USER.md": base(
+      "user",
+      "About me",
+      "Who I am and what context I work in.",
+      [
+        "Background, role, what you are working on, what an agent should assume",
+        "you already know.",
+        "",
+        "- "
+      ].join("\n")
+    ),
+    "01_BASE/PREFERENCES.md": base(
+      "preferences",
+      "Preferences",
+      "How I like answers, code and decisions handled.",
+      ["Style, verbosity, how much to check in, how you like code written.", "", "- "].join("\n")
+    ),
+    "01_BASE/BOUNDARIES.md": base(
+      "boundaries",
+      "Boundaries",
+      "What an agent must not do without asking me first.",
+      [
+        "Privacy, spending, anything irreversible, anything that leaves this",
+        "machine. Be specific \u2014 a boundary that has to be interpreted is one",
+        "that will be interpreted generously.",
+        "",
+        "- "
+      ].join("\n")
+    ),
+    "01_BASE/TOOLING.md": base(
+      "tooling",
+      "Tooling",
+      "The tools, machines and commands I actually use.",
+      [
+        "Editors, languages, deploy commands, where things run. Enough that an",
+        "agent does not have to guess or discover it again each time.",
+        "",
+        "- "
+      ].join("\n")
+    )
+  };
+}
+var OBSERVATIONS_DIR, FOLDERS;
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    init_adapter();
+    init_errors();
+    init_config();
+    init_index_build();
+    init_vault();
+    init_ui();
+    OBSERVATIONS_DIR = "20_TIMELINE/observations";
+    FOLDERS = [
+      "00_HUB",
+      "01_BASE",
+      "10_ENTITIES",
+      "20_TIMELINE",
+      "20_TIMELINE/observations",
+      "30_ACTIONS",
+      "40_KNOWLEDGE",
+      "50_SKILLS",
+      "60_TEMPLATES",
+      "70_SOURCES",
+      "80_SHAREABLE",
+      "90_ARCHIVE"
+    ];
+  }
+});
+
 // src/commands/link.ts
 import { readFile as readFile13 } from "fs/promises";
-import { join as join12 } from "path";
-import { Command as Command4 } from "commander";
+import { join as join13 } from "path";
+import { Command as Command5 } from "commander";
 import prompts from "prompts";
 function sameBasename(all, entry) {
   const base = (entry.split("/").pop() ?? entry).normalize("NFC").toLowerCase();
@@ -2846,7 +3071,7 @@ function spreadAcrossFolders(rows, max) {
   return picked;
 }
 function linkCommand() {
-  return new Command4("link").description("read a notes folder as a brain \u2014 audits its rules first").argument("<path>", "path to the notes folder").option("--yes", "skip the confirmation").option("--dry-run", "show exactly what would be stored, then stop").option(
+  return new Command5("link").description("read a notes folder as a brain \u2014 audits its rules first").argument("<path>", "path to the notes folder").option("--yes", "skip the confirmation").option("--dry-run", "show exactly what would be stored, then stop").option(
     "--observations <dir>",
     "where `remember` writes, relative to the folder",
     DEFAULT_OBSERVATIONS_DIR
@@ -3017,12 +3242,12 @@ async function recordLink(adapter, observationsDir) {
     linkedAt: (/* @__PURE__ */ new Date()).toISOString(),
     observationsDir: observationsDir.replace(/^\/+|\/+$/g, "")
   });
-  await saveConfig({ ...cfg, brain: { brains } });
+  await saveConfig({ ...cfg, brain: withDefaultBrain({ ...cfg.brain, brains }) });
   return built;
 }
 async function refuseSilentRules(path, denied, excluded, unsupported) {
   const denyEntries = (await LocalFileReadAdapter.readDenyFile(path, ".memgdeny")).entries;
-  const rawDenyLines = await readFile13(join12(path, ".memgdeny"), "utf8").then(
+  const rawDenyLines = await readFile13(join13(path, ".memgdeny"), "utf8").then(
     (t) => t.split("\n").map((l) => l.trim()).filter((l) => l !== "" && !l.startsWith("#"))
   ).catch(() => []);
   const asWritten = (folded) => rawDenyLines.find(
@@ -3176,216 +3401,19 @@ Brain: ${root}`));
   });
   return ok === true;
 }
-var DEFAULT_OBSERVATIONS_DIR;
-var init_link = __esm({
-  "src/commands/link.ts"() {
-    "use strict";
-    init_adapter();
-    init_rules_file();
-    init_src();
-    init_errors();
-    init_config();
-    init_index_build();
-    init_vault();
-    init_ui();
-    DEFAULT_OBSERVATIONS_DIR = "_observations";
-  }
-});
-
-// src/commands/init.ts
-import { mkdir as mkdir8, readdir as readdir5, writeFile as writeFile6 } from "fs/promises";
-import { join as join13, resolve as resolve6 } from "path";
-import { Command as Command7 } from "commander";
-function initCommand() {
-  return new Command7("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) => {
-    const { root: canonicalRoot2, indexed } = await createBrain(path, opts.name);
-    printDual({
-      json: {
-        brain: canonicalRoot2,
-        folders: FOLDERS,
-        files: Object.keys(files(opts.name)),
-        observations_dir: OBSERVATIONS_DIR,
-        indexed
-      },
-      human: () => {
-        printHuman(`Created a brain at \`${canonicalRoot2}\`.
-`);
-        printHuman(`- \`01_BASE/\` \u2014 five files your agent reads first`);
-        printHuman(`- \`${OBSERVATIONS_DIR}/\` \u2014 where \`remember\` writes`);
-        printHuman(`- nine more folders, ready when you need them
-`);
-        printHuman(c.gray("The five base files are empty templates.\n"));
-        printHuman(
-          c.gray(
-            "AGENT: offer to fill them in now, in conversation \u2014 one question at a time,\nstarting with who they are and how they want you to work. Do not make them\ntype into a file. `memgineering-memory` has the questions and how to write\nthe answers back.\n"
-          )
-        );
-        printHuman(
-          `If it does not offer, ask it: **"set up my memory"** / **"\uB0B4 \uC815\uBCF4 \uCC44\uC6CC\uC918"**`
-        );
-        printHuman(c.gray("Or run `memgineering onboard` \u2014 it prints what to ask.\n"));
-        printHuman(c.gray('Then: `memgineering remember "<something worth keeping>"`'));
-      }
-    });
-  });
-}
-async function createBrain(path, name) {
-  const root = resolve6(path);
-  const existing = await readdir5(root).catch(() => null);
-  if (existing && existing.filter((e) => !e.startsWith(".")).length > 0) {
-    throw memgError(
-      "already_initialized",
-      `${root} already has files in it`,
-      `\`init\` is for a fresh folder. To use notes you already have, read them as they are:
-  memgineering link ${path}`
-    );
-  }
-  await mkdir8(root, { recursive: true });
-  for (const dir of FOLDERS) await mkdir8(join13(root, dir), { recursive: true });
-  for (const [file, content] of Object.entries(files(name))) {
-    await writeFile6(join13(root, file), content, "utf8");
-  }
-  const canonicalRoot2 = await canonicalize(root);
-  const adapter = await LocalFileReadAdapter.openVault(canonicalRoot2);
-  const built = await openIndex(adapter, canonicalRoot2);
-  const cfg = await loadConfig();
-  const brains = cfg.brain.brains.filter((b) => b.root !== canonicalRoot2);
-  brains.push({
-    root: canonicalRoot2,
-    linkedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    observationsDir: OBSERVATIONS_DIR
-  });
-  await saveConfig({ ...cfg, brain: { brains } });
-  return { root: canonicalRoot2, indexed: built.entries.length };
-}
-function files(name) {
-  const base = (id, title, summary, body) => [
-    "---",
-    "memgineering:",
-    `  id: ${id}`,
-    `  title: ${title}`,
-    `  summary: ${summary}`,
-    "  scope: base",
-    "---",
-    "",
-    `# ${title}`,
-    "",
-    body,
-    ""
-  ].join("\n");
-  return {
-    "00_HUB/HUB.md": [
-      "---",
-      "memgineering:",
-      "  id: hub",
-      `  title: ${name}`,
-      "  summary: Where to look for what, in this brain.",
-      "---",
-      "",
-      `# ${name}`,
-      "",
-      "This file says where things are. It holds no content of its own \u2014",
-      "when it starts explaining something instead of pointing at it, that",
-      "explanation belongs in a note.",
-      "",
-      "## Read first",
-      "",
-      "- `01_BASE/CRITICAL_FACTS.md` \u2014 the handful of things that must never be wrong",
-      "- `01_BASE/BOUNDARIES.md` \u2014 what not to do without asking",
-      "",
-      "## Where things go",
-      "",
-      "| Folder | What lives here |",
-      "| --- | --- |",
-      "| `10_ENTITIES/` | People, projects, systems \u2014 one note each |",
-      "| `20_TIMELINE/` | What happened, when. `observations/` is written by the agent |",
-      "| `30_ACTIONS/` | Open work and decisions waiting on something |",
-      "| `40_KNOWLEDGE/` | Conclusions worth keeping: how things work, why they were decided |",
-      "| `50_SKILLS/` | Procedures \u2014 the steps for doing a thing again |",
-      "| `60_TEMPLATES/` | Shapes for notes you write often |",
-      "| `70_SOURCES/` | Where something came from: links, papers, transcripts |",
-      "| `80_SHAREABLE/` | Notes you would be willing to publish |",
-      "| `90_ARCHIVE/` | Kept, but no longer current |",
-      ""
-    ].join("\n"),
-    "01_BASE/CRITICAL_FACTS.md": base(
-      "critical-facts",
-      "Critical facts",
-      "The few things that must never be wrong.",
-      [
-        "Keep this short enough to read every session. Anything that can be",
-        "looked up when needed belongs in a note instead.",
-        "",
-        "- "
-      ].join("\n")
-    ),
-    "01_BASE/USER.md": base(
-      "user",
-      "About me",
-      "Who I am and what context I work in.",
-      [
-        "Background, role, what you are working on, what an agent should assume",
-        "you already know.",
-        "",
-        "- "
-      ].join("\n")
-    ),
-    "01_BASE/PREFERENCES.md": base(
-      "preferences",
-      "Preferences",
-      "How I like answers, code and decisions handled.",
-      ["Style, verbosity, how much to check in, how you like code written.", "", "- "].join("\n")
-    ),
-    "01_BASE/BOUNDARIES.md": base(
-      "boundaries",
-      "Boundaries",
-      "What an agent must not do without asking me first.",
-      [
-        "Privacy, spending, anything irreversible, anything that leaves this",
-        "machine. Be specific \u2014 a boundary that has to be interpreted is one",
-        "that will be interpreted generously.",
-        "",
-        "- "
-      ].join("\n")
-    ),
-    "01_BASE/TOOLING.md": base(
-      "tooling",
-      "Tooling",
-      "The tools, machines and commands I actually use.",
-      [
-        "Editors, languages, deploy commands, where things run. Enough that an",
-        "agent does not have to guess or discover it again each time.",
-        "",
-        "- "
-      ].join("\n")
-    )
-  };
-}
-var OBSERVATIONS_DIR, FOLDERS;
-var init_init = __esm({
-  "src/commands/init.ts"() {
+var DEFAULT_OBSERVATIONS_DIR;
+var init_link = __esm({
+  "src/commands/link.ts"() {
     "use strict";
     init_adapter();
+    init_rules_file();
+    init_src();
     init_errors();
     init_config();
     init_index_build();
     init_vault();
     init_ui();
-    OBSERVATIONS_DIR = "20_TIMELINE/observations";
-    FOLDERS = [
-      "00_HUB",
-      "01_BASE",
-      "10_ENTITIES",
-      "20_TIMELINE",
-      "20_TIMELINE/observations",
-      "30_ACTIONS",
-      "40_KNOWLEDGE",
-      "50_SKILLS",
-      "60_TEMPLATES",
-      "70_SOURCES",
-      "80_SHAREABLE",
-      "90_ARCHIVE"
-    ];
+    DEFAULT_OBSERVATIONS_DIR = "_observations";
   }
 });
 
@@ -4102,10 +4130,11 @@ import { randomBytes as randomBytes2, timingSafeEqual } from "crypto";
 import { readdir as readdir6, stat as stat3 } from "fs/promises";
 import { createServer } from "http";
 import { homedir as homedir3 } from "os";
-import { basename, isAbsolute as isAbsolute2, join as join14, resolve as resolve7 } from "path";
+import { basename, isAbsolute as isAbsolute2, join as join14, relative as relative2, resolve as resolve7 } from "path";
 async function startSetupWebServer(opts) {
   const token = randomBytes2(32).toString("hex");
   const idleMs = opts.idleMs ?? IDLE_TIMEOUT_MS;
+  const maxMs = opts.maxMs ?? MAX_LIFETIME_MS;
   const lingerMs = opts.lingerMs ?? APPLY_LINGER_MS;
   const sockets = /* @__PURE__ */ new Set();
   const server = createServer();
@@ -4134,6 +4163,7 @@ async function startSetupWebServer(opts) {
     if (stopped) return;
     stopped = true;
     if (idleTimer) clearTimeout(idleTimer);
+    clearTimeout(maxTimer);
     process.off("SIGINT", onInterrupt);
     await new Promise((resolve10) => {
       server.close(() => resolve10());
@@ -4147,14 +4177,15 @@ async function startSetupWebServer(opts) {
     idleTimer = setTimeout(() => void stop("idle"), idleMs);
     idleTimer.unref();
   };
+  const maxTimer = setTimeout(() => void stop("idle"), maxMs);
+  maxTimer.unref();
   function onInterrupt() {
     void stop("interrupted");
   }
   process.once("SIGINT", onInterrupt);
   const state = { detected: opts.detected, token, ownOrigins, applied: false };
   server.on("request", (req, res) => {
-    touch();
-    void handle(req, res, state, origin).then((outcome) => {
+    void handle(req, res, state, origin, touch).then((outcome) => {
       if (outcome === "applied") setTimeout(() => void stop("applied"), lingerMs).unref();
       if (outcome === "cancelled") setTimeout(() => void stop("cancelled"), 50).unref();
     }).catch((err) => {
@@ -4209,9 +4240,20 @@ async function runSetupWeb(opts) {
   else printHuman(`
 ${reason === "applied" ? c.green(ending[reason]) : c.gray(ending[reason])}`);
 }
-async function handle(req, res, state, origin) {
+async function handle(req, res, state, origin, touch = () => {
+}) {
   const url = new URL(req.url ?? "/", origin);
   const sender = req.headers.origin;
+  if (sender === void 0 && req.method !== "GET" && req.method !== "HEAD") {
+    sendJson(res, 403, {
+      error: {
+        code: "forbidden_origin",
+        message: "a request that changes something must say where it came from",
+        hint: "This screen answers the page it opened on this machine. If you are driving it directly, send `Origin` matching the URL `memgineering setup --web` printed."
+      }
+    });
+    return "served";
+  }
   if (sender !== void 0 && !state.ownOrigins.has(sender)) {
     sendJson(res, 403, {
       error: {
@@ -4232,6 +4274,7 @@ async function handle(req, res, state, origin) {
     });
     return "served";
   }
+  touch();
   if (req.method === "GET" && url.pathname === "/") {
     sendHtml(res, renderSetupPage());
     return "served";
@@ -4249,7 +4292,7 @@ async function handle(req, res, state, origin) {
     return "served";
   }
   if (req.method === "POST" && url.pathname === "/api/inspect") {
-    return inspectFromScreen(req, res);
+    return inspectFromScreen(req, res, state);
   }
   if (req.method === "POST" && url.pathname === "/api/apply") {
     return applyFromScreen(req, res, state);
@@ -4326,7 +4369,24 @@ async function holdsNotes(dir) {
   }
   return false;
 }
-async function inspectFromScreen(req, res) {
+function isSystemPath(path) {
+  return SYSTEM_ROOTS.some((root) => {
+    if (root === "/") return path === "/";
+    const rel = relative2(root, path);
+    return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
+  });
+}
+async function inspectFromScreen(req, res, state) {
+  if (state.applied) {
+    sendJson(res, 409, {
+      error: {
+        code: "already_applied",
+        message: "setup is finished \u2014 this screen no longer reads folders",
+        hint: "Run `memgineering link <folder>` to connect another set of notes, or `memgineering setup --web` again."
+      }
+    });
+    return "served";
+  }
   const parsed = await readJsonBody(req, res);
   if (parsed === void 0) return "served";
   const asked = parsed.path;
@@ -4340,7 +4400,17 @@ async function inspectFromScreen(req, res) {
     });
     return "served";
   }
-  const path = expandHome(asked.trim());
+  const path = resolve7(expandHome(asked.trim()));
+  if (isSystemPath(path)) {
+    sendJson(res, 400, {
+      error: {
+        code: "invalid_input",
+        message: `that is a system folder, not a notes folder: ${path}`,
+        hint: "Point this at the FOLDER holding your notes \u2014 somewhere you write, like `~/Documents/Notes`."
+      }
+    });
+    return "served";
+  }
   const info = await stat3(path).catch(() => null);
   if (info === null) {
     sendJson(res, 200, {
@@ -4362,7 +4432,8 @@ async function inspectFromScreen(req, res) {
   }
   try {
     const target = await openLinkTarget(path, { quiet: true });
-    const rows = await target.preview(Number.MAX_SAFE_INTEGER);
+    const rows = await target.preview(PREVIEW_CAP);
+    const capped = target.notes.length > PREVIEW_CAP;
     const cfg = await loadConfig();
     sendJson(res, 200, {
       path,
@@ -4373,6 +4444,10 @@ async function inspectFromScreen(req, res) {
       // number is the one a person is agreeing to; the first is why it moved.
       scanned: target.notes.length,
       would_index: rows.length,
+      // Named, so a number that stopped early is never read as a total. The
+      // screen shows what a person is agreeing to, and "5,000" presented as the
+      // whole of a 24,000-note folder is a worse answer than a slow one.
+      ...capped ? { would_index_capped: PREVIEW_CAP } : {},
       excluded: target.scan.excluded.length,
       skipped_symlinks: target.scan.skippedSymlinks.length,
       refused: [
@@ -4402,14 +4477,18 @@ async function applyFromScreen(req, res, state) {
     });
     return "served";
   }
+  state.applied = true;
   const parsed = await readJsonBody(req, res);
-  if (parsed === void 0) return "served";
+  if (parsed === void 0) {
+    state.applied = false;
+    return "served";
+  }
   const choice = readChoice(parsed, state.detected);
   if ("error" in choice) {
+    state.applied = false;
     sendJson(res, 400, { error: choice.error });
     return "served";
   }
-  state.applied = true;
   const changes = await applySetup(choice.value, false);
   const brain = await connectBrain(choice.brain);
   const cfg = await loadConfig();
@@ -4628,17 +4707,34 @@ function sendHtml(res, html) {
     // The page is one self-contained file by design; say so, so that a future
     // edit that reaches for a CDN font fails visibly here instead of quietly
     // making a local setup screen talk to the internet.
-    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'self'; form-action 'none'; base-uri 'none'"
+    // `frame-ancestors 'none'` because a hostile page could and did load this
+    // screen in an iframe. Nothing is exploitable through it while the token
+    // stands between an attacker and the API — but the consent screen for
+    // installing into somebody's agent should not be embeddable, and the day
+    // the token moves out of the URL into a cookie it would become the whole
+    // attack rather than a curiosity.
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'self'; form-action 'none'; base-uri 'none'; frame-ancestors 'none'",
+    // The header the older browsers read. Same statement, twice.
+    "x-frame-options": "DENY"
   });
   res.end(html);
 }
 async function openBrowser(url) {
   const { file, args } = browserOpener(url);
   return new Promise((resolve10) => {
+    let settled = false;
+    const finish = (opened) => {
+      if (settled) return;
+      settled = true;
+      resolve10(opened);
+    };
     const child = spawn(file, args, { detached: true, stdio: "ignore" });
-    child.on("error", () => resolve10(false));
+    child.on("error", () => finish(false));
+    child.on("exit", (code) => {
+      if (code !== null && code !== 0) finish(false);
+    });
     child.unref();
-    setTimeout(() => resolve10(true), 300).unref();
+    setTimeout(() => finish(true), 300).unref();
   });
 }
 function browserOpener(url) {
@@ -4646,7 +4742,7 @@ function browserOpener(url) {
   if (process.platform === "win32") return { file: "cmd", args: ["/c", "start", "", url] };
   return { file: "xdg-open", args: [url] };
 }
-var IDLE_TIMEOUT_MS, APPLY_LINGER_MS, MAX_BODY_BYTES, MAX_CANDIDATES;
+var IDLE_TIMEOUT_MS, MAX_LIFETIME_MS, APPLY_LINGER_MS, MAX_BODY_BYTES, MAX_CANDIDATES, PREVIEW_CAP, SYSTEM_ROOTS;
 var init_setup_web = __esm({
   "src/commands/setup-web.ts"() {
     "use strict";
@@ -4658,9 +4754,24 @@ var init_setup_web = __esm({
     init_setup();
     init_setup_web_page();
     IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
+    MAX_LIFETIME_MS = 60 * 60 * 1e3;
     APPLY_LINGER_MS = 1e3;
     MAX_BODY_BYTES = 64 * 1024;
     MAX_CANDIDATES = 8;
+    PREVIEW_CAP = 5e3;
+    SYSTEM_ROOTS = [
+      "/",
+      "/usr",
+      "/bin",
+      "/sbin",
+      "/etc",
+      "/dev",
+      "/proc",
+      "/sys",
+      "/System",
+      "/Library",
+      "/opt"
+    ];
   }
 });
 
@@ -5424,7 +5535,11 @@ function unlinkCommand() {
     const { brain } = await resolveBrain(path);
     const cfg = await loadConfig();
     const remaining = cfg.brain.brains.filter((b) => b.root !== brain.root);
-    await saveConfig({ ...cfg, brain: { brains: remaining } });
+    const nextDefault = cfg.brain.default === brain.root ? remaining[0]?.root : cfg.brain.default;
+    await saveConfig({
+      ...cfg,
+      brain: { brains: remaining, ...nextDefault ? { default: nextDefault } : {} }
+    });
     if (opts.purge) {
       await clearCache(cacheDirFor(brain.root, brandHome()));
       await rm5(stateDirFor(brain.root), { recursive: true, force: true });
@@ -5515,8 +5630,8 @@ async function readLines(root, name) {
 // src/commands/curation.ts
 init_src();
 import { stat as stat2 } from "fs/promises";
-import { resolve as resolve5 } from "path";
-import { Command as Command5 } from "commander";
+import { resolve as resolve6 } from "path";
+import { Command as Command6 } from "commander";
 
 // ../../packages/storage-adapter/src/local-file/ignore-file.ts
 init_atomic();
@@ -5964,7 +6079,7 @@ init_ui();
 // src/commands/open.ts
 init_src();
 init_errors();
-import { Command as Command3 } from "commander";
+import { Command as Command4 } from "commander";
 
 // src/lib/events.ts
 import { appendFile as appendFile2, mkdir as mkdir7, readFile as readFile12, readdir as readdir4 } from "fs/promises";
@@ -6037,6 +6152,96 @@ async function readEvents(vaultRoot) {
 // src/commands/open.ts
 init_index_build();
 
+// src/lib/base-files.ts
+init_init();
+var BASE_FILES = [
+  {
+    path: "01_BASE/USER.md",
+    title: "Who they are",
+    asks: "who they are, what they work on, and what they are trying to get done",
+    openers: [
+      "What should I know about you before we work together?",
+      "What are you building, or what do you spend most of your time on?"
+    ]
+  },
+  {
+    path: "01_BASE/PREFERENCES.md",
+    title: "How they want you to work",
+    asks: "how they like answers, code and decisions \u2014 length, tone, how much checking in",
+    openers: [
+      "When I answer you, do you want the short version or the reasoning too?",
+      "How much should I check in before doing something, versus just doing it?"
+    ]
+  },
+  {
+    path: "01_BASE/BOUNDARIES.md",
+    title: "What to ask before doing",
+    asks: "what you must never do without asking first",
+    openers: [
+      "What should I never do without asking you first?",
+      "Has an assistant ever done something for you that you wish it had asked about?"
+    ]
+  },
+  {
+    path: "01_BASE/CRITICAL_FACTS.md",
+    title: "What is expensive to get wrong",
+    asks: "the facts where being wrong costs real money, data, or trust",
+    openers: [
+      "What is the thing I most need to not get wrong \u2014 deploys, money, someone else\u2019s data?",
+      "Is there anything that looks routine but is actually irreversible?"
+    ]
+  },
+  {
+    path: "01_BASE/TOOLING.md",
+    title: "What they actually run",
+    asks: "the editors, machines, languages and commands they really use",
+    openers: [
+      "What do you actually run this on \u2014 editor, machine, language, deploy command?",
+      "Anything I would guess wrong about your setup if I did not ask?"
+    ]
+  }
+];
+var HUB_PATH = "00_HUB/HUB.md";
+function bodyOf(content) {
+  const stripped = content.replace(/^/, "");
+  const fence = /^---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*(\r?\n|$)/.exec(stripped);
+  return (fence ? stripped.slice(fence[0].length) : stripped).trim();
+}
+function bodyStillTemplate(path, content) {
+  const template = files("brain")[path];
+  if (template === void 0) return false;
+  const body = bodyOf(content);
+  return body !== "" && body === bodyOf(template);
+}
+async function scaffoldingAmong(adapter, notes) {
+  const basePaths = new Set(BASE_FILES.map((f) => f.path));
+  const found = await untouchedBase(
+    adapter,
+    notes.map((n) => n.path).filter((path) => basePaths.has(path))
+  );
+  const hub = notes.find((n) => n.path === HUB_PATH);
+  if (hub && await untouchedHub(adapter, hub.title)) found.add(HUB_PATH);
+  return found;
+}
+async function untouchedHub(adapter, title) {
+  const actual = await adapter.read(HUB_PATH).then((r) => r.content).catch(() => null);
+  if (actual === null) return false;
+  return actual.trimEnd() === (files(title)[HUB_PATH] ?? "").trimEnd();
+}
+async function untouchedBase(adapter, paths) {
+  const templates = files("brain");
+  const out = /* @__PURE__ */ new Set();
+  await Promise.all(
+    paths.map(async (path) => {
+      const template = templates[path];
+      if (template === void 0) return;
+      const actual = await adapter.read(path).then((r) => r.content).catch(() => null);
+      if (actual !== null && actual.trimEnd() === template.trimEnd()) out.add(path);
+    })
+  );
+  return out;
+}
+
 // src/lib/stages.ts
 init_sections();
 init_errors();
@@ -6082,7 +6287,7 @@ async function assembleStage(adapter, entry, detail, sectionName) {
 init_vault();
 init_ui();
 function openCommand() {
-  return new Command3("open").description("open one memory, as deeply as you ask").argument("<ref>", "handle, id, path, or exact title").option("--vault <path>", "which brain to read").option("--detail <level>", "card | summary | chunks | full (default: card)").option("--section <name>", "one section (implies --detail chunks)").action(async (ref, opts) => {
+  return new Command4("open").description("open one memory, as deeply as you ask").argument("<ref>", "handle, id, path, or exact title").option("--vault <path>", "which brain to read").option("--detail <level>", "card | summary | chunks | full (default: card)").option("--section <name>", "one section (implies --detail chunks)").action(async (ref, opts) => {
     const detail = parseDetail(opts.detail, opts.section ? "chunks" : "card");
     const { brain } = await resolveBrain(opts.vault);
     const adapter = await openBrainOrExplain(brain.root);
@@ -6101,12 +6306,14 @@ function openCommand() {
       entry.memory.id,
       built.entries.map((e) => e.memory.id)
     );
+    const scaffolding = (await scaffoldingAmong(adapter, [{ path: entry.path, title: entry.memory.title }])).has(entry.path);
     printDual({
       json: {
         id: entry.memory.id,
         handle: handle2,
         path: entry.path,
         detail,
+        scaffolding,
         memory: entry.memory,
         claims,
         relations: entry.relations,
@@ -6115,9 +6322,15 @@ function openCommand() {
       human: () => {
         printHuman(`## ${entry.memory.title}
 `);
-        printHuman(
-          `${confidenceOf(entry.memory, claims)} \xB7 ${freshnessOf(entry.memory, claims, now)} \xB7 ${entry.memory.provenance.mapping}`
-        );
+        if (scaffolding) {
+          printHuman(
+            c.yellow("not filled in yet") + c.gray(" \u2014 still the template `init` wrote")
+          );
+        } else {
+          printHuman(
+            `${confidenceOf(entry.memory, claims)} \xB7 ${freshnessOf(entry.memory, claims, now)} \xB7 ${entry.memory.provenance.mapping}`
+          );
+        }
         printHuman(`
 \`id: ${entry.memory.id}\`  \xB7  \`${entry.path}\`
 `);
@@ -6126,7 +6339,19 @@ function openCommand() {
           printHuman(`- ${claim.text}`);
           printHuman(c.gray(`  ${claim.confidence} \xB7 ${claim.status}`));
         }
-        if (claims.length === 0) {
+        if (claims.length === 0 && scaffolding) {
+          printHuman(
+            c.gray(
+              `_Nobody has written this yet. The line above is the prompt \`init\` left, and the
+body is its instructions \u2014 neither is something the user said, so do not answer
+from them._
+
+This one is filled in by asking. \`memgineering onboard\` prints the questions;
+write the body, then record the conclusion:
+    memgineering revise ${handle2} --claim "<what they told you>" --summary "<one line>"`
+            )
+          );
+        } else if (claims.length === 0) {
           printHuman(
             c.gray(
               entry.memory.provenance.mapping === "explicit" ? "_The title and summary above came from this note, but it declares no `claim` \u2014 so nothing here states a conclusion. That is what `stated` above refers to: where the fields came from, not that a conclusion exists._" : "_No claim declared \u2014 this card was inferred from the note._"
@@ -6223,7 +6448,7 @@ function fold2(value) {
 // src/commands/curation.ts
 init_link();
 function lifecycleCommand(action) {
-  return new Command5(action).description(
+  return new Command6(action).description(
     action === "retire" ? "mark a memory as no longer current \u2014 the note itself is not changed" : "mark a retired memory as current again"
   ).argument("<ref>", "handle, id, path, or exact title").option("--reason <text>", "why \u2014 kept in the ledger").option("--vault <path>", "which brain the memory is in").action(async (ref, opts) => {
     const rationale = sanitizeRationale(opts.reason);
@@ -6327,7 +6552,7 @@ Undo: \`${undoHint(record.op_id, opts.vault)}\``));
   });
 }
 function ignoreCommand(mode) {
-  return new Command5(mode).description(
+  return new Command6(mode).description(
     mode === "exclude" ? "stop reading a note entirely \u2014 the note itself is not changed" : "read a note again after excluding it"
   ).argument("<path>", "path inside the brain, e.g. decisions/launch-date.md").option("--reason <text>", "why \u2014 kept in the ledger").option("--vault <path>", "which brain the note is in").action(async (path, opts) => {
     const rationale = sanitizeRationale(opts.reason);
@@ -6385,7 +6610,7 @@ Undo: \`${undoHint(record.op_id, opts.vault)}\``));
 }
 async function mustMatchAFile(root, adapter, path) {
   const wanted = path.normalize("NFC").replace(/^\/+/, "");
-  const absolute = resolve5(root, wanted);
+  const absolute = resolve6(root, wanted);
   if (isInside(absolute, root)) {
     const found = await stat2(absolute).catch(() => null);
     if (found?.isFile()) return wanted;
@@ -6403,12 +6628,12 @@ var excludeCommand = () => ignoreCommand("exclude");
 var unexcludeCommand = () => ignoreCommand("unexclude");
 
 // src/commands/evidence.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 init_index_build();
 init_vault();
 init_ui();
 function evidenceCommand() {
-  return new Command6("evidence").description("how much a memory has been used, and why it last changed").argument("<ref>", "handle, id, path, or exact title").option("--vault <path>", "which brain to read").action(async (ref, opts) => {
+  return new Command7("evidence").description("how much a memory has been used, and why it last changed").argument("<ref>", "handle, id, path, or exact title").option("--vault <path>", "which brain to read").action(async (ref, opts) => {
     const { brain } = await resolveBrain(opts.vault);
     const adapter = await openBrainOrExplain(brain.root);
     const built = await openIndex(adapter, brain.root);
@@ -6673,71 +6898,6 @@ async function readOrNull(adapter, path) {
 
 // src/commands/onboard.ts
 import { Command as Command9 } from "commander";
-
-// src/lib/base-files.ts
-init_init();
-var BASE_FILES = [
-  {
-    path: "01_BASE/USER.md",
-    title: "Who they are",
-    asks: "who they are, what they work on, and what they are trying to get done",
-    openers: [
-      "What should I know about you before we work together?",
-      "What are you building, or what do you spend most of your time on?"
-    ]
-  },
-  {
-    path: "01_BASE/PREFERENCES.md",
-    title: "How they want you to work",
-    asks: "how they like answers, code and decisions \u2014 length, tone, how much checking in",
-    openers: [
-      "When I answer you, do you want the short version or the reasoning too?",
-      "How much should I check in before doing something, versus just doing it?"
-    ]
-  },
-  {
-    path: "01_BASE/BOUNDARIES.md",
-    title: "What to ask before doing",
-    asks: "what you must never do without asking first",
-    openers: [
-      "What should I never do without asking you first?",
-      "Has an assistant ever done something for you that you wish it had asked about?"
-    ]
-  },
-  {
-    path: "01_BASE/CRITICAL_FACTS.md",
-    title: "What is expensive to get wrong",
-    asks: "the facts where being wrong costs real money, data, or trust",
-    openers: [
-      "What is the thing I most need to not get wrong \u2014 deploys, money, someone else\u2019s data?",
-      "Is there anything that looks routine but is actually irreversible?"
-    ]
-  },
-  {
-    path: "01_BASE/TOOLING.md",
-    title: "What they actually run",
-    asks: "the editors, machines, languages and commands they really use",
-    openers: [
-      "What do you actually run this on \u2014 editor, machine, language, deploy command?",
-      "Anything I would guess wrong about your setup if I did not ask?"
-    ]
-  }
-];
-async function untouchedBase(adapter, paths) {
-  const templates = files("brain");
-  const out = /* @__PURE__ */ new Set();
-  await Promise.all(
-    paths.map(async (path) => {
-      const template = templates[path];
-      if (template === void 0) return;
-      const actual = await adapter.read(path).then((r) => r.content).catch(() => null);
-      if (actual !== null && actual.trimEnd() === template.trimEnd()) out.add(path);
-    })
-  );
-  return out;
-}
-
-// src/commands/onboard.ts
 init_vault();
 init_ui();
 function onboardCommand() {
@@ -6836,6 +6996,14 @@ function recallCommand() {
           stage: await stageFor(adapter, byId.get(card.id), detail)
         }))
       );
+      const scaffolding = await scaffoldingAmong(
+        adapter,
+        rows.map(({ card }) => {
+          const entry = byId.get(card.id);
+          return { path: entry?.path ?? "", title: entry?.memory.title ?? "" };
+        })
+      );
+      const isScaffolding = (card) => scaffolding.has(byId.get(card.id)?.path ?? "");
       const reasons = result.conflicts.length > 0 ? await conflictReasons(brain.root, result.conflicts, byId) : /* @__PURE__ */ new Map();
       printDual({
         json: {
@@ -6845,6 +7013,10 @@ function recallCommand() {
             ...card,
             handle: handle2,
             path: byId.get(card.id)?.path ?? null,
+            // A fact about the file, not a judgement about the match: this
+            // note is still exactly what `init` wrote, so nobody has answered
+            // it yet.
+            scaffolding: isScaffolding(card),
             ...stage
           })),
           related: result.related,
@@ -6855,9 +7027,7 @@ function recallCommand() {
           }))
         },
         human: () => {
-          const reachedSomethingWritten = rows.some(
-            ({ card }) => !(byId.get(card.id)?.path ?? "").startsWith("01_BASE/")
-          );
+          const reachedSomethingWritten = rows.some(({ card }) => !isScaffolding(card));
           const otherScript = reachedSomethingWritten ? null : unreachableScript(query, built.entries);
           const sayWhy = () => {
             printHuman(
@@ -6888,10 +7058,20 @@ function recallCommand() {
           }
           printHuman(`## recall: ${query}  (${rows.length} cards)
 `);
+          if (!reachedSomethingWritten) {
+            printHuman(
+              c.yellow("\u26A0 Nothing you have written matched this.") + c.gray(
+                "\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 (otherScript) sayWhy();
-          const glossOn = rows.findIndex(({ card }) => card.confidence === "stated");
+          const glossOn = rows.findIndex(
+            ({ card }) => card.confidence === "stated" && !isScaffolding(card)
+          );
           for (const [i, { card, handle: handle2, stage }] of rows.entries()) {
-            printHuman(renderCard(i + 1, card, handle2, detail, stage, i === glossOn));
+            const mark = reachedSomethingWritten && isScaffolding(card);
+            printHuman(renderCard(i + 1, card, handle2, detail, stage, i === glossOn, mark));
           }
           if (result.conflicts.length > 0) {
             printHuman(`### \u26A0 contradictions (${result.conflicts.length})
@@ -6947,13 +7127,19 @@ async function stageFor(adapter, entry, detail) {
   if (!entry) return {};
   return assembleStage(adapter, entry, detail);
 }
-function renderCard(n, card, handle2, detail, stage, glossHere = false) {
+function renderCard(n, card, handle2, detail, stage, glossHere = false, scaffolding = false) {
   const out = [];
   const standing = card.freshness === "current" ? "" : ` \xB7 ${card.freshness}`;
   const age = card.age_days === null ? "" : ` \xB7 ${ago2(card.age_days)}`;
   out.push(`### ${n}. ${card.title}`);
-  out.push(`${card.confidence}${standing}${age}`);
-  if (glossHere) out.push(c.gray("stated = these fields came from the note, not from inference"));
+  if (scaffolding) {
+    out.push(c.yellow("not filled in yet") + c.gray(" \u2014 still the template `init` wrote"));
+  } else {
+    out.push(`${card.confidence}${standing}${age}`);
+  }
+  if (glossHere && !scaffolding) {
+    out.push(c.gray("stated = these fields came from the note, not from inference"));
+  }
   if (detail !== "title") {
     if (card.summary) out.push("", quoteBlock(card.summary));
     out.push("", `\`open: ${handle2}\``);
@@ -7280,7 +7466,22 @@ function reviseCommand() {
   return new Command13("revise").description("change a memory's conclusion, and record how to undo it").argument("<ref>", "handle, id, path, or exact title").option("--claim <text>", "what is now true").option("--summary <text>", "the one line recall will show (defaults to the claim)").option("--title <text>", "the heading recall shows above it (unchanged when omitted)").option(
     "--valid-from <iso>",
     "when this became true (defaults: supersede = now, otherwise unchanged)"
-  ).option("--action <kind>", "reinforce | supersede | conflict", "supersede").option("--contradicts <ids...>", "memories this disagrees with").option("--reason <text>", "why this change is right").option("--because <text>", "the passage from the note that justifies it").option("--input <json>", "the whole change as JSON (file path, `-`, or inline)").option("--dry-run", "show the diff and write nothing").option("--vault <path>", "which brain to write to").action(async (ref, opts) => {
+  ).option("--action <kind>", "reinforce | supersede | conflict", "supersede").option("--contradicts <ids...>", "memories this disagrees with").option("--reason <text>", "why this change is right").option("--because <text>", "the passage from the note that justifies it").option("--input <json>", "the whole change as JSON (file path, `-`, or inline)").option("--dry-run", "show the diff and write nothing").option("--vault <path>", "which brain to write to").addHelpText(
+    "after",
+    [
+      "",
+      "Which --action:",
+      "  supersede   the conclusion CHANGED. Stamps valid_from with now, because a",
+      "              replaced conclusion starts now. The default.",
+      "  reinforce   the SAME conclusion, with new support. Leaves valid_from alone \u2014",
+      "              use this when nothing about the fact changed, only your evidence.",
+      "  conflict    two memories DISAGREE. Records the edge and leaves both standing;",
+      "              the claim you pass is deliberately not written.",
+      "",
+      "Filling in a blank 01_BASE file for the first time is `reinforce`: the fact was",
+      "always true, you have only just been told it. `supersede` would date it today."
+    ].join("\n")
+  ).action(async (ref, opts) => {
     const { brain } = await resolveBrain(opts.vault);
     await openBrainOrExplain(brain.root);
     const adapter = await LocalFileCasAdapter.openVault(brain.root, {
@@ -7294,9 +7495,23 @@ function reviseCommand() {
     );
     const result = commit(asSingleMatch(entry), input);
     if (result.action === "ignore") {
-      throw memgError("invalid_input", "nothing to revise", "Pass --claim, or --input with one.");
+      throw memgError(
+        "invalid_input",
+        "nothing to revise",
+        "Pass --claim, or --input with one."
+      );
     }
     const proposal = result.proposal;
+    if (proposal.action !== "conflict" && rationale === null && saysNothingNew(entry, input)) {
+      throw memgError(
+        "invalid_input",
+        `${entry.memory.title} already says this \u2014 nothing was written`,
+        `The claim, summary and title all match what the note already holds.
+If you meant to record that it still holds, say why:
+  memgineering revise ${ref} --action reinforce --claim "\u2026" --reason "<what confirms it>"
+To see what is there now: \`memgineering open ` + ref + "`"
+      );
+    }
     const preview = await previewProposal(adapter, proposal);
     if (preview.refusal) {
       throw Object.assign(preview.refusal, {
@@ -7305,7 +7520,12 @@ function reviseCommand() {
     }
     if (opts.dryRun) {
       printDual({
-        json: { dryRun: true, target: entry.path, before: preview.before, after: preview.after },
+        json: {
+          dryRun: true,
+          target: entry.path,
+          before: preview.before,
+          after: preview.after
+        },
         human: () => {
           printHuman(`## revise (dry run): ${entry.memory.title}
 `);
@@ -7353,6 +7573,7 @@ function reviseCommand() {
       return { record, content: outcome.content };
     });
     const drift = proposal.action === "supersede" ? bodyStillAsserts(applied.content, previousClaim(entry), proposal.claim?.text ?? null) : null;
+    const unwrittenBody = bodyStillTemplate(entry.path, applied.content);
     printDual({
       json: {
         target: entry.path,
@@ -7360,7 +7581,8 @@ function reviseCommand() {
         op_id: applied.record.op_id,
         before: preview.before,
         after: preview.after,
-        body_drift: drift
+        body_drift: drift,
+        body_unwritten: unwrittenBody
       },
       human: () => {
         if (proposal.action === "conflict") {
@@ -7388,6 +7610,14 @@ function reviseCommand() {
             )
           );
         }
+        if (unwrittenBody) {
+          printHuman(
+            c.yellow(`
+\u26A0 the body of this note is still the template \`init\` wrote`) + c.gray(
+              "\n  \u2014 the conclusion above it is theirs, the prose under it is instructions for\n  writing one. Anyone opening the file reads the form, not the answer.\n  Replace the body with what they actually said, in their words."
+            )
+          );
+        }
         if (isCritical(entry)) {
           printHuman(
             c.yellow(
@@ -7497,14 +7727,26 @@ function previousClaim(entry) {
   const current = entry.claims.find((claim) => claim.id === entry.memory.current_claim) ?? entry.claims[0];
   return current?.text ?? null;
 }
+function saysNothingNew(entry, input) {
+  const norm = (v) => stripControl(v ?? "").trim();
+  const claim = input.claim;
+  if (!claim || norm(claim.text) === "") return false;
+  if (norm(claim.text) !== norm(previousClaim(entry))) return false;
+  if (claim.summary != null && norm(claim.summary) !== norm(entry.memory.summary)) return false;
+  if (claim.title != null && norm(claim.title) !== norm(entry.memory.title)) return false;
+  const declared = new Set(
+    entry.relations.filter((r) => r.type === "contradicts").map((r) => r.to)
+  );
+  return (input.relations?.contradicts ?? []).every((id) => declared.has(id));
+}
 function bodyStillAsserts(content, oldClaim, newClaim) {
   if (oldClaim === null) return null;
   const line = stripControl(oldClaim.split("\n")[0] ?? "").trim();
   if (line === "") return null;
   if (line === stripControl(newClaim?.split("\n")[0] ?? "").trim()) return null;
-  return bodyOf(content).includes(line) ? line : null;
+  return bodyOf2(content).includes(line) ? line : null;
 }
-function bodyOf(content) {
+function bodyOf2(content) {
   const stripped = content.replace(/^/, "");
   const fence = /^---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*(\r?\n|$)/.exec(stripped);
   return fence ? stripped.slice(fence[0].length) : stripped;
@@ -8092,16 +8334,20 @@ init_errors();
 init_config();
 init_vault();
 init_ui();
-import { isAbsolute as isAbsolute3, relative as relative2, resolve as resolve9 } from "path";
+import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve9 } from "path";
 import { Command as Command17 } from "commander";
 var VIA_MEANS = {
   flag: "because --vault named it",
   pointer: `because a \`${BRAND.pointerFileName}\` file here points at it`,
   cwd: "because this folder is inside it",
-  only: "because it is the only brain linked"
+  only: "because it is the only brain linked",
+  default: "because it is your default brain (`memgineering use --default <path>` changes it)"
 };
 function useCommand() {
-  return new Command17("use").description("bind this folder (and everything under it) to one brain").argument("[brain]", "path to the brain \u2014 omit to show what this folder resolves to").option("--here <dir>", "write the pointer in this directory instead of the cwd").action(async (brainPath, opts) => {
+  return new Command17("use").description("bind this folder (and everything under it) to one brain").argument("[brain]", "path to the brain \u2014 omit to show what this folder resolves to").option("--here <dir>", "write the pointer in this directory instead of the cwd").option(
+    "--default",
+    "make this the brain used anywhere no pointer applies, instead of binding one folder"
+  ).action(async (brainPath, opts) => {
     const where = await canonicalize(resolve9(opts.here ?? process.cwd()));
     if (!brainPath) {
       const pointer = await readPointer(where);
@@ -8149,7 +8395,23 @@ ${hint}`));
 A pointer to an unlinked folder would fail on every command instead of at this one.`
       );
     }
-    const value = isInside(root, where) ? relative2(where, root) || "." : root;
+    if (opts.default) {
+      await saveConfig({ ...cfg, brain: { ...cfg.brain, default: root } });
+      printDual({
+        json: { default: root },
+        human: () => {
+          printHuman(`Default brain is now \`${root}\`.
+`);
+          printHuman(
+            c.gray(
+              "Used wherever no `.memgineering` pointer applies and you are not inside\nanother brain \u2014 so linking a second brain no longer makes every command\nambiguous. `--vault <path>` still wins for a single run."
+            )
+          );
+        }
+      });
+      return;
+    }
+    const value = isInside(root, where) ? relative3(where, root) || "." : root;
     const file = resolve9(where, BRAND.pointerFileName);
     await writeThenRename(file, `${value}
 `);