memgineering 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -11,6 +11,37 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [0.11.0] — 2026-08-26
+
+### Added
+
+- **`memgineering rename <new-name> [--brain <name-or-id>]` — a wrong name is
+  one command, not an orphan.** Renames a hosted brain in place: notes, ledger
+  and id untouched, this machine's pointer healed, other machines picking the
+  new name up on their next command. A server that predates renaming is told
+  apart from a missing brain and says which side needs updating.
+- **`memgineering delete-brain <name-or-id> --confirm "<exact name>"`.**
+  Deletes a hosted brain — every note, its ledger, its measurements — behind a
+  three-way gate: an exact-name `--confirm`, a retype-the-name prompt when a
+  person is at the terminal, and a hard refusal when nobody can answer.
+  Deleting the brain this machine reads also clears the pointer, and says so.
+  The server route existed since 0.6; the CLI now exposes it.
+
+### Changed
+
+- `create`'s follow-up and the `brains` listing hints now name `rename` (and,
+  on the listing, `delete-brain`) so an agent mid-task finds the right verb
+  instead of inventing a copy-rename that strands an orphan brain — the
+  failure measured 3/3 in round 9.
+
+### Agent guidance
+
+- The `memgineering-setup` skill gained "Renaming and deleting a hosted
+  brain": rename-not-delete for wrong names, the delete confirm contract
+  (only on the person's explicit ask, never to tidy up), and `unlink --brain`
+  as the non-destructive sibling. Skill trigger phrases now include renaming
+  and deleting. Restart your agent session after upgrading.
+
 ## [0.10.0] — 2026-08-26
 
 ### Added

package/assets/MEMGINEERING.md

@@ -2,7 +2,7 @@
 name: memgineering
 description: Use whenever the user refers to something they told you before, asks what was decided, tells you something worth keeping, or settles something that should hold next time. The memory lives in their own folder and outlives this session; check it before answering from guesswork, and write to it when you learn something durable.
 type: skill
-version: 0.10.0
+version: 0.11.0
 ---
 
 # memgineering

package/assets/memgineering-setup/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: memgineering-setup
-description: Use when installing or configuring memgineering, when moving a brain between a machine and an account, or whenever the user asks WHICH of their AI tools can see this memory. Triggers include "set up memgineering", "connect my notes", "does my other AI see this too", "which of my tools can read this", "will it work in the app on my phone", "no brain is linked".
+description: Use when installing or configuring memgineering, when moving a brain between a machine and an account, when renaming or deleting a hosted brain, or whenever the user asks WHICH of their AI tools can see this memory. Triggers include "set up memgineering", "connect my notes", "rename my brain", "delete that brain", "does my other AI see this too", "which of my tools can read this", "will it work in the app on my phone", "no brain is linked".
 type: skill
 allowed-tools: Bash(memgineering:*)
 ---
@@ -163,6 +163,25 @@ A name the account already holds is refused with nothing written — `use
 exception is a brain holding nothing but its own untouched scaffolding: that
 is an interrupted `create`, and running the same command again finishes it.
 
+### Renaming and deleting a hosted brain
+
+**A wrongly-named brain is a rename, not a delete.** `memgineering rename
+<new name>` changes what the brain this machine reads is called, in place —
+notes, ledger and id untouched; `--brain <name-or-id>` renames another one.
+Other machines pick the new name up on their own next command; nothing on
+them breaks, because pointers hold the id. Never create a second brain to
+fix a name.
+
+`memgineering delete-brain <name-or-id> --confirm "<exact name>"` is the
+destructive one: the brain, every note in it, its ledger and its
+measurements, gone from the server, not recoverable. Run it ONLY when the
+person has explicitly asked for THIS brain to be deleted, and take the
+confirm name from what they said — never type it for them from a listing to
+tidy an account up. Without `--confirm` in a real terminal it asks the
+person to retype the brain's name; with no terminal it refuses rather than
+deciding. `unlink --brain` is the gentle sibling: it only stops this machine
+reading a brain and deletes nothing.
+
 **They already keep notes in a folder on this machine** — carry them up
 instead of starting empty:
 

package/dist/index.js

@@ -5171,8 +5171,8 @@ var init_init = __esm({
 // src/commands/link.ts
 import { readFile as readFile16 } from "fs/promises";
 import { join as join15 } from "path";
-import { Command as Command9 } from "commander";
-import prompts from "prompts";
+import { Command as Command11 } from "commander";
+import prompts2 from "prompts";
 function sameBasename(all, entry) {
   const base = (entry.split("/").pop() ?? entry).normalize("NFC").toLowerCase();
   return all.filter((p) => (p.split("/").pop() ?? "").normalize("NFC").toLowerCase() === base);
@@ -5194,7 +5194,7 @@ function spreadAcrossFolders(rows, max) {
   return picked;
 }
 function linkCommand() {
-  return new Command9("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 Command11("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
@@ -5520,7 +5520,7 @@ Brain: ${root}`));
       "\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({
