memgineering 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -11,6 +11,74 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [0.4.0] — 2026-08-10
+
+A template is not an answer, a revision that revises nothing is not written,
+and linking a second brain no longer breaks the first one everywhere.
+
+### Added
+
+- **`recall` tells a template apart from an answer.** A card that is one of the
+  five `01_BASE/` files and is still byte-for-byte what `init` wrote is marked
+  `not filled in yet`; when every card in a result carries that mark, one line
+  above them says nothing you have written matched, and points at `onboard`.
+  `--json` carries it as `scaffolding`. Nothing is removed from the result —
+  the label is a fact about the file, so an unfilled base note padding out a
+  weak answer is visible as padding instead of reading like a conclusion. The
+  mark disappears the moment the file is edited, which is also the moment a base
+  note starts being the best answer in the brain.
+
+- **`revise` refuses a revision that revises nothing.** When the claim, summary
+  and title all match what the note already holds, nothing is written and the
+  reason is given — a user repeating an answer they had already given used to
+  become ledger entries recording no change. Saying `--reason` makes it a real
+  record again, which is what `reinforce` is for.
+- **`revise` says when a conclusion landed above `init`'s instructions.** These
+  files take two steps — write the body, then record the claim — and doing only
+  the second leaves a note whose frontmatter concludes something while the prose
+  under it is still the form telling you what to write.
+
+### Changed
+
+- **`revise --help` says which `--action` to pick and what it costs to pick
+  wrong.** Only `supersede` moves `valid_from`, so using it on a fact that was
+  true all along dates it from today. Filling in a blank `01_BASE/` file for the
+  first time is `reinforce`.
+
+### Fixed
+
+- **Linking a second brain no longer breaks the first one everywhere.** With
+  more than one brain linked and no pointer in the current folder, every command
+  refused as ambiguous — so a scratch brain linked for an afternoon stopped
+  `recall` and `remember` working in every other directory, for every tool
+  sharing the config. The first brain linked is now the default and is used when
+  nothing more specific applies; `memgineering use --default <path>` changes it,
+  and `--vault`, a `.memgineering` pointer, and standing inside a brain all
+  still win. The ambiguity refusal remains for the case it was written for —
+  several brains and nothing ever said which — and now names the one-time fix.
+  Upgrading picks the brain you already had, not the next one you happen to
+  link.
+- **The cross-language warning no longer fires over a base file the user wrote.**
+  It decided "did this query reach anything the person wrote" from the path — a
+  match under `01_BASE/` did not count — so somebody who had answered those five
+  questions could ask about their own preferences, get their own note, and be
+  told the query could not reach their brain. It now asks whether the file has
+  been touched, which is what it meant all along.
+
+### Agent guidance
+
+- `memgineering-memory` covers the `not filled in yet` mark and the header above
+  a result made only of templates: what they mean, and that a card carrying one
+  is not evidence of anything.
+- `memgineering-memory` spells out that filling in a base file is two steps —
+  write the body, then record the claim — why it is `--action reinforce` rather
+  than the default, and that re-recording something unchanged is refused.
+- `memgineering-setup` covers the default brain, and says not to abandon a write
+  because the brain was ambiguous: a refused `remember` means the thing the user
+  asked you to keep was not kept.
+
+**Restart your agent session after upgrading** so the updated skills load.
+
 ## [0.3.0] — 2026-08-10
 
 Recall says how old a memory is and why two of them disagree; a screen for

package/assets/memgineering-memory/SKILL.md

@@ -74,6 +74,29 @@ Say so. Only titles, aliases and summaries are searched, so suggest broader
 words — but do not go read their folder yourself to compensate. A brain that
 answers "nothing" is giving you real information.
 
+### Cards that are not answers
+
+A card marked `not filled in yet` is one of the five `01_BASE/` files, still
+byte-for-byte what `init` wrote. Nobody has answered it, so it is evidence of
+nothing — do not quote it back as if it were what they think.
+
+When every card carries that mark, recall says so above them:
+
+```
+⚠ Nothing you have written matched this.
+  Every card below is still the template `init` wrote
+```
+
+That is the moment to offer to fill them in rather than to answer from them —
+`memgineering onboard` prints the questions. The cards are still listed, because
+the label is a claim about the file, not a decision about what you may see;
+`--json` carries the same fact as `scaffolding: true`.
+
+The mark disappears the moment the user writes in the file. A base note they
+have filled in is an ordinary note of theirs and often the best answer in the
+brain — `who am I`, `what am I not allowed to do`, `where does everything live`
+are all answered from `01_BASE/`.
+
 ## Filling in the base files, which only you can do
 
 `init` creates five files in `01_BASE/` and leaves them empty, because what
