memgineering 0.7.4 → 0.8.0

package/dist/index.js

@@ -15,6 +15,9 @@ import { join } from "path";
 function brandHome() {
   return process.env[BRAND.homeEnvVar] ?? join(homedir(), BRAND.homeDirName);
 }
+function agentHome() {
+  return process.env[BRAND.agentHomeEnvVar] ?? homedir();
+}
 var BRAND;
 var init_brand = __esm({
   "src/brand.ts"() {
@@ -28,6 +31,16 @@ var init_brand = __esm({
        * real `~/.memgineering`.
        */
       homeEnvVar: "MEMGINEERING_HOME",
+      /**
+       * Where `setup` installs its guidance — the AGENT tools' homes, not ours.
+       *
+       * A separate variable from `MEMGINEERING_HOME` because they are separate
+       * things: that one moves this tool's own state, and this one moves the files
+       * it writes into somebody else's `~/.claude` and `~/.codex`. Conflating them
+       * would mean anyone relocating their state dir silently stopped installing
+       * into their real agents.
+       */
+      agentHomeEnvVar: "MEMGINEERING_AGENT_HOME",
       /** Force `--json` framing without passing the flag (used by wrappers). */
       jsonEnvVar: "MEMGINEERING_JSON",
       /**
@@ -120,32 +133,46 @@ function stripControl(input) {
   let out = "";
   for (let i = 0; i < input.length; i++) {
     const code = input.charCodeAt(i);
-    if (code === 27) {
-      const next = input[i + 1];
-      if (next === "]") {
-        let j = i + 2;
-        while (j < input.length && input.charCodeAt(j) !== 7 && !(input.charCodeAt(j) === 27 && input[j + 1] === "\\")) {
-          j++;
-        }
-        if (input.charCodeAt(j) === 7) j++;
-        else if (input.charCodeAt(j) === 27) j += 2;
-        i = j - 1;
+    if (code === 27 && input[i + 1] === "]" || code === 157) {
+      const from = code === 157 ? i + 1 : i + 2;
+      let j = from;
+      while (j < input.length && input.charCodeAt(j) !== 7 && input.charCodeAt(j) !== 156 && !(input.charCodeAt(j) === 27 && input[j + 1] === "\\")) {
+        j++;
+      }
+      if (j >= input.length) {
+        i = from - 1;
         continue;
       }
-      if (next === "[") {
-        let j = i + 2;
-        while (j < input.length && !(input.charCodeAt(j) >= 64 && input.charCodeAt(j) <= 126)) {
-          j++;
-        }
+      j += input.charCodeAt(j) === 27 ? 2 : 1;
+      i = j - 1;
+      continue;
+    }
+    if (code === 27 && input[i + 1] === "[" || code === 155) {
+      const from = code === 155 ? i + 1 : i + 2;
+      let j = from;
+      while (j < input.length && input.charCodeAt(j) >= 48 && input.charCodeAt(j) <= 63) j++;
+      while (j < input.length && input.charCodeAt(j) >= 32 && input.charCodeAt(j) <= 47) j++;
+      const final = j < input.length ? input.charCodeAt(j) : -1;
+      if (final >= 64 && final <= 126) {
         i = j;
         continue;
       }
+      i = from - 1;
+      continue;
+    }
+    if (code === 27) {
       i += 1;
       continue;
     }
-    if (code <= 31 && code !== 10 && code !== 9 || code === 127) {
+    if (code === 133 || code === 8232 || code === 8233) {
+      out += "\n";
       continue;
     }
+    if (code <= 31 && code !== 10 && code !== 9 || code === 127) continue;
+    if (code >= 128 && code <= 159) continue;
+    if (code === 1564 || code === 8206 || code === 8207) continue;
+    if (code >= 8234 && code <= 8238) continue;
+    if (code >= 8294 && code <= 8297) continue;
     out += input[i];
   }
   return out;
@@ -153,6 +180,15 @@ function stripControl(input) {
 function quoteBlock(text, prefix = "> ") {
   return stripControl(text).split("\n").map((line) => prefix + line).join("\n");
 }
+function oneLine(text, max) {
+  const flat = stripControl(text).replace(/\s+/g, " ").trim();
+  const chars = [...flat];
+  if (chars.length <= max) return flat;
+  return `${chars.slice(0, Math.max(1, max - 1)).join("").trimEnd()}\u2026`;
+}
+function printBlock(text) {
+  printHuman(stripControl(text));
+}
 function progress(text) {
   if (isInteractive()) process.stderr.write(kleur.gray(`  ${text}
 `));
@@ -167,12 +203,23 @@ function undoHint(opId, vault) {
 function quoteArg(value) {
   return /^[A-Za-z0-9._\/-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
 }
-var jsonMode, c;
+var jsonMode, CONTROL_INTRODUCER, WIDTH, c;
 var init_ui = __esm({
   "src/ui.ts"() {
     "use strict";
     init_brand();
     jsonMode = false;
+    CONTROL_INTRODUCER = /[\u001b\u009b\u009d]/;
+    WIDTH = {
+      /** A brain name, a note title — a heading-shaped thing. */
+      title: 72,
+      /** A vault path. Longer, because the tail is the part that identifies it. */
+      path: 120,
+      /** An id or an `open:` handle. */
+      handle: 64,
+      /** A claim, a summary, a server hint — a sentence rather than a label. */
+      text: 200
+    };
     c = kleur;
   }
 });
@@ -969,10 +1016,12 @@ function secretContentHits(text) {
     if (pattern.test(text)) hits.push({ code });
   }
   const plain = stripMarkdownEmphasis(text);
-  if (hasLabelledCredential(text) || hasLabelledCredential(plain)) {
+  const bare = withoutIntroducers(text);
+  const bothWays = (check) => check(text) || check(plain) || bare !== text && (check(bare) || check(stripMarkdownEmphasis(bare)));
+  if (bothWays(hasLabelledCredential)) {
     hits.push({ code: "labelled_credential" });
   }
-  if (hasSpacedCredential(text) || hasSpacedCredential(plain)) {
+  if (bothWays(hasSpacedCredential)) {
     hits.push({ code: "spaced_credential" });
   }
   if (hasCredentialNearPrivateIp(text)) hits.push({ code: "credential_near_private_ip" });
@@ -1003,7 +1052,7 @@ function isExplicitlyDenied(relPath, deny = EMPTY_DENY_LIST) {
 function isNameAllowlisted(relPath, allow = EMPTY_DENY_LIST) {
   return isExplicitlyDenied(relPath, allow);
 }
-var SENSITIVE_NAME_TERMS, foldForMatch, FOLDED_TERMS, SECRET_CONTENT_PATTERNS, CREDENTIAL_LABEL, LABEL_TAIL, LABEL_QUALIFIER, SEPARATOR, HEADER_CELL_IS_LABEL, stripMarkdownEmphasis, LABELLED_CREDENTIAL_RE, SPACED_CREDENTIAL_RE, LOOKS_LIKE_A_CREDENTIAL, FINANCIAL_NUMBER_RE, SHORT_SECRET_RE, PRIVATE_IP_RE, ACCESS_WORD_RE, VALUE_IS_NOT_A_SECRET, DeniedReadError, WEAK_CODES, isWeakSecretCode, EMPTY_DENY_LIST;
+var SENSITIVE_NAME_TERMS, foldForMatch, FOLDED_TERMS, SECRET_CONTENT_PATTERNS, CREDENTIAL_LABEL, LABEL_TAIL, LABEL_QUALIFIER, SEPARATOR, HEADER_CELL_IS_LABEL, stripMarkdownEmphasis, LABELLED_CREDENTIAL_RE, SPACED_CREDENTIAL_RE, LOOKS_LIKE_A_CREDENTIAL, FINANCIAL_NUMBER_RE, SHORT_SECRET_RE, PRIVATE_IP_RE, ACCESS_WORD_RE, VALUE_IS_NOT_A_SECRET, DeniedReadError, WEAK_CODES, isWeakSecretCode, withoutIntroducers, EMPTY_DENY_LIST;
 var init_deny = __esm({
   "../../packages/storage-adapter/src/local-file/deny.ts"() {
     "use strict";
@@ -1123,6 +1172,12 @@ var init_deny = __esm({
       "credential_table"
     ]);
     isWeakSecretCode = (code) => WEAK_CODES.has(code);
+    withoutIntroducers = (text) => (
+      // `ESC [` and `ESC ]` are two characters, so removing the ESC alone would
+      // leave a bracket where the hidden byte was and the label would still not
+      // read as itself.
+      text.replace(/\u001b[[\]]?|[\u009b\u009d]/g, "")
+    );
     EMPTY_DENY_LIST = { entries: [] };
   }
 });
@@ -3129,6 +3184,7 @@ async function walkVault(root, opts = {}) {
   const files2 = [];
   const skippedSymlinks = [];
   const excluded = [];
+  const excludedDirs = [];
   const visit = async (dirAbs, relDir, depth) => {
     if (depth > maxDepth) return;
     let entries;
@@ -3146,6 +3202,7 @@ async function walkVault(root, opts = {}) {
       const isDir = entry.isDirectory();
       if (isExcluded(rel, isDir, opts.ignore)) {
         excluded.push(rel);
+        if (isDir) excludedDirs.push(rel);
         continue;
       }
       if (isDir) {
@@ -3157,7 +3214,7 @@ async function walkVault(root, opts = {}) {
   };
   await visit(rootAbs, "", 0);
   files2.sort();
-  return { files: files2, skippedSymlinks, excluded };
+  return { files: files2, skippedSymlinks, excluded, excludedDirs };
 }
 function resolveInside(root, relPath) {
   if (relPath === "" || relPath.startsWith("/") || relPath.includes("\0")) {
@@ -4399,9 +4456,11 @@ function linkCommand() {
 Nothing was indexed. This is what WOULD be stored:
 `));
             for (const r of rows) {
-              printHuman(`  ${c.bold(stripControl(r.title))}`);
-              printHuman(c.gray(`    ${stripControl(r.summary ?? "(no summary \u2014 title only)")}`));
-              printHuman(c.gray(`    from ${stripControl(r.path)}`));
+              printHuman(`  ${c.bold(oneLine(r.title, WIDTH.title))}`);
+              printHuman(
+                c.gray(`    ${oneLine(r.summary ?? "(no summary \u2014 title only)", WIDTH.text)}`)
+              );
+              printHuman(c.gray(`    from ${oneLine(r.path, WIDTH.path)}`));
             }
             printHuman(
               c.gray(`
@@ -4674,8 +4733,8 @@ Brain: ${root}`));
   if (samples.length > 0) {
     printHuman(c.gray("\n  For example, these exact lines would be stored:"));
     for (const r of samples) {
-      printHuman(c.gray(`    ${stripControl(r.title)}`));
-      printHuman(c.gray(`      ${stripControl(r.summary ?? "(no summary \u2014 title only)")}`));
+      printHuman(c.gray(`    ${oneLine(r.title, WIDTH.title)}`));
+      printHuman(c.gray(`      ${oneLine(r.summary ?? "(no summary \u2014 title only)", WIDTH.text)}`));
     }
     if (notes.length > samples.length) {
       printHuman(
@@ -4795,7 +4854,7 @@ function loginCommand() {
         },
         human: () => {
           printHuman(
-            `Already signed in${already.display_name ? ` as ${c.bold(stripControl(already.display_name))}` : ""}.`
+            `Already signed in${already.display_name ? ` as ${c.bold(oneLine(already.display_name, WIDTH.title))}` : ""}.`
           );
           printHuman(c.gray("  `memgineering logout` first if you want a different account."));
         }
@@ -4868,13 +4927,13 @@ function emit(pending, ctx) {
     },
     human: () => {
       printHuman("Show this code to whoever is signing in:\n");
-      printHuman(`  ${c.bold().yellow(stripControl(pending.user_code))}
+      printHuman(`  ${c.bold().yellow(oneLine(pending.user_code, WIDTH.handle))}
 `);
       if (ctx.opened) {
         printHuman("Opened the approval page in your browser.");
       } else {
         printHuman("Open this to approve:\n");
-        printHuman(`  ${c.cyan(stripControl(pending.verification_url))}`);
+        printHuman(`  ${c.cyan(oneLine(pending.verification_url, WIDTH.path))}`);
       }
       printHuman(
         c.gray(
@@ -4882,7 +4941,7 @@ function emit(pending, ctx) {
         )
       );
       if (ctx.opened && ctx.showUrl) {
-        printHuman(c.gray(`  ${stripControl(pending.verification_url)}`));
+        printHuman(c.gray(`  ${oneLine(pending.verification_url, WIDTH.path)}`));
       }
       printHuman(
         c.gray(
@@ -4924,7 +4983,7 @@ async function waitForApproval(pending, base) {
         human: () => {
           printHuman(
             `
-Signed in${claimed.display_name ? ` as ${c.bold(stripControl(claimed.display_name))}` : ""}.`
+Signed in${claimed.display_name ? ` as ${c.bold(oneLine(claimed.display_name, WIDTH.title))}` : ""}.`
           );
           printHuman(c.gray("  The token is stored on this machine only, readable by you alone."));
         }
@@ -5025,17 +5084,19 @@ function printSignInStep(step) {
   switch (step.status) {
     case "signed-in":
       printHuman(
-        c.gray(`  signed in${step.displayName ? ` as ${stripControl(step.displayName)}` : ""}
-`)
+        c.gray(
+          `  signed in${step.displayName ? ` as ${oneLine(step.displayName, WIDTH.title)}` : ""}
+`
+        )
       );
       return;
     case "started":
       printHuman("Show this code to whoever is signing in:\n");
-      printHuman(`  ${c.bold().yellow(stripControl(step.userCode))}
+      printHuman(`  ${c.bold().yellow(oneLine(step.userCode, WIDTH.handle))}
 `);
       printHuman(
         step.opened ? c.gray("  The approval page is open in the browser.") : `Open this to approve:
-  ${c.cyan(stripControl(step.verificationUrl))}`
+  ${c.cyan(oneLine(step.verificationUrl, WIDTH.path))}`
       );
       printHuman(
         c.gray("  Not waiting \u2014 setup carries on, and the next command collects the token.\n")
@@ -5043,12 +5104,14 @@ function printSignInStep(step) {
       return;
     case "pending":
       printHuman(
-        c.gray(`  a sign-in is waiting for approval \u2014 code ${stripControl(step.userCode)}
-`)
+        c.gray(
+          `  a sign-in is waiting for approval \u2014 code ${oneLine(step.userCode, WIDTH.handle)}
+`
+        )
       );
       return;
     case "unavailable":
-      printHuman(c.yellow(`  Could not start a sign-in: ${stripControl(step.because)}`));
+      printHuman(c.yellow(`  Could not start a sign-in: ${oneLine(step.because, WIDTH.text)}`));
       printHuman(c.gray("  Setup continues \u2014 an account is not needed for any of it.\n"));
       return;
     case "would-start":
@@ -7356,11 +7419,11 @@ var init_setup_web = __esm({
 // src/commands/setup.ts
 import { createHash as createHash8 } from "crypto";
 import { access, mkdir as mkdir13, readFile as readFile19 } from "fs/promises";
-import { homedir as homedir4 } from "os";
 import { dirname as dirname5, join as join19 } from "path";
 import { fileURLToPath } from "url";
 import { Command as Command22 } from "commander";
 import prompts3 from "prompts";
+import { homedir as homedir4 } from "os";
 function setupCommand() {
   return new Command22("setup").description("install into your agents, and point at a brain (--dry-run to only report)").option("--agent", "non-interactive: take every answer from flags").option("--human", "interactive: choose from a list").option("--web", "open a screen in the browser and answer it there").option("--print-url", "with --web: print the URL instead of opening a browser").option(
     "--tools <list>",
@@ -7432,6 +7495,18 @@ function setupCommand() {
         ...signInStepJson(signIn),
         defaults_used: defaultsTaken,
         dry_run: opts.dryRun === true,
+        /*
+         * The home these paths are relative TO, and it is only here when it
+         * is not the ordinary one.
+         *
+         * Every path in `changes` is reported relative to the home being
+         * installed into, so `.claude/skills/…` names a file without saying
+         * whose. That ambiguity is why an agent writing into a real machine
+         * from inside a sandbox had nothing in front of it that looked
+         * wrong. Present only when scoped, so the common case stays quiet
+         * and the unusual one cannot be mistaken for it.
+         */
+        ...agentHome() !== homedir4() ? { agent_home: agentHome() } : {},
         tools: choice.tools.map((t) => t.id),
         auto_update: choice.autoUpdate,
         hook: choice.hook,
@@ -7455,9 +7530,27 @@ function setupCommand() {
         if (opts.silent && changed.length === 0) return;
         if (opts.dryRun) {
           printSignInStep(signIn);
-          printHuman(`Would change ${changed.length} file(s):
+          if (changed.length === 0) {
+            printHuman(
+              `Nothing to change \u2014 ${choice.tools.map((t) => t.label).join(", ")} ${choice.tools.length === 1 ? "is" : "are"} already up to date.
+`
+            );
+            printHuman(
+              c.gray(
+                `  ${results.length} file(s) checked. Run without \`--dry-run\` to reinstall them anyway.`
+              )
+            );
+            return;
+          }
+          printHuman(`Would change ${changed.length} of ${results.length} file(s):
 `);
           for (const r of changed) printHuman(c.gray(`  ${r.tool} \xB7 ${r.what}`));
+          printHuman(
+            c.gray(
+              `
+  The rest are already up to date. Tools found: ${choice.tools.map((t) => t.label).join(", ")}.`
+            )
+          );
           return;
         }
         printSignInStep(signIn);
@@ -7558,7 +7651,7 @@ async function applySetup(choice, dryRun) {
   const hub = await loadAsset(BRAND.hubFileName);
   const installed = { ...(await loadConfig()).system.installed };
   const mark = (path, hash) => {
-    const key2 = path.startsWith(homedir4()) ? path.slice(homedir4().length + 1) : path;
+    const key2 = path.startsWith(agentHome()) ? path.slice(agentHome().length + 1) : path;
     installed[key2] = hash;
   };
   const persist = async () => {
@@ -7570,11 +7663,11 @@ async function applySetup(choice, dryRun) {
     });
   };
   const wasEdited = (path, onDisk) => {
-    const key2 = path.startsWith(homedir4()) ? path.slice(homedir4().length + 1) : path;
+    const key2 = path.startsWith(agentHome()) ? path.slice(agentHome().length + 1) : path;
     const known = installed[key2];
     return known !== void 0 && onDisk !== null && fingerprint(onDisk) !== known;
   };
-  const keyOf = (path) => path.startsWith(homedir4()) ? path.slice(homedir4().length + 1) : path;
+  const keyOf = (path) => path.startsWith(agentHome()) ? path.slice(agentHome().length + 1) : path;
   try {
     return await write();
   } finally {
@@ -7582,7 +7675,7 @@ async function applySetup(choice, dryRun) {
   }
   async function write() {
     for (const tool of choice.tools) {
-      const hubPath = join19(homedir4(), tool.hubFile);
+      const hubPath = join19(agentHome(), tool.hubFile);
       const written = await injectBlock(
         hubPath,
         hub + tailFor(tool),
@@ -7598,7 +7691,7 @@ async function applySetup(choice, dryRun) {
       if (!dryRun && written.after !== null) mark(hubPath, written.after);
       for (const skill of BRAND.subSkills) {
         const content = await loadAsset(join19(skill, "SKILL.md"));
-        const path = join19(homedir4(), tool.skillsDir, skill, "SKILL.md");
+        const path = join19(agentHome(), tool.skillsDir, skill, "SKILL.md");
         const out = await writeIfDifferent(path, content, dryRun);
         results.push({
           tool: tool.label,
@@ -7668,7 +7761,7 @@ async function resolveMode(opts) {
   return { kind: mode ?? "agent", chosen: mode !== void 0 };
 }
 async function detectTools() {
-  const home = homedir4();
+  const home = agentHome();
   const found = [];
   for (const tool of TOOLS) {
     if (await exists2(join19(home, tool.dir))) found.push(tool);
@@ -7801,7 +7894,7 @@ async function writeIfDifferent(filePath, content, dryRun) {
   return { outcome: existing === null ? "injected" : "updated", before: existing, after };
 }
 async function installHook(spec, tool, dryRun) {
-  const settingsPath = join19(homedir4(), ...(tool.hooksFile ?? "").split("/"));
+  const settingsPath = join19(agentHome(), ...(tool.hooksFile ?? "").split("/"));
   const raw = await readFile19(settingsPath, "utf8").catch(() => null);
   let settings = {};
   if (raw !== null) {
@@ -7851,7 +7944,7 @@ async function installHook(spec, tool, dryRun) {
   return raw === null ? "injected" : "updated";
 }
 async function removeHook(spec, tool, dryRun) {
-  const settingsPath = join19(homedir4(), ...(tool.hooksFile ?? "").split("/"));
+  const settingsPath = join19(agentHome(), ...(tool.hooksFile ?? "").split("/"));
   const raw = await readFile19(settingsPath, "utf8").catch(() => null);
   if (raw === null) return "unchanged";
   let parsed;
@@ -8062,7 +8155,7 @@ For a guide: put ${BRAND.hubMarkerStart} and ${BRAND.hubMarkerEnd} back around t
 });
 
 // src/program.ts
-import { Command as Command27 } from "commander";
+import { Command as Command28 } from "commander";
 
 // src/help.ts
 init_ui();
@@ -8086,7 +8179,7 @@ var COMMAND_GROUPS = [
   {
     title: "ACCOUNT",
     blurb: "optional \u2014 connect a hosted brain; everything above works without it",
-    commands: ["login", "logout", "whoami", "push", "pull"]
+    commands: ["login", "logout", "whoami", "brains", "push", "pull"]
   },
   {
     title: "SYSTEM",
@@ -8099,7 +8192,12 @@ var ENV_ROWS = [
   ["MEMGINEERING_HOME=<dir>", "state + derived index (default: ~/.memgineering)"],
   ["MEMGINEERING_JSON=1", "force --json framing without the flag"],
   ["MEMGINEERING_NO_UPDATE=1", "skip the update check for this run"],
-  ["MEMGINEERING_API_URL=<url>", "hosted brain server (default: https://api.memgineering.com)"]
+  ["MEMGINEERING_API_URL=<url>", "hosted brain server (default: https://api.memgineering.com)"],
+  // The one that keeps `setup` off a real machine, and it was missing from this
+  // list while the other four were here. An agent testing this CLI in a sandbox
+  // had no documented handle for where `setup` writes — which is how one of them
+  // overwrote the live skill files of the session testing it.
+  ["MEMGINEERING_AGENT_HOME=<dir>", "where `setup` installs (default: your home)"]
 ];
 function commandLabel(sub) {
   const args = sub.registeredArguments.map((a) => a.required ? `<${a.name()}>` : `[${a.name()}]`).join(" ");
@@ -8252,12 +8350,13 @@ var cloudRules = (brain, args = {}) => call(brain, "POST", "/rules", {
 var cloudReindex = (brain, args = {}) => call(brain, "POST", "/reindex", {
   ...args.rebuild === true ? { rebuild: true } : {}
 });
-async function listCloudBrains(token, baseUrl) {
+async function listCloudBrains(token, baseUrl, opts = {}) {
   const res = await apiRequest({
     method: "GET",
     path: "/v1/brains",
     token,
-    baseUrl
+    baseUrl,
+    ...opts.retries === void 0 ? {} : { retries: opts.retries }
   });
   return res.body?.brains ?? [];
 }
@@ -8275,6 +8374,125 @@ async function createCloudBrain(token, baseUrl, name) {
 // src/commands/brain-admin.ts
 init_config();
 
+// src/lib/held-back.ts
+init_ui();
+var isNote = (p) => /\.(md|markdown)$/i.test(p);
+function heldBack(scan) {
+  const denied = scan.denied ?? [];
+  const byName = denied.filter((d) => d.kind === "name" && isNote(d.path)).map((d) => ({ path: d.path, term: d.term }));
+  const explicitly = denied.filter((d) => d.kind === "explicit" && isNote(d.path)).map((d) => d.path);
+  const byRule = scan.excluded.filter(isNote);
+  const symlinked = scan.skippedSymlinks.filter(isNote);
+  return {
+    total: byName.length + explicitly.length + byRule.length + symlinked.length,
+    folders: scan.excludedDirs ?? [],
+    byName,
+    explicitly,
+    byRule,
+    symlinked
+  };
+}
+function heldBackJson(held, totalKey = "not_sent") {
+  return {
+    // The count's key is the caller's, because `not_sent` is a claim about
+    // sending and `reindex` sends nothing. Naming its total `not_sent` would
+    // have an agent reporting a failed upload from a command that never
+    // contacts a server. `push` keeps the key it has always emitted.
+    [totalKey]: held.total,
+    denied_by_name: held.byName,
+    denied_explicitly: held.explicitly,
+    excluded_by_rule: held.byRule,
+    skipped_symlinks: held.symlinked,
+    // Present so a zero total can be read correctly. A non-empty list here means
+    // the count above is a floor, not the answer — nothing inside these was
+    // walked, so nobody knows how many notes they hold.
+    excluded_folders: held.folders
+  };
+}
+var NAME_GUESS_LABEL = "name looks private";
+function heldBackGroups(held) {
+  return [
+    {
+      label: NAME_GUESS_LABEL,
+      rows: held.byName.map((d) => ({ path: d.path, detail: `matched "${d.term ?? "?"}"` }))
+    },
+    { label: "listed in .memgdeny", rows: held.explicitly.map((p) => ({ path: p, detail: null })) },
+    { label: "excluded by a rule", rows: held.byRule.map((p) => ({ path: p, detail: null })) },
+    {
+      label: "a symlink, which is never followed",
+      rows: held.symlinked.map((p) => ({ path: p, detail: null }))
+    }
+  ];
+}
+function describeHeldBack(held) {
+  return [
+    ...heldBackGroups(held).flatMap(
+      ({ label, rows }) => rows.map(
+        (r) => `${oneLine(r.path, WIDTH.path)}  \u2014 ${label}${r.detail === null ? "" : ` (${oneLine(r.detail, WIDTH.text)})`}`
+      )
+    ),
+    ...held.folders.map(
+      (dir) => `${oneLine(dir, WIDTH.path)}/  \u2014 an excluded folder, whose contents were never walked`
+    )
+  ];
+}
+function printHeldBack(held, wording) {
+  if (held.total === 0 && held.folders.length === 0) return;
+  const guessed = held.byName;
+  const chosen = heldBackGroups(held).filter(({ label }) => label !== NAME_GUESS_LABEL);
+  const chosenCount = chosen.reduce((n, g) => n + g.rows.length, 0);
+  if (chosenCount > 0 || held.folders.length > 0) {
+    printHuman(
+      c.gray(
+        chosenCount === 0 ? `
+Some notes are not in ${wording.where}, because your rules say so:` : `
+${chosenCount} note(s) are not in ${wording.where}, because your rules say so:`
+      )
+    );
+    for (const { label, rows } of chosen) {
+      if (rows.length === 0) continue;
+      printHuman(c.gray(`  ${rows.length} \u2014 ${label}:`));
+      for (const r of rows.slice(0, 10)) printHuman(c.gray(`    ${oneLine(r.path, WIDTH.path)}`));
+      if (rows.length > 10) printHuman(c.gray(`    \u2026 and ${rows.length - 10} more`));
+    }
+    if (held.folders.length > 0) {
+      printHuman(
+        c.gray(
+          `  ${held.folders.length} excluded folder(s) \u2014 their contents were not walked, so notes
+  inside them are not counted above:`
+        )
+      );
+      for (const dir of held.folders.slice(0, 10))
+        printHuman(c.gray(`    ${oneLine(dir, WIDTH.path)}/`));
+      if (held.folders.length > 10) {
+        printHuman(c.gray(`    \u2026 and ${held.folders.length - 10} more`));
+      }
+    }
+  }
+  if (guessed.length > 0) {
+    printHuman(
+      c.yellow(
+        `
+\u26A0 ${guessed.length} note(s) are not in ${wording.where}, held back on this machine by a GUESS about the name:`
+      )
+    );
+    for (const d of guessed.slice(0, 10)) {
+      printHuman(
+        c.gray(
+          `    ${oneLine(d.path, WIDTH.path)}  (matched "${oneLine(d.term ?? "?", WIDTH.title)}")`
+        )
+      );
+    }
+    if (guessed.length > 10) printHuman(c.gray(`    \u2026 and ${guessed.length - 10} more`));
+    printHuman(
+      c.gray(
+        `  This may be a false alarm \u2014 rename the note, or list it in .memgallow,
+  and ${wording.retry}.`
+      )
+    );
+  }
+}
+
 // src/lib/ledger.ts
 init_deny();
 init_brand();
@@ -8311,13 +8529,13 @@ function isOpaqueId(id) {
   return id.length === OPAQUE_ID_LENGTH && /^[0-9ABCDEFGHJKMNPQRSTVWXYZ]+$/.test(id);
 }
 function displayHandle(id, allIds) {
-  if (!isOpaqueId(id)) return stripControl(id);
+  if (!isOpaqueId(id)) return oneLine(id, WIDTH.handle);
   for (let len = MIN_HANDLE_LENGTH; len < id.length; len++) {
     const prefix = id.slice(0, len);
     const matches = allIds.filter((other) => other.startsWith(prefix));
     if (matches.length === 1) return prefix;
   }
-  return stripControl(id);
+  return oneLine(id, WIDTH.handle);
 }
 function matchIds(ref, allIds) {
   const exact = allIds.filter((id) => id === ref);
@@ -8413,6 +8631,13 @@ var RULE_VERSION = 2;
 var RATIONALE_MAX = 500;
 function sanitizeRationale(raw) {
   if (raw == null) return null;
+  if (CONTROL_INTRODUCER.test(raw)) {
+    throw memgError(
+      "invalid_input",
+      "the reason contains a terminal control sequence",
+      "Nothing was saved. The text carries invisible formatting \u2014 usually from pasting out of a terminal, a chat window, or a file that was decoded wrongly \u2014 and stored prose that hides characters can read as something other than what it says. Type the same words in again as plain text and run it once more. Keep --reason: the reason is the part of a memory that still means anything later."
+    );
+  }
   const clean = stripControl(raw).trim();
   if (clean === "") return null;
   const hits = secretContentHits(clean);
@@ -8537,14 +8762,83 @@ init_api_client();
 init_credentials();
 init_pending_login();
 init_config();
+init_ui();
 init_vault();
 async function resolveTarget(opts = {}) {
   if (opts.local !== true) {
     const cloud = await cloudTarget();
-    if (cloud) return cloud;
+    if (cloud && cloud.kind === "cloud") {
+      if (opts.vault !== void 0) {
+        throw memgError(
+          "invalid_input",
+          `\`--vault\` names a folder on this machine, and this machine reads the hosted brain \`${oneLine(cloud.name, 72)}\``,
+          `Nothing was read from \`${oneLine(opts.vault, 120)}\`, and nothing was changed.
+
+To read that folder just this once:  add \`--local\`
+To change which hosted brain this machine reads:  \`memgineering use --brain <name>\`
+
+This used to answer from the hosted brain without saying so, so a check of one
+brain silently reported another.`
+        );
+      }
+      return cloud;
+    }
+  }
+  try {
+    const { brain, via } = await resolveBrain(opts.vault);
+    return { kind: "local", brain, via };
+  } catch (err) {
+    if (!isNoVaultLinked(err) || opts.local === true) throw err;
+    throw await accountAwareRefusal() ?? err;
+  }
+}
+var isNoVaultLinked = (err) => typeof err === "object" && err !== null && err.code === "no_vault_linked";
+async function accountAwareRefusal() {
+  try {
+    const base = apiUrl();
+    const credentials = await readCredentials();
+    if (!credentials || credentials.api_url !== base) {
+      const cloud = (await loadConfig()).brain.cloud;
+      if (!cloud || cloud.api_url !== base) return null;
+      return memgError(
+        "not_signed_in",
+        `this machine is signed out of \`${oneLine(cloud.name, 72)}\``,
+        "Your notes are on that account \u2014 nothing is lost, and nothing here needs creating.\n\nSign back in:  `memgineering login`\n\nDo NOT run `init` or `link` to fix this. They make a NEW empty brain on this\nmachine and leave the notes where they are."
+      );
+    }
+    const brains = await listCloudBrains(credentials.token, base, { retries: 0 });
+    if (brains.length === 0) return null;
+    const names = brains.map((b) => `  ${oneLine(b.name, 72)}`).join("\n");
+    return memgError(
+      "no_vault_linked",
+      "this machine is not pointed at any brain yet",
+      `Your notes are on your account \u2014 nothing is lost, and nothing here needs creating.
+This account holds:
+${names}
+
+Point at one:  \`memgineering use --brain <name>\`
+
+Do NOT run \`init\` or \`link\` to fix this. They make a NEW empty brain on this
+machine, which leaves the notes above exactly where they are and adds an empty
+notebook that looks like the answer.`
+    );
+  } catch (err) {
+    if (err instanceof MemgError && err.code !== "server_unreachable") {
+      return memgError(
+        "not_signed_in",
+        "this machine cannot read the account it is signed in to",
+        `The server refused: ${oneLine(err.message, 120)}
+
+Your notes are on that account \u2014 nothing is lost, and nothing here needs creating.
+
+Sign in again:  \`memgineering login\`
+
+Do NOT run \`init\` or \`link\` to fix this. They make a NEW empty brain on this
+machine and leave the notes where they are.`
+      );
+    }
+    return null;
   }
-  const { brain, via } = await resolveBrain(opts.vault);
-  return { kind: "local", brain, via };
 }
 async function hostedPointer() {
   const base = apiUrl();
@@ -8603,14 +8897,17 @@ function reindexCommand() {
       protectedVault: true
     });
     const scan = await adapter.scan();
-    const nameDenied = (scan.denied ?? []).filter((d) => d.kind !== "explicit");
+    const held = heldBack(scan);
     printDual({
       json: {
         brain: brain.root,
         indexed: built.entries.length,
         cache_dir: built.cacheDir,
         issues: built.issues,
-        denied_by_name: nameDenied.map((d) => ({ path: d.path, term: d.term })),
+        // Carries `denied_by_name` under the key it always had, plus the three
+        // this command used to drop. The total is `not_indexed` rather than
+        // push's `not_sent`: nothing is sent from here.
+        ...heldBackJson(held, "not_indexed"),
         denied_by_content: built.denied.filter((d) => d.reason === "content")
       },
       human: () => {
@@ -8623,14 +8920,23 @@ function reindexCommand() {
             )
           );
         }
+        printHeldBack(held, { where: "the index", retry: "reindex" });
         const byContent = built.denied.filter((d) => d.reason === "content");
-        for (const [label, rows] of [
-          ["name looks private", nameDenied.map((d) => `${d.path}  (matched "${d.term}")`)],
-          ["content looks like a credential", byContent.map((d) => `${d.path}  (${d.detail})`)]
-        ]) {
-          if (rows.length === 0) continue;
-          printHuman(c.yellow(`  ${rows.length} note(s) refused \u2014 ${label}:`));
-          for (const row of rows.slice(0, 10)) printHuman(c.gray(`    ${row}`));
+        if (byContent.length > 0) {
+          printHuman(
+            c.yellow(
+              `
+\u26A0 ${byContent.length} note(s) refused \u2014 content looks like a credential:`
+            )
+          );
+          for (const d of byContent.slice(0, 10)) {
+            printHuman(
+              c.gray(`    ${oneLine(d.path, WIDTH.path)}  (${oneLine(d.detail, WIDTH.text)})`)
+            );
+          }
+          if (byContent.length > 10) {
+            printHuman(c.gray(`    \u2026 and ${byContent.length - 10} more`));
+          }
         }
       }
     });
@@ -8647,7 +8953,7 @@ async function reindexHosted(target, rebuild) {
     // route documents, spelled the way the route spells it.
     json: { brain: { hosted: true, name: target.name }, ...answered },
     human: () => {
-      printHuman(`Reindexed ${stripControl(target.name)}.
+      printHuman(`Reindexed ${oneLine(target.name, WIDTH.title)}.
 `);
       if (lexical === void 0) {
         printHuman(c.yellow("\u26A0 this brain\u2019s server did not report the card index"));
@@ -8685,7 +8991,7 @@ async function reindexHosted(target, rebuild) {
       if (answered.usable === false) {
         printHuman(
           c.yellow(
-            `  \u26A0 vector search is off for this brain (${stripControl(answered.unusable_reason ?? "reason not given")})`
+            `  \u26A0 vector search is off for this brain (${oneLine(answered.unusable_reason ?? "reason not given", WIDTH.text)})`
           )
         );
       }
@@ -8704,7 +9010,7 @@ function printFailures(failed, failures) {
   for (const failure of (failures ?? []).slice(0, 3)) {
     printHuman(
       c.gray(
-        `    ${stripControl(failure.path)}  (${stripControl(failure.kind)}: ${stripControl(failure.detail)})`
+        `    ${oneLine(failure.path, WIDTH.path)}  (${oneLine(failure.kind, WIDTH.title)}: ${oneLine(failure.detail, WIDTH.text)})`
       )
     );
   }
@@ -8721,18 +9027,39 @@ function nextStep(stopReason) {
     case "unusable_index":
       return "This brain holds vectors of more than one width, so none of them can be compared. `memgineering reindex --rebuild` re-derives them from the model as it is configured now.";
     default:
-      return `The server stopped for \`${stripControl(stopReason)}\`, which this version has no next step for. Running \`memgineering reindex\` again is safe.`;
+      return `The server stopped for \`${oneLine(stopReason, WIDTH.title)}\`, which this version has no next step for. Running \`memgineering reindex\` again is safe.`;
   }
 }
 function unlinkCommand() {
-  return new Command2("unlink").description("stop reading a brain \u2014 your notes are not touched").argument("[path]", "which brain (default: the one this folder resolves to)").option("--purge", "also delete the local index, event log and undo snapshots").action(async (path, opts) => {
-    const { brain } = await resolveBrain(path);
+  return new Command2("unlink").description("stop reading a brain \u2014 your notes are not touched").argument("[path]", "which brain (default: the one this folder resolves to)").option("--brain", "stop reading the HOSTED brain instead of a folder on this disk").option("--purge", "also delete the local index, event log and undo snapshots").action(async (path, opts) => {
+    if (opts.brain === true) {
+      await stopReadingHosted(path);
+      return;
+    }
+    const hostedNow = await hostedPointer();
+    const linkedNow = (await loadConfig()).brain.brains;
+    if (hostedNow && linkedNow.length === 0) {
+      throw memgError(
+        "invalid_input",
+        `nothing is linked on this disk \u2014 this machine reads the hosted brain "${oneLine(hostedNow.name, 72)}"`,
+        "Nothing was changed, and nothing here creates a brain.\n`memgineering unlink --brain` stops reading the hosted one.\n`memgineering link <folder>` adds notes on this disk alongside it."
+      );
+    }
+    const { brain } = await resolveBrain(path).catch(async (err) => {
+      await resolveTarget({});
+      throw err;
+    });
     const cfg = await loadConfig();
     const remaining = cfg.brain.brains.filter((b) => b.root !== brain.root);
     const nextDefault = cfg.brain.default === brain.root ? remaining[0]?.root : cfg.brain.default;
+    const { default: _dropped, ...restOfBrain } = cfg.brain;
     await saveConfig({
       ...cfg,
-      brain: { brains: remaining, ...nextDefault ? { default: nextDefault } : {} }
+      brain: {
+        ...restOfBrain,
+        brains: remaining,
+        ...nextDefault === void 0 ? {} : { default: nextDefault }
+      }
     });
     if (opts.purge) {
       await clearCache(cacheDirFor(brain.root, brandHome()));
@@ -8820,6 +9147,54 @@ async function readLines(root, name) {
   const raw = await readFile10(join10(root, name), "utf8").catch(() => "");
   return raw.split("\n").map((l) => l.replace(/\r$/, "").trim()).filter((l) => l !== "" && !l.startsWith("#"));
 }
+async function stopReadingHosted(path) {
+  if (path !== void 0) {
+    throw memgError(
+      "invalid_input",
+      "`unlink --brain` does not take a path",
+      "It clears the one hosted brain this machine reads, which is a single setting for the whole machine. To unlink a folder on this disk, run `memgineering unlink <path>` without `--brain`."
+    );
+  }
+  const cfg = await loadConfig();
+  const previous = cfg.brain.cloud ?? null;
+  if (previous === null) {
+    throw memgError(
+      "invalid_input",
+      "this machine is not reading a hosted brain",
+      "Nothing was changed. `memgineering brains` lists what the account holds, and `memgineering use --brain <name>` points at one."
+    );
+  }
+  await saveConfig({
+    ...cfg,
+    // Rebuilt without `cloud` rather than set to undefined, so what lands on
+    // disk is a config with no such key rather than one asserting null.
+    brain: {
+      brains: cfg.brain.brains,
+      ...cfg.brain.default === void 0 ? {} : { default: cfg.brain.default }
+    }
+  });
+  printDual({
+    json: {
+      stopped_reading: { id: previous.id, name: previous.name, api_url: previous.api_url },
+      remaining_local: cfg.brain.brains.length
+    },
+    human: () => {
+      printHuman(`No longer reading \`${oneLine(previous.name, 72)}\`.
+`);
+      printHuman(
+        c.gray(
+          "  Nothing on the server was touched \u2014 the brain, its notes and its ledger\n  are exactly where they were. `memgineering use --brain <name>` points back."
+        )
+      );
+      if (cfg.brain.brains.length === 0) {
+        printHuman(
+          c.yellow("\n  No brain is linked on this disk either, so nothing answers here now.")
+        );
+        printHuman(c.gray("  `memgineering link <folder>` connects notes you already have."));
+      }
+    }
+  });
+}
 
 // src/commands/consolidate.ts
 init_src();
@@ -9117,17 +9492,23 @@ function openCommand() {
             brain: { hosted: true, name: target.name }
           },
           human: () => {
-            printHuman(`## ${stripControl(String(found.memory["title"] ?? found.path))}
-`);
+            printHuman(
+              `## ${oneLine(String(found.memory["title"] ?? found.path), WIDTH.title)}
+`
+            );
             const summary = found.memory["summary"];
             if (typeof summary === "string" && summary !== "") {
-              printHuman(`> ${stripControl(summary)}
+              printHuman(`> ${oneLine(summary, WIDTH.text)}
 `);
             }
-            printHuman(c.gray(`${stripControl(found.path)}  \xB7  ${stripControl(target.name)}`));
+            printHuman(
+              c.gray(
+                `${oneLine(found.path, WIDTH.path)}  \xB7  ${oneLine(target.name, WIDTH.title)}`
+              )
+            );
             if (detail !== "card" && found.body !== "") {
-              printHuman(`
-${stripControl(found.body)}`);
+              printHuman("\n");
+              printBlock(found.body);
             }
           }
         });
@@ -9164,7 +9545,7 @@ ${stripControl(found.body)}`);
           ...stage
         },
         human: () => {
-          printHuman(`## ${stripControl(entry.memory.title)}
+          printHuman(`## ${oneLine(entry.memory.title, WIDTH.title)}
 `);
           if (scaffolding) {
             printHuman(
@@ -9177,13 +9558,17 @@ ${stripControl(found.body)}`);
           }
           printHuman(
             `
-\`id: ${stripControl(entry.memory.id)}\`  \xB7  \`${stripControl(entry.path)}\`
+\`id: ${oneLine(entry.memory.id, WIDTH.handle)}\`  \xB7  \`${oneLine(entry.path, WIDTH.path)}\`
 `
           );
           if (entry.memory.summary) printHuman(quoteBlock(entry.memory.summary) + "\n");
           for (const claim of claims) {
-            printHuman(`- ${stripControl(claim.text)}`);
-            printHuman(c.gray(stripControl(`  ${claim.confidence} \xB7 ${claim.status}`)));
+            printHuman(`- ${oneLine(claim.text, WIDTH.text)}`);
+            printHuman(
+              c.gray(
+                `  ${oneLine(claim.confidence, WIDTH.title)} \xB7 ${oneLine(claim.status, WIDTH.title)}`
+              )
+            );
           }
           if (claims.length === 0 && scaffolding) {
             printHuman(
@@ -9214,13 +9599,14 @@ makes the two surface together as a conflict.`
           }
           if (stage.outline && stage.outline.length > 0) {
             printHuman("\n### sections\n");
-            for (const heading of stage.outline) printHuman(`- ${stripControl(heading)}`);
+            for (const heading of stage.outline)
+              printHuman(`- ${oneLine(heading, WIDTH.title)}`);
             printHuman("");
           }
           if (stage.sections) {
             for (const section of stage.sections) {
               printHuman(`
-### ${stripControl(section.label)}
+### ${oneLine(section.label, WIDTH.title)}
 `);
               printHuman(quoteBlock(section.body));
             }
@@ -9780,11 +10166,11 @@ To see what is there now: \`memgineering open ` + ref + "`"
           after: preview.after
         },
         human: () => {
-          printHuman(`## revise (dry run): ${stripControl(entry.memory.title)}
+          printHuman(`## revise (dry run): ${oneLine(entry.memory.title, WIDTH.title)}
 `);
-          printHuman(`\`${stripControl(entry.path)}\`
+          printHuman(`\`${oneLine(entry.path, WIDTH.path)}\`
 `);
-          printHuman(stripControl(renderDiff(preview.before, preview.after)));
+          printBlock(renderDiff(preview.before, preview.after));
           printHuman(c.gray("\nNothing was written. Drop --dry-run to apply."));
         }
       });
@@ -9844,10 +10230,10 @@ To see what is there now: \`memgineering open ` + ref + "`"
       human: () => {
         if (proposal.action === "conflict") {
           printHuman(
-            `Recorded a disagreement about **${stripControl(entry.memory.title)}**.
+            `Recorded a disagreement about **${oneLine(entry.memory.title, WIDTH.title)}**.
 `
           );
-          printHuman(`\`${stripControl(entry.path)}\`
+          printHuman(`\`${oneLine(entry.path, WIDTH.path)}\`
 `);
           printHuman(
             c.gray(
@@ -9855,12 +10241,12 @@ To see what is there now: \`memgineering open ` + ref + "`"
             )
           );
         } else {
-          printHuman(`Revised **${stripControl(entry.memory.title)}**.
+          printHuman(`Revised **${oneLine(entry.memory.title, WIDTH.title)}**.
 `);
-          printHuman(`\`${stripControl(entry.path)}\`
+          printHuman(`\`${oneLine(entry.path, WIDTH.path)}\`
 `);
         }
-        printHuman(stripControl(renderDiff(preview.before, preview.after)));
+        printBlock(renderDiff(preview.before, preview.after));
         if (drift) {
           printHuman(
             c.yellow(`
@@ -9927,18 +10313,18 @@ async function reviseHosted(where, ref, opts) {
     json: { brain: where.name, ...result },
     human: () => {
       if (result.dry_run) {
-        printHuman(`## revise (dry run) \u2014 ${stripControl(where.name)}
+        printHuman(`## revise (dry run) \u2014 ${oneLine(where.name, WIDTH.title)}
 `);
-        printHuman(`\`${stripControl(result.target)}\`
+        printHuman(`\`${oneLine(result.target, WIDTH.path)}\`
 `);
-        printHuman(stripControl(renderDiff(result.before, result.after)));
+        printBlock(renderDiff(result.before, result.after));
         printHuman(c.gray("\nNothing was written. Drop --dry-run to apply."));
         return;
       }
       if (opts.action === "conflict") {
-        printHuman(`Recorded a disagreement in **${stripControl(where.name)}**.
+        printHuman(`Recorded a disagreement in **${oneLine(where.name, WIDTH.title)}**.
 `);
-        printHuman(`\`${stripControl(result.target)}\`
+        printHuman(`\`${oneLine(result.target, WIDTH.path)}\`
 `);
         printHuman(
           c.gray(
@@ -9946,16 +10332,16 @@ async function reviseHosted(where, ref, opts) {
           )
         );
       } else {
-        printHuman(`Revised in **${stripControl(where.name)}**.
+        printHuman(`Revised in **${oneLine(where.name, WIDTH.title)}**.
 `);
-        printHuman(`\`${stripControl(result.target)}\`
+        printHuman(`\`${oneLine(result.target, WIDTH.path)}\`
 `);
       }
-      printHuman(stripControl(renderDiff(result.before, result.after)));
+      printBlock(renderDiff(result.before, result.after));
       if (result.body_drift) {
         printHuman(
           c.yellow(`
-\u26A0 the body still reads "${stripControl(result.body_drift)}"`) + c.gray(
+\u26A0 the body still reads "${oneLine(result.body_drift, WIDTH.text)}"`) + c.gray(
             "\n  \u2014 the frontmatter now concludes differently. The prose is yours and was not\n  touched; edit it yourself if it should agree."
           )
         );
@@ -9979,7 +10365,7 @@ To put it back: \`memgineering revise ${ref} --claim ${JSON.stringify(
         );
       } else if (result.reverse?.hint) {
         printHuman(c.gray(`
-${stripControl(result.reverse.hint)}`));
+${oneLine(result.reverse.hint, WIDTH.text)}`));
       }
     }
   });
@@ -10023,7 +10409,7 @@ function nothingToChange(path, ref, verb = "revise") {
   memgineering revise ${ref} --action reinforce --claim "<the conclusion>" --reason "<what confirms it>"` : `It is already ${verb === "retire" ? "retired" : "current"}. \`memgineering ${verb === "retire" ? "unretire" : "retire"} ${ref}\` is what changes that.`;
   return memgError(
     "nothing_to_change",
-    `${stripControl(path)} already says exactly this`,
+    `${oneLine(path, WIDTH.path)} already says exactly this`,
     `Nothing was written. ${way}
 A \`--reason\` does not make it a change either \u2014 it would record an operation that changed nothing, and one whose \`undo\` would reverse nothing while saying it had.
 To see what the note says now: \`memgineering open ${ref}\``
@@ -10066,11 +10452,17 @@ function proposalsCommand() {
       opts.all === true ? { all: true } : {}
     ) : await listLocally(where.brain.root, opts.all === true);
     const shown = listed.proposals;
+    const unavailable = shown.filter(
+      (p) => p.claim === void 0 && !carriesNoClaim(p.action)
+    );
+    const rows = shown.map(
+      (p) => p.claim === void 0 && !carriesNoClaim(p.action) ? { ...p, claim: null, claim_unavailable: true } : p
+    );
     printDual({
       json: {
-        proposals: shown,
-        count: shown.length,
-        hint: hintForList(shown.length, listed.total, opts.all === true)
+        proposals: rows,
+        count: rows.length,
+        hint: unavailable.length > 0 ? `${unavailable.length} of these came back without a claim because this brain's server is older than the CLI \u2014 they are marked \`claim_unavailable\`, and \`memgineering open <id>\` shows what each note says now. ${hintForList(shown.length, listed.total, opts.all === true)}` : hintForList(shown.length, listed.total, opts.all === true)
       },
       human: () => {
         if (shown.length === 0) {
@@ -10111,6 +10503,7 @@ function summarize(p) {
     action: p.action,
     memory_id: p.memory_id,
     target: p.target.path,
+    claim: p.claim?.text ?? null,
     reason: p.reason,
     proposed_kind: p.proposed_kind,
     supersedes: p.relations.supersedes,
@@ -10118,14 +10511,28 @@ function summarize(p) {
     expires_at: p.expiresAt
   };
 }
+var CLAIM_WIDTH = 160;
 function renderSummary(p) {
+  const claimless = carriesNoClaim(p.action);
+  const claim = p.claim === void 0 || p.claim === null ? null : oneLine(p.claim, CLAIM_WIDTH);
+  const unavailable = p.claim === void 0 && !claimless;
   const lines2 = [
-    `- **${stripControl(p.action)}**${p.proposed_kind ? ` \u2192 ${p.proposed_kind}` : ""}  \`${stripControl(p.target)}\``,
-    `  ${p.id}  ${p.state}`,
-    quoteBlock(p.reason, "  > ")
+    `- **${oneLine(p.action, WIDTH.title)}**${p.proposed_kind ? ` \u2192 ${p.proposed_kind}` : ""}  \`${oneLine(p.target, WIDTH.path)}\``,
+    `  ${p.id}  ${p.state}`
   ];
+  if (claim !== null && claim !== "") lines2.push(`  \u2192 ${claim}`);
+  else if (unavailable) {
+    lines2.push(
+      c.gray(
+        `  \u2192 (claim unavailable: this brain's server is older than the CLI. \`memgineering open ${oneLine(p.memory_id ?? p.target, WIDTH.handle)}\` shows what the note says NOW; upgrading the server restores the claim.)`
+      )
+    );
+  }
+  lines2.push(quoteBlock(p.reason, "  > "));
   if (p.supersedes.length > 0) {
-    lines2.push(c.gray(`  replaces: ${p.supersedes.map(stripControl).join(", ")}`));
+    lines2.push(
+      c.gray(`  replaces: ${p.supersedes.map((id) => oneLine(id, WIDTH.handle)).join(", ")}`)
+    );
   }
   return lines2.join("\n");
 }
@@ -10241,10 +10648,10 @@ function renderApproval(applied, vault) {
     },
     human: () => {
       printHuman(
-        `Applied **${stripControl(applied.action)}** to \`${stripControl(applied.target)}\`.
+        `Applied **${oneLine(applied.action, WIDTH.title)}** to \`${oneLine(applied.target, WIDTH.path)}\`.
 `
       );
-      printHuman(stripControl(renderDiff(applied.before, applied.after)));
+      printBlock(renderDiff(applied.before, applied.after));
       printHuman(c.gray(`
 Undo: \`${undoHint(applied.opId, vault)}\``));
     }
@@ -10254,7 +10661,7 @@ function renderRejection(id, state, target) {
   printDual({
     json: { proposal_id: id, state, target },
     human: () => {
-      printHuman(`Declined \`${stripControl(target)}\`.
+      printHuman(`Declined \`${oneLine(target, WIDTH.path)}\`.
 `);
       printHuman(c.gray("The note was not touched."));
     }
@@ -10312,9 +10719,9 @@ function renderRebase(id, state, target, before, after) {
       hint: `This is the change as it applies to the note TODAY, and it has not been approved. Read the diff, then \`memgineering proposals approve ${id}\` \u2014 or reject it if the note moving on made it wrong.`
     },
     human: () => {
-      printHuman(`Recomputed against \`${stripControl(target)}\`.
+      printHuman(`Recomputed against \`${oneLine(target, WIDTH.path)}\`.
 `);
-      printHuman(stripControl(renderDiff(before, after)));
+      printBlock(renderDiff(before, after));
       printHuman(
         c.gray(
           `
@@ -10471,14 +10878,25 @@ function consolidateCommand() {
     });
   });
 }
+var TITLE_WIDTH = 72;
+function noteLines(id, title, path) {
+  const shown = oneLine(title, TITLE_WIDTH);
+  return [
+    shown === "" ? `  ${oneLine(id, WIDTH.handle)}` : `  ${oneLine(id, WIDTH.handle)}  ${shown}`,
+    // Backticked, as it was before the title moved onto the row above it. This
+    // output is read by agents as markdown, and a path outside code formatting
+    // is a path they have to guess the extent of.
+    c.gray(`    \`${oneLine(path, WIDTH.path)}\``)
+  ];
+}
 function renderCandidate(candidate) {
   const lines2 = [
-    `- **${stripControl(candidate.rule)}** \u2014 ${stripControl(candidate.evidence)}`,
-    `  ${stripControl(candidate.memory_id)}  \`${stripControl(candidate.path)}\``
+    `- **${oneLine(candidate.rule, WIDTH.title)}** \u2014 ${oneLine(candidate.evidence, WIDTH.text)}`,
+    ...noteLines(candidate.memory_id, candidate.title, candidate.path)
   ];
   if (candidate.other_id !== null) {
     lines2.push(
-      `  ${stripControl(candidate.other_id)}  \`${stripControl(candidate.other_path ?? "")}\``
+      ...noteLines(candidate.other_id, candidate.other_title ?? "", candidate.other_path ?? "")
     );
   }
   lines2.push(
@@ -10515,7 +10933,7 @@ function proposeCommand() {
       },
       human: () => {
         printHuman(
-          `Proposed **${stripControl(filed.action)}** on \`${stripControl(filed.target)}\`.
+          `Proposed **${oneLine(filed.action, WIDTH.title)}** on \`${oneLine(filed.target, WIDTH.path)}\`.
 `
         );
         printHuman(c.gray(`  ${filed.id}`));
@@ -10950,14 +11368,14 @@ function lifecycleCommand(action) {
       json: { action, memory_id: entry.memory.id, target: entry.path, op_id: record.op_id },
       human: () => {
         printHuman(
-          action === "retire" ? `Retired **${stripControl(entry.memory.title)}**.
-` : `**${stripControl(entry.memory.title)}** is current again.
+          action === "retire" ? `Retired **${oneLine(entry.memory.title, WIDTH.title)}**.
+` : `**${oneLine(entry.memory.title, WIDTH.title)}** is current again.
 `
         );
         if (action === "retire") {
           printHuman(
             c.gray(
-              "It still appears in recall \u2014 ranked last and labelled. Nothing was removed.\nTo stop reading the note entirely: `memgineering exclude " + stripControl(entry.path) + "`"
+              "It still appears in recall \u2014 ranked last and labelled. Nothing was removed.\nTo stop reading the note entirely: `memgineering exclude " + oneLine(entry.path, WIDTH.path) + "`"
             )
           );
         }
@@ -11015,8 +11433,10 @@ function ignoreCommand(mode) {
             mode === "exclude" ? (
               // The path is argv here, but argv came from a listing of the
               // user's own notes — and a filename is as authored as a title.
-              c.gray(`\`${stripControl(target)}\` was already excluded \u2014 nothing changed.`)
-            ) : c.gray(`\`${stripControl(target)}\` was not excluded \u2014 nothing changed.`)
+              c.gray(
+                `\`${oneLine(target, WIDTH.path)}\` was already excluded \u2014 nothing changed.`
+              )
+            ) : c.gray(`\`${oneLine(target, WIDTH.path)}\` was not excluded \u2014 nothing changed.`)
           );
           return;
         }
@@ -11046,13 +11466,13 @@ async function lifecycleHosted(where, action, ref, reason) {
     json: { brain: where.name, ...result },
     human: () => {
       printHuman(
-        action === "retire" ? `Retired in **${stripControl(where.name)}**.
-` : `Current again in **${stripControl(where.name)}**.
+        action === "retire" ? `Retired in **${oneLine(where.name, WIDTH.title)}**.
+` : `Current again in **${oneLine(where.name, WIDTH.title)}**.
 `
       );
-      printHuman(`\`${stripControl(result.target)}\`
+      printHuman(`\`${oneLine(result.target, WIDTH.path)}\`
 `);
-      printHuman(c.gray(stripControl(result.note)));
+      printHuman(c.gray(oneLine(result.note, WIDTH.text)));
       printHuman(
         c.gray(
           `
@@ -11072,15 +11492,15 @@ async function ignoreHosted(where, mode, path, reason) {
     json: { brain: where.name, ...result },
     human: () => {
       if (!result.changed) {
-        printHuman(c.gray(stripControl(result.note)));
+        printHuman(c.gray(oneLine(result.note, WIDTH.text)));
         return;
       }
       printHuman(
-        mode === "exclude" ? `No longer reading \`${stripControl(result.path)}\` in **${stripControl(where.name)}**.
-` : `Reading \`${stripControl(result.path)}\` again in **${stripControl(where.name)}**.
+        mode === "exclude" ? `No longer reading \`${oneLine(result.path, WIDTH.path)}\` in **${oneLine(where.name, WIDTH.title)}**.
+` : `Reading \`${oneLine(result.path, WIDTH.path)}\` again in **${oneLine(where.name, WIDTH.title)}**.
 `
       );
-      printHuman(c.gray(stripControl(result.note)));
+      printHuman(c.gray(oneLine(result.note, WIDTH.text)));
       if (result.op_id) printHuman(c.gray(`
 Undo: \`memgineering ${opposite(mode)} ${path}\``));
     }
@@ -11144,10 +11564,12 @@ function evidenceCommand() {
   });
 }
 function renderEvidence(report, opts) {
-  printHuman(`## evidence: ${stripControl(report.title)}
-`);
-  printHuman(`\`id: ${stripControl(report.id)}\`  \xB7  \`${stripControl(report.path)}\`
+  printHuman(`## evidence: ${oneLine(report.title, WIDTH.title)}
 `);
+  printHuman(
+    `\`id: ${oneLine(report.id, WIDTH.handle)}\`  \xB7  \`${oneLine(report.path, WIDTH.path)}\`
+`
+  );
   if (report.critical) {
     printHuman(c.yellow("\u26A0 critical \u2014 this note defines how the agent behaves.") + "\n");
   }
@@ -11197,11 +11619,12 @@ function renderEvidence(report, opts) {
     ]);
   }
   const pad = rows.reduce((w, [label]) => Math.max(w, label.length), 0) + 2;
-  for (const [label, value] of rows) printHuman(stripControl(`  ${label.padEnd(pad)}${value}`));
+  for (const [label, value] of rows)
+    printHuman(`  ${label.padEnd(pad)}${oneLine(value, WIDTH.text)}`);
   if (report.standing) {
     const means = STANDING_MEANS[report.standing];
     printHuman(`
-**${stripControl(report.standing)}**${means ? ` \u2014 ${means}` : ""}`);
+**${oneLine(report.standing, WIDTH.title)}**${means ? ` \u2014 ${means}` : ""}`);
   }
   if (report.contradicts > 0) {
     printHuman(
@@ -11222,7 +11645,7 @@ function renderEvidence(report, opts) {
       report.last_reason.verb,
       report.last_reason.ts === null ? null : report.last_reason.ts.slice(0, 10)
     ].filter((part) => part !== null && part !== "").join(", ");
-    if (provenance !== "") printHuman(c.gray(`  ${stripControl(provenance)}`));
+    if (provenance !== "") printHuman(c.gray(`  ${oneLine(provenance, WIDTH.text)}`));
   } else if (report.changed > 0) {
     printHuman(
       c.gray(
@@ -11358,6 +11781,7 @@ import { Command as Command11 } from "commander";
 // src/lib/rules.ts
 init_src();
 init_index_build();
+init_ui();
 init_vault();
 var RULE_LIMIT = 8;
 async function collectRules(vault, contextDir, now = /* @__PURE__ */ new Date()) {
@@ -11386,11 +11810,12 @@ async function collectRules(vault, contextDir, now = /* @__PURE__ */ new Date())
   };
 }
 function renderRuleLines(rules) {
-  return rules.map(({ entry }) => `- ${entry.memory.summary ?? entry.memory.title}`);
+  return rules.map(({ entry }) => `- ${oneLine(entry.memory.summary ?? entry.memory.title, 200)}`);
 }
 
 // src/commands/guard.ts
 init_deadline();
+init_ui();
 function guardCommand() {
   return new Command11("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 {
@@ -11430,7 +11855,7 @@ async function runGuard(payload, contextDirFlag) {
   return JSON.stringify({
     hookSpecificOutput: {
       hookEventName: "PreToolUse",
-      additionalContext: contextFor(claimed.rules, claimed.total)
+      additionalContext: contextFor(claimed.lines, claimed.total)
     }
   });
 }
@@ -11444,16 +11869,22 @@ async function runStopGuard(payload, contextDirFlag) {
   return JSON.stringify({
     hookSpecificOutput: {
       hookEventName: "Stop",
-      additionalContext: stopContextFor(claimed.rules, claimed.total)
+      additionalContext: stopContextFor(claimed.lines, claimed.total)
     }
   });
 }
 async function claimRules(sessionId, contextDir) {
+  const hosted = await hostedRuleLines().catch(() => null);
+  if (hosted !== null) {
+    if (hosted.lines.length === 0) return null;
+    if (!await claimSession(sessionId, hosted.brainId)) return null;
+    return { lines: hosted.lines, total: hosted.total };
+  }
   const collected = await collectRules(void 0, contextDir).catch(() => null);
   if (collected === null) return null;
   const { brainRoot, rules, total } = collected;
   if (rules.length === 0) return null;
-  if (!await claimSession(sessionId)) return null;
+  if (!await claimSession(sessionId, brainRoot)) return null;
   await recordEvent(brainRoot, {
     verb: "guard",
     contextDir,
@@ -11461,22 +11892,20 @@ async function claimRules(sessionId, contextDir) {
     limit: RULE_LIMIT,
     returnedIds: rules.map((r) => r.entry.memory.id)
   });
-  return { rules, total };
+  return { lines: renderRuleLines(rules), total };
 }
-function contextFor(rules, total) {
-  const lines2 = renderRuleLines(rules);
-  const more = total > rules.length ? `
-(${total - rules.length} more \u2014 \`memgineering rules\` for all of them.)` : "";
+function contextFor(lines2, total) {
+  const more = total > lines2.length ? `
+(${total - lines2.length} more \u2014 \`memgineering rules\` for all of them.)` : "";
   return `Decisions this user has already made. They are theirs, not suggestions, and they hold whether or not this task mentions them:
 
 ${lines2.join("\n")}${more}
 
 Follow them. If what you are about to do goes against one, say so in a sentence instead of doing it quietly.`;
 }
-function stopContextFor(rules, total) {
-  const lines2 = renderRuleLines(rules);
-  const more = total > rules.length ? `
-(${total - rules.length} more \u2014 \`memgineering rules\` for all of them.)` : "";
+function stopContextFor(lines2, total) {
+  const more = total > lines2.length ? `
+(${total - lines2.length} more \u2014 \`memgineering rules\` for all of them.)` : "";
   return `Decisions this user has already made. They are theirs, not suggestions, and they hold whether or not this task mentions them:
 
 ${lines2.join("\n")}${more}
@@ -11507,10 +11936,10 @@ async function readPayload() {
   }
 }
 var guardDir = () => join16(brandHome(), "guard");
-async function claimSession(sessionId) {
+async function claimSession(sessionId, brain) {
   const marker = join16(
     guardDir(),
-    `${createHash7("sha256").update(sessionId).digest("hex").slice(0, 32)}`
+    `${createHash7("sha256").update(`${sessionId}\0${brain}`).digest("hex").slice(0, 32)}`
   );
   try {
     await mkdir11(guardDir(), { recursive: true, mode: 448 });
@@ -11535,6 +11964,17 @@ async function pruneOldMarkers() {
   } catch {
   }
 }
+var RULE_WIDTH = 200;
+async function hostedRuleLines() {
+  const where = await resolveTarget({});
+  if (where.kind !== "cloud") return null;
+  const { rules, total } = await cloudRules(await openCloudBrain(where));
+  return {
+    lines: rules.map((r) => `- ${oneLine(r.summary ?? r.title, RULE_WIDTH)}`),
+    total,
+    brainId: where.brainId
+  };
+}
 
 // src/program.ts
 init_init();
@@ -11577,7 +12017,7 @@ function logCommand() {
         human: () => {
           const diverged2 = Array.isArray(history["divergence"]) ? history["divergence"] : [];
           const total = typeof history["total"] === "number" ? history["total"] : rows.length;
-          printHuman(`## log \u2014 ${stripControl(target.name)}  (${total} operations)
+          printHuman(`## log \u2014 ${oneLine(target.name, WIDTH.title)}  (${total} operations)
 `);
           if (rows.length === 0) {
             printHuman("_This brain has no recorded operations._\n");
@@ -11591,7 +12031,8 @@ function logCommand() {
             );
           }
           const hint = history["hint"];
-          if (typeof hint === "string" && hint !== "") printHuman(c.gray(stripControl(hint)));
+          if (typeof hint === "string" && hint !== "")
+            printHuman(c.gray(oneLine(hint, WIDTH.text)));
         }
       });
       return;
@@ -11713,15 +12154,19 @@ function renderOps(ops, opts) {
       op.diverged && !op.undone ? "note has changed since" : null
     ].filter(Boolean);
     printHuman(
-      `- ${stripControl(op.verb)} \`${stripControl(op.target)}\`${marks.length ? c.yellow(`  (${marks.join(", ")})`) : ""}`
+      `- ${oneLine(op.verb, WIDTH.title)} \`${oneLine(op.target, WIDTH.path)}\`${marks.length ? c.yellow(`  (${marks.join(", ")})`) : ""}`
     );
     printHuman(
-      c.gray(`  ${stripControl(op.ts)}${op.actor ? ` \xB7 ${stripControl(op.actor)}` : ""}`) + `  ${c.gray(undoable(op, opts.hosted) ? "undo:" : "op:")} ${stripControl(op.op_id)}`
+      c.gray(
+        `  ${oneLine(op.ts, WIDTH.handle)}${op.actor ? ` \xB7 ${oneLine(op.actor, WIDTH.title)}` : ""}`
+      ) + `  ${c.gray(undoable(op, opts.hosted) ? "undo:" : "op:")} ${oneLine(op.op_id, WIDTH.handle)}`
     );
     if (op.rationale) printHuman(c.gray(quoteBlock(op.rationale, "  > ")));
     if (opts.verbose) {
       printHuman(
-        c.gray(`  ${stripControl(op.hash_before ?? "\u2205")} \u2192 ${stripControl(op.hash_after ?? "\u2205")}`)
+        c.gray(
+          `  ${oneLine(op.hash_before ?? "\u2205", WIDTH.handle)} \u2192 ${oneLine(op.hash_after ?? "\u2205", WIDTH.handle)}`
+        )
       );
     }
   }
@@ -11777,7 +12222,7 @@ init_pending_login();
 init_ui();
 import { Command as Command14 } from "commander";
 function logoutCommand() {
-  return new Command14("logout").description("sign out of a hosted brain").option("--all", "revoke every token on the account, not just this machine\u2019s").option(
+  return new Command14("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) => {
@@ -11860,6 +12305,11 @@ 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."
           )
         );
+        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."
+          )
+        );
       }
     });
   });
@@ -11943,12 +12393,12 @@ init_ui();
 function pullCommand() {
   return new Command16("pull").description("download your hosted brain to a folder on this machine").argument("[destination]", "folder to write into (created if missing)").option("--brain <name>", "which hosted brain to download").option("--dry-run", "say what would be written and write nothing").action(async (destination, opts) => {
     const { brain: source, others } = await resolveSource(opts.brain);
-    const target = resolve8(destination ?? `./${stripControl(source.name)}`);
+    const target = resolve8(destination ?? `./${oneLine(source.name, WIDTH.title)}`);
     const first = await cloudListNotes(source, { limit: 1 });
     if (first.total === 0) {
       throw memgError(
         "invalid_input",
-        `\u201C${stripControl(source.name)}\u201D has no notes to download`,
+        `\u201C${oneLine(source.name, WIDTH.title)}\u201D has no notes to download`,
         "Nothing was written. `memgineering push` carries a brain on this disk up to the hosted one, and `remember` writes a first note into it."
       );
     }
@@ -11969,13 +12419,13 @@ function pullCommand() {
           printHuman(`## pull (dry run)
 `);
           printHuman(
-            `${first.total} note(s) from \u201C${stripControl(source.name)}\u201D into \`${target}\`
+            `${first.total} note(s) from \u201C${oneLine(source.name, WIDTH.title)}\u201D into \`${target}\`
 `
           );
           for (const note of preview.slice(0, 20)) {
             printHuman(
               c.gray(
-                `  ${stripControl(note.path)}${note.excluded === true ? "   (excluded)" : ""}`
+                `  ${oneLine(note.path, WIDTH.path)}${note.excluded === true ? "   (excluded)" : ""}`
               )
             );
           }
@@ -11990,7 +12440,7 @@ function pullCommand() {
       });
       return;
     }
-    progress(`downloading ${first.total} note(s) from \u201C${stripControl(source.name)}\u201D\u2026`);
+    progress(`downloading ${first.total} note(s) from \u201C${oneLine(source.name, WIDTH.title)}\u201D\u2026`);
     const written = [];
     const already = [];
     const excluded = [];
@@ -12032,7 +12482,7 @@ function pullCommand() {
       human: () => {
         printHuman(
           c.green(
-            `\u2713 ${written.length} note(s) from \u201C${stripControl(source.name)}\u201D written to \`${target}\``
+            `\u2713 ${written.length} note(s) from \u201C${oneLine(source.name, WIDTH.title)}\u201D written to \`${target}\``
           )
         );
         if (already.length > 0) {
@@ -12084,8 +12534,8 @@ async function resolveSource(named) {
   if (!found) {
     throw memgError(
       "invalid_input",
-      named ? `no hosted brain called \u201C${stripControl(named)}\u201D` : "more than one hosted brain \u2014 say which",
-      `Pass one of: ${brains.map((b) => stripControl(b.name)).join(", ")}  (e.g. \`memgineering pull --brain ${stripControl(brains[0]?.name ?? "")}\`)`
+      named ? `no hosted brain called \u201C${oneLine(named, WIDTH.title)}\u201D` : "more than one hosted brain \u2014 say which",
+      `Pass one of: ${brains.map((b) => oneLine(b.name, WIDTH.title)).join(", ")}  (e.g. \`memgineering pull --brain ${oneLine(brains[0]?.name ?? "", WIDTH.title)}\`)`
     );
   }
   return {
@@ -12102,7 +12552,7 @@ async function resolveSource(named) {
 }
 function sayWhatIsElsewhere(others, into) {
   if (others.length === 0) return;
-  const names = others.map(stripControl);
+  const names = others.map((name) => oneLine(name, WIDTH.title));
   printHuman(
     c.yellow(
       `
@@ -12147,6 +12597,11 @@ init_api_client();
 import { Command as Command17 } from "commander";
 init_vault();
 init_ui();
+var HELD_BACK_WORDING = {
+  where: "the hosted brain",
+  retry: "push again"
+};
+var printHeldBack2 = (held) => printHeldBack(held, HELD_BACK_WORDING);
 function pushCommand() {
   return new Command17("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);
@@ -12155,11 +12610,16 @@ function pushCommand() {
     const paths = scan.files.filter(isNote);
     const held = heldBack(scan);
     if (paths.length === 0) {
+      const sawFiles = scan.files.length > 0;
+      const excluded = describeHeldBack(held).slice(0, 10).map((row) => `  ${row}`).join("\n");
       throw memgError(
         "invalid_input",
         `there is nothing to upload in ${local.root}`,
-        held.total === 0 ? "This brain has no markdown notes in it at all. Check the path \u2014 `--vault` takes the folder your notes live in." : `This brain has ${held.total} markdown note(s) and the rules on this machine hold back every one:
-` + describeHeldBack(held).slice(0, 10).map((row) => `  ${row}`).join("\n") + "\nRename one, or list it in .memgallow, if the name is a false alarm."
+        held.total > 0 ? `This brain has ${held.total} markdown note(s) and the rules on this machine hold back every one:
+${excluded}
+Rename one, or list it in .memgallow, if the name is a false alarm.` : held.folders.length > 0 ? `No markdown notes were found. ${held.folders.length} folder(s) were excluded by a rule and never looked inside:
+${excluded}
+If your notes are in one of those, that rule is why \u2014 nothing here can see them. If they are somewhere else, check the path: \`--vault\` takes the folder your notes live in.` : sawFiles ? "There are files here but no markdown notes. Check the path \u2014 `--vault` takes the folder your notes live in." : "This folder is empty. Check the path \u2014 `--vault` takes the folder your notes live in."
       );
     }
     if (opts.dryRun) {
@@ -12179,7 +12639,7 @@ function pushCommand() {
 `);
           for (const path of paths.slice(0, 20)) printHuman(c.gray(`  ${path}`));
           if (paths.length > 20) printHuman(c.gray(`  \u2026 and ${paths.length - 20} more`));
-          printHeldBack(held);
+          printHeldBack2(held);
           printHuman(
             c.gray(
               "\nNothing was sent. What a dry run cannot know is the other screen: a note\nwhose CONTENT looks like a credential is held back \u2014 by this machine before\nsending, and by the server on arrival \u2014 and deciding that needs the bytes,\nwhich this does not read. Those appear in the real run\u2019s summary."
@@ -12190,7 +12650,7 @@ function pushCommand() {
       return;
     }
     const destination = await resolveDestination(opts.brain, local.root);
-    progress(`uploading ${paths.length} note(s) to \u201C${stripControl(destination.name)}\u201D\u2026`);
+    progress(`uploading ${paths.length} note(s) to \u201C${oneLine(destination.name, WIDTH.title)}\u201D\u2026`);
     const uploaded = [];
     const already = [];
     const refused = [];
@@ -12260,7 +12720,9 @@ function pushCommand() {
       },
       human: () => {
         printHuman(
-          c.green(`\u2713 ${uploaded.length} note(s) uploaded to \u201C${stripControl(destination.name)}\u201D`)
+          c.green(
+            `\u2713 ${uploaded.length} note(s) uploaded to \u201C${oneLine(destination.name, WIDTH.title)}\u201D`
+          )
         );
         if (already.length > 0) {
           printHuman(c.gray(`  ${already.length} were already there \u2014 left as they are`));
@@ -12278,13 +12740,15 @@ function pushCommand() {
 \u26A0 ${refused.length} note(s) were NOT uploaded:`) + c.gray("\n  they are untouched on this machine and can be fixed and pushed again")
           );
           for (const r of refused.slice(0, 10)) {
-            printHuman(c.gray(`  ${stripControl(r.path)}  (${stripControl(r.code)})`));
+            printHuman(
+              c.gray(`  ${oneLine(r.path, WIDTH.path)}  (${oneLine(r.code, WIDTH.title)})`)
+            );
           }
           if (refused.length > 10) {
             printHuman(c.gray(`  \u2026 and ${refused.length - 10} more`));
           }
         }
-        printHeldBack(held);
+        printHeldBack2(held);
         printRepoint(repointed, destination);
         printHuman(
           c.gray(
@@ -12300,14 +12764,14 @@ Nothing was deleted from \`${local.root}\` \u2014
 function printRepoint(repoint, destination) {
   if (repoint === null) {
     printHuman(c.gray(`
-This machine still reads \u201C${stripControl(destination.name)}\u201D.`));
+This machine still reads \u201C${oneLine(destination.name, WIDTH.title)}\u201D.`));
     return;
   }
   if (repoint.from === null) {
     printHuman(
       c.gray(
         `
-This machine now reads \u201C${stripControl(destination.name)}\u201D \u2014 it was not reading a hosted
+This machine now reads \u201C${oneLine(destination.name, WIDTH.title)}\u201D \u2014 it was not reading a hosted
 brain before. \`memgineering recall --local\` still reads the folder.`
       )
     );
@@ -12316,85 +12780,9 @@ brain before. \`memgineering recall --local\` still reads the folder.`
   printHuman(
     c.yellow(
       `
-\u26A0 THIS MACHINE NOW READS \u201C${stripControl(destination.name)}\u201D \u2014 it was reading \u201C${stripControl(repoint.from.name)}\u201D.`
+\u26A0 THIS MACHINE NOW READS \u201C${oneLine(destination.name, WIDTH.title)}\u201D \u2014 it was reading \u201C${oneLine(repoint.from.name, WIDTH.title)}\u201D.`
     ) + c.gray(
-      "\n  That is a side effect of `--brain`, and it outlives this command: `recall`,\n  `remember` and the memories an agent session starts with all come from the\n  brain named here. Nothing in \u201C" + stripControl(repoint.from.name) + "\u201D was changed or deleted.\n  There is no verb that points back without uploading \u2014 `memgineering push\n  --brain " + stripControl(repoint.from.name) + "` would move the pointer AND send this folder into it."
-    )
-  );
-}
-var isNote = (p) => /\.(md|markdown)$/i.test(p);
-function heldBack(scan) {
-  const denied = scan.denied ?? [];
-  const byName = denied.filter((d) => d.kind === "name" && isNote(d.path)).map((d) => ({ path: d.path, term: d.term }));
-  const explicitly = denied.filter((d) => d.kind === "explicit" && isNote(d.path)).map((d) => d.path);
-  const byRule = scan.excluded.filter(isNote);
-  const symlinked = scan.skippedSymlinks.filter(isNote);
-  return {
-    total: byName.length + explicitly.length + byRule.length + symlinked.length,
-    byName,
-    explicitly,
-    byRule,
-    symlinked
-  };
-}
-function heldBackJson(held) {
-  return {
-    not_sent: held.total,
-    denied_by_name: held.byName,
-    denied_explicitly: held.explicitly,
-    excluded_by_rule: held.byRule,
-    skipped_symlinks: held.symlinked
-  };
-}
-function heldBackGroups(held) {
-  return [
-    {
-      label: "name looks private",
-      rows: held.byName.map((d) => ({ path: d.path, detail: `matched "${d.term ?? "?"}"` }))
-    },
-    { label: "listed in .memgdeny", rows: held.explicitly.map((p) => ({ path: p, detail: null })) },
-    { label: "excluded by a rule", rows: held.byRule.map((p) => ({ path: p, detail: null })) },
-    {
-      label: "a symlink, which is never followed",
-      rows: held.symlinked.map((p) => ({ path: p, detail: null }))
-    }
-  ];
-}
-function describeHeldBack(held) {
-  return heldBackGroups(held).flatMap(
-    ({ label, rows }) => rows.map(
-      (r) => `${stripControl(r.path)}  \u2014 ${label}${r.detail === null ? "" : ` (${stripControl(r.detail)})`}`
-    )
-  );
-}
-function printHeldBack(held) {
-  if (held.total === 0) return;
-  printHuman(
-    c.yellow(`
-\u26A0 ${held.total} note(s) held back on this machine \u2014 they never reach the brain:`)
-  );
-  for (const { label, rows } of heldBackGroups(held)) {
-    if (rows.length === 0) continue;
-    printHuman(c.gray(`  ${rows.length} \u2014 ${label}:`));
-    for (const r of rows.slice(0, 10)) {
-      printHuman(
-        c.gray(
-          `    ${stripControl(r.path)}${r.detail === null ? "" : `  (${stripControl(r.detail)})`}`
-        )
-      );
-    }
-    if (rows.length > 10) printHuman(c.gray(`    \u2026 and ${rows.length - 10} more`));
-  }
-  if (held.byName.length > 0) {
-    printHuman(
-      c.gray(
-        "  The name list is a GUESS and this may be a false alarm \u2014 rename the note,\n  or list it in .memgallow, and push again."
-      )
-    );
-  }
-  printHuman(
-    c.gray(
-      "  Counted per file. A rule that excludes a whole FOLDER stops the walk there,\n  so notes inside one are not listed above."
+      "\n  That is a side effect of `--brain`, and it outlives this command: `recall`,\n  `remember` and the memories an agent session starts with all come from the\n  brain named here. Nothing in \u201C" + oneLine(repoint.from.name, WIDTH.title) + "\u201D was changed or deleted.\n  To point back without uploading: `memgineering use --brain " + oneLine(repoint.from.name, 72) + "`."
     )
   );
 }
@@ -12601,7 +12989,7 @@ function recallCommand() {
             if (semantic.state !== "skipped" || semantic.hint === void 0) return;
             printHuman(
               c.yellow("\u26A0 Meaning was not searched \u2014 this answer matched words only.") + c.gray(`
-  ${stripControl(semantic.hint)}
+  ${oneLine(semantic.hint, WIDTH.text)}
 `)
             );
           };
@@ -12649,13 +13037,11 @@ function recallCommand() {
               for (const id of conflict.between) {
                 const reason = reasons.get(id);
                 if (!reason) {
-                  printHuman(c.gray(`  ${stripControl(id)} \u2014 no reason was recorded.`));
+                  printHuman(c.gray(`  ${oneLine(id, WIDTH.handle)} \u2014 no reason was recorded.`));
                   continue;
                 }
                 printHuman(
-                  stripControl(
-                    `  ${id} \u2014 ${reason.verb === "remember" ? "why it was recorded" : "why it last changed"} (${reason.ts.slice(0, 10)}):`
-                  )
+                  `  ${oneLine(id, WIDTH.handle)} \u2014 ${reason.verb === "remember" ? "why it was recorded" : "why it last changed"} (${reason.ts.slice(0, 10)}):`
                 );
                 printHuman(quoteBlock(reason.text, "  > "));
               }
@@ -12671,8 +13057,10 @@ function recallCommand() {
             );
           }
           if (result.related.length > 0) {
-            printHuman(`_related:_ ${result.related.map(stripControl).join(", ")}
-`);
+            printHuman(
+              `_related:_ ${result.related.map((id) => oneLine(id, WIDTH.handle)).join(", ")}
+`
+            );
           }
           if (result.truncated) {
             const { withheld, estimated_tokens, budget_tokens } = result.truncated;
@@ -12726,9 +13114,8 @@ function asksInSentences(query) {
   return query.trim().split(/\s+/).filter(Boolean).length >= 4;
 }
 function side(id, status, validFrom2) {
-  return stripControl(
-    `${id} (${status}${validFrom2 === null ? "" : ` \xB7 ${validFrom2.slice(0, 10)}`})`
-  );
+  const date = validFrom2 === null ? "" : ` \xB7 ${oneLine(validFrom2.slice(0, 10), WIDTH.handle)}`;
+  return `${oneLine(id, WIDTH.handle)} (${oneLine(status, WIDTH.title)}${date})`;
 }
 async function conflictReasons(vaultRoot, conflicts, byId) {
   const { ops } = await readOps(vaultRoot);
@@ -12747,7 +13134,7 @@ function renderCard(n, card, handle2, detail, stage, glossHere = false, scaffold
   const out = [];
   const standing = card.freshness === "current" ? "" : ` \xB7 ${card.freshness}`;
   const age = Number.isFinite(card.age_days) ? ` \xB7 ${ago2(Math.floor(card.age_days))}` : "";
-  out.push(`### ${n}. ${stripControl(card.title)}`);
+  out.push(`### ${n}. ${oneLine(card.title, WIDTH.title)}`);
   if (scaffolding) {
     out.push(c.yellow("not filled in yet") + c.gray(" \u2014 still the template `init` wrote"));
   } else {
@@ -12755,14 +13142,14 @@ function renderCard(n, card, handle2, detail, stage, glossHere = false, scaffold
       card.binding ? c.bold("a standing decision") : null,
       `${card.confidence}${standing}${age}`
     ].filter(Boolean);
-    out.push(stripControl(marks.join(c.gray(" \xB7 "))));
+    out.push(oneLine(marks.join(c.gray(" \xB7 ")), WIDTH.text));
   }
   if (glossHere && !scaffolding) {
     out.push(c.gray("stated = these fields came from the note, not from inference"));
   }
   if (detail !== "title") {
     if (card.summary) out.push("", quoteBlock(card.summary));
-    out.push("", `\`open: ${stripControl(handle2)}\``);
+    out.push("", `\`open: ${oneLine(handle2, WIDTH.handle)}\``);
   }
   if (stage.outline && stage.outline.length > 0) {
     out.push("", ...stage.outline.map((h) => `- ${h}`));
@@ -12893,10 +13280,10 @@ function rememberCommand() {
             ...kindLanded ? {} : { kind_dropped: kind }
           },
           human: () => {
-            printHuman(`Remembered in ${stripControl(target.name)}.
+            printHuman(`Remembered in ${oneLine(target.name, WIDTH.title)}.
 `);
             printHuman(
-              `note:  \`${stripControl(written.id)}\`  \xB7  \`${stripControl(written.path)}\``
+              `note:  \`${oneLine(written.id, WIDTH.handle)}\`  \xB7  \`${oneLine(written.path, WIDTH.path)}\``
             );
             if (opts.rule === true) {
               printHuman("rule:  shown before you write a file here, once a session");
@@ -12908,7 +13295,9 @@ function rememberCommand() {
                 )
               );
             }
-            printHuman(c.gray(`undo:  \`memgineering undo ${stripControl(written.op_id)}\``));
+            printHuman(
+              c.gray(`undo:  \`memgineering undo ${oneLine(written.op_id, WIDTH.handle)}\``)
+            );
           }
         });
         return;
@@ -13109,9 +13498,7 @@ function resurfaceCommand() {
 `);
             if (unreachableDefault) {
               printHuman(
-                c.yellow(
-                  `Your default brain is not on disk right now: ${unreachableDefault}`
-                )
+                c.yellow(`Your default brain is not on disk right now: ${unreachableDefault}`)
               );
               printHuman(
                 c.gray(
@@ -13125,7 +13512,7 @@ function resurfaceCommand() {
             );
             for (const [i, { entry, why }] of rankedShown.entries()) {
               const blank = untouched.has(entry.path);
-              printHuman(`### ${i + 1}. ${stripControl(entry.memory.title)}`);
+              printHuman(`### ${i + 1}. ${oneLine(entry.memory.title, WIDTH.title)}`);
               printHuman(blank ? c.yellow("not filled in yet") : why.join(" \xB7 "));
               if (blank) {
                 const hasWritten = rankedShown.some((r) => !untouched.has(r.entry.path));
@@ -13167,31 +13554,31 @@ async function resurfaceHosted(where, limit) {
     },
     human: () => {
       if (result.cards.length === 0) {
-        printHuman(`## resurface \u2014 ${stripControl(where.name)}
+        printHuman(`## resurface \u2014 ${oneLine(where.name, WIDTH.title)}
 `);
         printHuman("_Nothing to bring up yet._\n");
-        if (result.hint) printHuman(c.gray(stripControl(result.hint)));
+        if (result.hint) printHuman(c.gray(oneLine(result.hint, WIDTH.text)));
         return;
       }
-      printHuman(`## resurface \u2014 ${stripControl(where.name)}  (${result.cards.length} cards)
-`);
+      printHuman(
+        `## resurface \u2014 ${oneLine(where.name, WIDTH.title)}  (${result.cards.length} cards)
+`
+      );
       for (const [i, card] of result.cards.entries()) {
-        printHuman(`### ${i + 1}. ${stripControl(card.title)}`);
+        printHuman(`### ${i + 1}. ${oneLine(card.title, WIDTH.title)}`);
         if (card.untouched === true) printHuman(c.yellow("not filled in yet"));
-        else if (card.why.length > 0) printHuman(stripControl(card.why.join(" \xB7 ")));
+        else if (card.why.length > 0) printHuman(oneLine(card.why.join(" \xB7 "), WIDTH.text));
         if (card.summary) printHuman(`
 ${quoteBlock(card.summary)}`);
         printHuman(`
-\`open: ${stripControl(card.handle)}\`
+\`open: ${oneLine(card.handle, WIDTH.handle)}\`
 `);
       }
-      printHuman(
+      printBlock(
         c.gray(
-          stripControl(
-            `Ranked by ${result.ranked_by.join(", ")}. A hosted brain does not record where a
+          `Ranked by ${oneLine(result.ranked_by.join(", "), WIDTH.text)}. A hosted brain does not record where a
 question was asked from, so "in this folder" is not one of them \u2014 that signal
 exists only for a brain on this machine.`
-          )
         )
       );
     }
@@ -13212,7 +13599,7 @@ function rulesCommand() {
       printDual({
         json: { brain: where.name, hosted: true, rules: rules2, total: total2 },
         human: () => {
-          printHuman(`## rules \u2014 ${stripControl(where.name)}  (${total2})
+          printHuman(`## rules \u2014 ${oneLine(where.name, WIDTH.title)}  (${total2})
 `);
           if (rules2.length === 0) {
             printHuman("_Nothing is marked as a rule in this brain._\n");
@@ -13224,8 +13611,8 @@ function rulesCommand() {
             return;
           }
           for (const rule of rules2) {
-            printHuman(`- ${stripControl(rule.summary ?? rule.title)}`);
-            printHuman(c.gray(`  \`open: ${stripControl(rule.handle)}\``));
+            printHuman(`- ${oneLine(rule.summary ?? rule.title, WIDTH.text)}`);
+            printHuman(c.gray(`  \`open: ${oneLine(rule.handle, WIDTH.handle)}\``));
           }
           if (total2 > rules2.length) {
             printHuman(c.gray(`
@@ -13277,10 +13664,10 @@ This answered from \`${brainRoot}\` instead, so rules you wrote in the missing o
         printHuman(`## rules  (${rules.length}${total > rules.length ? ` of ${total}` : ""})
 `);
         for (const { entry } of rules) {
-          printHuman(`- ${stripControl(entry.memory.summary ?? entry.memory.title)}`);
+          printHuman(`- ${oneLine(entry.memory.summary ?? entry.memory.title, WIDTH.text)}`);
           printHuman(
             c.gray(
-              `  \`open: ${displayHandle(entry.memory.id, allIds)}\`${entry.memory.scope ? `  \xB7  ${stripControl(entry.memory.scope)}` : ""}`
+              `  \`open: ${displayHandle(entry.memory.id, allIds)}\`${entry.memory.scope ? `  \xB7  ${oneLine(entry.memory.scope, WIDTH.title)}` : ""}`
             )
           );
         }
@@ -13642,7 +14029,7 @@ async function reportPreviousAttempt() {
 function reportNotice(text) {
   if (!text) return;
   printHuman(c.gray(`
-  note from memgineering.com: "${stripControl(text)}"`));
+  note from memgineering.com: "${oneLine(text, WIDTH.text)}"`));
 }
 function reportBelowMinimum(below) {
   if (!below) return;
@@ -13680,11 +14067,11 @@ function undoCommand() {
           json: { ...undone, brain: { hosted: true, name: where.name } },
           human: () => {
             printHuman(
-              `Took back \`${stripControl(undone.undone)}\` \u2014 a ${stripControl(undone.verb)}.
+              `Took back \`${oneLine(undone.undone, WIDTH.handle)}\` \u2014 a ${oneLine(undone.verb, WIDTH.title)}.
 `
             );
-            printHuman(c.gray(`  ${stripControl(undone.target)}`));
-            printHuman(c.gray(`  recorded as \`${stripControl(undone.op_id)}\``));
+            printHuman(c.gray(`  ${oneLine(undone.target, WIDTH.path)}`));
+            printHuman(c.gray(`  recorded as \`${oneLine(undone.op_id, WIDTH.handle)}\``));
           }
         });
         return;
@@ -13770,7 +14157,7 @@ ${matches.slice(0, 8).map((id) => `  ${id}`).join("\n")}${matches.length > 8 ? "
         },
         human: () => {
           printHuman(
-            `Undone: ${stripControl(target.verb)} on \`${stripControl(target.target)}\`
+            `Undone: ${oneLine(target.verb, WIDTH.title)} on \`${oneLine(target.target, WIDTH.path)}\`
 `
           );
           if (opId === void 0) {
@@ -13861,13 +14248,91 @@ Read what it says now, then decide what should stay.`;
 The text from before that change is still on this machine: ${join23(snapshotDir(vaultRoot), `${op.op_id}.txt`)}`;
 }
 
+// src/commands/brains.ts
+init_errors();
+init_api_client();
+import { Command as Command25 } from "commander";
+init_config();
+init_ui();
+var NAME_WIDTH = 48;
+function brainsCommand() {
+  return new Command25("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 push --brain <name>` is what creates a new one."
+  ).action(async () => {
+    const base = apiUrl();
+    const credentials = await requireCredentials(base);
+    const brains = await listCloudBrains(credentials.token, base);
+    const pointer = (await loadConfig()).brain.cloud;
+    const currentId = pointer?.api_url === base ? pointer.id : null;
+    if (brains.length === 0) {
+      throw memgError(
+        "invalid_input",
+        "this account has no hosted brains",
+        "Nothing is wrong \u2014 none has been made yet. `memgineering push --brain <name>` creates one and fills it from a folder on this machine."
+      );
+    }
+    const rows = brains.map((b) => ({
+      id: b.id,
+      name: b.name,
+      // Passed through rather than defaulted to 0. A server that does not send
+      // a count and a brain that holds no notes are different facts, and the
+      // second is alarming.
+      note_count: b.note_count ?? null,
+      created_at: b.created_at ?? null,
+      current: b.id === currentId
+    }));
+    printDual({
+      json: {
+        // WHOSE ACCOUNT, on the command that lists what the account holds.
+        //
+        // "What is this computer connected to?" took three commands to answer:
+        // `whoami` for the identity, this for the brains, `use` for the folder
+        // — and `whoami`, the one named after the account, was the only one
+        // that answered none of the rest. Two round-test agents ran all three.
+        // The name is free here; it came back with the token.
+        account: { id: credentials.account_id, name: credentials.display_name },
+        server: base,
+        brains: rows,
+        count: rows.length,
+        // Named at the top level too, so a caller does not have to scan the
+        // array to answer the question it most often has.
+        current: currentId,
+        hint: currentId === null ? "This machine is not pointed at any of them. `memgineering use --brain <name>` picks one \u2014 it moves the pointer and uploads nothing." : "Switch with `memgineering use --brain <name>`, which moves the pointer and uploads nothing. `push --brain <name>` is what creates a new brain."
+      },
+      human: () => {
+        printHuman(
+          `## ${rows.length} brain${rows.length === 1 ? "" : "s"} on ${credentials.display_name === null ? "this account" : `${oneLine(credentials.display_name, NAME_WIDTH)}\u2019s account`}
+`
+        );
+        for (const row of rows) {
+          const name = oneLine(row.name, NAME_WIDTH).padEnd(NAME_WIDTH);
+          const notes = row.note_count === null ? "" : `${String(row.note_count).padStart(6)} note(s)`;
+          const made = row.created_at === null ? "" : `  made ${row.created_at.slice(0, 10)}`;
+          printHuman(
+            `  ${name}${c.gray(notes)}${c.gray(made)}` + (row.current ? c.yellow("   \u2190 this machine reads this one") : "")
+          );
+        }
+        printHuman("");
+        printHuman(
+          c.gray(
+            currentId === null ? "  This machine is not pointed at any of them.\n  `memgineering use --brain <name>` picks one \u2014 nothing is uploaded." : "  `memgineering use --brain <name>` switches \u2014 nothing is uploaded.\n  `memgineering push --brain <name>` is what creates a new one."
+          )
+        );
+      }
+    });
+  });
+}
+
 // src/commands/use.ts
 init_atomic();
 init_brand();
 init_errors();
-init_config();
+init_api_client();
+init_credentials();
 import { isAbsolute as isAbsolute5, relative as relative3, resolve as resolve11 } from "path";
-import { Command as Command25 } from "commander";
+import { Command as Command26 } from "commander";
+init_config();
 init_vault();
 init_ui();
 function lostDefaultLines(missing) {
@@ -13886,16 +14351,24 @@ var VIA_MEANS = {
   default: "because it is your default brain (`memgineering use --default <path>` changes it)"
 };
 function useCommand() {
-  return new Command25("use").description("bind this folder (and everything under it) to one brain").argument("[brain]", "path to the brain \u2014 omit to show what this folder resolves to").option("--here <dir>", "write the pointer in this directory instead of the cwd").option(
+  return new Command26("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",
-    "make this the brain used anywhere no pointer applies, instead of binding one folder"
+    "for a FOLDER on this machine: make it the one used wherever no pointer applies. Not for hosted brains \u2014 `--brain <name>` is that"
   ).action(async (brainPath, opts) => {
+    if (opts.brain !== void 0) {
+      await pointAtHosted(opts.brain, opts, brainPath);
+      return;
+    }
     const where = await canonicalize(resolve11(opts.here ?? process.cwd()));
     if (!brainPath) {
       const pointer = await readPointer(where);
       const resolved = await resolveBrain(void 0, where).catch((err) => err);
       const stuck = resolved instanceof Error;
       const hosted = await hostedPointer();
+      const stored = await readCredentials().catch(() => null);
+      const signedIn = stored !== null && stored.api_url === apiUrl();
       printDual({
         json: {
           // The brain that answers `recall` and takes `remember` — the same
@@ -13930,14 +14403,24 @@ function useCommand() {
           brain: stuck ? null : resolved.brain.root,
           via: stuck ? null : resolved.via,
           pointer: pointer ? pointer.from : null,
-          ...stuck ? {
+          // ONLY WHEN THE LOCAL FOLDER IS THE ANSWER. `stuck` describes the
+          // FOLDER resolver, and on a machine reading a hosted brain that
+          // resolver having nothing is the expected state, not a problem —
+          // but it was reported unqualified beside `destination: "hosted"`,
+          // so a successful switch produced `problem: "no_vault_linked"` and
+          // `message: "no brain is linked yet"` in the same document that
+          // named the brain it had just moved to. Two agents read `problem`
+          // first and would have told the user the switch failed.
+          //
+          // `--local` is how somebody asks what the folder side would do.
+          ...stuck && hosted?.signedIn !== true ? {
             problem: resolved.code ?? "unresolved",
             message: resolved.message
           } : {}
         },
         human: () => {
           if (hosted?.signedIn) {
-            printHuman(`Using the hosted brain \`${stripControl(hosted.name)}\`
+            printHuman(`Using the hosted brain \`${oneLine(hosted.name, NAME_WIDTH2)}\`
 `);
             printHuman(
               c.gray(
@@ -13958,7 +14441,7 @@ function useCommand() {
             );
             printHuman(
               c.yellow(
-                `  A sign-in to \`${stripControl(hosted.name)}\` is waiting to be approved.`
+                `  A sign-in to \`${oneLine(hosted.name, NAME_WIDTH2)}\` is waiting to be approved.`
               )
             );
             printHuman(
@@ -13975,7 +14458,9 @@ function useCommand() {
               printHuman(`No brain resolves here.
 `);
               printHuman(
-                c.yellow(`  Pointed at the hosted brain \`${stripControl(hosted.name)}\`,`) + c.gray(" with no sign-in on this machine that matches it,\n") + c.gray("  and no brain linked here either. `memgineering login` connects it.")
+                c.yellow(
+                  `  Pointed at the hosted brain \`${oneLine(hosted.name, NAME_WIDTH2)}\`,`
+                ) + c.gray(" with no sign-in on this machine that matches it,\n") + c.gray("  and no brain linked here either. `memgineering login` connects it.")
               );
               return;
             }
@@ -13984,7 +14469,7 @@ function useCommand() {
             printHuman(c.gray(`  ${VIA_MEANS[resolved.via]}`));
             printHuman(
               c.yellow(
-                `  This machine is pointed at the hosted brain \`${stripControl(hosted.name)}\` and is not signed in to it,`
+                `  This machine is pointed at the hosted brain \`${oneLine(hosted.name, NAME_WIDTH2)}\` and is not signed in to it,`
               ) + c.gray("\n  so reads and writes are landing here instead.")
             );
             printHuman(
@@ -13995,6 +14480,14 @@ function useCommand() {
           if (stuck) {
             printHuman(`No brain resolves here.
 `);
+            if (signedIn) {
+              printHuman(
+                c.yellow("  This machine is signed in, and pointed at no brain.") + c.gray(
+                  "\n  Your notes may be on the account rather than missing.\n  `memgineering brains` lists them; `memgineering use --brain <name>` points here.\n  `init` and `link` make a NEW empty brain on this machine \u2014 not what you want\n  if the notes are already on the account."
+                )
+              );
+              return;
+            }
             printHuman(c.gray(`  ${resolved.message}`));
             const hint = resolved.hint;
             if (hint) printHuman(c.gray(`
@@ -14061,13 +14554,114 @@ A pointer to an unlinked folder would fail on every command instead of at this o
     });
   });
 }
+var NAME_WIDTH2 = 72;
+function describeSize(count) {
+  if (count === void 0) return "";
+  if (count === 0)
+    return " \u2014 which is EMPTY. Nothing here has been lost; that brain has no notes yet";
+  return ` \u2014 ${count} note(s)`;
+}
+async function pointAtHosted(named, opts, path) {
+  if (named.startsWith("--")) {
+    throw memgError(
+      "invalid_input",
+      `\`--brain\` was given the flag \`${oneLine(named, 32)}\` as its name`,
+      "Nothing was changed. `--brain` takes the name or id of a hosted brain, and the\nflag written after it was read as that name. Put the name first \u2014 `memgineering\nuse --brain <name>` \u2014 and run the other flag as its own command."
+    );
+  }
+  const clash = path !== void 0 ? "a folder path" : opts.default === true ? "`--default`" : opts.here !== void 0 ? "`--here`" : null;
+  if (clash !== null) {
+    throw memgError(
+      "invalid_input",
+      `\`--brain\` cannot be combined with ${clash}`,
+      "They point different things. `--brain <name>` moves the one hosted brain this machine reads, which is a single setting for the whole machine; a path, `--default` and `--here` all bind a FOLDER on this disk. Run them separately."
+    );
+  }
+  const base = apiUrl();
+  const credentials = await requireCredentials(base).catch((err) => {
+    if (err instanceof MemgError && err.code === "not_signed_in") {
+      throw memgError(
+        "not_signed_in",
+        "this machine is not signed in to any account",
+        "Nothing was changed. `--brain` names a brain on an ACCOUNT, so there has to be one:\n\n  `memgineering login --emit-only`   then show the user the code, and re-run this\n\nA brain in a folder on this machine is a different thing and `use <path>` binds one."
+      );
+    }
+    throw err;
+  });
+  const brains = await listCloudBrains(credentials.token, base);
+  if (brains.length === 0) {
+    throw memgError(
+      "invalid_input",
+      "this account has no hosted brains",
+      "Nothing was changed. `memgineering push --brain <name>` creates one and fills it from a folder on this machine."
+    );
+  }
+  const found = brains.find((b) => b.id === named) ?? brains.find((b) => b.name === named);
+  if (!found) {
+    throw memgError(
+      "invalid_input",
+      `no hosted brain called "${oneLine(named, NAME_WIDTH2)}"`,
+      "Nothing was changed. This account has:\n" + brains.map((b) => `  ${oneLine(b.name, NAME_WIDTH2)}  (${oneLine(b.id, NAME_WIDTH2)})`).join("\n") + "\nIf one of those is the one they meant, use it. If they genuinely want a NEW\nnotebook, ASK THEM FIRST and say what it costs: `memgineering push --brain\n<name>` creates one by UPLOADING a folder into it, so a new brain arrives\nholding whatever that folder held \u2014 which on a fresh one is five empty\ntemplate files, not their notes. Creating one is not a way to find\nnotes that already exist."
+    );
+  }
+  const config = await loadConfig();
+  const previous = config.brain.cloud ?? null;
+  const unchanged = previous?.id === found.id && previous.api_url === base && previous.name === found.name;
+  if (!unchanged) {
+    await saveConfig({
+      ...config,
+      brain: { ...config.brain, cloud: { id: found.id, name: found.name, api_url: base } }
+    });
+  }
+  printDual({
+    json: {
+      brain: {
+        id: found.id,
+        name: found.name,
+        api_url: base,
+        // Carried because the human line says it. A caller that has to ask a
+        // second time to learn the destination is empty is a caller that will
+        // not ask.
+        ...found.note_count === void 0 ? {} : { note_count: found.note_count }
+      },
+      previous: previous ? { id: previous.id, name: previous.name } : null,
+      // Present even when nothing moved, so a caller can tell "already there"
+      // from "switched" without comparing two names itself.
+      changed: !unchanged
+    },
+    human: () => {
+      if (unchanged) {
+        printHuman(`Already using \`${oneLine(found.name, NAME_WIDTH2)}\`.
+`);
+        printHuman(c.gray("  Nothing changed."));
+        return;
+      }
+      printHuman(
+        `Now using the hosted brain \`${oneLine(found.name, NAME_WIDTH2)}\`${describeSize(found.note_count)}.
+`
+      );
+      if (previous) {
+        printHuman(
+          c.yellow(
+            `  This machine was reading \`${oneLine(previous.name, NAME_WIDTH2)}\` and now is not.`
+          )
+        );
+      }
+      printHuman(
+        c.gray(
+          "  Reads and writes go there from now on. Nothing was uploaded and nothing\n  was downloaded \u2014 `push` and `pull` are what move notes."
+        )
+      );
+    }
+  });
+}
 
 // src/commands/whoami.ts
 init_api_client();
 init_ui();
-import { Command as Command26 } from "commander";
+import { Command as Command27 } from "commander";
 function whoamiCommand() {
-  return new Command26("whoami").description("show which account this machine is signed in as").action(async () => {
+  return new Command27("whoami").description("show which account this machine is signed in as").action(async () => {
     const base = apiUrl();
     const credentials = await requireCredentials(base);
     const res = await apiRequest({
@@ -14093,9 +14687,11 @@ function whoamiCommand() {
       },
       human: () => {
         printHuman(
-          c.bold(stripControl(account.display_name ?? account.id ?? credentials.account_id))
+          c.bold(
+            oneLine(account.display_name ?? account.id ?? credentials.account_id, WIDTH.title)
+          )
         );
-        if (account.email) printHuman(c.gray(`  ${stripControl(account.email)}`));
+        if (account.email) printHuman(c.gray(`  ${oneLine(account.email, WIDTH.title)}`));
         printHuman(c.gray(`  on ${base}`));
         if (live !== null) {
           printHuman(
@@ -14110,6 +14706,8 @@ function whoamiCommand() {
 }
 
 // src/lib/next-step.ts
+init_api_client();
+init_credentials();
 init_config();
 function isSetUp(cfg) {
   return Object.keys(cfg.system.installed).length > 0;
@@ -14163,7 +14761,16 @@ Then run \`memgineering onboard\`: it prints what to ask so the brain knows whos
 it is. A brain whose \`01_BASE/\` is still template text answers almost nothing.
 
 Read \`memgineering-setup\` for accounts and which of their tools this reaches.`;
-function nextStepFor(cfg) {
+var POINT_AT_A_BRAIN = `## Signed in, and this machine reads no brain yet.
+
+\`memgineering brains\` lists what is on the account.
+\`memgineering use --brain <name>\` points this machine at one.
+`;
+function nextStepFor(cfg, signedIn = false) {
+  if (signedIn && cfg.brain.cloud === void 0) {
+    return { id: "point_at_a_brain", markdown: POINT_AT_A_BRAIN };
+  }
+  if (cfg.brain.cloud !== void 0 && cfg.brain.cloud.api_url === apiUrl()) return null;
   if (!isSetUp(cfg)) return { id: "finish_setup", markdown: FINISH_SETUP };
   if (cfg.brain.brains.length === 0 && cfg.brain.cloud === void 0) {
     return { id: "connect_a_brain", markdown: CONNECT_A_BRAIN };
@@ -14172,7 +14779,8 @@ function nextStepFor(cfg) {
 }
 async function currentNextStep() {
   try {
-    return nextStepFor(await loadConfig());
+    const stored = await readCredentials().catch(() => null);
+    return nextStepFor(await loadConfig(), stored !== null && stored.api_url === apiUrl());
   } catch {
     return null;
   }
@@ -14182,7 +14790,7 @@ async function currentNextStep() {
 init_ui();
 init_brand();
 function buildProgram() {
-  const program = new Command27("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 Command28("memgineering").version(VERSION).description("memgineering \u2014 one memory for the AI you connect").option("--json", "emit JSON to stdout instead of markdown", false).hook("preAction", async (thisCommand, actionCommand) => {
     const opts = thisCommand.optsWithGlobals();
     if (opts.json || process.env[BRAND.jsonEnvVar] === "1") setJsonMode(true);
     await announceNextStep(actionCommand.name());
@@ -14203,6 +14811,7 @@ function buildProgram() {
   program.addCommand(initCommand());
   program.addCommand(linkCommand());
   program.addCommand(useCommand());
+  program.addCommand(brainsCommand());
   program.addCommand(unlinkCommand());
   program.addCommand(reindexCommand());
   program.addCommand(syncRulesCommand());
@@ -14242,8 +14851,15 @@ function makeParseErrorsActionable(program) {
       outputError: (str, write) => {
         write(str);
         if (!/unknown option|unknown command|too many arguments/i.test(str)) return;
-        const flags = cmd.options.map((o) => o.long ?? o.short).filter(Boolean);
         const path = cmd.parent === null ? cmd.name() : `${cmd.parent.name()} ${cmd.name()}`;
+        if (/unknown command/i.test(str) && cmd.commands.length > 0) {
+          write(
+            `hint: ${path} has ${cmd.commands.map((c2) => c2.name()).sort().join(" ")}
+`
+          );
+          return;
+        }
+        const flags = cmd.options.map((o) => o.long ?? o.short).filter(Boolean);
         write(
           flags.length > 0 ? `hint: ${path} takes ${flags.join(" ")}
 ` : `hint: \`${path} --help\` lists what this takes.
@@ -14271,7 +14887,7 @@ async function handleError(err) {
     if (isJsonMode()) {
       printJson({ error: { code: err.code, message: err.message, hint: err.hint } });
     } else {
-      printHuman(c.red(`\u2717 ${stripControl(err.message)}`));
+      printHuman(c.red(`\u2717 ${oneLine(err.message, WIDTH.text)}`));
       for (const line of stripControl(err.hint).split("\n")) printHuman(c.gray(`  \u2192 ${line}`));
     }
     process.exit(1);
@@ -14288,7 +14904,7 @@ async function handleError(err) {
         }
       });
     } else {
-      printHuman(c.red(`\u2717 ${stripControl(err.message)}`));
+      printHuman(c.red(`\u2717 ${oneLine(err.message, WIDTH.text)}`));
       if (hintStr) {
         for (const line of stripControl(hintStr).split("\n")) printHuman(c.gray(`  \u2192 ${line}`));
       }
@@ -14296,7 +14912,7 @@ async function handleError(err) {
     process.exit(1);
   }
   if (isJsonMode()) printJson({ error: { code: "generic_failure", message: String(err) } });
-  else printHuman(c.red(`\u2717 ${stripControl(String(err))}`));
+  else printHuman(c.red(`\u2717 ${oneLine(String(err), WIDTH.text)}`));
   process.exit(1);
 }