memgineering 0.27.0 → 0.28.0

package/dist/index.js

@@ -6865,10 +6865,10 @@ var init_cloud_pointer = __esm({
 });
 
 // src/commands/link.ts
-import { readFile as readFile19 } from "fs/promises";
-import { join as join19 } from "path";
-import { Command as Command13 } from "commander";
-import prompts2 from "prompts";
+import { readFile as readFile20 } from "fs/promises";
+import { join as join20 } from "path";
+import { Command as Command14 } from "commander";
+import prompts3 from "prompts";
 function sameBasename(all, entry) {
   const base2 = (entry.split("/").pop() ?? entry).normalize("NFC").toLowerCase();
   return all.filter((p) => (p.split("/").pop() ?? "").normalize("NFC").toLowerCase() === base2);
@@ -6890,7 +6890,7 @@ function spreadAcrossFolders(rows, max) {
   return picked;
 }
 function linkCommand() {
-  return new Command13("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 Command14("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
@@ -7070,7 +7070,7 @@ async function recordLink(adapter, observationsDir) {
 }
 async function refuseSilentRules(path, denied, excluded, unsupported) {
   const denyEntries = (await LocalFileReadAdapter.readDenyFile(path, ".memgdeny")).entries;
-  const rawDenyLines = await readFile19(join19(path, ".memgdeny"), "utf8").then(
+  const rawDenyLines = await readFile20(join20(path, ".memgdeny"), "utf8").then(
     (t) => t.split("\n").map((l) => l.trim()).filter((l) => l !== "" && !l.startsWith("#"))
   ).catch(() => []);
   const asWritten = (folded) => rawDenyLines.find(
@@ -7216,7 +7216,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 prompts2({
+  const { ok } = await prompts3({
     type: "confirm",
     name: "ok",
     message: "Build the index for this folder?",
@@ -7297,9 +7297,9 @@ var init_open_browser = __esm({
 });
 
 // src/commands/login.ts
-import { Command as Command21 } from "commander";
+import { Command as Command22 } from "commander";
 function loginCommand() {
-  return new Command21("login").description("sign in to a hosted brain").option(
+  return new Command22("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(
@@ -7499,9 +7499,9 @@ var push_exports = {};
 __export(push_exports, {
   pushCommand: () => pushCommand
 });
-import { Command as Command36 } from "commander";
+import { Command as Command37 } from "commander";
 function pushCommand() {
-  return new Command36("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 Command37("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();
@@ -7753,8 +7753,8 @@ var init_guard_shell = __esm({
 });
 
 // src/lib/hook-refresh.ts
-import { chmod, lstat as lstat5, readFile as readFile25 } from "fs/promises";
-import { join as join25 } from "path";
+import { chmod, lstat as lstat5, readFile as readFile26 } from "fs/promises";
+import { join as join26 } from "path";
 function moveShippedCommands(parsed, moves) {
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
   const settings = parsed;
@@ -7785,10 +7785,10 @@ function moveShippedCommands(parsed, moves) {
   return { next: changed === 0 ? settings : { ...settings, hooks: nextHooks }, changed };
 }
 function withHookFileLock(fn, waitMs = 0) {
-  return withPathLock(join25(brandHome(), "hook-files.lock"), fn, waitMs);
+  return withPathLock(join26(brandHome(), "hook-files.lock"), fn, waitMs);
 }
 async function readSettings(path) {
-  const raw = await readFile25(path, "utf8").catch(() => null);
+  const raw = await readFile26(path, "utf8").catch(() => null);
   if (raw === null) return void 0;
   try {
     return JSON.parse(raw);
@@ -8024,7 +8024,7 @@ var init_setup_brain = __esm({
 });
 
 // src/commands/setup-signin.ts
-import prompts4 from "prompts";
+import prompts5 from "prompts";
 async function runSignInStep(opts) {
   const summary = await signInSummary();
   if (summary.signedIn) return { status: "signed-in", displayName: summary.displayName };
@@ -8051,7 +8051,7 @@ async function runSignInStep(opts) {
   }
   if (opts.interactive) {
     printHuman(c.bold("\nmemgineering \u2014 setup\n"));
-    const { wants } = await prompts4({
+    const { wants } = await prompts5({
       type: "toggle",
       name: "wants",
       message: "Sign in to a memgineering account first?",
@@ -8181,37 +8181,37 @@ var init_setup_signin = __esm({
 });
 
 // src/lib/next-step.ts
-import { mkdir as mkdir16, readFile as readFile26, writeFile as writeFile14 } from "fs/promises";
-import { join as join26 } from "path";
+import { mkdir as mkdir17, readFile as readFile27, writeFile as writeFile14 } from "fs/promises";
+import { join as join27 } from "path";
 function isSetUp(cfg) {
   return Object.keys(cfg.system.installed).length > 0;
 }
 function connectedMarker(at) {
-  return join26(brandHome(), `setup-connected-shown-${at.replace(/[^0-9A-Za-z]/g, "")}`);
+  return join27(brandHome(), `setup-connected-shown-${at.replace(/[^0-9A-Za-z]/g, "")}`);
 }
 async function connectedNoticeShown(at) {
-  return readFile26(connectedMarker(at), "utf8").then(
+  return readFile27(connectedMarker(at), "utf8").then(
     () => true,
     () => false
   );
 }
 async function markConnectedNoticeShown(at) {
   try {
-    await mkdir16(brandHome(), { recursive: true });
+    await mkdir17(brandHome(), { recursive: true });
     await writeFile14(connectedMarker(at), `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   } catch {
   }
 }
 async function claimFullSetupNotice() {
-  const marker = join26(brandHome(), "setup-notice-shown");
+  const marker = join27(brandHome(), "setup-notice-shown");
   try {
-    await readFile26(marker, "utf8");
+    await readFile27(marker, "utf8");
     return false;
   } catch {
   }
   try {
-    await mkdir16(brandHome(), { recursive: true });
+    await mkdir17(brandHome(), { recursive: true });
     await writeFile14(marker, `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   } catch {
@@ -8378,7 +8378,7 @@ Synced instead? \`memgineering login\`, then \`memgineering create <name>\`.`;
 // src/lib/provenance.ts
 import { execFile, spawn as spawn2 } from "child_process";
 import { realpath as realpath3 } from "fs/promises";
-import { dirname as dirname9, join as join27, resolve as resolve14 } from "path";
+import { dirname as dirname9, join as join28, resolve as resolve14 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { promisify } from "util";
 async function detectProvenance(selfPath, opts = {}) {
@@ -8516,7 +8516,7 @@ var init_provenance = __esm({
         kind: "npm",
         bin: "npm",
         prefixArgs: ["prefix", "-g"],
-        moduleRoot: (prefix) => process.platform === "win32" ? join27(prefix, "node_modules") : join27(prefix, "lib", "node_modules"),
+        moduleRoot: (prefix) => process.platform === "win32" ? join28(prefix, "node_modules") : join28(prefix, "lib", "node_modules"),
         install: "npm i -g memgineering@latest"
       },
       {
@@ -8553,9 +8553,9 @@ __export(setup_cloud_exports, {
 });
 import { spawn as spawn3 } from "child_process";
 import { realpathSync as realpathSync2 } from "fs";
-import { readdir as readdir9, stat as stat8 } from "fs/promises";
+import { readdir as readdir9, stat as stat9 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename4, dirname as dirname10, join as join28, resolve as resolve15, sep as sep4 } from "path";
+import { basename as basename4, dirname as dirname10, join as join29, resolve as resolve15, sep as sep4 } from "path";
 async function report2(setupToken, state, detail, code) {
   try {
     await apiRequest({
@@ -8573,7 +8573,7 @@ async function report2(setupToken, state, detail, code) {
 }
 async function folderCandidates() {
   const home = homedir5();
-  const roots = ["Documents", "notes", "Notes", "Obsidian", "vault"].map((d) => join28(home, d));
+  const roots = ["Documents", "notes", "Notes", "Obsidian", "vault"].map((d) => join29(home, d));
   const found = [];
   const countNotes = async (dir) => {
     let count = 0;
@@ -8582,7 +8582,7 @@ async function folderCandidates() {
       if (entry.name.startsWith(".")) continue;
       if (entry.isFile() && /\.(md|markdown)$/i.test(entry.name)) count += 1;
       else if (entry.isDirectory()) {
-        const inner = await readdir9(join28(dir, entry.name)).catch(() => []);
+        const inner = await readdir9(join29(dir, entry.name)).catch(() => []);
         count += inner.filter((n) => /\.(md|markdown)$/i.test(n)).length;
       }
       if (count > 999) break;
@@ -8590,7 +8590,7 @@ async function folderCandidates() {
     return count;
   };
   for (const root of roots) {
-    const info = await stat8(root).catch(() => null);
+    const info = await stat9(root).catch(() => null);
     if (!info?.isDirectory()) continue;
     const notes = await countNotes(root);
     if (notes > 0) found.push({ path: root, note_count: notes });
@@ -8935,8 +8935,8 @@ function insideFolder(target, folder) {
   return landed === root || landed.startsWith(root + sep4);
 }
 async function askBeforeUpload(q) {
-  const { default: prompts6 } = await import("prompts");
-  const { yes } = await prompts6({
+  const { default: prompts7 } = await import("prompts");
+  const { yes } = await prompts7({
     type: "confirm",
     name: "yes",
     message: `Upload the notes in ${q.path} to the brain on ${q.email ?? "this account"}?`,
@@ -8974,14 +8974,14 @@ var init_setup_cloud = __esm({
 
 // src/commands/setup.ts
 import { createHash as createHash9 } from "crypto";
-import { access as access2, mkdir as mkdir17, readFile as readFile27 } from "fs/promises";
-import { dirname as dirname11, join as join29 } from "path";
+import { access as access2, mkdir as mkdir18, readFile as readFile28 } from "fs/promises";
+import { dirname as dirname11, join as join30 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { Command as Command38 } from "commander";
-import prompts5 from "prompts";
+import { Command as Command39 } from "commander";
+import prompts6 from "prompts";
 import { homedir as homedir6 } from "os";
 function setupCommand() {
-  return new Command38("setup").description("install into your agents, and point at a brain (--dry-run to only report)").option("--agent", "non-interactive: take every answer from flags").option("--human", "interactive: choose from a list").option("--web", "open a screen in the browser and answer it there").option("--print-url", "with --web: print the URL instead of opening a browser").option(
+  return new Command39("setup").description("install into your agents, and point at a brain (--dry-run to only report)").option("--agent", "non-interactive: take every answer from flags").option("--human", "interactive: choose from a list").option("--web", "open a screen in the browser and answer it there").option("--print-url", "with --web: print the URL instead of opening a browser").option(
     "--wait",
     "with --web: block until the screen is finished, even with nobody watching the terminal"
   ).option(
@@ -9002,9 +9002,11 @@ function setupCommand() {
       "",
       "Chat apps with no shell need no setup. They read and write the brain on your",
       `account (not a folder on this machine) at ${HOSTED_CONNECTOR_URL}:`,
-      "  ChatGPT: Settings \u2192 Developer mode \u2192 add an MCP server with that URL, sign in.",
       "  Claude.ai, Claude Desktop, Cowork: Customize \u2192 Connectors \u2192 Add custom",
-      "  connector with that URL, sign in."
+      "  connector with that URL, sign in.",
+      "  ChatGPT: Settings \u2192 Developer mode \u2192 add an MCP server with that URL, sign in",
+      "  (paused for now: the connect screen refuses ChatGPT while its notice is",
+      "  verified; use Claude or Gemini meanwhile)."
     ].join("\n")
   ).action(async (opts) => {
     const detected = await detectTools();
@@ -9277,7 +9279,7 @@ function setupCommand() {
       }
     });
     if (mode.kind === "human" && brains.length === 0 && !opts.dryRun && isInteractive()) {
-      const { path } = await prompts5({
+      const { path } = await prompts6({
         type: "text",
         name: "path",
         message: "Path to your notes folder (blank to skip)"
@@ -9342,7 +9344,7 @@ async function applySetup(choice, dryRun) {
   }
   async function write2() {
     for (const tool of choice.tools) {
-      const hubPath = join29(agentHome(), tool.hubFile);
+      const hubPath = join30(agentHome(), tool.hubFile);
       const written = await injectBlock(
         hubPath,
         hub + tailFor(tool, choice.hook),
@@ -9357,8 +9359,8 @@ async function applySetup(choice, dryRun) {
       });
       if (!dryRun && written.after !== null) mark(hubPath, written.after);
       for (const skill of BRAND.subSkills) {
-        const content = await loadAsset(join29(skill, "SKILL.md"));
-        const path = join29(agentHome(), tool.skillsDir, skill, "SKILL.md");
+        const content = await loadAsset(join30(skill, "SKILL.md"));
+        const path = join30(agentHome(), tool.skillsDir, skill, "SKILL.md");
         const out = await writeIfDifferent(path, content, dryRun);
         results.push({
           tool: tool.label,
@@ -9448,7 +9450,7 @@ async function hooksArmed(tools) {
   const capable = tools.filter((t) => t.hooks && t.hooksFile);
   if (capable.length === 0) return void 0;
   for (const tool of capable) {
-    const raw = await readFile27(join29(agentHome(), ...(tool.hooksFile ?? "").split("/")), "utf8").catch(
+    const raw = await readFile28(join30(agentHome(), ...(tool.hooksFile ?? "").split("/")), "utf8").catch(
       () => ""
     );
     if (hooksFor([tool]).some((spec) => raw.includes(spec.signature))) return "on";
@@ -9468,7 +9470,7 @@ async function resolveMode(opts) {
     return { kind: "human", chosen: true };
   }
   if (!isInteractive() || isJsonMode()) return { kind: "agent", chosen: false };
-  const { mode } = await prompts5({
+  const { mode } = await prompts6({
     type: "select",
     name: "mode",
     message: "How would you like to set this up?",
@@ -9488,7 +9490,7 @@ async function detectTools() {
   const home = agentHome();
   const found = [];
   for (const tool of TOOLS) {
-    if (await exists2(join29(home, tool.dir))) found.push(tool);
+    if (await exists2(join30(home, tool.dir))) found.push(tool);
   }
   return found;
 }
@@ -9535,7 +9537,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 prompts5([
+  const answers = await prompts6([
     {
       type: "multiselect",
       name: "tools",
@@ -9588,10 +9590,10 @@ async function injectBlock(filePath, content, dryRun, weWroteThis) {
   const block = `${BRAND.hubMarkerStart}
 ${content.trimEnd()}
 ${BRAND.hubMarkerEnd}`;
-  const existing = await readFile27(filePath, "utf8").catch(() => null);
+  const existing = await readFile28(filePath, "utf8").catch(() => null);
   if (existing === null) {
     if (!dryRun) {
-      await mkdir17(dirname11(filePath), { recursive: true });
+      await mkdir18(dirname11(filePath), { recursive: true });
       await writeThenRename(filePath, `${block}
 `);
     }
@@ -9631,11 +9633,11 @@ function looksLikeOurGuide(text) {
   return text.includes("memgineering recall") && text.includes("memgineering remember");
 }
 async function writeIfDifferent(filePath, content, dryRun) {
-  const existing = await readFile27(filePath, "utf8").catch(() => null);
+  const existing = await readFile28(filePath, "utf8").catch(() => null);
   const after = fingerprint(content);
   if (existing === content) return { outcome: "unchanged", before: existing, after };
   if (!dryRun) {
-    await mkdir17(dirname11(filePath), { recursive: true });
+    await mkdir18(dirname11(filePath), { recursive: true });
     await writeThenRename(filePath, content);
   }
   return { outcome: existing === null ? "injected" : "updated", before: existing, after };
@@ -9652,7 +9654,7 @@ async function refreshOwnHookCommands() {
   const changed = [];
   const skipped = [];
   for (const tool of TOOLS.filter((t) => t.hooks && t.hooksFile && DEFAULT_HOOK_TOOLS.includes(t.id))) {
-    const path = join29(agentHome(), ...(tool.hooksFile ?? "").split("/"));
+    const path = join30(agentHome(), ...(tool.hooksFile ?? "").split("/"));
     const outcome = await refreshHookFile(path, moves);
     if (outcome === "changed") changed.push(path);
     else if (outcome === "symlink" || outcome === "refused") skipped.push({ path, why: outcome });
@@ -9679,8 +9681,8 @@ function hooksFor(tools) {
   );
 }
 async function installHook(spec, tool, dryRun) {
-  const settingsPath = join29(agentHome(), ...(tool.hooksFile ?? "").split("/"));
-  const raw = await readFile27(settingsPath, "utf8").catch(() => null);
+  const settingsPath = join30(agentHome(), ...(tool.hooksFile ?? "").split("/"));
+  const raw = await readFile28(settingsPath, "utf8").catch(() => null);
   let settings = {};
   if (raw !== null) {
     try {
@@ -9722,15 +9724,15 @@ async function installHook(spec, tool, dryRun) {
   }
   const next = { ...settings, hooks: { ...hooks, [spec.event]: existingGroups } };
   if (!dryRun) {
-    await mkdir17(dirname11(settingsPath), { recursive: true });
+    await mkdir18(dirname11(settingsPath), { recursive: true });
     await writeThenRename(settingsPath, `${JSON.stringify(next, null, 2)}
 `);
   }
   return raw === null ? "injected" : "updated";
 }
 async function removeHook(spec, tool, dryRun) {
-  const settingsPath = join29(agentHome(), ...(tool.hooksFile ?? "").split("/"));
-  const raw = await readFile27(settingsPath, "utf8").catch(() => null);
+  const settingsPath = join30(agentHome(), ...(tool.hooksFile ?? "").split("/"));
+  const raw = await readFile28(settingsPath, "utf8").catch(() => null);
   if (raw === null) return "unchanged";
   let parsed;
   try {
@@ -9754,7 +9756,7 @@ async function removeHook(spec, tool, dryRun) {
   return "removed";
 }
 async function loadAsset(relPath) {
-  const raw = await readFile27(join29(await assetRoot(), relPath), "utf8");
+  const raw = await readFile28(join30(await assetRoot(), relPath), "utf8");
   if (relPath === BRAND.hubFileName && raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 4);
     if (end !== -1) return raw.slice(end + 4).trimStart();
@@ -9763,12 +9765,12 @@ async function loadAsset(relPath) {
 }
 async function assetRoot() {
   const here = dirname11(fileURLToPath3(import.meta.url));
-  const bundled = join29(here, "..", "assets");
-  if (await exists2(join29(bundled, BRAND.hubFileName))) return bundled;
+  const bundled = join30(here, "..", "assets");
+  if (await exists2(join30(bundled, BRAND.hubFileName))) return bundled;
   let dir = here;
   for (; ; ) {
-    const candidate = join29(dir, "packages", "skills");
-    if (await exists2(join29(candidate, BRAND.hubFileName))) return candidate;
+    const candidate = join30(dir, "packages", "skills");
+    if (await exists2(join30(candidate, BRAND.hubFileName))) return candidate;
     const parent = dirname11(dir);
     if (parent === dir) break;
     dir = parent;
@@ -9963,7 +9965,7 @@ For a guide: put ${BRAND.hubMarkerStart} and ${BRAND.hubMarkerEnd} back around t
 import net from "net";
 
 // src/program.ts
-import { Command as Command46 } from "commander";
+import { Command as Command47 } from "commander";
 
 // src/help.ts
 init_ui();
@@ -10031,6 +10033,7 @@ var COMMAND_GROUPS = [
       "create",
       "rename",
       "delete-brain",
+      "delete-account",
       "push",
       "pull"
     ]
@@ -11525,6 +11528,11 @@ var YankResponseSchema = z19.object({
   yank_reason: z19.string().max(280).nullable(),
   effective_current_version: SemverSchema
 });
+var RestorePackageResponseSchema = z19.object({
+  full_slug: FullSlugSchema,
+  status: z19.literal("restored"),
+  restored_at: IsoDateTimeSchema
+});
 var ResolveVersionQuerySchema = z19.object({
   range: SemverRangeSchema
 });
@@ -11569,7 +11577,15 @@ var UserProfileResponseSchema = PublicUserSchema.extend({
    * responses omit both. Optional so pre-P1 clients ignore them.
    */
   viewer_is_following: z19.boolean().optional(),
-  viewer_is_self: z19.boolean().optional()
+  viewer_is_self: z19.boolean().optional(),
+  /**
+   * Whether other people can see this profile (migration 0031). A profile
+   * becomes public with its owner's first public publish, comment or star,
+   * and stays public. Anyone else asking for a non-public profile gets the
+   * unknown-user `404`, so `false` only ever reaches the owner. Absent from
+   * servers that predate it; treat absent as public.
+   */
+  is_public: z19.boolean().optional()
 });
 var UserPackagesQuerySchema = z19.object({
   sort: SortModeSchema.default("stars"),
@@ -11597,6 +11613,81 @@ var ListFollowersResponseSchema = z19.object({
   results: PublicUserSchema.array(),
   next_cursor: z19.string().nullable()
 });
+var MeResponseSchema = SelfUserSchema.extend({
+  /**
+   * Whether the caller's registry profile is visible to other people
+   * (migration 0031): false until their first public publish, comment or
+   * star. Absent from servers that predate it; treat absent as public.
+   */
+  profile_public: z19.boolean().optional()
+});
+var DeleteMeRequestSchema = z19.object({
+  confirm_username: z19.string().min(1).max(32)
+});
+var AccountExportUserSchema = z19.object({
+  id: z19.string(),
+  username: z19.string(),
+  display_name: z19.string().nullable(),
+  email: z19.string().nullable(),
+  bio: z19.string().nullable(),
+  avatar_url: z19.string().nullable(),
+  primary_provider: z19.string(),
+  role: z19.string(),
+  created_at: z19.string(),
+  updated_at: z19.string(),
+  last_active_at: z19.string().nullable()
+});
+var AccountExportSchema = z19.object({
+  schema_version: z19.literal(1),
+  exported_at: z19.string(),
+  user: AccountExportUserSchema,
+  packages: z19.array(
+    z19.object({
+      id: z19.string(),
+      slug: z19.string(),
+      full_slug: z19.string(),
+      type: z19.string(),
+      tier: z19.string(),
+      title: z19.string(),
+      description: z19.string(),
+      content: z19.string(),
+      current_version: z19.string(),
+      visibility: z19.string(),
+      created_at: z19.string(),
+      updated_at: z19.string(),
+      deleted_at: z19.string().nullable()
+    })
+  ),
+  package_versions: z19.array(
+    z19.object({
+      id: z19.string(),
+      package_id: z19.string(),
+      version: z19.string(),
+      content: z19.string(),
+      review_status: z19.string(),
+      published_at: z19.string(),
+      yanked_at: z19.string().nullable()
+    })
+  ),
+  comments: z19.array(
+    z19.object({
+      id: z19.string(),
+      package_id: z19.string(),
+      body: z19.string(),
+      kind: z19.string(),
+      title: z19.string().nullable(),
+      status: z19.string().nullable(),
+      parent_id: z19.string().nullable(),
+      created_at: z19.string(),
+      edited_at: z19.string().nullable(),
+      deleted_at: z19.string().nullable()
+    })
+  ),
+  stars: z19.array(z19.object({ package_id: z19.string(), created_at: z19.string() })),
+  follows: z19.array(
+    z19.object({ follower_id: z19.string(), following_id: z19.string(), created_at: z19.string() })
+  )
+});
 
 // ../../packages/contracts/src/context.ts
 import { z as z20 } from "zod";
@@ -12078,6 +12169,23 @@ var KordisClient = class {
   me() {
     return this.request("/api/me");
   }
+  /**
+   * The account's own data — the one registry answer that carries its `email`.
+   * A GET, so it is retried once on a failed fetch like every other GET.
+   */
+  exportMe() {
+    return this.request("/api/me/export");
+  }
+  /**
+   * Delete the signed-in registry account. Irreversible: the server compares
+   * `confirm_username` with the current username and answers 204. The account
+   * is renamed `deleted-<id>`; its published packages and versions stay at their
+   * existing addresses, which still contain the old username. Never retried
+   * (a DELETE), like every write here.
+   */
+  deleteMe(body) {
+    return this.request("/api/me", { method: "DELETE", body });
+  }
   listMyPackages(opts = {}) {
     return this.request("/api/me/packages", {
       query: {
@@ -12109,6 +12217,18 @@ var KordisClient = class {
   deletePackage(username, slug) {
     return this.request(`/api/packages/${seg(username)}/${seg(slug)}`, { method: "DELETE" });
   }
+  /**
+   * Undo a delete. Author only, within 30 days of the deletion and before the
+   * package's content is deleted; refusals are `conflict` (not deleted, too
+   * late, content already deleted), `not_authorized` and `not_found`, each
+   * with a hint.
+   */
+  restorePackage(username, slug) {
+    return this.request(
+      `/api/packages/${seg(username)}/${seg(slug)}/restore`,
+      { method: "POST" }
+    );
+  }
   getContent(username, slug, opts = {}) {
     return this.request(
       `/api/packages/${seg(username)}/${seg(slug)}/content`,
@@ -16890,88 +17010,316 @@ function nextStep3(renamed) {
   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
+// src/commands/delete-account.ts
+import { Command as Command12 } from "commander";
+import prompts from "prompts";
 init_errors();
 init_api_client();
-init_cloud_brain();
+
+// src/lib/account-deletion-marker.ts
+init_atomic();
+init_brand();
+import { mkdir as mkdir12, readFile as readFile18, stat as stat5, unlink as unlink5 } from "fs/promises";
+import { join as join19 } from "path";
+import { z as z25 } from "zod";
+var SideSchema = z25.object({
+  api_url: z25.string().min(1),
+  /** When the delete request was sent — set before it goes, so a lost answer is visible. */
+  requested_at: z25.string().min(1).nullable().default(null),
+  /** When the server confirmed it. Null while that side is still to do. */
+  deleted_at: z25.string().min(1).nullable().default(null)
+});
+var MarkerSchema = z25.object({
+  version: z25.literal(1),
+  started_at: z25.string().min(1),
+  /** How the two accounts were matched before anything was deleted. */
+  matched_by: z25.enum(["email", "federation"]),
+  brain: SideSchema.extend({ account_id: z25.string().min(1) }),
+  registry: SideSchema.extend({
+    user_id: z25.string().min(1),
+    username: z25.string().min(1)
+  })
+});
+function accountDeletionMarkerPath() {
+  return join19(brandHome(), "delete-account.json");
+}
+async function readAccountDeletionMarker() {
+  try {
+    const parsed = MarkerSchema.safeParse(
+      JSON.parse(await readFile18(accountDeletionMarkerPath(), "utf8"))
+    );
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+async function accountDeletionMarkerExists() {
+  return stat5(accountDeletionMarkerPath()).then(
+    () => true,
+    () => false
+  );
+}
+async function saveAccountDeletionMarker(marker) {
+  await mkdir12(brandHome(), { recursive: true });
+  await writeThenRename(accountDeletionMarkerPath(), `${JSON.stringify(marker, null, 2)}
+`);
+}
+async function clearAccountDeletionMarker() {
+  await unlink5(accountDeletionMarkerPath()).catch(() => void 0);
+}
+
+// src/commands/delete-account.ts
 init_config();
+init_credentials();
+init_pending_login();
+
+// src/lib/registry-session.ts
+init_errors();
+init_credentials();
+init_version();
+function registryApiUrl(stored) {
+  const override = process.env["KORDIS_API_URL"];
+  return override !== void 0 && override !== "" ? override : stored;
+}
+async function requireRegistryCredentials() {
+  const credentials = await readCredentials();
+  const registry = credentials?.registry;
+  if (!registry) {
+    throw memgError(
+      "not_linked",
+      "this machine holds no registry identity",
+      credentials === null ? "Nothing was sent. Sign in with `memgineering login` \u2014 it links the registry identity at the same time, so one sign-in covers both." : "Nothing was sent. This machine is signed in to a brain, and the registry half of that sign-in is missing \u2014 which is what a credential file written before federation looks like. Run `memgineering login` again; it links the registry identity too."
+    );
+  }
+  return registry;
+}
+var RACE_WAIT_MS = 2e3;
+var RACE_POLL_MS = 50;
+function lostRace(err) {
+  return err instanceof KordisApiError && err.status === 401 && isRefreshRace({ error: { code: err.code, flags: err.flags } });
+}
+async function newerRegistry(sent) {
+  const deadline = Date.now() + RACE_WAIT_MS;
+  for (; ; ) {
+    const registry = (await readCredentials())?.registry;
+    if (registry !== void 0 && registry.refresh_token !== sent) return registry;
+    if (Date.now() >= deadline) return null;
+    await new Promise((resolve17) => setTimeout(resolve17, RACE_POLL_MS));
+  }
+}
+async function refreshRegistrySession(stored, opts = {}) {
+  const attempt = async (registry) => {
+    const baseUrl = (opts.apiUrlOf ?? ((r) => registryApiUrl(r.api_url)))(registry);
+    const anonymous = new KordisClient({
+      baseUrl,
+      userAgent: `memgineering/${VERSION}`,
+      ...opts.fetchImpl ? { fetch: opts.fetchImpl } : {},
+      ...opts.requestTimeoutMs === void 0 ? {} : { requestTimeoutMs: opts.requestTimeoutMs }
+    });
+    return { registry, baseUrl, tokens: await anonymous.refreshSession(registry.refresh_token) };
+  };
+  try {
+    return await attempt(stored);
+  } catch (err) {
+    if (!lostRace(err)) throw err;
+    const newer = await newerRegistry(stored.refresh_token);
+    if (newer === null) throw err;
+    return attempt(newer);
+  }
+}
+function refusal(err) {
+  if (lostRace(err)) {
+    return memgError(
+      "not_authenticated",
+      err.message,
+      "This machine's registry sign-in was refreshed by another request at the same moment, so this command could not use it. Run this command again."
+    );
+  }
+  const busyOrUnreachable = err instanceof KordisNetworkError || err instanceof KordisApiError && (err.status === 429 || err.status >= 500);
+  return (busyOrUnreachable ? adaptRegistryError(err) : null) ?? memgError(
+    "not_linked",
+    `the registry refused this machine's stored sign-in: ${err instanceof Error ? err.message : String(err)}`,
+    "Nothing was sent. The link between this brain and your registry account has expired or been revoked. `memgineering login` re-links both."
+  );
+}
+async function openRegistrySession(fetchImpl) {
+  const stored = await requireRegistryCredentials();
+  let refreshed;
+  try {
+    refreshed = await refreshRegistrySession(stored, fetchImpl ? { fetchImpl } : {});
+  } catch (err) {
+    throw refusal(err);
+  }
+  const { registry, baseUrl, tokens } = refreshed;
+  const credentialsRotated = await persistRotatedRefresh(
+    registry,
+    tokens.refresh_token,
+    tokens.session_id
+  );
+  const client = new KordisClient({
+    baseUrl,
+    userAgent: `memgineering/${VERSION}`,
+    getAccessToken: () => tokens.access_token,
+    ...fetchImpl ? { fetch: fetchImpl } : {}
+  });
+  return { client, username: registry.username, apiUrl: baseUrl, credentialsRotated };
+}
+async function persistRotatedRefresh(sent, refreshToken, sessionId) {
+  if (refreshToken === sent.refresh_token && sessionId === sent.session_id) return false;
+  try {
+    return await saveRotatedRegistry(sent.refresh_token, {
+      refresh_token: refreshToken,
+      session_id: sessionId
+    });
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/delete-account.ts
 init_ui();
-import { Command as Command12 } from "commander";
-import prompts from "prompts";
-function deleteBrainCommand() {
-  return new Command12("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(
+var DELETE_ACCOUNT_PHRASE = "delete my account";
+var SUPPORT_ADDRESS = "support@memgineering.com";
+function deleteAccountCommand() {
+  return new Command12("delete-account").description("delete your hosted brain account and your registry account, for good").option(
+    "--confirm <phrase>",
+    `the sentence "${DELETE_ACCOUNT_PHRASE}", 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("--")) {
+    `
+Irreversible, and server-side, in this order: the hosted brain account (every
+brain on it, every note, every token), then the registry account made by the
+same Google sign-in (profile, stars, follows, comment text, sign-ins; the account
+is renamed deleted-\u2026, and published packages stay at their existing addresses).
+Then this machine is signed out.
+Folders on this disk are never touched. Run this ONLY when the person has
+explicitly asked for their account to be deleted, and pass --confirm "${DELETE_ACCOUNT_PHRASE}".
+If a run stops halfway, run it again: it finishes the side that is left.
+\`memgineering delete-brain\` deletes one brain and keeps the account;
+\`memgineering logout\` only signs this machine out.`
+  ).action(async (opts) => {
+    const confirmFlag = opts.confirm;
+    if (confirmFlag !== void 0 && confirmFlag.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.'
+        `\`--confirm\` was given the flag \`${oneLine(confirmFlag, WIDTH.title)}\` as its sentence`,
+        `Nothing was deleted. \`--confirm\` takes the sentence "${DELETE_ACCOUNT_PHRASE}", and the flag written after it was read as that sentence. Put the sentence, in quotes, immediately after \`--confirm\`.`
       );
     }
-    const confirmFlag = opts.confirm;
-    if (confirmFlag !== void 0 && confirmFlag.startsWith("--")) {
+    const server = apiUrl();
+    const stored = await readCredentials();
+    const saved = await readAccountDeletionMarker();
+    const marker = saved !== null && (stored === null || stored.account_id === saved.brain.account_id) ? saved : null;
+    const brainDone = marker?.brain.deleted_at != null;
+    const registryDone = marker?.registry.deleted_at != null;
+    if (!brainDone) requireBrainSignIn(stored, server);
+    if (!registryDone && stored?.registry === void 0) {
+      throw noRegistrySignIn(marker);
+    }
+    if (confirmFlag !== void 0 && confirmFlag !== DELETE_ACCOUNT_PHRASE) {
       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."
+        "the confirmation is not the sentence this needs",
+        `Nothing was deleted. The sentence is "${DELETE_ACCOUNT_PHRASE}" \u2014 exactly that, lower case, no punctuation. It deletes the hosted brain account with every brain and note on it, and the registry account; none of it comes back. Pass --confirm "${DELETE_ACCOUNT_PHRASE}" only if the person explicitly asked for their account to be deleted.`
       );
     }
-    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;
+    if (confirmFlag === void 0 && !isInteractive()) {
+      throw 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 "${DELETE_ACCOUNT_PHRASE}"; or, once they have explicitly asked for their account to be deleted, pass --confirm "${DELETE_ACCOUNT_PHRASE}". Deciding for them is the one thing this gate exists to prevent.`
+      );
     }
-    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 brain = brainDone ? null : await brainAccount(stored, marker);
+    const registry = registryDone ? null : await registryAccount(stored?.registry, marker);
+    const match = matchAccounts({ stored, marker, brain, registry });
+    if (confirmFlag === void 0) {
+      const typed = await retypeThePhrase({ brain, registry, marker, match });
+      if (typed !== DELETE_ACCOUNT_PHRASE) {
+        printHuman(c.yellow("Cancelled \u2014 nothing was deleted."));
+        return;
+      }
     }
-    const hint = deleted.hint ?? "The brain, its notes and its ledger are gone. `memgineering brains` lists what is left.";
+    const record = marker ?? {
+      version: 1,
+      started_at: (/* @__PURE__ */ new Date()).toISOString(),
+      matched_by: match.by === "earlier-run" ? match.matched_by : match.by,
+      brain: {
+        api_url: stored.api_url,
+        account_id: brain.id,
+        requested_at: null,
+        deleted_at: null
+      },
+      registry: {
+        api_url: registry.apiUrl,
+        user_id: registry.id,
+        username: registry.username,
+        requested_at: null,
+        deleted_at: null
+      }
+    };
+    try {
+      await saveAccountDeletionMarker(record);
+    } catch (err) {
+      throw memgError(
+        "filesystem_error",
+        `could not write ${accountDeletionMarkerPath()}`,
+        `Nothing was deleted. This command records its progress there so a run that stops halfway can be finished, and it will not start without it. Free the disk or fix the permissions of that folder, then run this again. Underlying cause: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (brain !== null) {
+      record.brain.requested_at = (/* @__PURE__ */ new Date()).toISOString();
+      await saveBestEffort(record);
+      await deleteBrainAccount(stored, registry);
+      record.brain.deleted_at = (/* @__PURE__ */ new Date()).toISOString();
+      await saveBestEffort(record);
+    }
+    if (registry !== null) {
+      record.registry.requested_at = (/* @__PURE__ */ new Date()).toISOString();
+      await saveBestEffort(record);
+      await deleteRegistryAccount(registry);
+      record.registry.deleted_at = (/* @__PURE__ */ new Date()).toISOString();
+      await saveBestEffort(record);
+    }
+    const pointerCleared = await signOutHere(record.brain.api_url);
+    await clearAccountDeletionMarker();
+    const hint = "Both accounts are gone and this machine is signed out. Signing in again with the same Google account creates a new, empty account. Folders on this disk were not touched.";
     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. */
+        deleted: true,
+        brain: {
+          status: brain === null ? "deleted-earlier" : "deleted",
+          account_id: record.brain.account_id,
+          api_url: record.brain.api_url
+        },
+        registry: {
+          status: registry === null ? "deleted-earlier" : "deleted",
+          user_id: record.registry.user_id,
+          username: record.registry.username,
+          api_url: record.registry.api_url
+        },
+        matched: match,
+        credentials_cleared: true,
         pointer_cleared: pointerCleared,
+        local_folders: "untouched",
         hint
       },
       human: () => {
+        printHuman(c.green("\u2713 Account deleted."));
         printHuman(
-          c.green(`\u2713 deleted \u201C${oneLine(deleted.name, WIDTH.title)}\u201D`) + c.gray(`  (${oneLine(deleted.deleted, WIDTH.handle)})`)
+          c.gray(
+            brain === null ? "  brain     the hosted account was deleted by an earlier run" : "  brain     the hosted account, every brain and note on it, and every token \u2014 gone"
+          )
         );
         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`
+            `  registry  ${oneLine(record.registry.username, WIDTH.title)} \u2014 ` + (registry === null ? "deleted by an earlier run" : "profile, stars, follows, comment text and sign-ins removed; renamed deleted-\u2026; published packages stay at their existing addresses")
           )
         );
+        printHuman(c.gray(`  matched   ${matchLine(match)}`));
+        printHuman(c.gray("  here      signed out; this machine\u2019s credentials are removed"));
         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("            and it no longer points at a hosted brain"));
         }
         printHuman(c.gray(`
 ${hint}`));
@@ -16979,7 +17327,408 @@ ${hint}`));
     });
   });
 }
-async function tokenFor2(server) {
+function requireBrainSignIn(stored, server) {
+  if (stored !== null && stored.api_url === server) return;
+  if (stored !== null) {
+    throw memgError(
+      "not_signed_in",
+      `this machine is signed in to ${oneLine(stored.api_url, WIDTH.path)}, not ${oneLine(server, WIDTH.path)}`,
+      "Nothing was deleted. The account to delete is on the server this machine signed in to. If MEMGINEERING_API_URL points somewhere else, unset it and run this again."
+    );
+  }
+  throw memgError(
+    "not_signed_in",
+    "this machine is not signed in to a memgineering account",
+    `Nothing was deleted, and there may be nothing to delete. A brain kept in a folder on this machine has no account \u2014 it is the person\u2019s own files, and this command never touches them; deleting the folder deletes it (\`memgineering unlink <folder>\` first makes this tool forget it). To delete a hosted account, sign in to it first \u2014 \`memgineering login --emit-only\`, show the person the code it prints, and run this again once they approve. Without a sign-in, mail ${SUPPORT_ADDRESS} from the Google address of the account.`
+  );
+}
+function noRegistrySignIn(marker) {
+  if (marker !== null) {
+    return memgError(
+      "not_linked",
+      "the brain account is already deleted, and this machine holds no registry sign-in to finish with",
+      `The hosted brain account was deleted by an earlier run of this command and cannot be undone. The registry account \`${oneLine(marker.registry.username, WIDTH.title)}\` still needs deleting, and that needs this machine's registry sign-in, which is gone. Mail ${SUPPORT_ADDRESS} from the Google address of the account, naming \`${oneLine(marker.registry.username, WIDTH.title)}\`, and it is deleted by hand.`
+    );
+  }
+  return memgError(
+    "not_linked",
+    "this machine is signed in to a brain account but holds no registry sign-in",
+    `Nothing was deleted. This command deletes the brain account and the registry account together, and will not delete one alone. The registry half of the sign-in is missing \u2014 which is what a sign-in made before the two were linked looks like. Run \`memgineering logout\` and then \`memgineering login\` (it links the registry account too), then run this again. Or mail ${SUPPORT_ADDRESS} from the Google address of the account.`
+  );
+}
+async function brainAccount(stored, marker) {
+  let body;
+  try {
+    body = (await apiRequest({
+      method: "GET",
+      path: "/v1/me",
+      token: stored.token,
+      baseUrl: stored.api_url
+    })).body;
+  } catch (err) {
+    if (!(err instanceof MemgError)) throw err;
+    if (err.code === "not_authenticated" && marker?.brain.requested_at) {
+      throw memgError(
+        "not_authenticated",
+        "this machine\u2019s brain sign-in no longer works, after an earlier run asked for the account to be deleted",
+        `Nothing more was deleted. An earlier run of this command asked the brain server to delete this account at ${marker.brain.requested_at} and did not hear the answer. A sign-in that stops working is what a deleted account looks like, and also what a revoked sign-in looks like, so this command will not guess and delete the registry account on that basis. Mail ${SUPPORT_ADDRESS} from the Google address of the account, naming registry account \`${oneLine(marker.registry.username, WIDTH.title)}\`, and both are finished by hand.`
+      );
+    }
+    if (err.code === "not_authenticated") {
+      const name = stored.registry === void 0 ? "" : ` \`${oneLine(stored.registry.username, WIDTH.title)}\``;
+      const file = await accountDeletionMarkerExists() ? ` A progress file from an earlier run is on disk (${accountDeletionMarkerPath()}) but could not be used for this account.` : "";
+      throw memgError(
+        "not_authenticated",
+        "the brain server no longer accepts this machine\u2019s sign-in",
+        `This run deleted nothing. Either the sign-in was revoked or has expired \u2014 then \`memgineering login --emit-only\`, show the person the code it prints, and run this again once they approve \u2014 or this account was already deleted by an earlier run of this command whose progress file is gone.${file} If that may be so, the registry account${name} may still exist: mail ${SUPPORT_ADDRESS} from the Google address of the account${name === "" ? "" : `, naming${name}`}.`
+      );
+    }
+    if (err.code === "server_unreachable") {
+      throw memgError(
+        "server_unreachable",
+        err.message,
+        `This run deleted nothing \u2014 neither the brain account nor the registry account. The brain server could not be reached: check the connection, or MEMGINEERING_API_URL if the brain server is somewhere else, then run this again.`
+      );
+    }
+    throw new MemgError({
+      code: err.code,
+      message: err.message,
+      hint: `This run deleted nothing \u2014 neither the brain account nor the registry account. ${err.hint}`
+    });
+  }
+  const account = body?.account;
+  if (!account || typeof account.id !== "string") {
+    throw memgError(
+      "server_refused",
+      `${stored.api_url} answered /v1/me without an account`,
+      "Nothing was deleted. This is not an answer a memgineering brain server gives. If MEMGINEERING_API_URL points at something else, unset it and run this again."
+    );
+  }
+  if (account.id !== stored.account_id) {
+    throw mismatch(
+      `this machine's credentials name brain account ${oneLine(stored.account_id, WIDTH.handle)}, and its token belongs to ${oneLine(account.id, WIDTH.handle)}`
+    );
+  }
+  return {
+    id: account.id,
+    email: typeof account.email === "string" && account.email !== "" ? account.email : null,
+    display_name: typeof account.display_name === "string" ? account.display_name : null
+  };
+}
+async function registryAccount(snapshot, marker) {
+  let session;
+  try {
+    session = await openRegistrySession();
+  } catch (err) {
+    if (err instanceof MemgError && err.code === "not_linked") {
+      throw memgError(
+        "not_linked",
+        err.message,
+        marker !== null && marker.brain.deleted_at !== null ? `The hosted brain account was deleted by an earlier run and cannot be undone. The registry account \`${oneLine(marker.registry.username, WIDTH.title)}\` still needs deleting, and this machine's registry sign-in no longer works \u2014 if an earlier run's registry request reached the server, the account may already be gone, which ends sign-ins the same way. Mail ${SUPPORT_ADDRESS} from the Google address of the account, naming \`${oneLine(marker.registry.username, WIDTH.title)}\`, and it is finished by hand.` : `Nothing was deleted. The registry sign-in on this machine has expired or been revoked. Run \`memgineering logout\` and then \`memgineering login\` (it links the registry account again), then run this again. Or mail ${SUPPORT_ADDRESS} from the Google address of the account.`
+      );
+    }
+    throw withNothingDeleted(err, marker);
+  }
+  let exported;
+  try {
+    exported = await session.client.exportMe();
+  } catch (err) {
+    throw withNothingDeleted(err, marker);
+  }
+  const user = exported?.user;
+  if (!user || typeof user.id !== "string" || typeof user.username !== "string") {
+    throw memgError(
+      "server_refused",
+      `${session.apiUrl} answered /api/me/export without an account`,
+      "Nothing was deleted. This is not an answer the registry gives. If KORDIS_API_URL points at something else, unset it and run this again."
+    );
+  }
+  if (snapshot.user_id !== user.id) {
+    throw mismatch(
+      `this run began with a registry sign-in for registry account ${oneLine(snapshot.user_id, WIDTH.handle)}, and the registry answered for ${oneLine(user.id, WIDTH.handle)}`
+    );
+  }
+  return {
+    client: session.client,
+    apiUrl: session.apiUrl,
+    id: user.id,
+    username: user.username,
+    email: typeof user.email === "string" && user.email !== "" ? user.email : null,
+    linkedAt: snapshot.linked_at
+  };
+}
+function withNothingDeleted(err, marker) {
+  const adapted = err instanceof MemgError ? err : adaptRegistryError(err);
+  if (adapted === null) return err;
+  const prefix = marker !== null && marker.brain.deleted_at !== null ? "Nothing more was deleted: the brain account is already gone, and the registry account is not deleted yet \u2014 run this again once the registry answers." : "Nothing was deleted \u2014 neither the brain account nor the registry account.";
+  return new MemgError({
+    code: adapted.code,
+    message: adapted.message,
+    hint: `${prefix} ${adapted.hint}`
+  });
+}
+function matchAccounts(args) {
+  const { marker, brain, registry } = args;
+  if (marker !== null) {
+    if (registry !== null && registry.id !== marker.registry.user_id) {
+      throw mismatch(
+        `an earlier run matched registry account \`${oneLine(marker.registry.username, WIDTH.title)}\`, and this machine's registry sign-in is now for \`${oneLine(registry.username, WIDTH.title)}\``
+      );
+    }
+    return { by: "earlier-run", matched_by: marker.matched_by };
+  }
+  const b = brain;
+  const r = registry;
+  if (b.email !== null && r.email !== null) {
+    if (normaliseEmail(b.email) !== normaliseEmail(r.email)) {
+      throw mismatch(
+        `the brain account's email is ${oneLine(b.email, WIDTH.title)} and the registry account's is ${oneLine(r.email, WIDTH.title)}`
+      );
+    }
+    return { by: "email", email: b.email };
+  }
+  return { by: "federation", linked_at: r.linkedAt };
+}
+function normaliseEmail(email) {
+  return email.trim().toLowerCase();
+}
+function mismatch(detail) {
+  return memgError(
+    "account_mismatch",
+    `the brain account and the registry account do not look like the same person: ${detail}`,
+    `Nothing was deleted. This command deletes both accounts together and only when they are one person's. Run \`memgineering logout\` and then \`memgineering login\` with the Google account whose accounts should be deleted, then run this again. If they really are one person's, mail ${SUPPORT_ADDRESS} from that Google address.`
+  );
+}
+function matchLine(match) {
+  switch (match.by) {
+    case "email":
+      return `same person \u2014 both accounts carry ${oneLine(match.email, WIDTH.title)}`;
+    case "federation":
+      return `same person \u2014 one of the two accounts has no email on record, so the match is this machine's registry sign-in, which the brain sign-in issued for the same Google account (linked ${oneLine(match.linked_at, WIDTH.title)})`;
+    case "earlier-run":
+      return `same person \u2014 matched by ${match.matched_by} before an earlier run deleted anything`;
+  }
+}
+async function retypeThePhrase(args) {
+  const { brain, registry, marker, match } = args;
+  printHuman(c.bold("\nDelete your account?"));
+  if (brain !== null) {
+    const who = brain.email ?? brain.display_name ?? brain.id;
+    printHuman(
+      c.gray(
+        `  brain     ${oneLine(who, WIDTH.title)} \u2014 every brain on it, every note, every token`
+      )
+    );
+  } else {
+    printHuman(c.gray("  brain     already deleted by an earlier run"));
+  }
+  const username = registry?.username ?? marker?.registry.username ?? "";
+  printHuman(
+    c.gray(
+      registry !== null ? `  registry  ${oneLine(username, WIDTH.title)} \u2014 profile, stars, follows, comment text, sign-ins` : `  registry  ${oneLine(username, WIDTH.title)} \u2014 already deleted by an earlier run`
+    )
+  );
+  printHuman(c.gray(`  matched   ${matchLine(match)}`));
+  printHuman(
+    c.yellow(
+      "\n  None of this comes back. The registry account is renamed deleted-\u2026; published\n  packages stay at their existing addresses. Folders on this disk are not\n  touched. Signing in again later makes a new, empty account."
+    )
+  );
+  const { typed } = await prompts({
+    type: "text",
+    name: "typed",
+    message: `Type "${DELETE_ACCOUNT_PHRASE}" to delete both accounts`
+  });
+  return typed;
+}
+async function deleteBrainAccount(stored, registry) {
+  try {
+    await apiRequest({
+      method: "DELETE",
+      path: "/v1/account",
+      token: stored.token,
+      baseUrl: stored.api_url,
+      body: { confirm: DELETE_ACCOUNT_PHRASE }
+    });
+    return;
+  } catch (err) {
+    if (!(err instanceof MemgError)) throw err;
+    if (err.code === "server_unreachable" && await brainTokenIsDead(stored)) {
+      return;
+    }
+    const registryLine = registry === null ? "" : ` The registry account \`${oneLine(registry.username, WIDTH.title)}\` was not touched.`;
+    if (err.code === "server_unreachable") {
+      throw new MemgError({
+        code: err.code,
+        message: err.message,
+        hint: `The brain server did not confirm the deletion, and the request may have reached it.${registryLine} Check the connection, then run this command again: it asks the server first. If it then says this machine's brain sign-in no longer works, the brain account was deleted \u2014 it will not delete the registry account on that basis; it says how to finish by mail.`
+      });
+    }
+    throw new MemgError({
+      code: err.code,
+      message: err.message,
+      hint: `The brain account was not confirmed deleted.${registryLine} ${err.hint} Then run this again.`
+    });
+  }
+}
+async function brainTokenIsDead(stored) {
+  try {
+    await apiRequest({
+      method: "GET",
+      path: "/v1/me",
+      token: stored.token,
+      baseUrl: stored.api_url
+    });
+    return false;
+  } catch (err) {
+    return err instanceof MemgError && err.code === "not_authenticated";
+  }
+}
+async function deleteRegistryAccount(registry) {
+  try {
+    await registry.client.deleteMe({ confirm_username: registry.username });
+    return;
+  } catch (err) {
+    if (err instanceof KordisNetworkError && await registrySessionIsDead(registry)) {
+      return;
+    }
+    const adapted = adaptRegistryError(err) ?? memgError(
+      "server_refused",
+      err instanceof Error ? err.message : String(err),
+      "The registry refused the request without saying why."
+    );
+    const name = oneLine(registry.username, WIDTH.title);
+    const unconfirmed = err instanceof KordisNetworkError;
+    const said = err instanceof KordisApiError && err.hint !== void 0 && err.hint !== "" ? ` The registry said: ${err.hint}` : "";
+    throw memgError(
+      "account_partly_deleted",
+      unconfirmed ? `the hosted brain account is deleted; the registry did not confirm deleting \`${name}\` \u2014 ${adapted.code}: ${oneLine(adapted.message, WIDTH.text)}` : `the hosted brain account is deleted; the registry account \`${name}\` is not \u2014 ${adapted.code}: ${oneLine(adapted.message, WIDTH.text)}`,
+      `The brain half is done and cannot be undone. ${unconfirmed ? `The registry did not answer, so it is not known whether \`${name}\` was deleted.` : `The registry account \`${name}\` still exists.`}${said}
+Run \`memgineering delete-account --confirm "${DELETE_ACCOUNT_PHRASE}"\` again: it skips the brain and deletes only the registry account${unconfirmed ? " if it is still there; if this machine's registry sign-in then no longer works, the account is gone or the sign-in was revoked, and it says how to finish by mail" : ""}. If it keeps failing, mail ${SUPPORT_ADDRESS} from the Google address of the account, naming \`${name}\`.`
+    );
+  }
+}
+async function registrySessionIsDead(registry) {
+  try {
+    await registry.client.exportMe();
+    return false;
+  } catch (err) {
+    return err instanceof KordisApiError && err.status === 401;
+  }
+}
+async function signOutHere(brainApiUrl) {
+  await clearPendingLogin();
+  await clearSetupFollowUps();
+  await clearCredentials();
+  const cfg = await loadConfig();
+  const pointer = cfg.brain.cloud;
+  if (pointer === void 0 || pointer.api_url !== brainApiUrl) return false;
+  await saveConfig({
+    ...cfg,
+    brain: {
+      brains: cfg.brain.brains,
+      ...cfg.brain.default === void 0 ? {} : { default: cfg.brain.default }
+    }
+  });
+  return true;
+}
+async function saveBestEffort(marker) {
+  try {
+    await saveAccountDeletionMarker(marker);
+  } catch {
+  }
+}
+
+// src/commands/delete-brain.ts
+init_errors();
+init_api_client();
+init_cloud_brain();
+init_config();
+init_ui();
+import { Command as Command13 } from "commander";
+import prompts2 from "prompts";
+function deleteBrainCommand() {
+  return new Command13("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(
@@ -17036,7 +17785,7 @@ Delete \u201C${oneLine(target.name, WIDTH.title)}\u201D?`));
       "\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({
+  const { typed } = await prompts2({
     type: "text",
     name: "typed",
     message: "Type the brain\u2019s name exactly to delete it"
@@ -17070,21 +17819,21 @@ async function deleteCloudBrain(args) {
 
 // src/commands/curation.ts
 init_src();
-import { stat as stat5 } from "fs/promises";
+import { stat as stat6 } from "fs/promises";
 import { resolve as resolve8 } from "path";
-import { Command as Command14 } from "commander";
+import { Command as Command15 } from "commander";
 
 // ../../packages/storage-adapter/src/local-file/ignore-file.ts
 init_atomic();
 init_exclude();
 init_walk();
 import { createHash as createHash6 } from "crypto";
-import { readFile as readFile18 } from "fs/promises";
+import { readFile as readFile19 } from "fs/promises";
 var FILE = ".memgignore";
 var hashOf = (content) => createHash6("sha256").update(Buffer.from(content, "utf8")).digest("hex");
 async function readIgnoreFileState(root) {
   try {
-    const content = await readFile18(resolveInside(root, FILE), "utf8");
+    const content = await readFile19(resolveInside(root, FILE), "utf8");
     return { content, exists: true, hash: hashOf(content) };
   } catch (err) {
     if (err?.code === "ENOENT") {
@@ -17174,7 +17923,7 @@ init_vault();
 init_ui();
 init_link();
 function lifecycleCommand(action) {
-  return new Command14(action).description(
+  return new Command15(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 where = await resolveTarget({
@@ -17261,7 +18010,7 @@ async function lifecycleLocal(vault, action, ref, reason) {
   return { entry, record };
 }
 function ignoreCommand(mode) {
-  return new Command14(mode).description(
+  return new Command15(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);
@@ -17386,7 +18135,7 @@ async function mustMatchAFile(root, adapter, path) {
   const wanted = path.normalize("NFC").replace(/^\/+/, "");
   const absolute = resolve8(root, wanted);
   if (isInside(absolute, root)) {
-    const found = await stat5(absolute).catch(() => null);
+    const found = await stat6(absolute).catch(() => null);
     if (found?.isFile()) return wanted;
   }
   const hits = sameBasename(await adapter.list(""), path);
@@ -17403,14 +18152,14 @@ var unexcludeCommand = () => ignoreCommand("unexclude");
 
 // src/commands/scope-validity.ts
 init_src();
-import { Command as Command15 } from "commander";
+import { Command as Command16 } from "commander";
 init_errors();
 init_index_build();
 init_cloud_brain();
 init_vault();
 init_ui();
 function rescopeCommand() {
-  return new Command15("rescope").description("change which project a memory binds in \u2014 nothing it says changes").argument("<ref>", "handle, id, path, or exact title").option("--scope <name>", "the project it binds in from now on").option("--global", "it binds everywhere \u2014 say this rather than leaving the scope off").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(
+  return new Command16("rescope").description("change which project a memory binds in \u2014 nothing it says changes").argument("<ref>", "handle, id, path, or exact title").option("--scope <name>", "the project it binds in from now on").option("--global", "it binds everywhere \u2014 say this rather than leaving the scope off").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 scope = scopeAskedFor(opts);
       const where = await resolveTarget({
@@ -17446,7 +18195,7 @@ Undo: \`${undoHint(record.op_id, opts)}\``));
   );
 }
 function expireCommand() {
-  return new Command15("expire").description("give a memory an end date \u2014 it is NOT retired, and recall still returns it").argument("<ref>", "handle, id, path, or exact title").requiredOption("--until <date>", "the day it stops being current, e.g. 2026-10-31").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(
+  return new Command16("expire").description("give a memory an end date \u2014 it is NOT retired, and recall still returns it").argument("<ref>", "handle, id, path, or exact title").requiredOption("--until <date>", "the day it stops being current, e.g. 2026-10-31").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 where = await resolveTarget({
         ...opts.local === void 0 ? {} : { local: opts.local },
@@ -17665,13 +18414,13 @@ Undo: \`memgineering undo ${result.op_id}\``));
 
 // src/commands/evidence.ts
 init_src();
-import { Command as Command16 } from "commander";
+import { Command as Command17 } from "commander";
 init_index_build();
 init_cloud_brain();
 init_vault();
 init_ui();
 function evidenceCommand() {
-  return new Command16("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 Command17("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) => {
@@ -17960,9 +18709,9 @@ function ago(iso, now) {
 init_brand();
 init_config();
 import { createHash as createHash7 } from "crypto";
-import { mkdir as mkdir12, readdir as readdir8, stat as stat6, unlink as unlink5, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname6, isAbsolute as isAbsolute3, join as join20, resolve as resolve9 } from "path";
-import { Command as Command17 } from "commander";
+import { mkdir as mkdir13, readdir as readdir8, stat as stat7, unlink as unlink6, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname6, isAbsolute as isAbsolute3, join as join21, resolve as resolve9 } from "path";
+import { Command as Command18 } from "commander";
 
 // src/lib/rules.ts
 init_src();
@@ -18034,7 +18783,7 @@ init_deadline();
 init_cloud_brain();
 init_vault();
 function guardCommand() {
-  return new Command17("guard").description("hook entry \u2014 show the user\u2019s rules before the first edit of a session").option("--context-dir <path>", "where the work is happening, when stdin does not say").option("--at <event>", "pre-tool-use | stop", "pre-tool-use").action(async (opts) => {
+  return new Command18("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();
@@ -18181,7 +18930,7 @@ async function readPayload() {
     return null;
   }
 }
-var guardDir = () => join20(brandHome(), "guard");
+var guardDir = () => join21(brandHome(), "guard");
 var WRITE_TOOLS = /* @__PURE__ */ new Set([
   "Write",
   "Edit",
@@ -18202,7 +18951,7 @@ async function misdeliveryNotice(toolName, filePath, sessionId) {
   return 'This file is this harness\u2019s own memory \u2014 no other tool the user works with will ever read it. Durable facts about the user belong in their brain, which every tool shares: memgineering remember "<the fact>" --reason "<why>" (add --rule if they stated a standing rule). Write it there instead, or in addition.';
 }
 function markerFor(sessionId, brain) {
-  return join20(
+  return join21(
     guardDir(),
     `${createHash7("sha256").update(`${sessionId}\0${brain}`).digest("hex").slice(0, 32)}`
   );
@@ -18210,7 +18959,7 @@ function markerFor(sessionId, brain) {
 async function claimSession(sessionId, brain) {
   const marker = markerFor(sessionId, brain);
   try {
-    await mkdir12(guardDir(), { recursive: true, mode: 448 });
+    await mkdir13(guardDir(), { recursive: true, mode: 448 });
     await writeFile10(marker, "", { flag: "wx", mode: 384 });
   } catch {
     return false;
@@ -18219,10 +18968,10 @@ async function claimSession(sessionId, brain) {
   return true;
 }
 async function releaseSession(sessionId, brain) {
-  await unlink5(markerFor(sessionId, brain)).catch(() => void 0);
+  await unlink6(markerFor(sessionId, brain)).catch(() => void 0);
 }
 async function claimExists(sessionId, brain) {
-  return stat6(markerFor(sessionId, brain)).then(() => true).catch(() => false);
+  return stat7(markerFor(sessionId, brain)).then(() => true).catch(() => false);
 }
 var MARKER_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 async function pruneOldMarkers() {
@@ -18230,10 +18979,10 @@ async function pruneOldMarkers() {
     const dir = guardDir();
     const now = Date.now();
     for (const name of await readdir8(dir)) {
-      const path = join20(dir, name);
+      const path = join21(dir, name);
       if (!isAbsolute3(path)) continue;
-      const info = await stat6(path).catch(() => null);
-      if (info && now - info.mtimeMs > MARKER_TTL_MS) await unlink5(path).catch(() => void 0);
+      const info = await stat7(path).catch(() => null);
+      if (info && now - info.mtimeMs > MARKER_TTL_MS) await unlink6(path).catch(() => void 0);
     }
     await pruneFast(now);
   } catch {
@@ -18277,15 +19026,15 @@ init_link();
 // src/commands/log.ts
 init_src();
 init_walk();
-import { lstat as lstat4, readFile as readFile20 } from "fs/promises";
-import { Command as Command19 } from "commander";
+import { lstat as lstat4, readFile as readFile21 } from "fs/promises";
+import { Command as Command20 } from "commander";
 init_errors();
 init_cloud_brain();
 
 // src/commands/retract.ts
 init_errors();
 init_cloud_brain();
-import { Command as Command18 } from "commander";
+import { Command as Command19 } from "commander";
 init_vault();
 init_ui();
 var CONTENT_VERBS = /* @__PURE__ */ new Set([
@@ -18356,7 +19105,7 @@ function parseInstant(flag2, raw) {
   return { ms, iso: new Date(ms).toISOString() };
 }
 function retractCommand() {
-  return new Command18("retract").description(
+  return new Command19("retract").description(
     "retire every memory one writer or one stretch of time wrote \u2014 shows the set first; --yes applies it"
   ).option("--actor <actor>", 'writes recorded under this actor, e.g. "mcp:ChatGPT" or "agent"').option(
     "--token <id>",
@@ -18571,7 +19320,7 @@ ${failed.length} could not be retired:`);
 init_vault();
 init_ui();
 function logCommand() {
-  return new Command19("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 Command20("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"
   ).option("--actor <actor>", 'only operations recorded under this actor, e.g. "mcp:ChatGPT" or "agent"').option("--token <id>", "only operations made with this token (id or 5+ char prefix) \u2014 hosted brains").option("--since <when>", "only operations at or after this date / ISO instant").option("--until <when>", "only operations before this date / ISO instant").action(async (opts) => {
@@ -18843,16 +19592,16 @@ async function readOrNull(root, path) {
   if (absolute === null) return null;
   const info = await lstat4(absolute).catch(() => null);
   if (!info || !info.isFile()) return null;
-  return readFile20(absolute, "utf8").catch(() => null);
+  return readFile21(absolute, "utf8").catch(() => null);
 }
 
 // src/commands/project.ts
 init_errors();
 import { resolve as resolve10 } from "path";
-import { Command as Command20 } from "commander";
+import { Command as Command21 } from "commander";
 init_ui();
 function projectCommand() {
-  return new Command20("project").description("show or set what the work in this folder is called").argument("[name]", "what to call it \u2014 omit to show what this folder answers to").option("--here <dir>", "act on this directory instead of the current one").option("--unset", "forget the name set here and go back to what the repository says").addHelpText(
+  return new Command21("project").description("show or set what the work in this folder is called").argument("[name]", "what to call it \u2014 omit to show what this folder answers to").option("--here <dir>", "act on this directory instead of the current one").option("--unset", "forget the name set here and go back to what the repository says").addHelpText(
     "after",
     [
       "",
@@ -18979,115 +19728,10 @@ init_api_client();
 init_credentials();
 init_config();
 init_pending_login();
-import { Command as Command22 } from "commander";
-
-// src/lib/registry-session.ts
-init_errors();
-init_credentials();
-init_version();
-function registryApiUrl(stored) {
-  const override = process.env["KORDIS_API_URL"];
-  return override !== void 0 && override !== "" ? override : stored;
-}
-async function requireRegistryCredentials() {
-  const credentials = await readCredentials();
-  const registry = credentials?.registry;
-  if (!registry) {
-    throw memgError(
-      "not_linked",
-      "this machine holds no registry identity",
-      credentials === null ? "Nothing was sent. Sign in with `memgineering login` \u2014 it links the registry identity at the same time, so one sign-in covers both." : "Nothing was sent. This machine is signed in to a brain, and the registry half of that sign-in is missing \u2014 which is what a credential file written before federation looks like. Run `memgineering login` again; it links the registry identity too."
-    );
-  }
-  return registry;
-}
-var RACE_WAIT_MS = 2e3;
-var RACE_POLL_MS = 50;
-function lostRace(err) {
-  return err instanceof KordisApiError && err.status === 401 && isRefreshRace({ error: { code: err.code, flags: err.flags } });
-}
-async function newerRegistry(sent) {
-  const deadline = Date.now() + RACE_WAIT_MS;
-  for (; ; ) {
-    const registry = (await readCredentials())?.registry;
-    if (registry !== void 0 && registry.refresh_token !== sent) return registry;
-    if (Date.now() >= deadline) return null;
-    await new Promise((resolve17) => setTimeout(resolve17, RACE_POLL_MS));
-  }
-}
-async function refreshRegistrySession(stored, opts = {}) {
-  const attempt = async (registry) => {
-    const baseUrl = (opts.apiUrlOf ?? ((r) => registryApiUrl(r.api_url)))(registry);
-    const anonymous = new KordisClient({
-      baseUrl,
-      userAgent: `memgineering/${VERSION}`,
-      ...opts.fetchImpl ? { fetch: opts.fetchImpl } : {},
-      ...opts.requestTimeoutMs === void 0 ? {} : { requestTimeoutMs: opts.requestTimeoutMs }
-    });
-    return { registry, baseUrl, tokens: await anonymous.refreshSession(registry.refresh_token) };
-  };
-  try {
-    return await attempt(stored);
-  } catch (err) {
-    if (!lostRace(err)) throw err;
-    const newer = await newerRegistry(stored.refresh_token);
-    if (newer === null) throw err;
-    return attempt(newer);
-  }
-}
-function refusal(err) {
-  if (lostRace(err)) {
-    return memgError(
-      "not_authenticated",
-      err.message,
-      "This machine's registry sign-in was refreshed by another request at the same moment, so this command could not use it. Run this command again."
-    );
-  }
-  const busyOrUnreachable = err instanceof KordisNetworkError || err instanceof KordisApiError && (err.status === 429 || err.status >= 500);
-  return (busyOrUnreachable ? adaptRegistryError(err) : null) ?? memgError(
-    "not_linked",
-    `the registry refused this machine's stored sign-in: ${err instanceof Error ? err.message : String(err)}`,
-    "Nothing was sent. The link between this brain and your registry account has expired or been revoked. `memgineering login` re-links both."
-  );
-}
-async function openRegistrySession(fetchImpl) {
-  const stored = await requireRegistryCredentials();
-  let refreshed;
-  try {
-    refreshed = await refreshRegistrySession(stored, fetchImpl ? { fetchImpl } : {});
-  } catch (err) {
-    throw refusal(err);
-  }
-  const { registry, baseUrl, tokens } = refreshed;
-  const credentialsRotated = await persistRotatedRefresh(
-    registry,
-    tokens.refresh_token,
-    tokens.session_id
-  );
-  const client = new KordisClient({
-    baseUrl,
-    userAgent: `memgineering/${VERSION}`,
-    getAccessToken: () => tokens.access_token,
-    ...fetchImpl ? { fetch: fetchImpl } : {}
-  });
-  return { client, username: registry.username, apiUrl: baseUrl, credentialsRotated };
-}
-async function persistRotatedRefresh(sent, refreshToken, sessionId) {
-  if (refreshToken === sent.refresh_token && sessionId === sent.session_id) return false;
-  try {
-    return await saveRotatedRegistry(sent.refresh_token, {
-      refresh_token: refreshToken,
-      session_id: sessionId
-    });
-  } catch {
-    return false;
-  }
-}
-
-// src/commands/logout.ts
+import { Command as Command23 } from "commander";
 init_ui();
 function logoutCommand() {
-  return new Command22("logout").description("sign out of your account \u2014 the pointer and your notes stay").option("--all", "revoke every token on the account, not just this machine\u2019s").option(
+  return new Command23("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) => {
@@ -19096,9 +19740,18 @@ function logoutCommand() {
     await clearPendingLogin();
     await clearSetupFollowUps();
     if (!credentials) {
+      const hint = opts.all ? NOT_SIGNED_IN_ALL_HINT : void 0;
       printDual({
-        json: { signed_out: true, was_signed_in: false, api_url: base2 },
-        human: () => printHuman("Not signed in \u2014 nothing to do.")
+        json: {
+          signed_out: true,
+          was_signed_in: false,
+          api_url: base2,
+          ...hint ? { hint } : {}
+        },
+        human: () => {
+          printHuman("Not signed in \u2014 nothing to do.");
+          if (hint) printHuman(c.gray(`  ${hint}`));
+        }
       });
       return;
     }
@@ -19118,6 +19771,8 @@ function logoutCommand() {
       return;
     }
     let revoked = null;
+    let registrySessions = null;
+    let revokedBefore = null;
     try {
       if (opts.all) {
         const res = await apiRequest({
@@ -19127,6 +19782,8 @@ function logoutCommand() {
           baseUrl: credentials.api_url
         });
         revoked = res.body?.revoked ?? null;
+        registrySessions = readRegistrySessions(res.body?.registry_sessions);
+        revokedBefore = typeof res.body?.revoked_before === "string" ? res.body.revoked_before : null;
       } else {
         const me = await apiRequest({
           method: "GET",
@@ -19156,7 +19813,7 @@ function logoutCommand() {
       }
     }
     const registry = (await readCredentials())?.registry ?? credentials.registry;
-    const registryRevoked = await revokeRegistrySession(registry);
+    const registryRevoked = registrySessions?.status === "revoked" ? true : await revokeRegistrySession(registry);
     await clearCredentials();
     printDual({
       json: {
@@ -19165,7 +19822,9 @@ function logoutCommand() {
         revoked_on_server: true,
         revoked,
         all: opts.all === true,
-        api_url: credentials.api_url
+        api_url: credentials.api_url,
+        ...registrySessions ? { registry_sessions: registrySessions } : {},
+        ...revokedBefore ? { revoked_before: revokedBefore } : {}
       },
       human: () => {
         printHuman(opts.all ? "Signed out everywhere." : "Signed out.");
@@ -19174,6 +19833,8 @@ function logoutCommand() {
             opts.all ? "  Every token on the account is dead. `memgineering login` starts a new one." : "  This machine\u2019s token is revoked. Other machines are unaffected."
           )
         );
+        const registryLine = registrySessions ? registrySessionsLine(registrySessions) : null;
+        if (registryLine !== null) printHuman(registryLine);
         printHuman(
           c.gray(
             "  Your notes are untouched: signing out takes a token, not a brain.\n  This machine still remembers which brain it was reading, so `memgineering\n  login` picks up where you left off. `memgineering unlink --brain` forgets it."
@@ -19183,6 +19844,34 @@ function logoutCommand() {
     });
   });
 }
+var NOT_SIGNED_IN_ALL_HINT = 'Nothing is signed in on this machine, so nothing could be ended from here. To disconnect everything, press "disconnect everything" on the website, or run `memgineering login` and then `memgineering logout --all`.';
+function readRegistrySessions(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const r = raw;
+  if (r["status"] === "revoked" && typeof r["count"] === "number") {
+    return { status: "revoked", count: r["count"] };
+  }
+  if (r["status"] === "not_linked") return { status: "not_linked" };
+  if (r["status"] === "unreachable" && typeof r["hint"] === "string") {
+    return { status: "unreachable", hint: r["hint"] };
+  }
+  return null;
+}
+function registrySessionsLine(r) {
+  switch (r.status) {
+    case "revoked":
+      if (r.count === 0) return null;
+      return c.gray(
+        `  Registry sign-ins ended too: ${r.count}. Anything approved before now cannot sign back in.`
+      );
+    case "not_linked":
+      return c.gray(
+        "  No registry account is linked to this Google account; nothing to end there."
+      );
+    case "unreachable":
+      return c.yellow(`  Registry sign-ins could not be ended: ${oneLineWhole(r.hint)}`);
+  }
+}
 async function revokeRegistrySession(reg) {
   if (!reg) return false;
   try {
@@ -19206,12 +19895,12 @@ async function revokeRegistrySession(reg) {
 
 // src/commands/onboard.ts
 init_src();
-import { Command as Command23 } from "commander";
+import { Command as Command24 } from "commander";
 init_cloud_brain();
 init_vault();
 init_ui();
 function onboardCommand() {
-  return new Command23("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 Command24("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) => {
@@ -19357,11 +20046,11 @@ init_api_client();
 init_config();
 init_cloud_brain();
 init_ui();
-import { mkdir as mkdir13, readFile as readFile21, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname7, isAbsolute as isAbsolute4, join as join21, resolve as resolve11, sep as sep2 } from "path";
-import { Command as Command24 } from "commander";
+import { mkdir as mkdir14, readFile as readFile22, writeFile as writeFile11 } from "fs/promises";
+import { dirname as dirname7, isAbsolute as isAbsolute4, join as join22, resolve as resolve11, sep as sep2 } from "path";
+import { Command as Command25 } from "commander";
 function pullCommand() {
-  return new Command24("pull").description("download your hosted brain to a folder on this machine").argument("[destination]", "folder to write into (created if missing)").option("--brain <name>", "which hosted brain to download").option("--dry-run", "say what would be written and write nothing").action(async (destination, opts) => {
+  return new Command25("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 = resolve11(destination ?? `./${oneLine(source.name, WIDTH.title)}`);
     const first = await cloudListNotes(source, { limit: 1 });
@@ -19426,7 +20115,7 @@ function pullCommand() {
           already.push(note.path);
           continue;
         }
-        await mkdir13(dirname7(file), { recursive: true });
+        await mkdir14(dirname7(file), { recursive: true });
         await writeFile11(file, note.content ?? "", "utf8");
         written.push(note.path);
         if (note.excluded === true) excluded.push(note.path);
@@ -19541,7 +20230,7 @@ function safeJoin(root, relative3) {
       "Nothing was written for it. This should not happen \u2014 please report it."
     );
   }
-  const full = resolve11(join21(root, relative3));
+  const full = resolve11(join22(root, relative3));
   if (full !== root && !full.startsWith(root + sep2)) {
     throw memgError(
       "server_refused",
@@ -19553,7 +20242,7 @@ function safeJoin(root, relative3) {
 }
 async function exists(file) {
   try {
-    await readFile21(file);
+    await readFile22(file);
     return true;
   } catch {
     return false;
@@ -19561,8 +20250,8 @@ async function exists(file) {
 }
 
 // src/commands/publish.ts
-import { Command as Command26 } from "commander";
-import { z as z32 } from "zod";
+import { Command as Command27 } from "commander";
+import { z as z33 } from "zod";
 init_src();
 init_errors();
 
@@ -19709,9 +20398,9 @@ import semver from "semver";
 init_parser();
 
 // ../../packages/harness-schema/src/deps.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var StringDepRe = /^([a-z0-9](-?[a-z0-9])*\/[a-z0-9](-?[a-z0-9])*)(?:@(.+))?$/;
-var ObjectDepSchema = z25.object({
+var ObjectDepSchema = z26.object({
   full_slug: FullSlugSchema,
   version_range: SemverRangeSchema.default("*")
 });
@@ -19746,33 +20435,33 @@ function normaliseDep(entry, idx) {
 init_parser();
 
 // ../../packages/harness-schema/src/types/skill.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var SKILL_DESCRIPTION_SPEC_MAX = 1024;
 var SKILL_DESCRIPTION_HARD_MAX = 2048;
 var SKILL_COMPATIBILITY_MAX = 500;
-var MetadataValueSchema = z26.union([z26.string(), z26.number(), z26.boolean()]).transform((v) => String(v));
-var SkillSpecFrontmatterSchema = z26.object({
-  name: z26.string().min(1).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "name must be lowercase-with-hyphens (Agent Skills spec)"),
-  description: z26.string().min(1).max(SKILL_DESCRIPTION_HARD_MAX),
+var MetadataValueSchema = z27.union([z27.string(), z27.number(), z27.boolean()]).transform((v) => String(v));
+var SkillSpecFrontmatterSchema = z27.object({
+  name: z27.string().min(1).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "name must be lowercase-with-hyphens (Agent Skills spec)"),
+  description: z27.string().min(1).max(SKILL_DESCRIPTION_HARD_MAX),
   // The spec puts no length limit on license (it is an SPDX identifier or a
   // short phrase); the old 64-char cap here was Kordis-invented.
-  license: z26.string().optional(),
-  compatibility: z26.string().max(SKILL_COMPATIBILITY_MAX).optional(),
+  license: z27.string().optional(),
+  compatibility: z27.string().max(SKILL_COMPATIBILITY_MAX).optional(),
   // Spec form is a space-separated STRING. The array form is what Kordis
   // accepted before the spec settled — still parsed, flagged
   // `legacy_frontmatter`, and re-emitted unchanged by the translators.
-  "allowed-tools": z26.union([z26.string(), z26.array(z26.string())]).optional(),
-  metadata: z26.record(z26.string(), MetadataValueSchema).optional()
+  "allowed-tools": z27.union([z27.string(), z27.array(z27.string())]).optional(),
+  metadata: z27.record(z27.string(), MetadataValueSchema).optional()
 }).strict();
-var LegacySkillExtrasSchema = z26.object({
+var LegacySkillExtrasSchema = z27.object({
   version: SemverSchema.optional(),
-  homepage: z26.string().url().optional(),
-  model: z26.string().optional(),
+  homepage: z27.string().url().optional(),
+  model: z27.string().optional(),
   // model override hint
-  "disable-model-invocation": z26.boolean().optional(),
-  title: z26.string().min(1).max(200).optional(),
-  tags: z26.array(TagSchema).max(16).optional(),
-  tools: z26.array(ToolSlugSchema).optional()
+  "disable-model-invocation": z27.boolean().optional(),
+  title: z27.string().min(1).max(200).optional(),
+  tags: z27.array(TagSchema).max(16).optional(),
+  tools: z27.array(ToolSlugSchema).optional()
 });
 var LEGACY_SKILL_EXTRA_KEYS = [
   "version",
@@ -19787,10 +20476,10 @@ var LEGACY_KEY_SET = new Set(LEGACY_SKILL_EXTRA_KEYS);
 var NONSTANDARD_HINT = 'These are not Agent Skills fields. Move them to `metadata` (string values: `metadata: {version: "1.2.3", tags: "a, b", tools: "claude-code, codex"}`). Accepted with a warning for now; a future release will make this an error and will say so in its changelog.';
 var METADATA_READBACK = [
   { field: "version", schema: SemverSchema, list: false },
-  { field: "homepage", schema: z26.string().url(), list: false },
-  { field: "model", schema: z26.string().min(1), list: false },
-  { field: "tags", schema: z26.array(TagSchema).max(16), list: true },
-  { field: "tools", schema: z26.array(ToolSlugSchema), list: true }
+  { field: "homepage", schema: z27.string().url(), list: false },
+  { field: "model", schema: z27.string().min(1), list: false },
+  { field: "tags", schema: z27.array(TagSchema).max(16), list: true },
+  { field: "tools", schema: z27.array(ToolSlugSchema), list: true }
 ];
 function splitList(raw) {
   return raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
@@ -19885,30 +20574,30 @@ function parseSkillFrontmatter(raw) {
 }
 
 // ../../packages/harness-schema/src/types/mcp-server.ts
-import { z as z27 } from "zod";
-var McpTransportSchema = z27.union([
-  z27.object({
-    type: z27.literal("stdio"),
-    command: z27.string().min(1),
-    args: z27.array(z27.string()).optional().default([]),
-    env: z27.record(z27.string()).optional().default({})
+import { z as z28 } from "zod";
+var McpTransportSchema = z28.union([
+  z28.object({
+    type: z28.literal("stdio"),
+    command: z28.string().min(1),
+    args: z28.array(z28.string()).optional().default([]),
+    env: z28.record(z28.string()).optional().default({})
   }),
-  z27.object({
-    type: z27.enum(["http", "sse"]),
-    url: z27.string().url(),
-    headers: z27.record(z27.string()).optional().default({})
+  z28.object({
+    type: z28.enum(["http", "sse"]),
+    url: z28.string().url(),
+    headers: z28.record(z28.string()).optional().default({})
   })
 ]);
-var McpCapabilitiesSchema = z27.object({
-  tools: z27.array(z27.string()).optional().default([]),
-  resources: z27.array(z27.string()).optional().default([]),
-  prompts: z27.array(z27.string()).optional().default([])
+var McpCapabilitiesSchema = z28.object({
+  tools: z28.array(z28.string()).optional().default([]),
+  resources: z28.array(z28.string()).optional().default([]),
+  prompts: z28.array(z28.string()).optional().default([])
 });
-var McpServerFrontmatterSchema = z27.object({
-  name: z27.string().min(1).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
-  description: z27.string().min(1).max(2048),
+var McpServerFrontmatterSchema = z28.object({
+  name: z28.string().min(1).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
+  description: z28.string().min(1).max(2048),
   version: SemverSchema,
-  mcp_spec_version: z27.string().default("2026-03"),
+  mcp_spec_version: z28.string().default("2026-03"),
   transport: McpTransportSchema,
   capabilities: McpCapabilitiesSchema.optional().default({
     tools: [],
@@ -19916,34 +20605,34 @@ var McpServerFrontmatterSchema = z27.object({
     prompts: []
   }),
   /** Human-readable setup / auth instructions. Surfaced in `kordis info`. */
-  auth_notes: z27.string().optional(),
+  auth_notes: z28.string().optional(),
   /** Required env vars with description + whether they must be secret. */
-  env_schema: z27.record(
-    z27.object({
-      description: z27.string(),
-      required: z27.boolean().default(true),
-      secret: z27.boolean().default(false)
+  env_schema: z28.record(
+    z28.object({
+      description: z28.string(),
+      required: z28.boolean().default(true),
+      secret: z28.boolean().default(false)
     })
   ).optional(),
-  homepage: z27.string().url().optional(),
-  repository: z27.string().url().optional(),
-  license: z27.string().max(64).optional(),
-  title: z27.string().min(1).max(200).optional()
+  homepage: z28.string().url().optional(),
+  repository: z28.string().url().optional(),
+  license: z28.string().max(64).optional(),
+  title: z28.string().min(1).max(200).optional()
 }).strict();
 
 // ../../packages/harness-schema/src/types/project-rules.ts
-import { z as z28 } from "zod";
-var ProjectRulesFrontmatterSchema = z28.object({
-  title: z28.string().min(1).max(200),
-  description: z28.string().min(1).max(2048),
+import { z as z29 } from "zod";
+var ProjectRulesFrontmatterSchema = z29.object({
+  title: z29.string().min(1).max(200),
+  description: z29.string().min(1).max(2048),
   version: SemverSchema.optional(),
-  scope: z28.enum(["root", "nested", "globs"]).default("root"),
-  target_path: z28.string().optional(),
-  globs: z28.array(z28.string()).optional(),
-  target_tools: z28.array(ToolSlugSchema).optional().default([]),
+  scope: z29.enum(["root", "nested", "globs"]).default("root"),
+  target_path: z29.string().optional(),
+  globs: z29.array(z29.string()).optional(),
+  target_tools: z29.array(ToolSlugSchema).optional().default([]),
   /** When true, installation is idempotent via `<!-- kordis:... -->` markers. */
-  mergeable: z28.boolean().default(true),
-  license: z28.string().max(64).optional()
+  mergeable: z29.boolean().default(true),
+  license: z29.string().max(64).optional()
 }).strict().refine((v) => v.scope !== "nested" || !!v.target_path, {
   message: 'scope="nested" requires target_path'
 }).refine((v) => v.scope !== "globs" || v.globs && v.globs.length > 0, {
@@ -19951,32 +20640,32 @@ var ProjectRulesFrontmatterSchema = z28.object({
 });
 
 // ../../packages/harness-schema/src/types/custom-agent.ts
-import { z as z29 } from "zod";
-var CustomAgentFrontmatterSchema = z29.object({
-  name: z29.string().min(1).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
-  description: z29.string().min(1).max(2048),
-  title: z29.string().min(1).max(200).optional(),
+import { z as z30 } from "zod";
+var CustomAgentFrontmatterSchema = z30.object({
+  name: z30.string().min(1).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
+  description: z30.string().min(1).max(2048),
+  title: z30.string().min(1).max(200).optional(),
   version: SemverSchema.optional(),
   /** System prompt that defines the agent's persona + rules. Required. */
-  system_prompt: z29.string().min(1).max(5e4),
+  system_prompt: z30.string().min(1).max(5e4),
   /** Optional model override — string passed verbatim to the host. */
-  model: z29.string().optional(),
+  model: z30.string().optional(),
   /** Tools this agent can call. Host-specific names (no uniform namespace). */
-  allowed_tools: z29.array(z29.string()).optional().default([]),
-  disallowed_tools: z29.array(z29.string()).optional().default([]),
+  allowed_tools: z30.array(z30.string()).optional().default([]),
+  disallowed_tools: z30.array(z30.string()).optional().default([]),
   /** Fork/context behaviour hint (Claude: `context: fork` etc.). */
-  context: z29.enum(["inherit", "fork", "isolated"]).optional(),
+  context: z30.enum(["inherit", "fork", "isolated"]).optional(),
   /** Known-good tool runtimes. Empty = untested everywhere. */
-  tool_compat: z29.array(ToolSlugSchema).optional().default([]),
+  tool_compat: z30.array(ToolSlugSchema).optional().default([]),
   /** Pre-load skills when this agent activates. */
-  preload_skills: z29.array(z29.string()).optional().default([]),
-  license: z29.string().max(64).optional(),
-  homepage: z29.string().url().optional()
+  preload_skills: z30.array(z30.string()).optional().default([]),
+  license: z30.string().max(64).optional(),
+  homepage: z30.string().url().optional()
 }).strict();
 
 // ../../packages/harness-schema/src/types/hook.ts
-import { z as z30 } from "zod";
-var HookEventSchema = z30.enum([
+import { z as z31 } from "zod";
+var HookEventSchema = z31.enum([
   "PreToolUse",
   "PostToolUse",
   "UserPromptSubmit",
@@ -19988,78 +20677,78 @@ var HookEventSchema = z30.enum([
   "SubagentStop",
   "Background"
 ]);
-var HookActionSchema = z30.union([
-  z30.object({
-    type: z30.literal("command"),
-    command: z30.string().min(1),
-    timeout_ms: z30.number().int().positive().max(6e5).optional(),
-    blocking: z30.boolean().default(false)
+var HookActionSchema = z31.union([
+  z31.object({
+    type: z31.literal("command"),
+    command: z31.string().min(1),
+    timeout_ms: z31.number().int().positive().max(6e5).optional(),
+    blocking: z31.boolean().default(false)
   }),
-  z30.object({
-    type: z30.literal("http"),
-    url: z30.string().url(),
-    method: z30.enum(["GET", "POST", "PUT", "PATCH"]).default("POST"),
-    headers: z30.record(z30.string()).optional().default({}),
-    timeout_ms: z30.number().int().positive().max(6e5).optional(),
-    blocking: z30.boolean().default(false)
+  z31.object({
+    type: z31.literal("http"),
+    url: z31.string().url(),
+    method: z31.enum(["GET", "POST", "PUT", "PATCH"]).default("POST"),
+    headers: z31.record(z31.string()).optional().default({}),
+    timeout_ms: z31.number().int().positive().max(6e5).optional(),
+    blocking: z31.boolean().default(false)
   })
 ]);
-var HookBindingSchema = z30.object({
+var HookBindingSchema = z31.object({
   event: HookEventSchema,
-  matcher: z30.string().optional(),
+  matcher: z31.string().optional(),
   action: HookActionSchema
 });
-var HookFrontmatterSchema = z30.object({
-  name: z30.string().min(1).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
-  description: z30.string().min(1).max(2048),
-  title: z30.string().min(1).max(200).optional(),
+var HookFrontmatterSchema = z31.object({
+  name: z31.string().min(1).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
+  description: z31.string().min(1).max(2048),
+  title: z31.string().min(1).max(200).optional(),
   version: SemverSchema.optional(),
   /** One or more hook bindings. */
-  hooks: z30.array(HookBindingSchema).min(1),
+  hooks: z31.array(HookBindingSchema).min(1),
   /** Declared to surface in search filters — always "claude-code" for now. */
-  tool_compat: z30.array(z30.enum(["claude-code"])).default(["claude-code"]),
-  license: z30.string().max(64).optional()
+  tool_compat: z31.array(z31.enum(["claude-code"])).default(["claude-code"]),
+  license: z31.string().max(64).optional()
 }).strict();
 
 // ../../packages/harness-schema/src/types/judgment-pattern.ts
-import { z as z31 } from "zod";
-var FailureModeSchema = z31.object({
-  symptom: z31.string().min(1).max(600).describe("the observable sign the judgment was ignored"),
-  correction: z31.string().min(1).max(1200).describe("what to do once the symptom shows")
+import { z as z32 } from "zod";
+var FailureModeSchema = z32.object({
+  symptom: z32.string().min(1).max(600).describe("the observable sign the judgment was ignored"),
+  correction: z32.string().min(1).max(1200).describe("what to do once the symptom shows")
 }).strict();
-var AdaptHintsSchema = z31.object({
+var AdaptHintsSchema = z32.object({
   /**
    * Parts that transplant verbatim into ANY harness — the invariant core.
    * Required, min 1: a judgment-pattern with no universal part has nothing
    * to transplant, which makes it a skill/project-rules in disguise, not a
    * judgment worth the dedicated type.
    */
-  universal: z31.array(z31.string().min(1).max(400)).min(1, "adapt_hints.universal must list at least one transplantable, harness-agnostic part").max(20),
+  universal: z32.array(z32.string().min(1).max(400)).min(1, "adapt_hints.universal must list at least one transplantable, harness-agnostic part").max(20),
   /** Parts the adapting agent must re-express in the host's stack/conventions. */
-  context_specific: z31.array(z31.string().min(1).max(400)).max(20).optional()
+  context_specific: z32.array(z32.string().min(1).max(400)).max(20).optional()
 }).strict();
-var JudgmentPatternFrontmatterSchema = z31.object({
-  name: z31.string().min(1).max(64).regex(
+var JudgmentPatternFrontmatterSchema = z32.object({
+  name: z32.string().min(1).max(64).regex(
     /^[a-z0-9]+(-[a-z0-9]+)*$/,
     'name must be lowercase-with-hyphens, e.g. "additive-only-migrations"'
   ),
-  description: z31.string().min(1).max(2048),
+  description: z32.string().min(1).max(2048),
   version: SemverSchema.optional(),
-  title: z31.string().min(1).max(200).optional(),
+  title: z32.string().min(1).max(200).optional(),
   /** The recurring situation / trap this judgment addresses. */
-  problem: z31.string().min(1).max(4e3),
+  problem: z32.string().min(1).max(4e3),
   /**
    * The judgment itself — free-form Markdown. The agent is the interpreter,
    * so this stays unstructured prose (decision tree, heuristics, rationale).
    * This is the part that gets transplanted.
    */
-  decision_logic: z31.string().min(1).max(2e4),
+  decision_logic: z32.string().min(1).max(2e4),
   /** Triggers — when this judgment should fire. At least one. */
-  when_to_apply: z31.array(z31.string().min(1).max(400)).min(1).max(12),
+  when_to_apply: z32.array(z32.string().min(1).max(400)).min(1).max(12),
   /** Counter-triggers — when applying it would be wrong. */
-  when_not_to_apply: z31.array(z31.string().min(1).max(400)).max(12).optional(),
+  when_not_to_apply: z32.array(z32.string().min(1).max(400)).max(12).optional(),
   /** How it fails in practice, and how to recover — the hard-won part. */
-  failure_modes: z31.array(FailureModeSchema).max(12).optional(),
+  failure_modes: z32.array(FailureModeSchema).max(12).optional(),
   /**
    * Transplant steering — the field unique to judgment-pattern. Required:
    * `adapt_hints.universal` (min 1) is what makes this a judgment-pattern
@@ -20067,13 +20756,13 @@ var JudgmentPatternFrontmatterSchema = z31.object({
    */
   adapt_hints: AdaptHintsSchema,
   /** Where this judgment came from (project, incident, paper). Provenance. */
-  origin: z31.string().min(1).max(600).optional(),
+  origin: z32.string().min(1).max(600).optional(),
   /** Proof it works (anti-spam lever for AI review). */
-  evidence: z31.string().min(1).max(2e3).optional(),
+  evidence: z32.string().min(1).max(2e3).optional(),
   // Kordis-forwarded cross-type fields (kept minimal, like skill).
-  tags: z31.array(TagSchema).max(16).optional(),
-  tools: z31.array(ToolSlugSchema).optional(),
-  license: z31.string().max(64).optional()
+  tags: z32.array(TagSchema).max(16).optional(),
+  tools: z32.array(ToolSlugSchema).optional(),
+  license: z32.string().max(64).optional()
 }).strict();
 
 // ../../packages/harness-schema/src/validator.ts
@@ -20392,7 +21081,7 @@ function isSameBrainNote(publishedOrigin, memoryId) {
 }
 
 // src/commands/registry/read.ts
-import { Command as Command25 } from "commander";
+import { Command as Command26 } from "commander";
 init_errors();
 init_credentials();
 
@@ -20415,7 +21104,7 @@ function untrustedFenceNotice(sentinel) {
 init_ui();
 init_version();
 function readCommand() {
-  return new Command25("read").description("read a judgment from the public layer into your context (nothing is installed)").argument("<full_slug>", "package identifier {username}/{slug} or {username}/{slug}@{version}").option("--allow-pending", "allow versions whose AI review has not passed", false).option("--vault <path>", "which brain records that this was read").option("--local", "record it beside the brain on this machine, not the hosted one").addHelpText(
+  return new Command26("read").description("read a judgment from the public layer into your context (nothing is installed)").argument("<full_slug>", "package identifier {username}/{slug} or {username}/{slug}@{version}").option("--allow-pending", "allow versions whose AI review has not passed", false).option("--vault <path>", "which brain records that this was read").option("--local", "record it beside the brain on this machine, not the hosted one").addHelpText(
     "after",
     "\nEnvironment:\n  KORDIS_API_URL=<url>   read from this registry instead of the linked one\n"
   ).action(async (rawSlug, opts) => {
@@ -20563,7 +21252,7 @@ async function recordUsage(verb, detail, where = {}) {
 init_vault();
 init_ui();
 function publishCommand() {
-  return new Command26("publish").description("publish one decision from this brain to the public layer").argument("<ref>", "handle, id, path, or exact title of the note to publish").option("--slug <name>", "the package name (default: derived from the note title)").option("--yes", "actually send it (without this, nothing leaves this machine)").option("--reason <text>", "why this is being published \u2014 the user's own words").option("--no-lineage", "do not propose lineage from what this machine has adapted").option(
+  return new Command27("publish").description("publish one decision from this brain to the public layer").argument("<ref>", "handle, id, path, or exact title of the note to publish").option("--slug <name>", "the package name (default: derived from the note title)").option("--yes", "actually send it (without this, nothing leaves this machine)").option("--reason <text>", "why this is being published \u2014 the user's own words").option("--no-lineage", "do not propose lineage from what this machine has adapted").option(
     "--bump <kind>",
     "patch | minor | major \u2014 publish the next version of a package this note already produced"
   ).option("--wait <ms>", "how long to wait for the AI review before answering (default 3000)").option("--vault <path>", "which brain to read").option("--local", "read the brain on this machine, even when signed in to a hosted one").addHelpText(
@@ -20704,7 +21393,7 @@ async function hostedAssertion(target, ref) {
   const cloud = await openCloudBrain(target);
   const found = await cloudOpen(cloud, ref, await projectAskedFrom());
   const memory = MemorySchema.safeParse(found.memory);
-  const claims = z32.array(ClaimSchema).safeParse(found.claims);
+  const claims = z33.array(ClaimSchema).safeParse(found.claims);
   if (!memory.success || !claims.success) {
     throw memgError(
       "server_refused",
@@ -20889,13 +21578,13 @@ function parseWait(raw) {
 }
 
 // src/commands/registry/adapt.ts
-import { Command as Command27 } from "commander";
+import { Command as Command28 } from "commander";
 init_errors();
 
 // src/lib/harness-context.ts
 init_brand();
-import { access, readFile as readFile22 } from "fs/promises";
-import { join as join22 } from "path";
+import { access, readFile as readFile23 } from "fs/promises";
+import { join as join23 } from "path";
 var PER_FILE_CAP = 16 * 1024;
 var TOTAL_CAP = 48 * 1024;
 var TRUNCATION_RESERVE = 64;
@@ -20940,13 +21629,13 @@ function extractHeadings(content) {
 }
 async function readHarnessContext(cwd = process.cwd(), home = agentHome()) {
   const candidates = [
-    { path: join22(cwd, "CLAUDE.md"), display: "CLAUDE.md", scope: "project" },
-    { path: join22(cwd, "AGENTS.md"), display: "AGENTS.md", scope: "project" },
-    { path: join22(cwd, "GEMINI.md"), display: "GEMINI.md", scope: "project" },
-    { path: join22(cwd, ".claude", "CLAUDE.md"), display: ".claude/CLAUDE.md", scope: "project" },
-    { path: join22(home, ".claude", "CLAUDE.md"), display: "~/.claude/CLAUDE.md", scope: "global" },
-    { path: join22(home, ".codex", "AGENTS.md"), display: "~/.codex/AGENTS.md", scope: "global" },
-    { path: join22(home, ".gemini", "GEMINI.md"), display: "~/.gemini/GEMINI.md", scope: "global" }
+    { path: join23(cwd, "CLAUDE.md"), display: "CLAUDE.md", scope: "project" },
+    { path: join23(cwd, "AGENTS.md"), display: "AGENTS.md", scope: "project" },
+    { path: join23(cwd, "GEMINI.md"), display: "GEMINI.md", scope: "project" },
+    { path: join23(cwd, ".claude", "CLAUDE.md"), display: ".claude/CLAUDE.md", scope: "project" },
+    { path: join23(home, ".claude", "CLAUDE.md"), display: "~/.claude/CLAUDE.md", scope: "global" },
+    { path: join23(home, ".codex", "AGENTS.md"), display: "~/.codex/AGENTS.md", scope: "global" },
+    { path: join23(home, ".gemini", "GEMINI.md"), display: "~/.gemini/GEMINI.md", scope: "global" }
   ];
   const files2 = [];
   let totalBytes = 0;
@@ -20954,7 +21643,7 @@ async function readHarnessContext(cwd = process.cwd(), home = agentHome()) {
     if (!await pathExists(cand.path)) continue;
     let raw;
     try {
-      raw = await readFile22(cand.path, "utf8");
+      raw = await readFile23(cand.path, "utf8");
     } catch {
       continue;
     }
@@ -21025,7 +21714,7 @@ function renderBrief(res, harness) {
   return out.join("\n");
 }
 function adaptCommand() {
-  return new Command27("adapt").description("fit a public judgment to your existing harness (prints a brief; writes nothing)").argument("<full_slug>", "package identifier {username}/{slug} or {username}/{slug}@{version}").option("--allow-pending", "allow versions whose AI review has not passed", false).option("--vault <path>", "which brain records that this was adapted").option("--local", "record it beside the brain on this machine, not the hosted one").addHelpText(
+  return new Command28("adapt").description("fit a public judgment to your existing harness (prints a brief; writes nothing)").argument("<full_slug>", "package identifier {username}/{slug} or {username}/{slug}@{version}").option("--allow-pending", "allow versions whose AI review has not passed", false).option("--vault <path>", "which brain records that this was adapted").option("--local", "record it beside the brain on this machine, not the hosted one").addHelpText(
     "after",
     "\nEnvironment:\n  KORDIS_API_URL=<url>   read from this registry instead of the linked one\n"
   ).action(async (rawSlug, opts) => {
@@ -21073,10 +21762,10 @@ function adaptCommand() {
 }
 
 // src/commands/registry/info.ts
-import { Command as Command28 } from "commander";
+import { Command as Command29 } from "commander";
 init_ui();
 function infoCommand() {
-  return new Command28("info").description("what a package in the public layer is, without reading it").argument("<full_slug>", "package identifier {username}/{slug} or {username}/{slug}@{version}").addHelpText(
+  return new Command29("info").description("what a package in the public layer is, without reading it").argument("<full_slug>", "package identifier {username}/{slug} or {username}/{slug}@{version}").addHelpText(
     "after",
     "\nEnvironment:\n  KORDIS_API_URL=<url>   ask this registry instead of the linked one\n"
   ).action(async (rawSlug) => {
@@ -21162,7 +21851,7 @@ function renderCanonical(component) {
 }
 
 // src/commands/registry/search.ts
-import { Command as Command29 } from "commander";
+import { Command as Command30 } from "commander";
 init_errors();
 init_ui();
 var SEARCHABLE_TYPES = PHASE_1_TYPES;
@@ -21170,7 +21859,7 @@ var LIMIT_MIN = 1;
 var LIMIT_MAX = 100;
 var LIMIT_DEFAULT = 20;
 function searchCommand() {
-  return new Command29("search").description("find a judgment in the public layer (titles only; nothing is read or installed)").argument("[query...]", "words to match against title and description").option("--type <type>", `narrow by kind: ${SEARCHABLE_TYPES.join("|")}`).option("--limit <n>", `how many results (${LIMIT_MIN}-${LIMIT_MAX})`, String(LIMIT_DEFAULT)).addHelpText(
+  return new Command30("search").description("find a judgment in the public layer (titles only; nothing is read or installed)").argument("[query...]", "words to match against title and description").option("--type <type>", `narrow by kind: ${SEARCHABLE_TYPES.join("|")}`).option("--limit <n>", `how many results (${LIMIT_MIN}-${LIMIT_MAX})`, String(LIMIT_DEFAULT)).addHelpText(
     "after",
     "\nEnvironment:\n  KORDIS_API_URL=<url>   search this registry instead of the linked one\n"
   ).action(async (query, opts) => {
@@ -21348,11 +22037,11 @@ function parseLimit2(raw) {
 }
 
 // src/commands/registry/pull.ts
-import { Command as Command30 } from "commander";
-import prompts3 from "prompts";
+import { Command as Command31 } from "commander";
+import prompts4 from "prompts";
 import { existsSync, lstatSync, realpathSync } from "fs";
-import { mkdir as mkdir15, readFile as readFile24, stat as stat7, writeFile as writeFile13 } from "fs/promises";
-import { dirname as dirname8, join as join24, resolve as resolve12, sep as sep3 } from "path";
+import { mkdir as mkdir16, readFile as readFile25, stat as stat8, writeFile as writeFile13 } from "fs/promises";
+import { dirname as dirname8, join as join25, resolve as resolve12, sep as sep3 } from "path";
 
 // ../../packages/translators/src/skill/identity.ts
 function buildSkillFile(input, outputPath) {
@@ -22077,17 +22766,17 @@ init_ui();
 
 // src/lib/lockfile.ts
 init_brand();
-import { copyFile, mkdir as mkdir14, readFile as readFile23, writeFile as writeFile12, constants as fsConstants } from "fs/promises";
+import { copyFile, mkdir as mkdir15, readFile as readFile24, writeFile as writeFile12, constants as fsConstants } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 function effectiveRange(entry) {
   return entry.requestedRange ?? `^${entry.version}`;
 }
 function lockfilePath() {
-  return join23(brandHome(), "installed.json");
+  return join24(brandHome(), "installed.json");
 }
 function kordisLockfilePath() {
-  return join23(process.env["KORDIS_HOME"] ?? join23(homedir4(), ".kordis"), "installed.json");
+  return join24(process.env["KORDIS_HOME"] ?? join24(homedir4(), ".kordis"), "installed.json");
 }
 function lockfileDisplayPath() {
   const path = lockfilePath();
@@ -22098,13 +22787,13 @@ async function migrateFromKordis() {
   const source = kordisLockfilePath();
   const destination = lockfilePath();
   try {
-    await mkdir14(brandHome(), { recursive: true });
+    await mkdir15(brandHome(), { recursive: true });
     await copyFile(source, destination, fsConstants.COPYFILE_EXCL);
   } catch {
     return;
   }
   try {
-    const raw = await readFile23(destination, "utf8");
+    const raw = await readFile24(destination, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.migratedFrom === void 0) {
       parsed.migratedFrom = source;
@@ -22115,18 +22804,18 @@ async function migrateFromKordis() {
 }
 async function readLockfile() {
   try {
-    return JSON.parse(await readFile23(lockfilePath(), "utf8"));
+    return JSON.parse(await readFile24(lockfilePath(), "utf8"));
   } catch {
     await migrateFromKordis();
   }
   try {
-    return JSON.parse(await readFile23(lockfilePath(), "utf8"));
+    return JSON.parse(await readFile24(lockfilePath(), "utf8"));
   } catch {
     return { packages: {} };
   }
 }
 async function writeLockfile(lf) {
-  await mkdir14(brandHome(), { recursive: true });
+  await mkdir15(brandHome(), { recursive: true });
   await writeFile12(lockfilePath(), JSON.stringify(lf, null, 2) + "\n", {
     encoding: "utf8",
     mode: 384
@@ -22134,7 +22823,7 @@ async function writeLockfile(lf) {
 }
 async function recordInstalled(fullSlug, entry) {
   const home = brandHome();
-  await withFileLock(join23(home, "installed.lock"), home, async () => {
+  await withFileLock(join24(home, "installed.lock"), home, async () => {
     const lf = await readLockfile();
     lf.packages[fullSlug] = entry;
     await writeLockfile(lf);
@@ -22197,7 +22886,7 @@ async function promptForExecutableApproval(review) {
     );
     printHuman(c.gray("  \u2500\u2500 END EXECUTABLE CONFIG \u2500\u2500"));
   }
-  const { confirmed } = await prompts3({
+  const { confirmed } = await prompts4({
     type: "confirm",
     name: "confirmed",
     message: "Install and activate these exact executable settings?",
@@ -22290,7 +22979,7 @@ async function doPullInstall(fullSlug, tool, installRoot, opts = {}) {
   );
   for (const f of translated.files) {
     const abs = safeInstallPath(installRoot, f.path);
-    await mkdir15(dirname8(abs), { recursive: true });
+    await mkdir16(dirname8(abs), { recursive: true });
     await applyEmittedFile(abs, f, fullSlug, notes);
     written.push(abs);
   }
@@ -22319,7 +23008,7 @@ async function doPullInstall(fullSlug, tool, installRoot, opts = {}) {
   };
 }
 function registryPullCommand() {
-  return new Command30("pull").description("install a package from the public layer into this project").argument(
+  return new Command31("pull").description("install a package from the public layer into this project").argument(
     "<full_slug>",
     "package identifier {username}/{slug}, optionally @{version} or @{range}"
   ).option("--tool <name>", "target tool format (default: work it out from this directory)").option("--target <path>", "install into this directory instead of the current one").option("--with-recommends", "also install recommended (depth-0) dependencies", false).option(
@@ -22446,7 +23135,7 @@ var TOOL_MARKERS = [
 async function detectTool(root) {
   for (const [path, tool] of TOOL_MARKERS) {
     try {
-      await stat7(join24(root, path));
+      await stat8(join25(root, path));
       return tool;
     } catch {
     }
@@ -22462,7 +23151,7 @@ function safeInstallPath(installRoot, relPath) {
       "Nothing was written. The package emits an absolute file path. Tell the author to publish it with relative paths only; if you did not publish it, treat it as an attempt to write outside your project."
     );
   }
-  const abs = join24(installRoot, relPath);
+  const abs = join25(installRoot, relPath);
   const resolvedRoot = resolve12(installRoot);
   const resolvedAbs = resolve12(abs);
   if (resolvedAbs !== resolvedRoot && !resolvedAbs.startsWith(resolvedRoot + sep3)) {
@@ -22528,7 +23217,7 @@ async function applyEmittedFile(abs, f, fullSlug, notes) {
   }
   let existingRaw = null;
   try {
-    existingRaw = await readFile24(abs, "utf8");
+    existingRaw = await readFile25(abs, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -22559,10 +23248,10 @@ async function applyEmittedFile(abs, f, fullSlug, notes) {
 // src/commands/registry/update.ts
 init_errors();
 init_ui();
-import { Command as Command31 } from "commander";
+import { Command as Command32 } from "commander";
 import semver2 from "semver";
 function registryUpdateCommand() {
-  return new Command31("update").description("update installed packages to their latest in-range versions").argument("[full_slug]", "package identifier {username}/{slug} (omit to update all)").option("--dry-run", "show what would be updated without doing it", false).addHelpText(
+  return new Command32("update").description("update installed packages to their latest in-range versions").argument("[full_slug]", "package identifier {username}/{slug} (omit to update all)").option("--dry-run", "show what would be updated without doing it", false).addHelpText(
     "after",
     "\nEnvironment:\n  KORDIS_API_URL=<url>   ask this registry instead of the linked one\n"
   ).action(async (fullSlugArg, opts) => {
@@ -22696,10 +23385,10 @@ function registryUpdateCommand() {
 
 // src/commands/registry/outdated.ts
 init_ui();
-import { Command as Command32 } from "commander";
+import { Command as Command33 } from "commander";
 import semver3 from "semver";
 function outdatedCommand() {
-  return new Command32("outdated").description("check installed packages for available updates").addHelpText(
+  return new Command33("outdated").description("check installed packages for available updates").addHelpText(
     "after",
     "\nEnvironment:\n  KORDIS_API_URL=<url>   ask this registry instead of the linked one\n"
   ).action(async () => {
@@ -22791,9 +23480,9 @@ function outdatedCommand() {
 // src/commands/registry/versions.ts
 init_errors();
 init_ui();
-import { Command as Command33 } from "commander";
+import { Command as Command34 } from "commander";
 function versionsCommand() {
-  return new Command33("versions").description("list every published version of a package").argument("<full_slug>", "package identifier {username}/{slug}").addHelpText(
+  return new Command34("versions").description("list every published version of a package").argument("<full_slug>", "package identifier {username}/{slug}").addHelpText(
     "after",
     "\nEnvironment:\n  KORDIS_API_URL=<url>   ask this registry instead of the linked one\n"
   ).action(async (fullSlug) => {
@@ -22857,9 +23546,9 @@ function relativeTime(isoString) {
 // src/commands/registry/diff.ts
 init_errors();
 init_ui();
-import { Command as Command34 } from "commander";
+import { Command as Command35 } from "commander";
 function diffCommand() {
-  return new Command34("diff").description("show what changed between two versions of a package").argument(
+  return new Command35("diff").description("show what changed between two versions of a package").argument(
     "<full_slug>",
     "package identifier {username}/{slug}, or {username}/{slug}@{from}..{to}"
   ).argument("[from]", "older version (omit to use the second-latest)").argument("[to]", "newer version (omit to use the latest)").addHelpText(
@@ -22936,7 +23625,7 @@ function diffCommand() {
 }
 
 // src/commands/registry/list.ts
-import { Command as Command35 } from "commander";
+import { Command as Command36 } from "commander";
 init_errors();
 init_ui();
 var SORT_KEYWORDS = ["latest", "popular", "recent", "updated", "stars", "downloads"];
@@ -22959,7 +23648,7 @@ function parseUsername(raw) {
   return parsed.data;
 }
 function listCommand() {
-  return new Command35("list").description("list packages \u2014 your own with no argument, or a public user\u2019s").argument("[username]", "whose packages to list (omit for your own)").option("--limit <n>", "maximum results per page", (v) => parseInt(v, 10), 20).option("--page <n>", "page number for your own packages (1-based)", (v) => parseInt(v, 10), 1).option("--cursor <token>", "continue a public listing from a previous result").option(
+  return new Command36("list").description("list packages \u2014 your own with no argument, or a public user\u2019s").argument("[username]", "whose packages to list (omit for your own)").option("--limit <n>", "maximum results per page", (v) => parseInt(v, 10), 20).option("--page <n>", "page number for your own packages (1-based)", (v) => parseInt(v, 10), 1).option("--cursor <token>", "continue a public listing from a previous result").option(
     "--sort <mode>",
     "latest|popular for your own; stars|downloads|recent|updated for a public listing",
     "latest"
@@ -23058,7 +23747,7 @@ init_push();
 init_src();
 init_exclude();
 init_config();
-import { Command as Command37 } from "commander";
+import { Command as Command38 } from "commander";
 import { basename as basename3, resolve as resolve13 } from "path";
 init_index_build();
 init_cloud_brain();
@@ -23067,7 +23756,7 @@ init_held_back();
 init_vault();
 init_ui();
 function recallCommand() {
-  return new Command37("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 Command38("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(
@@ -23742,13 +24431,13 @@ init_setup();
 init_ui();
 init_deadline();
 init_src();
-import { Command as Command39 } from "commander";
+import { Command as Command40 } from "commander";
 init_index_build();
 init_cloud_brain();
 init_vault();
 init_ui();
 function resurfaceCommand() {
-  return new Command39("resurface").description("what is worth having in view right now, without being asked").option("--context-dir <path>", "where the work is happening (default: cwd)").option("--limit <n>", "how many cards", (v) => parseInt(v, 10), 5).option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
+  return new Command40("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(
@@ -23975,11 +24664,11 @@ rank by project yet, so that is not one of the signals above.`
 }
 
 // src/commands/rules.ts
-import { Command as Command40 } from "commander";
+import { Command as Command41 } from "commander";
 init_cloud_brain();
 init_ui();
 function rulesCommand() {
-  return new Command40("rules").description("the user\u2019s standing decisions \u2014 what binds you here").option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
+  return new Command41("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) => {
@@ -24146,24 +24835,24 @@ init_next_step();
 init_provenance();
 import { spawn as spawn4 } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
-import { mkdir as mkdir19, open, readFile as readFile29, rename as rename5, rm as rm8, stat as stat9, unlink as unlink6, writeFile as writeFile16 } from "fs/promises";
-import { join as join31 } from "path";
-import { Command as Command41 } from "commander";
+import { mkdir as mkdir20, open, readFile as readFile30, rename as rename5, rm as rm8, stat as stat10, unlink as unlink7, writeFile as writeFile16 } from "fs/promises";
+import { join as join32 } from "path";
+import { Command as Command42 } from "commander";
 
 // src/lib/update-check.ts
 init_atomic();
 init_brand();
 import { execFile as execFile2 } from "child_process";
-import { mkdir as mkdir18, readFile as readFile28, writeFile as writeFile15 } from "fs/promises";
-import { join as join30 } from "path";
+import { mkdir as mkdir19, readFile as readFile29, writeFile as writeFile15 } from "fs/promises";
+import { join as join31 } from "path";
 import { promisify as promisify2 } from "util";
 import semver4 from "semver";
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var run2 = promisify2(execFile2);
-var PolicySchema = z33.object({
-  latest: z33.string().optional(),
-  minimum_supported: z33.string().optional(),
-  notice: z33.string().optional()
+var PolicySchema = z34.object({
+  latest: z34.string().optional(),
+  minimum_supported: z34.string().optional(),
+  notice: z34.string().optional()
 });
 var POLICY_URL = "https://memgineering.com/version-policy.json";
 var NOTICE_MAX = 300;
@@ -24228,19 +24917,19 @@ function shouldCheck(lastCheck, now) {
   if (!Number.isFinite(last)) return true;
   return now.getTime() - last > 864e5;
 }
-var UpdateStateSchema = z33.object({
-  at: z33.string(),
-  ok: z33.boolean(),
-  from: z33.string(),
-  to: z33.string().nullable(),
-  message: z33.string().nullable()
+var UpdateStateSchema = z34.object({
+  at: z34.string(),
+  ok: z34.boolean(),
+  from: z34.string(),
+  to: z34.string().nullable(),
+  message: z34.string().nullable()
 });
 function statePath() {
-  return join30(brandHome(), "update-state.json");
+  return join31(brandHome(), "update-state.json");
 }
 async function readUpdateState() {
   try {
-    const parsed = UpdateStateSchema.safeParse(JSON.parse(await readFile28(statePath(), "utf8")));
+    const parsed = UpdateStateSchema.safeParse(JSON.parse(await readFile29(statePath(), "utf8")));
     return parsed.success ? parsed.data : null;
   } catch {
     return null;
@@ -24248,7 +24937,7 @@ async function readUpdateState() {
 }
 async function writeUpdateState(state) {
   try {
-    await mkdir18(brandHome(), { recursive: true });
+    await mkdir19(brandHome(), { recursive: true });
     await writeThenRename(statePath(), `${JSON.stringify(state, null, 2)}
 `);
   } catch {
@@ -24304,7 +24993,7 @@ function shortMessage(err) {
 // src/commands/update.ts
 init_ui();
 function updateCommand() {
-  return new Command41("update").description("update memgineering itself").option("--check", "report what is available and change nothing").action(async (opts) => {
+  return new Command42("update").description("update memgineering itself").option("--check", "report what is available and change nothing").action(async (opts) => {
     const inherited = process.env[UPDATE_CLAIM_ENV] || void 0;
     try {
       await runUpdate(opts, inherited);
@@ -24360,7 +25049,7 @@ async function runUpdate(opts, inherited) {
   }
   const held = await holdUpdateSlot(inherited);
   if (held === null && await blockedBy() === "stuck") {
-    const lock = join31(brandHome(), RECLAIM_LOCK);
+    const lock = join32(brandHome(), RECLAIM_LOCK);
     const hint = `A previous update did not finish, and clearing what it left is blocked by ${lock}. If no memgineering update is running, delete that folder and run \`memgineering update\` again.`;
     printDual({
       json: { ...status, provenance: provenance.kind, updated: false, reason: "update_claim_stuck", hint },
@@ -24475,14 +25164,14 @@ function newClaimToken() {
 }
 async function claimOwner() {
   try {
-    return (await readFile29(join31(brandHome(), "update-running"), "utf8")).trim() || null;
+    return (await readFile30(join32(brandHome(), "update-running"), "utf8")).trim() || null;
   } catch {
     return null;
   }
 }
 async function releaseUpdateSlot(token) {
   if (await claimOwner() !== token) return;
-  await unlink6(join31(brandHome(), "update-running")).catch(() => void 0);
+  await unlink7(join32(brandHome(), "update-running")).catch(() => void 0);
 }
 async function holdUpdateSlot(inherited) {
   if (inherited !== void 0 && await claimOwner() === inherited) return inherited;
@@ -24494,9 +25183,9 @@ async function holdUpdateSlot(inherited) {
 var HOOK_VERBS = /* @__PURE__ */ new Set(["guard", "resurface"]);
 var UPDATE_CLAIM_MS = 15 * 6e4;
 async function claimUpdateSlot(token = newClaimToken(), hooks = {}) {
-  const path = join31(brandHome(), "update-running");
+  const path = join32(brandHome(), "update-running");
   try {
-    await mkdir19(brandHome(), { recursive: true });
+    await mkdir20(brandHome(), { recursive: true });
     const handle = await open(path, "wx");
     await handle.writeFile(`${token}
 `);
@@ -24506,12 +25195,12 @@ async function claimUpdateSlot(token = newClaimToken(), hooks = {}) {
     if (err?.code !== "EEXIST") return false;
   }
   try {
-    if (Date.now() - (await stat9(path)).mtimeMs >= UPDATE_CLAIM_MS) {
+    if (Date.now() - (await stat10(path)).mtimeMs >= UPDATE_CLAIM_MS) {
       await hooks.afterObserve?.();
       await withReclaimLock(async () => {
-        if (Date.now() - (await stat9(path)).mtimeMs < UPDATE_CLAIM_MS) return;
+        if (Date.now() - (await stat10(path)).mtimeMs < UPDATE_CLAIM_MS) return;
         await hooks.afterRecheck?.();
-        await unlink6(path);
+        await unlink7(path);
       });
     }
   } catch {
@@ -24522,10 +25211,10 @@ var RECLAIM_LOCK = "update-running.reclaim";
 var RECLAIM_LOCK_MAX_MS = 10 * 6e4;
 async function withReclaimLock(fn) {
   const home = brandHome();
-  const lock = join31(home, RECLAIM_LOCK);
-  const staging = join31(home, `${RECLAIM_LOCK}.${process.pid}.${randomBytes2(4).toString("hex")}`);
-  await mkdir19(staging, { recursive: true });
-  await writeFile16(join31(staging, "owner"), `${process.pid} ${Date.now()}
+  const lock = join32(home, RECLAIM_LOCK);
+  const staging = join32(home, `${RECLAIM_LOCK}.${process.pid}.${randomBytes2(4).toString("hex")}`);
+  await mkdir20(staging, { recursive: true });
+  await writeFile16(join32(staging, "owner"), `${process.pid} ${Date.now()}
 `);
   try {
     await rename5(staging, lock);
@@ -24543,11 +25232,11 @@ async function withReclaimLock(fn) {
 }
 async function breakAbandonedLock(lock) {
   try {
-    const seen = (await readFile29(join31(lock, "owner"), "utf8")).trim();
+    const seen = (await readFile30(join32(lock, "owner"), "utf8")).trim();
     if (!lockAbandoned(seen)) return;
     const aside = `${lock}.dead.${randomBytes2(4).toString("hex")}`;
     await rename5(lock, aside);
-    const moved = (await readFile29(join31(aside, "owner"), "utf8").catch(() => "")).trim();
+    const moved = (await readFile30(join32(aside, "owner"), "utf8").catch(() => "")).trim();
     if (moved !== seen) {
       await rename5(aside, lock).catch(() => void 0);
       return;
@@ -24571,9 +25260,9 @@ function lockAbandoned(owner, now = Date.now()) {
 }
 async function blockedBy() {
   try {
-    const old = Date.now() - (await stat9(join31(brandHome(), "update-running"))).mtimeMs >= UPDATE_CLAIM_MS;
+    const old = Date.now() - (await stat10(join32(brandHome(), "update-running"))).mtimeMs >= UPDATE_CLAIM_MS;
     if (old) {
-      await stat9(join31(brandHome(), RECLAIM_LOCK));
+      await stat10(join32(brandHome(), RECLAIM_LOCK));
       return "stuck";
     }
   } catch {
@@ -24605,16 +25294,16 @@ function reportBelowMinimum(below) {
 
 // src/commands/undo.ts
 init_src();
-import { readFile as readFile30, rm as rm9 } from "fs/promises";
-import { join as join32 } from "path";
-import { Command as Command42 } from "commander";
+import { readFile as readFile31, rm as rm9 } from "fs/promises";
+import { join as join33 } from "path";
+import { Command as Command43 } from "commander";
 init_atomic();
 init_errors();
 init_cloud_brain();
 init_vault();
 init_ui();
 function undoCommand() {
-  return new Command42("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 Command43("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({
@@ -24703,8 +25392,8 @@ ${matches.slice(0, 8).map((id) => `  ${id}`).join("\n")}${matches.length > 8 ? "
         );
       }
       const record = await withWriteLock(brain.root, async () => {
-        const absolute = join32(brain.root, target.target);
-        const current = await readFile30(absolute, "utf8").catch(() => null);
+        const absolute = join33(brain.root, target.target);
+        const current = await readFile31(absolute, "utf8").catch(() => null);
         const actualHash = current === null ? null : hashContent(current);
         if (actualHash !== target.hash_after) {
           throw memgError(
@@ -24766,7 +25455,7 @@ function minutesSince(iso) {
   return Math.max(0, Math.floor((Date.now() - at) / 6e4));
 }
 async function reverse(brain, op, current) {
-  const absolute = join32(brain.root, op.target);
+  const absolute = join33(brain.root, op.target);
   if (op.verb === "remember") {
     if (current === null) {
       throw memgError(
@@ -24823,7 +25512,7 @@ async function conflictHint(vaultRoot, op) {
 Read what it says now, then decide what should stay.`;
   const snapshot = await readSnapshot(vaultRoot, op.op_id);
   return snapshot === null ? base2 : `${base2}
-The text from before that change is still on this machine: ${join32(snapshotDir(vaultRoot), `${op.op_id}.txt`)}`;
+The text from before that change is still on this machine: ${join33(snapshotDir(vaultRoot), `${op.op_id}.txt`)}`;
 }
 
 // src/commands/brains.ts
@@ -24832,11 +25521,11 @@ init_api_client();
 init_cloud_brain();
 init_config();
 init_ui();
-import { Command as Command43 } from "commander";
+import { Command as Command44 } from "commander";
 import stringWidth from "string-width";
 var NAME_WIDTH2 = 48;
 function brainsCommand() {
-  return new Command43("brains").description("list the hosted brains on your account, and which one this machine reads").addHelpText(
+  return new Command44("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 () => {
@@ -24916,7 +25605,7 @@ init_credentials();
 init_cloud_brain();
 init_config();
 import { isAbsolute as isAbsolute5, relative as relative2, resolve as resolve16 } from "path";
-import { Command as Command44 } from "commander";
+import { Command as Command45 } from "commander";
 init_vault();
 init_ui();
 function lostDefaultLines(missing) {
@@ -24935,7 +25624,7 @@ var VIA_MEANS = {
   default: "because it is your default brain (`memgineering use --default <path>` changes it)"
 };
 function useCommand() {
-  return new Command44("use").description(
+  return new Command45("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",
@@ -25243,9 +25932,9 @@ async function pointAtHosted(named, opts, path) {
 // src/commands/whoami.ts
 init_api_client();
 init_ui();
-import { Command as Command45 } from "commander";
+import { Command as Command46 } from "commander";
 function whoamiCommand() {
-  return new Command45("whoami").description("show which account this machine is signed in as").action(async () => {
+  return new Command46("whoami").description("show which account this machine is signed in as").action(async () => {
     const base2 = apiUrl();
     const credentials = await requireCredentials(base2);
     const res = await apiRequest({
@@ -25320,7 +26009,7 @@ var NO_FLAT_ALIAS = new Set(HOMONYM_VERBS);
 // src/program.ts
 init_version();
 function buildProgram() {
-  const program = new Command46("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 Command47("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(commandPath(actionCommand), "verb");
@@ -25349,7 +26038,7 @@ function buildProgram() {
     diffCommand,
     listCommand
   ];
-  const registry = new Command46("registry").description(
+  const registry = new Command47("registry").description(
     "the public layer: find, read, adapt, publish, install and keep packages current"
   );
   for (const factory of publicLayer) registry.addCommand(factory());
@@ -25387,6 +26076,7 @@ function buildProgram() {
   program.addCommand(setupCommand());
   program.addCommand(loginCommand());
   program.addCommand(logoutCommand());
+  program.addCommand(deleteAccountCommand());
   program.addCommand(whoamiCommand());
   program.addCommand(updateCommand());
   makeParseErrorsActionable(program);
@@ -25406,6 +26096,7 @@ var WITHOUT_NEXT_STEP = /* @__PURE__ */ new Set([
   "setup",
   "login",
   "logout",
+  "delete-account",
   "whoami",
   "update",
   "guard",