@@ -114,17 +137,30 @@ answers thin out — three good lines beat a filled-in template. Take what they
 say in passing during ordinary work too; most of `TOOLING.md` gets written by
 noticing, not by asking.
 
-**How to write it.** These files' bodies are prose, and `revise` only touches
-frontmatter — so write the body with your normal file tools, then set the
-summary so recall shows the real thing rather than the prompt:
+**How to write it — both halves.** `revise` only touches frontmatter, so it
+takes two steps, and skipping the first is the common failure: write the body
+with your normal file tools FIRST, replacing `init`'s instructions with what
+they actually said, then record the conclusion.
 
 ```
+# 1. replace the body — their words, not the template's prompt
+# 2. then:
 memgineering revise 01_BASE/USER.md \
   --action reinforce \
   --claim "<one line: who they are>" \
   --summary "<the line recall should show>"
 ```
 
+A claim written above the untouched template leaves the file reading as a form
+somebody half-filled — the conclusion in the frontmatter, the instructions for
+writing one still underneath. `revise` warns when you do this; the warning means
+go back and write the body.
+
+`--action reinforce`, not the default, and the reason is the date. `supersede`
+stamps `valid_from` with now because a replaced conclusion starts now — but
+these facts were always true and you have only just been told them. Dating them
+today is wrong in the one field a memory store exists to get right.
+
 This is the ONE place you edit a brain file directly, and the boundary is
 narrow: `01_BASE/` only, and only while the file is still the template `init`
 wrote. Nothing is lost — there is no history to break and nothing to undo — and
@@ -221,11 +257,24 @@ memgineering revise deploy-manual \
   --summary "manual only, no CD"
 ```
 
-- `--action supersede` (default) replaces the conclusion
-- `--action reinforce` keeps it and adds support
-- `--action conflict` records that two notes disagree without picking a winner
+- `--action supersede` (default) — the conclusion CHANGED. Stamps `valid_from`
+  with now, because a replaced conclusion starts now.
+- `--action reinforce` — the SAME conclusion, new support. Leaves `valid_from`
+  alone. Use it when nothing about the fact changed, only your evidence.
+- `--action conflict` — two notes DISAGREE. Records the edge, leaves both
+  standing, and deliberately does not write the claim you passed.
 - `--dry-run` shows the diff and writes nothing
 
+Pick by what changed, not by habit: `supersede` on a fact that was true all
+along dates it from today, and the date is the field this is all for.
+
+**Re-recording something unchanged is refused.** If the claim, summary and title
+all match what the note already holds, `revise` writes nothing and says so —
+otherwise a user repeating themselves turns into ledger entries that record no
+change. When you do mean "this still holds", say what confirms it:
+`--action reinforce --reason "<what confirms it>"`. Check with `open <ref>`
+before rewriting something you may already have.
+
 This only ever rewrites the memory block in a note's frontmatter. The prose is
 the user's; neither this command nor you should rewrite it uninvited.
 

package/assets/memgineering-setup/SKILL.md

@@ -137,8 +137,9 @@ one answers is decided by where you are, in this order:
 2. a `.memgineering` pointer file, found by walking up from the cwd
 3. the brain the current directory is inside
 4. the only one linked
+5. their default brain — the first one they linked, unless they changed it
 
-If it says the choice is ambiguous, bind the directory once:
+Bind a directory to one brain when that directory belongs to it:
 
 ```
 memgineering use ~/brains/work
@@ -147,6 +148,19 @@ memgineering use ~/brains/work
 Inside a repository this writes a relative path, so it can be committed and
 will resolve for a teammate who links the same brain.
 