+  const { ok } = await prompts2({
     type: "confirm",
     name: "ok",
     message: "Build the index for this folder?",
@@ -5601,9 +5601,9 @@ var init_open_browser = __esm({
 });
 
 // src/commands/login.ts
-import { Command as Command14 } from "commander";
+import { Command as Command16 } from "commander";
 function loginCommand() {
-  return new Command14("login").description("sign in to a hosted brain").option(
+  return new Command16("login").description("sign in to a hosted brain").option(
     "--emit-only",
     "start the sign-in, open the browser, and return immediately \u2014 THE path an agent should use on a user\u2019s behalf; the next command claims the token automatically. Prefer this over the plain form, whose wait for a human click will outlast an agent\u2019s command timeout"
   ).option("--no-browser", "do not try to open a browser \u2014 just print the link").option("--print-url", "print the approval link even when a browser opened").addHelpText(
@@ -5962,7 +5962,7 @@ var init_setup_brain = __esm({
 });
 
 // src/commands/setup-signin.ts
-import prompts2 from "prompts";
+import prompts3 from "prompts";
 async function runSignInStep(opts) {
   const summary = await signInSummary();
   if (summary.signedIn) return { status: "signed-in", displayName: summary.displayName };
@@ -5989,7 +5989,7 @@ async function runSignInStep(opts) {
   }
   if (opts.interactive) {
     printHuman(c.bold("\nmemgineering \u2014 setup\n"));
-    const { wants } = await prompts2({
+    const { wants } = await prompts3({
       type: "toggle",
       name: "wants",
       message: "Sign in to a memgineering account first?",
@@ -8364,11 +8364,11 @@ import { createHash as createHash8 } from "crypto";
 import { access, mkdir as mkdir13, readFile as readFile19 } from "fs/promises";
 import { dirname as dirname5, join as join19 } from "path";
 import { fileURLToPath } from "url";
-import { Command as Command23 } from "commander";
-import prompts3 from "prompts";
+import { Command as Command25 } from "commander";
+import prompts4 from "prompts";
 import { homedir as homedir4 } from "os";
 function setupCommand() {
-  return new Command23("setup").description("install into your agents, and point at a brain (--dry-run to only report)").option("--agent", "non-interactive: take every answer from flags").option("--human", "interactive: choose from a list").option("--web", "open a screen in the browser and answer it there").option("--print-url", "with --web: print the URL instead of opening a browser").option(
+  return new Command25("setup").description("install into your agents, and point at a brain (--dry-run to only report)").option("--agent", "non-interactive: take every answer from flags").option("--human", "interactive: choose from a list").option("--web", "open a screen in the browser and answer it there").option("--print-url", "with --web: print the URL instead of opening a browser").option(
     "--tools <list>",
     "comma-separated: claude, codex, grok, gemini (default: all detected)"
   ).option("--auto-update <choice>", "on | off  (default: on, recommended)").option(
@@ -8584,7 +8584,7 @@ function setupCommand() {
       }
     });
     if (mode.kind === "human" && brains.length === 0 && !opts.dryRun && isInteractive()) {
-      const { path } = await prompts3({
+      const { path } = await prompts4({
         type: "text",
         name: "path",
         message: "Path to your notes folder (blank to skip)"
@@ -8705,7 +8705,7 @@ async function resolveMode(opts) {
     return { kind: "human", chosen: true };
   }
   if (!isInteractive() || isJsonMode()) return { kind: "agent", chosen: false };
-  const { mode } = await prompts3({
+  const { mode } = await prompts4({
     type: "select",
     name: "mode",
     message: "How would you like to set this up?",
@@ -8762,7 +8762,7 @@ async function askHuman(detected, opts) {
   printHuman(c.bold("\nmemgineering \u2014 setup\n"));
   printHuman(c.gray("  Found: ") + detected.map((t) => t.label).join(", "));
   printHuman("");
-  const answers = await prompts3([
+  const answers = await prompts4([
     {
       type: "multiselect",
       name: "tools",
@@ -9117,7 +9117,7 @@ For a guide: put ${BRAND.hubMarkerStart} and ${BRAND.hubMarkerEnd} back around t
 });
 
 // src/program.ts
-import { Command as Command29 } from "commander";
+import { Command as Command31 } from "commander";
 
 // src/help.ts
 init_ui();
@@ -9141,7 +9141,17 @@ var COMMAND_GROUPS = [
   {
     title: "ACCOUNT",
     blurb: "optional \u2014 connect a hosted brain; everything above works without it",
-    commands: ["login", "logout", "whoami", "brains", "create", "push", "pull"]
+    commands: [
+      "login",
+      "logout",
+      "whoami",
+      "brains",
+      "create",
+      "rename",
+      "delete-brain",
+      "push",
+      "pull"
+    ]
   },
   {
     title: "SYSTEM",
@@ -12407,7 +12417,7 @@ async function refuseUnlessInterrupted(brain, name) {
   );
 }
 function nextStep2(created, filledCount) {
-  const ask = "Run `memgineering onboard` \u2014 it prints what to ask, in their words. Do not invent answers; a guessed BOUNDARIES file is worse than an empty one, because the next agent reads it as something they said.";
+  const ask = "Run `memgineering onboard` \u2014 it prints what to ask, in their words. Do not invent answers; a guessed BOUNDARIES file is worse than an empty one, because the next agent reads it as something they said. If this name turns out wrong, `memgineering rename <new name>` renames it in place \u2014 never create a second brain to fix a name.";
   return created ? `${BASE_COUNT - filledCount} of ${BASE_COUNT} base files are still empty templates. ${ask}` : `Some base files may still be empty templates \u2014 the ones already there were left as they were. ${ask}`;
 }
 function printPointed(repoint, name) {
@@ -12435,11 +12445,396 @@ This machine now reads \u201C${shown}\u201D.
   );
 }
 
+// src/commands/rename.ts
+init_errors();
+init_api_client();
+init_cloud_brain();
+import { Command as Command9 } from "commander";
+init_config();
+init_ui();
+function renameCommand() {
+  return new Command9("rename").description("change what a hosted brain is called, in place").argument("<new-name>", "what to call it instead").option("--brain <name>", "which hosted brain to rename, by its name or id").option("--dry-run", "say what would be renamed and send nothing").addHelpText(
+    "after",
+    "\nRenames the brain this machine reads unless `--brain` names another one.\nNothing is uploaded, downloaded or deleted: the notes, the history and every\npointer at this brain resolve by id, so only the label changes."
+  ).action(async (rawName, opts) => {
+    if (rawName.startsWith("--")) {
+      throw memgError(
+        "invalid_input",
+        `\`rename\` was given the flag \`${oneLine(rawName, 32)}\` as a brain name`,
+        "Nothing was renamed. The first argument is the NEW NAME for the brain, and the\nflag written there was read as that name. Put the name first \u2014 `memgineering\nrename <new name> --brain <name-or-id>` \u2014 and pass the other flag after it."
+      );
+    }
+    const named = opts.brain;
+    if (named !== void 0 && named.startsWith("--")) {
+      throw memgError(
+        "invalid_input",
+        `\`--brain\` was given the flag \`${oneLine(named, WIDTH.title)}\` as its name`,
+        "Nothing was renamed. Put the hosted brain name or id immediately after `--brain`, then pass the other flag separately. The new name is the first argument, not this one."
+      );
+    }
+    const name = rawName.replace(/\s+/g, " ").trim();
+    if (name === "") {
+      throw memgError(
+        "invalid_input",
+        "a brain needs a name",
+        "Nothing was renamed. `memgineering rename <new name>` needs the new name as its first argument \u2014 it is what the user will see in `memgineering brains` and how they tell two brains apart."
+      );
+    }
+    const server = apiUrl();
+    const pointer = (await loadConfig()).brain.cloud;
+    const pointed = pointer !== void 0 && pointer.api_url === server ? pointer : void 0;
+    if (opts.dryRun === true) {
+      printDual({
+        json: {
+          dry_run: true,
+          would_rename_to: name,
+          api_url: server,
+          // The unresolved flag value is echoed rather than looked up: which
+          // brain it names is a question only the server can answer, and this
+          // run does not ask it anything.
+          target: named !== void 0 ? { source: "flag", requested: named, id: null, name: null } : pointed === void 0 ? null : { source: "pointer", requested: null, id: pointed.id, name: pointed.name }
+        },
+        human: () => {
+          printHuman(`## rename (dry run)
+`);
+          if (named !== void 0) {
+            printHuman(
+              `whichever brain \`--brain ${oneLine(named, WIDTH.title)}\` turns out to name \u2192 \u201C${oneLine(name, WIDTH.title)}\u201D on \`${server}\`
+`
+            );
+          } else if (pointed !== void 0) {
+            printHuman(
+              `\u201C${oneLine(pointed.name, WIDTH.title)}\u201D \u2192 \u201C${oneLine(name, WIDTH.title)}\u201D on \`${server}\`
+` + c.gray(
+                `  (${oneLine(pointed.id, WIDTH.handle)} \u2014 the brain this machine reads)
+`
+              )
+            );
+          } else {
+            printHuman(
+              c.yellow("nothing to rename: this machine is not reading a hosted brain\n") + c.gray("  A real run would refuse. `--brain <name-or-id>` picks one instead.\n")
+            );
+          }
+          printHuman(
+            c.gray(
+              "\nNothing was sent, and nothing was asked of the server \u2014 including whether\nthis account already holds a brain by that name, which is the one thing a\nreal run finds out. Run without --dry-run to find out."
+            )
+          );
+        }
+      });
+      return;
+    }
+    const { target, token, viaPointer } = await resolveTarget2({
+      named,
+      pointed,
+      pointer,
+      server
+    });
+    const renamed = await renameCloudBrain({ token, server, id: target.id, name, viaPointer });
+    const pointerUpdated = pointed !== void 0 && pointed.id === renamed.id;
+    if (pointerUpdated) {
+      await pointConfigAt({ brainId: renamed.id, name: renamed.name, apiUrl: server });
+    }
+    const changed = renamed.renamed_from !== null;
+    const next = nextStep3(renamed);
+    printDual({
+      json: {
+        brain: { id: renamed.id, name: renamed.name, api_url: server },
+        renamed_from: renamed.renamed_from,
+        /** False when the brain already carried this name — a repeat, not a failure. */
+        changed,
+        /** Whether this machine's own pointer was rewritten to carry the new name. */
+        pointer_updated: pointerUpdated,
+        next
+      },
+      human: () => {
+        printHuman(
+          c.green(
+            changed ? `\u2713 renamed \u201C${oneLine(renamed.renamed_from ?? "", WIDTH.title)}\u201D \u2192 \u201C${oneLine(renamed.name, WIDTH.title)}\u201D` : `\u2713 \u201C${oneLine(renamed.name, WIDTH.title)}\u201D is already what it is called \u2014 nothing changed`
+          )
+        );
+        if (changed) {
+          printHuman(
+            c.gray("  the notes, the history and every id are untouched \u2014 only the label moved")
+          );
+        }
+        if (pointerUpdated) {
+          printHuman(c.gray("  this machine reads this brain, and now calls it that too"));
+        } else if (pointed !== void 0) {
+          printHuman(
+            c.gray(`
+This machine still reads \u201C${oneLine(pointed.name, WIDTH.title)}\u201D.`)
+          );
+        }
+        printHuman(c.gray(`
+${next}`));
+      }
+    });
+  });
+}
+async function resolveTarget2(args) {
+  const { named, pointed, pointer, server } = args;
+  if (named === void 0) {
+    if (pointed === void 0) throw notPointed(pointer, server);
+    const token2 = await tokenFor(server);
+    return { target: { id: pointed.id, name: pointed.name }, token: token2, viaPointer: true };
+  }
+  const token = await tokenFor(server);
+  const brains = await listCloudBrains(token, server);
+  const found = findCloudBrain(brains, named);
+  if (!found) throw noSuchBrain(named, brains);
+  return { target: { id: found.id, name: found.name }, token, viaPointer: false };
+}
+async function tokenFor(server) {
+  const credentials = await requireCredentials(server).catch((err) => {
+    if (err instanceof MemgError && err.code === "not_signed_in") {
+      throw memgError(
+        "not_signed_in",
+        "renaming a hosted brain needs the account it lives on, and this machine is not signed in",
+        "Nothing was renamed. `memgineering login --emit-only`, show the user the code it\nprints, then run this again \u2014 the token is claimed once they approve."
+      );
+    }
+    throw err;
+  });
+  return credentials.token;
+}
+async function renameCloudBrain(args) {
+  const { token, server, id, name, viaPointer } = args;
+  try {
+    const res = await apiRequest({
+      method: "PATCH",
+      path: `/v1/brains/${encodeURIComponent(id)}`,
+      token,
+      baseUrl: server,
+      body: { name }
+    });
+    return res.body;
+  } catch (err) {
+    if (!(err instanceof MemgError)) throw err;
+    if (err.code === "not_found") {
+      throw new MemgError({
+        code: err.code,
+        message: `${server} answered as if \`PATCH /v1/brains/:id\` does not exist \u2014 it predates renaming`,
+        hint: "Nothing was renamed, and the brain and its name are unchanged. Nothing in this CLI will change that: the server needs its brain-api updated to a version that has the route. Every other verb still works against it, and `memgineering brains` lists what the account holds."
+      });
+    }
+    if (err.code === "brain_not_found" && viaPointer) {
+      throw new MemgError({
+        code: err.code,
+        message: err.message,
+        hint: `Nothing was renamed. This machine is pointed at a brain this account no longer has \u2014 deleted somewhere else, or made on a different account. \`memgineering brains\` lists what is actually there and \`memgineering use --brain <name-or-id>\` points this machine at one of them; then run this again. The server said: ${err.hint}`
+      });
+    }
+    throw err;
+  }
+}
+function notPointed(pointer, server) {
+  return memgError(
+    "invalid_input",
+    pointer === void 0 ? "this machine is not reading a hosted brain" : `this machine is not reading a hosted brain on ${server} \u2014 its pointer names one on ${pointer.api_url}`,
+    "Nothing was renamed. `memgineering brains` lists the account\u2019s brains; rename one with `memgineering rename <new name> --brain <name-or-id>`, or point this machine first with `memgineering use --brain <name>`."
+  );
+}
+function noSuchBrain(named, brains) {
+  const available = brains.map((brain) => `  ${oneLine(brain.name, WIDTH.title)}  (${oneLine(brain.id, WIDTH.handle)})`).join("\n");
+  return memgError(
+    "invalid_input",
+    `no hosted brain called "${oneLine(named, WIDTH.title)}"`,
+    brains.length === 0 ? "Nothing was renamed. This account holds no hosted brains at all, so there is nothing here to rename \u2014 `memgineering create <name>` makes one." : `Nothing was renamed. This account has:
+${available}
+Use one of those names or ids after \`--brain\`. The NEW name is the first argument.`
+  );
+}
+function nextStep3(renamed) {
+  if (renamed.renamed_from === null) {
+    return `Nothing changed: \u201C${oneLine(renamed.name, WIDTH.title)}\u201D is already what this brain is called. If a different brain was meant, \`memgineering brains\` lists the account's with their ids.`;
+  }
+  return `Other machines that point at this brain keep showing the old name until their next command against it; nothing on them breaks \u2014 the pointer holds the id. \`--brain "${oneLine(renamed.renamed_from, WIDTH.title)}"\` no longer matches anywhere; use the new name or the id.`;
+}
+
+// src/commands/delete-brain.ts
+init_errors();
+init_api_client();
+init_cloud_brain();
+init_config();
+init_ui();
+import { Command as Command10 } from "commander";
+import prompts from "prompts";
+function deleteBrainCommand() {
+  return new Command10("delete-brain").description("delete a hosted brain and everything in it, for good").argument("<name-or-id>", "which hosted brain to delete, by its name or id").option("--confirm <exact-name>", "the brain\u2019s name, typed exactly, authorising the deletion").addHelpText(
+    "after",
+    "\nIrreversible, and server-side: the brain, every note in it, its ledger and its\nmeasurements. `memgineering unlink --brain` is the other thing \u2014 it only stops\nthis machine reading a brain and deletes nothing. Run this ONLY when the person\nhas explicitly asked for this brain to be deleted, and pass --confirm with the\nexact name. A wrongly-named brain is a rename, not a delete."
+  ).action(async (named, opts) => {
+    if (named.startsWith("--")) {
+      throw memgError(
+        "invalid_input",
+        `\`delete-brain\` was given the flag \`${oneLine(named, 32)}\` as a brain name`,
+        'Nothing was deleted. The first argument is WHICH BRAIN to delete, and the flag written there was read as its name. Put the name or id first \u2014 `memgineering delete-brain <name-or-id> --confirm "<name>"`. If a brain really is called that, pass its id instead; `memgineering brains` lists them.'
+      );
+    }
+    const confirmFlag = opts.confirm;
+    if (confirmFlag !== void 0 && confirmFlag.startsWith("--")) {
+      throw memgError(
+        "invalid_input",
+        `\`--confirm\` was given the flag \`${oneLine(confirmFlag, WIDTH.title)}\` as a name`,
+        "Nothing was deleted. `--confirm` takes the brain\u2019s own name, typed exactly, and the flag written after it was read as that name. Put the name immediately after `--confirm`, then pass the other flag separately."
+      );
+    }
+    const server = apiUrl();
+    const token = await tokenFor2(server);
+    const brains = await listCloudBrains(token, server);
+    const target = findCloudBrain(brains, named);
+    if (!target) throw noSuchBrain2(named, brains);
+    const authorised = await authorise(target, confirmFlag);
+    if (authorised === void 0) {
+      printHuman(c.yellow("Cancelled \u2014 nothing was deleted."));
+      return;
+    }
+    const deleted = await deleteCloudBrain({ token, server, id: target.id, authorised });
+    const cfg = await loadConfig();
+    const pointer = cfg.brain.cloud;
+    const pointerCleared = pointer !== void 0 && pointer.id === deleted.deleted && pointer.api_url === server;
+    if (pointerCleared) {
+      await saveConfig({
+        ...cfg,
+        brain: {
+          brains: cfg.brain.brains,
+          ...cfg.brain.default === void 0 ? {} : { default: cfg.brain.default }
+        }
+      });
+    }
+    const hint = deleted.hint ?? "The brain, its notes and its ledger are gone. `memgineering brains` lists what is left.";
+    printDual({
+      json: {
+        deleted: { id: deleted.deleted, name: deleted.name },
+        /** Null when the server said nothing — which is not the same as zero. */
+        notes_deleted: deleted.notes_deleted ?? null,
+        /** Whether this machine had been reading it, and has now stopped. */
+        pointer_cleared: pointerCleared,
+        hint
+      },
+      human: () => {
+        printHuman(
+          c.green(`\u2713 deleted \u201C${oneLine(deleted.name, WIDTH.title)}\u201D`) + c.gray(`  (${oneLine(deleted.deleted, WIDTH.handle)})`)
+        );
+        printHuman(
+          c.gray(
+            deleted.notes_deleted === void 0 ? "  its notes, its ledger and its measurements went with it" : `  ${deleted.notes_deleted} note(s) went with it, along with its ledger and its measurements`
+          )
+        );
+        if (pointerCleared) {
+          printHuman(
+            c.yellow(
+              `
+\u26A0 THIS MACHINE NO LONGER READS A HOSTED BRAIN \u2014 it was reading \u201C${oneLine(deleted.name, WIDTH.title)}\u201D, which is now deleted.`
+            )
+          );
+          printHuman(
+            c.gray(
+              "  `memgineering brains` lists what is left; `use --brain <name>` points at one.\n  `recall --local` still reads a folder, if one is linked."
+            )
+          );
+        }
+        printHuman(c.gray(`
+${hint}`));
+      }
+    });
+  });
+}
+async function tokenFor2(server) {
+  const credentials = await requireCredentials(server).catch((err) => {
+    if (err instanceof MemgError && err.code === "not_signed_in") {
+      throw memgError(
+        "not_signed_in",
+        "deleting a hosted brain needs the account it lives on, and this machine is not signed in",
+        "Nothing was deleted. `memgineering login --emit-only`, show the user the code it\nprints, then run this again \u2014 the token is claimed once they approve."
+      );
+    }
+    throw err;
+  });
+  return credentials.token;
+}
+async function authorise(target, confirmFlag) {
+  if (confirmFlag !== void 0) {
+    if (confirmFlag !== target.name) throw confirmationMismatch(target);
+    return confirmFlag;
+  }
+  if (!isInteractive()) throw cannotAsk(target);
+  return retypeTheName(target);
+}
+function confirmationMismatch(target) {
+  const name = oneLine(target.name, WIDTH.title);
+  const removes = target.note_count === void 0 ? "Deleting it removes its notes, its ledger and its measurements, and none of that comes back." : `Deleting it removes its ${target.note_count} note(s), its ledger and its measurements, and none of that comes back.`;
+  return memgError(
+    "invalid_input",
+    "the confirmation does not match this brain\u2019s name",
+    `Nothing was deleted. The brain is called \u201C${name}\u201D \u2014 exactly that, including case and spacing. ${removes} Pass --confirm "${name}" only if the person explicitly asked for THIS brain to be deleted.`
+  );
+}
+function cannotAsk(target) {
+  const name = oneLine(target.name, WIDTH.title);
+  return memgError(
+    "invalid_input",
+    "cannot ask for confirmation here \u2014 this is not an interactive terminal",
+    `Nothing was deleted. Two ways forward: run this in a terminal the person can see and let them type the name; or, once they have explicitly said \u201Cdelete ${name}\u201D, pass --confirm "${name}". Deciding for them is the one thing this gate exists to prevent.`
+  );
+}
+async function retypeTheName(target) {
+  printHuman(c.bold(`
+Delete \u201C${oneLine(target.name, WIDTH.title)}\u201D?`));
+  printHuman(c.gray(`  id      ${oneLine(target.id, WIDTH.handle)}`));
+  printHuman(
+    c.gray(
+      target.note_count === void 0 ? "  notes   (this server does not say how many)" : `  notes   ${target.note_count}`
+    )
+  );
+  printHuman(
+    c.yellow(
+      "\n  This deletes the brain on the server \u2014 every note in it, its ledger and\n  its measurements. None of it comes back, and no other machine holds a copy."
+    )
+  );
+  printHuman(
+    c.gray(
+      "\n  `memgineering unlink --brain` is the other thing: it stops this machine\n  reading a brain and deletes nothing. A wrongly-named brain is a rename."
+    )
+  );
+  const { typed } = await prompts({
+    type: "text",
+    name: "typed",
+    message: "Type the brain\u2019s name exactly to delete it"
+  });
+  return typed === target.name ? typed : void 0;
+}
+function noSuchBrain2(named, brains) {
+  const available = brains.map((brain) => {
+    const count = brain.note_count === void 0 ? "" : `, ${brain.note_count} notes`;
+    return `  ${oneLine(brain.name, WIDTH.title)}  (${oneLine(brain.id, WIDTH.handle)}${count})`;
+  }).join("\n");
+  return memgError(
+    "invalid_input",
+    `no brain called \u201C${oneLine(named, WIDTH.title)}\u201D on this account`,
+    brains.length === 0 ? "Nothing was deleted. This account holds no hosted brains at all. If it was already deleted, that is what is left: nothing." : `Nothing was deleted. This account has:
+${available}
+If it was already deleted, the list above is what is left.`
+  );
+}
+async function deleteCloudBrain(args) {
+  const { token, server, id, authorised } = args;
+  const res = await apiRequest({
+    method: "DELETE",
+    path: `/v1/brains/${encodeURIComponent(id)}`,
+    token,
+    baseUrl: server,
+    body: { confirm: authorised }
+  });
+  return res.body;
+}
+
 // src/commands/curation.ts
 init_src();
 import { stat as stat2 } from "fs/promises";
 import { resolve as resolve6 } from "path";
-import { Command as Command10 } from "commander";
+import { Command as Command12 } from "commander";
 
 // ../../packages/storage-adapter/src/local-file/ignore-file.ts
 init_atomic();
@@ -12541,7 +12936,7 @@ init_vault();
 init_ui();
 init_link();
 function lifecycleCommand(action) {
-  return new Command10(action).description(
+  return new Command12(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").option("--local", "use the brain on this machine, even when signed in to a hosted one").action(async (ref, opts) => {
     const rationale = sanitizeRationale(opts.reason);
@@ -12624,7 +13019,7 @@ Undo: \`${undoHint(record.op_id, opts.vault)}\``));
   });
 }
 function ignoreCommand(mode) {
-  return new Command10(mode).description(
+  return new Command12(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").option("--local", "use the brain on this machine, even when signed in to a hosted one").action(async (path, opts) => {
     const rationale = sanitizeRationale(opts.reason);
@@ -12765,13 +13160,13 @@ var excludeCommand = () => ignoreCommand("exclude");
 var unexcludeCommand = () => ignoreCommand("unexclude");
 
 // src/commands/evidence.ts
-import { Command as Command11 } from "commander";
+import { Command as Command13 } from "commander";
 init_index_build();
 init_cloud_brain();
 init_vault();
 init_ui();
 function evidenceCommand() {
-  return new Command11("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").option("--local", "read the brain on this machine, even when signed in to a hosted one").option(
+  return new Command13("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").option("--local", "read the brain on this machine, even when signed in to a hosted one").option(
     "--brain <name>",
     "read from one existing hosted brain by name or id, without changing the pointer"
   ).action(async (ref, opts) => {
@@ -13025,7 +13420,7 @@ init_config();
 import { createHash as createHash7 } from "crypto";
 import { mkdir as mkdir11, readdir as readdir6, stat as stat3, unlink as unlink3, writeFile as writeFile9 } from "fs/promises";
 import { dirname as dirname3, isAbsolute as isAbsolute2, join as join16, resolve as resolve7 } from "path";
-import { Command as Command12 } from "commander";
+import { Command as Command14 } from "commander";
 
 // src/lib/rules.ts
 init_src();
@@ -13067,7 +13462,7 @@ init_deadline();
 init_cloud_brain();
 init_ui();
 function guardCommand() {
-  return new Command12("guard").description("hook entry \u2014 show the user\u2019s rules before the first edit of a session").option("--context-dir <path>", "where the work is happening, when stdin does not say").option("--at <event>", "pre-tool-use | stop", "pre-tool-use").action(async (opts) => {
+  return new Command14("guard").description("hook entry \u2014 show the user\u2019s rules before the first edit of a session").option("--context-dir <path>", "where the work is happening, when stdin does not say").option("--at <event>", "pre-tool-use | stop", "pre-tool-use").action(async (opts) => {
     try {
       const out = await withDeadline(HOOK_DEADLINE_MS, async () => {
         const payload = await readPayload();
@@ -13251,12 +13646,12 @@ init_link();
 // src/commands/log.ts
 init_walk();
 import { lstat as lstat4, readFile as readFile17 } from "fs/promises";
-import { Command as Command13 } from "commander";
+import { Command as Command15 } from "commander";
 init_cloud_brain();
 init_vault();
 init_ui();
 function logCommand() {
-  return new Command13("log").description("what changed in this brain, and what can still be undone").option("--limit <n>", "how many operations", (v) => parseInt(v, 10), 20).option("--verbose", "include hashes and reverse patches").option("--vault <path>", "which brain to read").option("--local", "read the brain on this machine, even when signed in to a hosted one").option(
+  return new Command15("log").description("what changed in this brain, and what can still be undone").option("--limit <n>", "how many operations", (v) => parseInt(v, 10), 20).option("--verbose", "include hashes and reverse patches").option("--vault <path>", "which brain to read").option("--local", "read the brain on this machine, even when signed in to a hosted one").option(
     "--brain <name>",
     "read one existing hosted brain by name or id, without changing the pointer"
   ).action(async (opts) => {
@@ -13493,9 +13888,9 @@ init_api_client();
 init_credentials();
 init_pending_login();
 init_ui();
-import { Command as Command15 } from "commander";
+import { Command as Command17 } from "commander";
 function logoutCommand() {
-  return new Command15("logout").description("sign out of your account \u2014 the pointer and your notes stay").option("--all", "revoke every token on the account, not just this machine\u2019s").option(
+  return new Command17("logout").description("sign out of your account \u2014 the pointer and your notes stay").option("--all", "revoke every token on the account, not just this machine\u2019s").option(
     "--local",
     "forget the token here without telling the server \u2014 only for a server you cannot reach"
   ).action(async (opts) => {
@@ -13590,12 +13985,12 @@ function logoutCommand() {
 
 // src/commands/onboard.ts
 init_src();
-import { Command as Command16 } from "commander";
+import { Command as Command18 } from "commander";
 init_cloud_brain();
 init_vault();
 init_ui();
 function onboardCommand() {
-  return new Command16("onboard").description("what to ask so the brain knows who it belongs to").option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
+  return new Command18("onboard").description("what to ask so the brain knows who it belongs to").option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
     "--brain <name>",
     "read one existing hosted brain by name or id, without changing the pointer"
   ).action(async (opts) => {
@@ -13741,9 +14136,9 @@ init_cloud_brain();
 init_ui();
 import { mkdir as mkdir12, readFile as readFile18, writeFile as writeFile10 } from "fs/promises";
 import { dirname as dirname4, isAbsolute as isAbsolute3, join as join17, resolve as resolve8, sep as sep2 } from "path";
-import { Command as Command17 } from "commander";
+import { Command as Command19 } from "commander";
 function pullCommand() {
-  return new Command17("pull").description("download your hosted brain to a folder on this machine").argument("[destination]", "folder to write into (created if missing)").option("--brain <name>", "which hosted brain to download").option("--dry-run", "say what would be written and write nothing").action(async (destination, opts) => {
+  return new Command19("pull").description("download your hosted brain to a folder on this machine").argument("[destination]", "folder to write into (created if missing)").option("--brain <name>", "which hosted brain to download").option("--dry-run", "say what would be written and write nothing").action(async (destination, opts) => {
     const { brain: source, others } = await resolveSource(opts.brain);
     const target = resolve8(destination ?? `./${oneLine(source.name, WIDTH.title)}`);
     const first = await cloudListNotes(source, { limit: 1 });
@@ -13947,7 +14342,7 @@ init_errors();
 init_config();
 init_api_client();
 init_cloud_brain();
-import { Command as Command18 } from "commander";
+import { Command as Command20 } from "commander";
 init_vault();
 init_ui();
 var HELD_BACK_WORDING = {
@@ -13956,7 +14351,7 @@ var HELD_BACK_WORDING = {
 };
 var printHeldBack2 = (held) => printHeldBack(held, HELD_BACK_WORDING);
 function pushCommand() {
-  return new Command18("push").description("upload the brain on this machine to your hosted one").option("--vault <path>", "which local brain to upload").option("--brain <name>", "the hosted brain to upload into (created if it does not exist)").option("--dry-run", "list what would be uploaded and send nothing").action(async (opts) => {
+  return new Command20("push").description("upload the brain on this machine to your hosted one").option("--vault <path>", "which local brain to upload").option("--brain <name>", "the hosted brain to upload into (created if it does not exist)").option("--dry-run", "list what would be uploaded and send nothing").action(async (opts) => {
     const { brain: local } = await resolveBrain(opts.vault);
     const adapter = await openBrainOrExplain(local.root);
     const scan = await adapter.scan();
@@ -14136,7 +14531,7 @@ async function resolveDestination(named, root) {
 // src/commands/recall.ts
 init_src();
 init_config();
-import { Command as Command19 } from "commander";
+import { Command as Command21 } from "commander";
 import { basename, resolve as resolve9 } from "path";
 init_index_build();
 init_cloud_brain();
@@ -14144,7 +14539,7 @@ init_errors();
 init_vault();
 init_ui();
 function recallCommand() {
-  return new Command19("recall").description("recall memory cards for a question").argument("<query>", "what you want to remember").option("--vault <path>", "which brain to search").option("--local", "search the brain on this machine, even when signed in to a hosted one").option(
+  return new Command21("recall").description("recall memory cards for a question").argument("<query>", "what you want to remember").option("--vault <path>", "which brain to search").option("--local", "search the brain on this machine, even when signed in to a hosted one").option(
     "--brain <name>",
     "search one existing hosted brain by name or id, without changing the pointer"
   ).option("--scope <scope>", "restrict to one scope").option("--limit <n>", "max cards", (v) => parseInt(v, 10), 8).option(
@@ -14611,14 +15006,14 @@ function scriptsIn(text) {
 }
 
 // src/commands/remember.ts
-import { Command as Command20 } from "commander";
+import { Command as Command22 } from "commander";
 init_src();
 init_errors();
 init_cloud_brain();
 init_vault();
 init_ui();
 function rememberCommand() {
-  return new Command20("remember").description("write something down now, with no approval step").argument("<text>", "what to remember").option("--vault <path>", "which brain to write to").option("--local", "write to the brain on this machine, even when signed in to a hosted one").option("--scope <scope>", "what this is about \u2014 a project, an area").option(
+  return new Command22("remember").description("write something down now, with no approval step").argument("<text>", "what to remember").option("--vault <path>", "which brain to write to").option("--local", "write to the brain on this machine, even when signed in to a hosted one").option("--scope <scope>", "what this is about \u2014 a project, an area").option(
     "--rule",
     "this is a decision that binds what you do, not a fact to look up (shown before edits)"
   ).option(
@@ -14793,13 +15188,13 @@ function yamlString(value) {
 // src/commands/resurface.ts
 init_deadline();
 init_src();
-import { Command as Command21 } from "commander";
+import { Command as Command23 } from "commander";
 init_index_build();
 init_cloud_brain();
 init_vault();
 init_ui();
 function resurfaceCommand() {
-  return new Command21("resurface").description("what is worth having in view right now, without being asked").option("--context-dir <path>", "where the work is happening (default: cwd)").option("--limit <n>", "how many cards", (v) => parseInt(v, 10), 5).option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
+  return new Command23("resurface").description("what is worth having in view right now, without being asked").option("--context-dir <path>", "where the work is happening (default: cwd)").option("--limit <n>", "how many cards", (v) => parseInt(v, 10), 5).option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
     "--brain <name>",
     "read one existing hosted brain by name or id, without changing the pointer"
   ).option(
@@ -14984,11 +15379,11 @@ exists only for a brain on this machine.`
 }
 
 // src/commands/rules.ts
-import { Command as Command22 } from "commander";
+import { Command as Command24 } from "commander";
 init_cloud_brain();
 init_ui();
 function rulesCommand() {
-  return new Command22("rules").description("the user\u2019s standing decisions \u2014 what binds you here").option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
+  return new Command24("rules").description("the user\u2019s standing decisions \u2014 what binds you here").option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
     "--brain <name>",
     "read one existing hosted brain by name or id, without changing the pointer"
   ).action(async (opts) => {
@@ -15090,7 +15485,7 @@ Retire what no longer decides anything: \`memgineering retire <handle>\`.` : "Th
 init_setup();
 
 // src/commands/update.ts
-import { Command as Command24 } from "commander";
+import { Command as Command26 } from "commander";
 
 // src/version.ts
 import { readFileSync } from "fs";
@@ -15338,7 +15733,7 @@ function shortMessage(err) {
 // src/commands/update.ts
 init_ui();
 function updateCommand() {
-  return new Command24("update").description("update memgineering itself").option("--check", "report what is available and change nothing").action(async (opts) => {
+  return new Command26("update").description("update memgineering itself").option("--check", "report what is available and change nothing").action(async (opts) => {
     const status = await checkForUpdate(VERSION);
     const provenance = await detectProvenance();
     const previous = await readUpdateState();
@@ -15447,14 +15842,14 @@ function reportBelowMinimum(below) {
 init_src();
 import { readFile as readFile21, rm as rm8 } from "fs/promises";
 import { join as join23 } from "path";
-import { Command as Command25 } from "commander";
+import { Command as Command27 } from "commander";
 init_atomic();
 init_errors();
 init_cloud_brain();
 init_vault();
 init_ui();
 function undoCommand() {
-  return new Command25("undo").description("take back the last change, or a named one").argument("[op]", "operation id (default: the most recent)").option("--reason <text>", "why it is being taken back \u2014 kept in the ledger").option("--vault <path>", "which brain to act on").option("--local", "act on the brain on this machine, even when signed in to a hosted one").action(
+  return new Command27("undo").description("take back the last change, or a named one").argument("[op]", "operation id (default: the most recent)").option("--reason <text>", "why it is being taken back \u2014 kept in the ledger").option("--vault <path>", "which brain to act on").option("--local", "act on the brain on this machine, even when signed in to a hosted one").action(
     async (opId, opts) => {
       const rationale = sanitizeRationale(opts.reason);
       const where = await resolveTarget({
@@ -15658,11 +16053,11 @@ init_api_client();
 init_cloud_brain();
 init_config();
 init_ui();
-import { Command as Command26 } from "commander";
+import { Command as Command28 } from "commander";
 import stringWidth from "string-width";
 var NAME_WIDTH2 = 48;
 function brainsCommand() {
-  return new Command26("brains").description("list the hosted brains on your account, and which one this machine reads").addHelpText(
+  return new Command28("brains").description("list the hosted brains on your account, and which one this machine reads").addHelpText(
     "after",
     "\nReads only. `memgineering use --brain <name>` points this machine at one of\nthem. `memgineering create <name>` makes a new empty one, and\n`push --brain <name>` makes one from a folder on this machine."
   ).action(async () => {
@@ -15704,7 +16099,7 @@ function brainsCommand() {
         // Named at the top level too, so a caller does not have to scan the
         // array to answer the question it most often has.
         current: currentId,
-        hint: currentId === null ? "This machine is not pointed at any of them. `memgineering use --brain <name>` picks one \u2014 it moves the pointer and uploads nothing." : "Switch with `memgineering use --brain <name>`, which moves the pointer and uploads nothing. `memgineering create <name>` makes a new empty brain; `push --brain <name>` makes one from a folder on this machine."
+        hint: currentId === null ? "This machine is not pointed at any of them. `memgineering use --brain <name>` picks one \u2014 it moves the pointer and uploads nothing." : 'Switch with `memgineering use --brain <name>`, which moves the pointer and uploads nothing. `memgineering create <name>` makes a new empty brain; `push --brain <name>` makes one from a folder on this machine. `memgineering rename <new name>` renames the one this machine reads; `memgineering delete-brain <name> --confirm "<name>"` permanently deletes one \u2014 only on the owner\'s explicit ask.'
       },
       human: () => {
         printHuman(
@@ -15725,7 +16120,7 @@ function brainsCommand() {
         printHuman("");
         printHuman(
           c.gray(
-            currentId === null ? "  This machine is not pointed at any of them.\n  `memgineering use --brain <name>` picks one \u2014 nothing is uploaded." : "  `memgineering use --brain <name>` switches \u2014 nothing is uploaded.\n  `memgineering create <name>` makes a new empty one; `push --brain <name>`\n  makes one from a folder on this machine."
+            currentId === null ? "  This machine is not pointed at any of them.\n  `memgineering use --brain <name>` picks one \u2014 nothing is uploaded." : '  `memgineering use --brain <name>` switches \u2014 nothing is uploaded.\n  `memgineering create <name>` makes a new empty one; `push --brain <name>`\n  makes one from a folder on this machine.\n  `memgineering rename <new name>` renames the one this machine reads;\n  `delete-brain <name> --confirm "<name>"` deletes one \u2014 only on the owner\'s\n  explicit ask.'
           )
         );
       }
@@ -15742,7 +16137,7 @@ init_credentials();
 init_cloud_brain();
 init_config();
 import { isAbsolute as isAbsolute5, relative as relative3, resolve as resolve12 } from "path";
-import { Command as Command27 } from "commander";
+import { Command as Command29 } from "commander";
 init_vault();
 init_ui();
 function lostDefaultLines(missing) {
@@ -15761,7 +16156,7 @@ var VIA_MEANS = {
   default: "because it is your default brain (`memgineering use --default <path>` changes it)"
 };
 function useCommand() {
-  return new Command27("use").description(
+  return new Command29("use").description(
     "say which brain answers here \u2014 `--brain <name>` for the whole machine, or a path to bind this folder"
   ).argument("[brain]", "path to the brain \u2014 omit to show what this folder resolves to").option("--brain <name>", "point this machine at a hosted brain, by its name or id").option("--here <dir>", "write the pointer in this directory instead of the cwd").option(
     "--default",
@@ -16069,9 +16464,9 @@ async function pointAtHosted(named, opts, path) {
 // src/commands/whoami.ts
 init_api_client();
 init_ui();
-import { Command as Command28 } from "commander";
+import { Command as Command30 } from "commander";
 function whoamiCommand() {
-  return new Command28("whoami").description("show which account this machine is signed in as").action(async () => {
+  return new Command30("whoami").description("show which account this machine is signed in as").action(async () => {
     const base = apiUrl();
     const credentials = await requireCredentials(base);
     const res = await apiRequest({
@@ -16206,7 +16601,7 @@ async function currentNextStep() {
 init_ui();
 init_brand();
 function buildProgram() {
-  const program = new Command29("memgineering").version(VERSION).description("memgineering \u2014 one memory for the AI you connect").option("--json", "emit JSON to stdout instead of markdown", false).hook("preAction", async (thisCommand, actionCommand) => {
+  const program = new Command31("memgineering").version(VERSION).description("memgineering \u2014 one memory for the AI you connect").option("--json", "emit JSON to stdout instead of markdown", false).hook("preAction", async (thisCommand, actionCommand) => {
     const opts = thisCommand.optsWithGlobals();
     if (opts.json || process.env[BRAND.jsonEnvVar] === "1") setJsonMode(true);
     await announceNextStep(actionCommand.name());
@@ -16229,6 +16624,8 @@ function buildProgram() {
   program.addCommand(useCommand());
   program.addCommand(brainsCommand());
   program.addCommand(createCommand());
+  program.addCommand(renameCommand());
+  program.addCommand(deleteBrainCommand());
   program.addCommand(unlinkCommand());
   program.addCommand(reindexCommand());
   program.addCommand(syncRulesCommand());

package/package.json

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