+If it still says the choice is ambiguous — several brains, and nothing has ever
+said which is theirs — that is a question for them, not a guess for you. Show
+the list it printed and offer the one-time fix:
+
+```
+memgineering use --default ~/brains/work
+```
+
+**Do not give up on a write because of this.** A refused `remember` means the
+thing they asked you to keep was not kept, and "I could not tell which brain"
+is a solvable problem — ask which one, or use `--vault` for the write and raise
+the default with them afterwards.
+
 ## Checking it worked
 
 ```

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(
@@ -3145,247 +3370,50 @@ Brain: ${root}`));
     for (const d of refused.slice(0, 10)) printHuman(c.gray(`    ${d.path}  (${d.detail})`));
     printHuman(c.gray("    Those are not read, not indexed, and not recalled."));
   }
-  if (samples.length > 0) {
-    printHuman(c.gray("\n  For example, these exact lines would be stored:"));
-    for (const r of samples) {
-      printHuman(c.gray(`    ${r.title}`));
-      printHuman(c.gray(`      ${r.summary ?? "(no summary \u2014 title only)"}`));
-    }
-    if (notes.length > samples.length) {
-      printHuman(
-        c.gray(`    \u2026and ${notes.length - samples.length} more \u2014 see them all with --dry-run.`)
-      );
-    }
-  }
-  printHuman(c.bold("\n  A name list cannot protect a file with an ordinary name."));
-  printHuman(
-    c.gray(
-      "  Notes whose CONTENT looks like a credential are refused automatically,\n  but a diagnosis or an address written as plain prose matches nothing.\n  List those by exact path in a .memgdeny file at the top of your notes\n  folder \u2014 one path per line, relative to that folder, no wildcards:\n      30_personal/medical.md\n      99_archive/            (a trailing slash covers a whole folder)"
-    )
-  );
-  printHuman(
-    c.gray(
-      "\n  This tool writes into your notes without asking each time \u2014 new\n  observations, and changes to the memory block of a note. Every one is\n  recorded and reversible:  memgineering log  \xB7  memgineering undo"
-    )
-  );
-  const { ok } = await prompts({
-    type: "confirm",
-    name: "ok",
-    message: "Build the index for this folder?",
-    initial: false
-  });
-  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")
+  if (samples.length > 0) {
+    printHuman(c.gray("\n  For example, these exact lines would be stored:"));
+    for (const r of samples) {
+      printHuman(c.gray(`    ${r.title}`));
+      printHuman(c.gray(`      ${r.summary ?? "(no summary \u2014 title only)"}`));
+    }
+    if (notes.length > samples.length) {
+      printHuman(
+        c.gray(`    \u2026and ${notes.length - samples.length} more \u2014 see them all with --dry-run.`)
+      );
+    }
+  }
+  printHuman(c.bold("\n  A name list cannot protect a file with an ordinary name."));
+  printHuman(
+    c.gray(
+      "  Notes whose CONTENT looks like a credential are refused automatically,\n  but a diagnosis or an address written as plain prose matches nothing.\n  List those by exact path in a .memgdeny file at the top of your notes\n  folder \u2014 one path per line, relative to that folder, no wildcards:\n      30_personal/medical.md\n      99_archive/            (a trailing slash covers a whole folder)"
     )
-  };
+  );
+  printHuman(
+    c.gray(
+      "\n  This tool writes into your notes without asking each time \u2014 new\n  observations, and changes to the memory block of a note. Every one is\n  recorded and reversible:  memgineering log  \xB7  memgineering undo"
+    )
+  );
+  const { ok } = await prompts({
+    type: "confirm",
+    name: "ok",
+    message: "Build the index for this folder?",
+    initial: false
+  });
+  return ok === true;
 }
-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";
   }
 });
 
@@ -5424,7 +5452,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 +5547,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 +5996,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 +6069,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 +6204,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 +6223,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 +6239,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 +6256,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 +6365,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 +6469,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 +6527,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 +6545,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 +6815,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 +6913,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 +6930,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 +6944,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 +6975,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 +7044,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 +7383,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 +7412,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 +7437,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 +7490,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 +7498,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 +7527,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 +7644,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;
@@ -8098,10 +8257,14 @@ 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,6 +8312,22 @@ ${hint}`));
 A pointer to an unlinked folder would fail on every command instead of at this one.`
       );
     }
+    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) ? relative2(where, root) || "." : root;
     const file = resolve9(where, BRAND.pointerFileName);
     await writeThenRename(file, `${value}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memgineering",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "private": false,
   "description": "One memory for the AI you connect. Recall, remember, and revise a brain your agents share — stored in your own folder.",
   "license": "Apache-2.0",