memgineering 0.7.5 → 0.9.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",
       /**
@@ -168,10 +181,32 @@ 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 flat = oneLineWhole(text);
   const chars = [...flat];
   if (chars.length <= max) return flat;
-  return `${chars.slice(0, Math.max(1, max - 1)).join("").trimEnd()}\u2026`;
+  const budget = Math.max(1, max - 1);
+  let shown = chars.slice(0, budget).join("").trimEnd();
+  const next = chars[budget];
+  const cutsWord = next !== void 0 && /\S/.test(next) && /\S/.test(shown.at(-1) ?? "");
+  const lastSpace = shown.lastIndexOf(" ");
+  if (cutsWord && lastSpace >= Math.floor(budget * 0.6))
+    shown = shown.slice(0, lastSpace).trimEnd();
+  return `${shown}\u2026`;
+}
+function oneLineWhole(text) {
+  return stripControl(text).replace(/\s+/g, " ").trim();
+}
+function middleLine(text, max) {
+  const chars = [...oneLineWhole(text)];
+  if (chars.length <= max) return chars.join("");
+  if (max <= 1) return "\u2026";
+  const budget = max - 1;
+  const headLength = Math.max(1, Math.floor(budget * 0.4));
+  const tailLength = Math.max(1, budget - headLength);
+  return `${chars.slice(0, headLength).join("")}\u2026${chars.slice(-tailLength).join("")}`;
+}
+function printBlock(text) {
+  printHuman(stripControl(text));
 }
 function progress(text) {
   if (isInteractive()) process.stderr.write(kleur.gray(`  ${text}
@@ -187,13 +222,23 @@ function undoHint(opId, vault) {
 function quoteArg(value) {
   return /^[A-Za-z0-9._\/-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
 }
-var jsonMode, CONTROL_INTRODUCER, 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: 128,
+      /** A claim, a summary, a server hint — a sentence rather than a label. */
+      text: 200
+    };
     c = kleur;
   }
 });
@@ -221,11 +266,12 @@ var init_errors = __esm({
 
 // ../../packages/memory-engine/src/schema.ts
 import { z } from "zod";
-var MappingModeSchema, ProvenanceSchema, MemoryStatusSchema, ClaimConfidenceSchema, MemoryKindSchema, ClaimSchema, MemorySchema, RelationTypeSchema, RelationSourceSchema, RelationSchema;
+var MappingModeSchema, ScopeSourceSchema, ProvenanceSchema, MemoryStatusSchema, ClaimConfidenceSchema, MemoryKindSchema, ClaimSchema, MemorySchema, RelationTypeSchema, RelationSourceSchema, RelationSchema;
 var init_schema = __esm({
   "../../packages/memory-engine/src/schema.ts"() {
     "use strict";
     MappingModeSchema = z.enum(["explicit", "heuristic"]);
+    ScopeSourceSchema = z.enum(["explicit", "path", "none"]);
     ProvenanceSchema = z.object({
       /** Vault-relative path of the note this was mapped from. */
       sourcePath: z.string().min(1),
@@ -238,7 +284,9 @@ var init_schema = __esm({
        * here would be the engine learning one backend's internals.
        */
       sourceRevision: z.unknown(),
-      mapping: MappingModeSchema
+      mapping: MappingModeSchema,
+      /** Field-level provenance needed before scope may lower a semantic threshold. */
+      scopeSource: ScopeSourceSchema.optional()
     });
     MemoryStatusSchema = z.enum(["active", "superseded", "retired"]);
     ClaimConfidenceSchema = z.enum(["stated", "observed", "inferred"]);
@@ -618,6 +666,8 @@ function mapNoteToMemory(input) {
   const ns = explicit ? nsRaw : {};
   const id = asString(ns["id"]) ?? path;
   const title = asString(ns["title"]) ?? asString(frontmatter?.["title"]) ?? h1Of(outline.intro) ?? titleFromPath(path);
+  const declaredScope = asString(ns["scope"]);
+  const scope = declaredScope ?? scopeFromPath(path);
   const summary = asString(ns["summary"]) ?? outline.description ?? firstParagraph(outline.intro) ?? firstSectionParagraph(outline.sections) ?? null;
   const memory = {
     id,
@@ -632,7 +682,7 @@ function mapNoteToMemory(input) {
     })(),
     title,
     summary,
-    scope: asString(ns["scope"]) ?? scopeFromPath(path),
+    scope,
     current_claim: asString(ns["current_claim"]),
     status: statusOf(ns["status"], issues),
     // Only the author's own `binding: true`. Never inferred: guessing that a
@@ -650,7 +700,8 @@ function mapNoteToMemory(input) {
     provenance: {
       sourcePath: path,
       sourceRevision: revision,
-      mapping: explicit ? "explicit" : "heuristic"
+      mapping: explicit ? "explicit" : "heuristic",
+      scopeSource: declaredScope !== null ? "explicit" : scope === null ? "none" : "path"
     }
   };
   const claims = [];
@@ -764,7 +815,7 @@ var init_cache_io = __esm({
   "../../packages/memory-engine/src/view/cache-io.ts"() {
     "use strict";
     init_schema();
-    SCHEMA_VERSION = 5;
+    SCHEMA_VERSION = 6;
     POLICY_VERSION = 1;
     CacheEntrySchema = z2.object({
       path: z2.string().min(1),
@@ -1371,18 +1422,40 @@ var init_conflicts = __esm({
 });
 
 // ../../packages/memory-engine/src/recall/search.ts
+function splitMixedScript(token) {
+  return token.split(LATIN_HANGUL_BOUNDARY).filter((part) => part.length > 0);
+}
 function terms(text) {
-  return text.normalize("NFC").toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length > 0);
+  return [...text.normalize("NFC").toLowerCase().matchAll(TOKEN)].flatMap(
+    (match) => splitMixedScript(match[0])
+  );
+}
+function indexTerms(text) {
+  return [...text.normalize("NFC").toLowerCase().matchAll(TOKEN)].flatMap((match) => {
+    const token = match[0];
+    const exact = splitMixedScript(token);
+    if (!HAS_COMPONENT_SEPARATOR.test(token)) return exact;
+    const components = token.split(COMPONENT_SEPARATOR).filter((part) => part.length > 0).flatMap(splitMixedScript);
+    return [...exact, ...components];
+  });
+}
+function exactOnly(term) {
+  return HAS_COMPONENT_SEPARATOR.test(term) || new RegExp("\\p{N}", "u").test(term);
 }
 function startsWithFieldTerm(query, fieldTerms) {
-  if (query.length <= SUBSTRING_MIN) return false;
+  if (query.length <= SUBSTRING_MIN || !HANGUL.test(query)) return false;
   for (const f of fieldTerms) {
-    if (f.length >= SUBSTRING_MIN && f.length < query.length && query.startsWith(f)) return true;
+    if (HANGUL.test(f) && f.length >= SUBSTRING_MIN && f.length < query.length && query.startsWith(f))
+      return true;
   }
   return false;
 }
+function particleSuffixedFieldTerm(query, firstFieldTerm) {
+  if (!ONE_SYLLABLE_TOPIC_TERMS.has(query)) return false;
+  return PARTICLES.some((particle) => firstFieldTerm === `${query}${particle}`);
+}
 function variantsOf(term) {
-  if (!HANGUL.test(term)) return [term];
+  if (exactOnly(term) || !HANGUL.test(term)) return [term];
   for (const particle of PARTICLES) {
     if (!term.endsWith(particle)) continue;
     const stem = term.slice(0, -particle.length);
@@ -1390,19 +1463,22 @@ function variantsOf(term) {
   }
   return [term];
 }
-function fieldScore(queryTerms, field, weight) {
+function fieldScore(queryTerms, field, weight, allowLeadingOneSyllable = false) {
   if (field === null || field === "") return 0;
   const normalized = field.normalize("NFC").toLowerCase();
-  const fieldTerms = new Set(terms(field));
+  const orderedFieldTerms = indexTerms(field);
+  const fieldTerms = new Set(orderedFieldTerms);
   let score = 0;
-  for (const q of queryTerms) {
+  for (const [queryIndex, q] of queryTerms.entries()) {
     let best = 0;
     for (const variant of variantsOf(q)) {
       if (fieldTerms.has(variant)) {
         best = Math.max(best, weight);
-      } else if (variant.length >= SUBSTRING_MIN && normalized.includes(variant)) {
+      } else if (allowLeadingOneSyllable && queryIndex === 0 && particleSuffixedFieldTerm(variant, orderedFieldTerms[0])) {
+        best = Math.max(best, weight);
+      } else if (!exactOnly(variant) && variant.length >= SUBSTRING_MIN && normalized.includes(variant)) {
         best = Math.max(best, weight / 2);
-      } else if (startsWithFieldTerm(variant, fieldTerms)) {
+      } else if (!exactOnly(variant) && startsWithFieldTerm(variant, fieldTerms)) {
         best = Math.max(best, weight / 2);
       }
     }
@@ -1415,7 +1491,7 @@ function searchMemories(memories, query) {
   if (q.length === 0) return [];
   const scored = [];
   for (const memory of memories) {
-    let score = fieldScore(q, memory.title, WEIGHTS.title);
+    let score = fieldScore(q, memory.title, WEIGHTS.title, true);
     for (const alias of memory.aliases) score += fieldScore(q, alias, WEIGHTS.alias);
     for (const entity of memory.entities) score += fieldScore(q, entity, WEIGHTS.entity);
     score += fieldScore(q, memory.summary, WEIGHTS.summary);
@@ -1426,11 +1502,15 @@ function searchMemories(memories, query) {
     (a, b) => b.score !== a.score ? b.score - a.score : a.memory.id < b.memory.id ? -1 : 1
   );
 }
-var WEIGHTS, SUBSTRING_MIN, PARTICLES, HANGUL;
+var WEIGHTS, TOKEN, COMPONENT_SEPARATOR, HAS_COMPONENT_SEPARATOR, LATIN_HANGUL_BOUNDARY, SUBSTRING_MIN, PARTICLES, HANGUL, ONE_SYLLABLE_TOPIC_TERMS;
 var init_search = __esm({
   "../../packages/memory-engine/src/recall/search.ts"() {
     "use strict";
     WEIGHTS = { title: 6, alias: 4, entity: 3, summary: 2, scope: 1 };
+    TOKEN = /[./]?[\p{L}\p{N}]+(?:[._/-][\p{L}\p{N}]+)*/gu;
+    COMPONENT_SEPARATOR = /[._/-]+/u;
+    HAS_COMPONENT_SEPARATOR = /[._/-]/u;
+    LATIN_HANGUL_BOUNDARY = new RegExp("(?<=\\p{Script=Latin})(?=\\p{Script=Hangul})|(?<=\\p{Script=Hangul})(?=\\p{Script=Latin})", "u");
     SUBSTRING_MIN = 2;
     PARTICLES = [
       "\uC774\uB77C\uB3C4",
@@ -1468,6 +1548,7 @@ var init_search = __esm({
       "\uAED8"
     ];
     HANGUL = /[\uac00-\ud7a3]/;
+    ONE_SYLLABLE_TOPIC_TERMS = /* @__PURE__ */ new Set(["\uD0A4"]);
   }
 });
 
@@ -1485,7 +1566,7 @@ var init_chunks = __esm({
       avgLength;
       constructor(refs) {
         for (const ref of refs) {
-          const tokens = terms(ref.text);
+          const tokens = indexTerms(ref.text);
           if (tokens.length === 0) continue;
           const counts = /* @__PURE__ */ new Map();
           for (const token of tokens) counts.set(token, (counts.get(token) ?? 0) + 1);
@@ -1547,6 +1628,34 @@ var init_chunks = __esm({
 function isRecallDepth(value) {
   return typeof value === "string" && RECALL_DEPTHS.includes(value);
 }
+function isStrongDecisionMarker(term) {
+  return /^(?:정하|정했|정한|정해|결정하|결정했|결정한|합의하|합의했|합의한|지키|지켜|따르|골랐|고른)/u.test(
+    term
+  ) || /^(?:decide[ds]?|deciding|settle[ds]?|settling|agree[ds]?|agreeing|choose[ds]?|choosing|chose|chosen|follow(?:s|ed|ing)?)$/u.test(
+    term
+  );
+}
+function variantsInclude(term, candidates) {
+  return variantsOf(term).some((variant) => candidates.has(variant));
+}
+function isDecisionContext(term) {
+  return variantsInclude(term, DECISION_CONTEXT) || term.startsWith("\uC720\uD6A8");
+}
+function shapeRecallQuery(query) {
+  const queryTerms = terms(query);
+  const strong = queryTerms.some(isStrongDecisionMarker);
+  const noun = queryTerms.some((term) => variantsInclude(term, DECISION_NOUNS));
+  const contextual = queryTerms.some(isDecisionContext);
+  const decisionIntent = strong || noun && contextual;
+  if (!decisionIntent) return { lexical: query, decisionIntent: false };
+  const topical = queryTerms.filter(
+    (term) => !isStrongDecisionMarker(term) && !variantsInclude(term, DECISION_NOUNS) && !variantsInclude(term, DECISION_FILLERS) && !term.startsWith("\uC720\uD6A8")
+  );
+  return {
+    lexical: topical.length === 0 ? query : topical.join(" "),
+    decisionIntent
+  };
+}
 function freshnessOf(memory, claims, now) {
   if (memory.status === "superseded") return "superseded";
   if (memory.status === "retired") return "retired";
@@ -1573,12 +1682,14 @@ function recall(entries, query, opts = {}) {
   const claimsById = new Map(inScope.map((e) => [e.memory.id, e.claims]));
   const relations = inScope.flatMap((e) => e.relations);
   const allMemories = inScope.map((e) => e.memory);
-  const cardHits = searchMemories(allMemories, query);
+  const allMemoryIds = new Set(allMemories.map((memory) => memory.id));
+  const queryShape = shapeRecallQuery(query);
+  const cardHits = searchMemories(allMemories, queryShape.lexical);
   const chunkHits = depth === "exact" ? [] : new ChunkIndex(
     inScope.flatMap(
       (e) => (e.chunks ?? []).map((c2) => ({ memoryId: e.memory.id, label: c2.label, text: c2.text }))
     )
-  ).search(query);
+  ).search(queryShape.lexical);
   const semanticHits = depth === "exact" ? [] : opts.semantic ?? [];
   const scoreById = /* @__PURE__ */ new Map();
   for (const hit of cardHits) scoreById.set(hit.memory.id, hit.score);
@@ -1594,14 +1705,26 @@ function recall(entries, query, opts = {}) {
     const memory = memoryById.get(id);
     return memory === void 0 ? [] : [{ memory, score }];
   }).sort((a, b) => b.score !== a.score ? b.score - a.score : a.memory.id < b.memory.id ? -1 : 1);
-  const queryTerms = Math.max(1, terms(query).length);
+  const authoritativeSupersedes = queryShape.decisionIntent ? relations.filter(
+    (relation) => relation.type === "supersedes" && relation.source === "explicit" && relation.weight > 0 && allMemoryIds.has(relation.from) && allMemoryIds.has(relation.to)
+  ) : [];
+  const supersededByAnother = new Set(authoritativeSupersedes.map((relation) => relation.to));
+  const supersedingIds = new Set(
+    authoritativeSupersedes.map((relation) => relation.from).filter((id) => !supersededByAnother.has(id))
+  );
+  const queryTerms = Math.max(1, terms(queryShape.lexical).length);
   const scored = hits.map((hit) => ({
     memory: hit.memory,
     currency: CURRENCY_RANK[freshnessOf(hit.memory, claimsById.get(hit.memory.id) ?? [], now)],
-    score: hit.score + boostFor(hit.memory) / queryTerms
+    score: hit.score + boostFor(hit.memory) / queryTerms,
+    // Only a final tie-break, and only when the question asks for a standing
+    // decision. A valid outgoing supersedes edge says this note is the declared
+    // replacement; it does not say an off-topic replacement beats a better
+    // topical match.
+    superseding: supersedingIds.has(hit.memory.id)
   }));
   const ranked = scored.sort(
-    (a, b) => a.currency !== b.currency ? a.currency - b.currency : b.score !== a.score ? b.score - a.score : a.memory.id < b.memory.id ? -1 : 1
+    (a, b) => a.currency !== b.currency ? a.currency - b.currency : b.score !== a.score ? b.score - a.score : a.superseding !== b.superseding ? a.superseding ? -1 : 1 : a.memory.id < b.memory.id ? -1 : 1
   );
   const selected = ranked.slice(0, limit).map((s) => s.memory);
   const byId = new Map(allMemories.map((m) => [m.id, m]));
@@ -1686,7 +1809,7 @@ function depthOf(value) {
 function boostFor(memory) {
   return (memory.binding === true ? BINDING_BOOST : 0) + (memory.kind === void 0 ? 0 : KIND_BOOST[memory.kind] ?? 0);
 }
-var RECALL_DEPTHS, RecallOptionError, DEFAULTS, BODY_WEIGHT, SEMANTIC_WEIGHT, BINDING_BOOST, KIND_BOOST, CURRENCY_RANK, WIDEST_ESTIMATE;
+var RECALL_DEPTHS, RecallOptionError, DEFAULTS, BODY_WEIGHT, SEMANTIC_WEIGHT, BINDING_BOOST, KIND_BOOST, DECISION_NOUNS, DECISION_CONTEXT, DECISION_FILLERS, CURRENCY_RANK, WIDEST_ESTIMATE;
 var init_planner = __esm({
   "../../packages/memory-engine/src/recall/planner.ts"() {
     "use strict";
@@ -1716,6 +1839,60 @@ var init_planner = __esm({
       decision: BINDING_BOOST / 2,
       preference: BINDING_BOOST / 2
     };
+    DECISION_NOUNS = /* @__PURE__ */ new Set([
+      "\uACB0\uC815",
+      "\uADDC\uCE59",
+      "\uB8F0",
+      "\uD569\uC758",
+      "decision",
+      "decisions",
+      "rule",
+      "rules",
+      "agreement"
+    ]);
+    DECISION_CONTEXT = /* @__PURE__ */ new Set([
+      "\uC9C0\uAE08",
+      "\uD604\uC7AC",
+      "\uC544\uC9C1",
+      "\uC608\uC804\uC5D0",
+      "\uBB58",
+      "\uBB50",
+      "\uBB34\uC5C7",
+      "\uC5B4\uB5BB\uAC8C",
+      "what",
+      "which",
+      "did",
+      "now",
+      "current",
+      "currently",
+      "still"
+    ]);
+    DECISION_FILLERS = /* @__PURE__ */ new Set([
+      ...DECISION_CONTEXT,
+      "\uB0B4\uAC00",
+      "\uC6B0\uB9AC\uAC00",
+      "\uC6B0\uB9AC",
+      "\uB300\uD574",
+      "\uAD00\uD574",
+      "\uD558\uB294",
+      "\uD588\uB358",
+      "\uD560",
+      "\uAC83",
+      "\uBC18\uB4DC\uC2DC",
+      "\uC911",
+      "about",
+      "on",
+      "for",
+      "to",
+      "do",
+      "does",
+      "is",
+      "the",
+      "we",
+      "i",
+      "our",
+      "my"
+    ]);
     CURRENCY_RANK = {
       current: 0,
       expired: 1,
@@ -1958,18 +2135,21 @@ function detectConsolidation(entries, opts = {}) {
     scanned: 0,
     truncated: false
   };
-  const out = [
-    ...similarTitles(live, budget),
-    ...sharedContext(live, budget),
-    // Neither of these enumerates pairs — one walks declared edges, the other
-    // walks notes — so neither can be the thing that blows up, and neither
-    // spends the budget.
+  const semanticExcluded = semanticGlobalExclusions(live, []);
+  const semantic = opts.semantic === void 0 ? [] : boundedSemanticSimilarities(live, budget, opts.semantic, semanticExcluded);
+  const titles = similarTitles(live, budget);
+  const context = sharedContext(live, budget);
+  const scored = [
+    // Declared edges enumerate no pairs and spend no budget. Supersession is
+    // first because it names both the winner and the still-active loser.
+    ...declaredSupersessions(live),
     ...declaredContradictions(live),
-    ...kindPromotions(live)
+    ...kindPromotions(live),
+    ...semantic,
+    ...context,
+    ...titles
   ];
-  out.sort(
-    (a, b) => CONSOLIDATION_RULES.indexOf(a.rule) - CONSOLIDATION_RULES.indexOf(b.rule) || a.memory_id.localeCompare(b.memory_id) || (a.other_id ?? "").localeCompare(b.other_id ?? "")
-  );
+  const out = rankCandidates(scored);
   return {
     candidates: out.slice(0, opts.limit ?? DEFAULT_LIMIT),
     scanned: budget.scanned,
@@ -1991,24 +2171,63 @@ function overlap(a, b) {
 }
 function similarTitles(entries, budget) {
   const termSets = entries.map((e) => titleTerms(e.memory.title));
+  const cyclicKeys = entries.map((entry) => cyclicTitleKey(entry.memory.title));
   const buckets = /* @__PURE__ */ new Map();
+  const byCyclicTitle = /* @__PURE__ */ new Map();
   termSets.forEach((set, i) => {
+    const cyclicKey = cyclicKeys[i];
+    if (cyclicKey !== null && cyclicKey !== void 0) addToBucket(byCyclicTitle, cyclicKey, i);
     for (const term of set) {
       const bucket = buckets.get(term);
       if (bucket) bucket.push(i);
       else buckets.set(term, [i]);
     }
   });
-  const out = [];
+  const out = cyclicTitleSpanningCandidates(entries, byCyclicTitle);
   for (const [i, j] of pairsFrom(buckets, budget)) {
     const score = overlap(termSets[i], termSets[j]);
     if (score < TITLE_OVERLAP) continue;
-    out.push(
-      pairCandidate("similar_title", entries[i], entries[j], {
+    out.push({
+      candidate: pairCandidate("similar_title", entries[i], entries[j], {
         evidence: `titles overlap ${Math.round(score * 100)}%: "${entries[i].memory.title}" / "${entries[j].memory.title}"`,
         suggested_action: "supersede"
-      })
+      }),
+      // Exact lexical identity is a little stronger than the broad
+      // scope+entity rule. This changes only ordering/evidence selection — the
+      // same pair was already detected at the 2/3 threshold.
+      confidence: score === 1 && cyclicKeys[i] !== null && cyclicKeys[i] === cyclicKeys[j] ? 2.01 : 1 + score
+    });
+  }
+  return out;
+}
+function cyclicTitleKey(title) {
+  const sequence = terms(title).map((term) => term.normalize("NFC").toLowerCase());
+  if (sequence.length === 0) return null;
+  if (sequence.length < 3) return sequence.join("\0");
+  let best = null;
+  for (let offset = 0; offset < sequence.length; offset += 1) {
+    const key2 = [...sequence.slice(offset), ...sequence.slice(0, offset)].join("\0");
+    if (best === null || key2 < best) best = key2;
+  }
+  return best;
+}
+function cyclicTitleSpanningCandidates(entries, buckets) {
+  const out = [];
+  for (const indices of buckets.values()) {
+    if (indices.length < 2) continue;
+    const ordered = [...indices].sort(
+      (a, b) => entries[a].memory.id.localeCompare(entries[b].memory.id) || entries[a].path.localeCompare(entries[b].path)
     );
+    const anchor = ordered[0];
+    for (const other of ordered.slice(1)) {
+      out.push({
+        candidate: pairCandidate("similar_title", entries[anchor], entries[other], {
+          evidence: `titles overlap 100%: "${entries[anchor].memory.title}" / "${entries[other].memory.title}"`,
+          suggested_action: "supersede"
+        }),
+        confidence: 2.01
+      });
+    }
   }
   return out;
 }
@@ -2038,12 +2257,221 @@ function sharedContext(entries, budget) {
     }
     for (const [i, j] of pairsFrom(byEntity, budget)) {
       const shared = [...entitySets.get(i)].filter((e) => entitySets.get(j).has(e));
-      out.push(
-        pairCandidate("shared_context", entries[i], entries[j], {
+      out.push({
+        candidate: pairCandidate("shared_context", entries[i], entries[j], {
           evidence: `both in scope "${scope}" and both about: ${shared.sort().join(", ")}`,
           suggested_action: "supersede"
-        })
-      );
+        }),
+        confidence: 2
+      });
+    }
+  }
+  return out;
+}
+function boundedSemanticSimilarities(entries, budget, source, globalExcluded) {
+  const semanticBudget = {
+    left: Math.min(budget.left, SEMANTIC_PAIR_BUDGET),
+    scanned: 0,
+    truncated: false
+  };
+  const out = semanticSimilarities(entries, semanticBudget, source, globalExcluded);
+  budget.left -= semanticBudget.scanned;
+  budget.scanned += semanticBudget.scanned;
+  budget.truncated ||= semanticBudget.truncated;
+  return out;
+}
+function semanticSimilarities(entries, budget, source, globalExcluded) {
+  const buckets = /* @__PURE__ */ new Map();
+  const scopes = entries.map(declaredSemanticScope);
+  const entities = entries.map(
+    (entry) => new Set(entry.memory.entities.map((entity) => normalizeContext(entity)).filter(isPresent))
+  );
+  entries.forEach((entry, i) => {
+    if (!source.has(entry.memory.id)) return;
+    const scope = scopes[i];
+    if (scope !== null) addToBucket(buckets, `scope:${scope}`, i);
+    for (const entity of entities[i]) addToBucket(buckets, `entity:${entity}`, i);
+    if (scope === null && entities[i].size === 0 && !globalExcluded.has(entry.memory.id)) {
+      addToBucket(buckets, "global:unanchored", i);
+    }
+  });
+  const observations = [];
+  const byIndex = /* @__PURE__ */ new Map();
+  for (const [i, j] of pairsFrom(buckets, budget)) {
+    const sharedScope = scopes[i] !== null && scopes[i] === scopes[j] ? scopes[i] : null;
+    const sharedEntities = [...entities[i]].filter((entity) => entities[j].has(entity)).sort();
+    const contextual = sharedScope !== null || sharedEntities.length > 0;
+    const raw = source.compare(entries[i].memory.id, entries[j].memory.id);
+    if (raw === null || raw === void 0 || !Number.isFinite(raw)) continue;
+    const score = Math.max(-1, Math.min(1, raw));
+    const threshold = sharedScope !== null ? SAME_SCOPE_SEMANTIC_SIMILARITY : sharedEntities.length > 0 ? SHARED_ENTITY_SEMANTIC_SIMILARITY : GLOBAL_SEMANTIC_SIMILARITY;
+    if (score < threshold) continue;
+    const observation = {
+      i,
+      j,
+      key: indexPairKey(i, j),
+      score,
+      context: !contextual ? "with no lexical context, corroborated by a three-note semantic cluster" : sharedScope === null ? `inside shared entity ${sharedEntities.join(", ")}` : `inside scope "${entries[i].memory.scope ?? sharedScope}"`,
+      contextual
+    };
+    observations.push(observation);
+    addObservation(byIndex, i, observation);
+    addObservation(byIndex, j, observation);
+  }
+  if (budget.truncated) return [];
+  const nearest = /* @__PURE__ */ new Map();
+  for (const [i, adjacent] of byIndex) {
+    const ranked = adjacent.sort((a, b) => b.score - a.score || a.key.localeCompare(b.key)).slice(0, RECIPROCAL_NEIGHBOURS);
+    nearest.set(i, new Set(ranked.map((observation) => observation.key)));
+  }
+  const reciprocal = observations.filter(
+    (observation) => nearest.get(observation.i)?.has(observation.key) === true && nearest.get(observation.j)?.has(observation.key) === true
+  );
+  const corroborated = triangleEdges(reciprocal);
+  return reciprocal.filter((observation) => corroborated.has(observation.key)).map((observation) => ({
+    candidate: pairCandidate(
+      "semantic_similarity",
+      entries[observation.i],
+      entries[observation.j],
+      {
+        evidence: `indexed meaning is ${Math.round(observation.score * 100)}% similar ${observation.context} (reciprocal top-${RECIPROCAL_NEIGHBOURS}, three-note cluster)`,
+        suggested_action: "supersede"
+      }
+    ),
+    // Unanchored embedding evidence deliberately waits behind authored
+    // context and strict lexical matches even after triangle corroboration.
+    confidence: observation.contextual ? 3 + observation.score : 1.9
+  }));
+}
+function triangleEdges(observations) {
+  const adjacent = /* @__PURE__ */ new Map();
+  for (const observation of observations) {
+    addNeighbour(adjacent, observation.i, observation.j);
+    addNeighbour(adjacent, observation.j, observation.i);
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const observation of observations) {
+    const left = adjacent.get(observation.i) ?? /* @__PURE__ */ new Set();
+    const right = adjacent.get(observation.j) ?? /* @__PURE__ */ new Set();
+    if ([...left].some((index) => index !== observation.j && right.has(index))) {
+      out.add(observation.key);
+    }
+  }
+  return out;
+}
+function addNeighbour(values, from, to) {
+  const adjacent = values.get(from);
+  if (adjacent) adjacent.add(to);
+  else values.set(from, /* @__PURE__ */ new Set([to]));
+}
+function semanticGlobalExclusions(entries, titleCandidates) {
+  const out = /* @__PURE__ */ new Set();
+  const liveIds = new Set(entries.map((entry) => entry.memory.id));
+  for (const entry of entries) {
+    if (entry.relations.length === 0) continue;
+    out.add(entry.memory.id);
+    for (const relation of entry.relations) if (liveIds.has(relation.to)) out.add(relation.to);
+  }
+  for (const { candidate } of titleCandidates) {
+    out.add(candidate.memory_id);
+    if (candidate.other_id !== null) out.add(candidate.other_id);
+  }
+  return out;
+}
+function addObservation(byIndex, index, observation) {
+  const values = byIndex.get(index);
+  if (values) values.push(observation);
+  else byIndex.set(index, [observation]);
+}
+function declaredSupersessions(entries) {
+  const byId = new Map(entries.map((entry) => [entry.memory.id, entry]));
+  const cyclicEdges = cyclicSupersessionEdges(entries, byId);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const winner of entries) {
+    for (const relation of winner.relations) {
+      if (relation.type !== "supersedes") continue;
+      const loser = byId.get(relation.to);
+      if (!loser || loser.memory.id === winner.memory.id) continue;
+      if (cyclicEdges.has(directedPairKey(winner.memory.id, loser.memory.id))) continue;
+      const key2 = memoryPairKey(winner.memory.id, loser.memory.id);
+      if (seen.has(key2)) continue;
+      seen.add(key2);
+      out.push({
+        candidate: pairCandidate("declared_supersession", loser, winner, {
+          evidence: `"${winner.memory.title}" already declares it supersedes "${loser.memory.title}", but the replaced note is still active`,
+          suggested_action: "retire"
+        }),
+        confidence: 6
+      });
+    }
+  }
+  return out;
+}
+function cyclicSupersessionEdges(entries, byId) {
+  const adjacent = /* @__PURE__ */ new Map();
+  const reversed = /* @__PURE__ */ new Map();
+  for (const id of byId.keys()) {
+    adjacent.set(id, []);
+    reversed.set(id, []);
+  }
+  for (const entry of entries) {
+    for (const relation of entry.relations) {
+      if (relation.type !== "supersedes" || relation.to === entry.memory.id) continue;
+      if (!byId.has(relation.to)) continue;
+      adjacent.get(entry.memory.id).push(relation.to);
+      reversed.get(relation.to).push(entry.memory.id);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const finished = [];
+  for (const start of byId.keys()) {
+    if (visited.has(start)) continue;
+    visited.add(start);
+    const stack = [{ id: start, next: 0 }];
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      const neighbours = adjacent.get(frame.id) ?? [];
+      if (frame.next < neighbours.length) {
+        const neighbour = neighbours[frame.next];
+        frame.next += 1;
+        if (!visited.has(neighbour)) {
+          visited.add(neighbour);
+          stack.push({ id: neighbour, next: 0 });
+        }
+      } else {
+        finished.push(frame.id);
+        stack.pop();
+      }
+    }
+  }
+  const componentById = /* @__PURE__ */ new Map();
+  const componentSizes = /* @__PURE__ */ new Map();
+  let component = 0;
+  for (let index = finished.length - 1; index >= 0; index -= 1) {
+    const start = finished[index];
+    if (componentById.has(start)) continue;
+    const stack = [start];
+    componentById.set(start, component);
+    let size = 0;
+    while (stack.length > 0) {
+      const id = stack.pop();
+      size += 1;
+      for (const neighbour of reversed.get(id) ?? []) {
+        if (componentById.has(neighbour)) continue;
+        componentById.set(neighbour, component);
+        stack.push(neighbour);
+      }
+    }
+    componentSizes.set(component, size);
+    component += 1;
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const [from, targets] of adjacent) {
+    const fromComponent = componentById.get(from);
+    if (fromComponent === void 0 || (componentSizes.get(fromComponent) ?? 0) < 2) continue;
+    for (const to of targets) {
+      if (componentById.get(to) === fromComponent) out.add(directedPairKey(from, to));
     }
   }
   return out;
@@ -2057,15 +2485,16 @@ function declaredContradictions(entries) {
       if (relation.type !== "contradicts") continue;
       const other = byId.get(relation.to);
       if (!other || other.memory.id === entry.memory.id) continue;
-      const key2 = [entry.memory.id, other.memory.id].sort().join("\0");
+      const key2 = memoryPairKey(entry.memory.id, other.memory.id);
       if (seen.has(key2)) continue;
       seen.add(key2);
-      out.push(
-        pairCandidate("contradiction", entry, other, {
+      out.push({
+        candidate: pairCandidate("contradiction", entry, other, {
           evidence: `"${entry.memory.title}" declares it contradicts "${other.memory.title}" \u2014 recorded, never settled`,
           suggested_action: "supersede"
-        })
-      );
+        }),
+        confidence: 5
+      });
     }
   }
   return out;
@@ -2076,20 +2505,88 @@ function kindPromotions(entries) {
     if (entry.memory.binding !== true) continue;
     if (entry.memory.kind === "decision") continue;
     out.push({
-      rule: "kind_promotion",
-      memory_id: entry.memory.id,
-      path: entry.path,
-      title: entry.memory.title,
-      other_id: null,
-      other_path: null,
-      other_title: null,
-      evidence: entry.memory.kind === void 0 ? "marked as binding but left unclassified \u2014 a memory that binds is a decision" : `marked as binding but classified as ${entry.memory.kind} \u2014 a memory that binds is a decision`,
-      suggested_action: "reclassify",
-      suggested_kind: "decision"
+      candidate: {
+        rule: "kind_promotion",
+        memory_id: entry.memory.id,
+        path: entry.path,
+        title: entry.memory.title,
+        other_id: null,
+        other_path: null,
+        other_title: null,
+        evidence: entry.memory.kind === void 0 ? "marked as binding but left unclassified \u2014 a memory that binds is a decision" : `marked as binding but classified as ${entry.memory.kind} \u2014 a memory that binds is a decision`,
+        suggested_action: "reclassify",
+        suggested_kind: "decision"
+      },
+      confidence: 4
     });
   }
   return out;
 }
+function normalizeContext(value) {
+  if (value === null) return null;
+  const normalized = value.normalize("NFC").trim().toLowerCase();
+  return normalized === "" ? null : normalized;
+}
+function declaredSemanticScope(entry) {
+  const scope = normalizeContext(entry.memory.scope);
+  if (scope === null) return null;
+  if (entry.memory.provenance.scopeSource === "explicit") return scope;
+  if (entry.memory.provenance.scopeSource === "path") return null;
+  const parts = entry.path.split("/");
+  const parent = parts.length >= 2 ? normalizeContext(parts[parts.length - 2] ?? null) : null;
+  return scope === parent ? null : scope;
+}
+function isPresent(value) {
+  return value !== null;
+}
+function addToBucket(buckets, key2, index) {
+  const bucket = buckets.get(key2);
+  if (bucket) bucket.push(index);
+  else buckets.set(key2, [index]);
+}
+function memoryPairKey(left, right) {
+  return left < right ? `${left}\0${right}` : `${right}\0${left}`;
+}
+function directedPairKey(from, to) {
+  return `${from}\0${to}`;
+}
+function indexPairKey(left, right) {
+  return left < right ? `${left}:${right}` : `${right}:${left}`;
+}
+function rankCandidates(scored) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const item of scored) {
+    const candidate = item.candidate;
+    const key2 = candidate.other_id === null ? `single:${candidate.rule}:${candidate.memory_id}` : `pair:${memoryPairKey(candidate.memory_id, candidate.other_id)}`;
+    const current = unique.get(key2);
+    if (current === void 0 || compareScored(item, current) < 0) unique.set(key2, item);
+  }
+  const ordered = [...unique.values()].sort(compareScored);
+  const tiers = /* @__PURE__ */ new Map();
+  for (const item of ordered) addScored(tiers, Math.floor(item.confidence), item);
+  const components = new CandidateComponents();
+  const out = [];
+  for (const tier of [...tiers.keys()].sort((a, b) => b - a)) {
+    const useful = [];
+    const cycles = [];
+    for (const item of tiers.get(tier) ?? []) {
+      const other = item.candidate.other_id;
+      if (other === null || components.join(item.candidate.memory_id, other)) useful.push(item);
+      else cycles.push(item);
+    }
+    for (const item of useful) out.push(item.candidate);
+    for (const item of cycles) out.push(item.candidate);
+  }
+  return out;
+}
+function addScored(tiers, tier, item) {
+  const values = tiers.get(tier);
+  if (values) values.push(item);
+  else tiers.set(tier, [item]);
+}
+function compareScored(a, b) {
+  return b.confidence - a.confidence || CONSOLIDATION_RULES.indexOf(a.candidate.rule) - CONSOLIDATION_RULES.indexOf(b.candidate.rule) || a.candidate.memory_id.localeCompare(b.candidate.memory_id) || (a.candidate.other_id ?? "").localeCompare(b.candidate.other_id ?? "");
+}
 function pairCandidate(rule, a, b, rest) {
   return {
     rule,
@@ -2125,20 +2622,54 @@ function* pairsFrom(buckets, budget) {
     }
   }
 }
-var CONSOLIDATION_RULES, DEFAULT_LIMIT, DEFAULT_PAIR_BUDGET, TITLE_OVERLAP;
+var CONSOLIDATION_RULES, DEFAULT_LIMIT, DEFAULT_PAIR_BUDGET, SEMANTIC_PAIR_BUDGET, TITLE_OVERLAP, SAME_SCOPE_SEMANTIC_SIMILARITY, SHARED_ENTITY_SEMANTIC_SIMILARITY, GLOBAL_SEMANTIC_SIMILARITY, RECIPROCAL_NEIGHBOURS, CandidateComponents;
 var init_detect = __esm({
   "../../packages/memory-engine/src/proposal/detect.ts"() {
     "use strict";
     init_search();
     CONSOLIDATION_RULES = [
-      "similar_title",
-      "shared_context",
+      "declared_supersession",
       "contradiction",
+      "semantic_similarity",
+      "shared_context",
+      "similar_title",
       "kind_promotion"
     ];
     DEFAULT_LIMIT = 50;
     DEFAULT_PAIR_BUDGET = 2e5;
-    TITLE_OVERLAP = 0.6;
+    SEMANTIC_PAIR_BUDGET = 5e4;
+    TITLE_OVERLAP = 2 / 3;
+    SAME_SCOPE_SEMANTIC_SIMILARITY = 0.6;
+    SHARED_ENTITY_SEMANTIC_SIMILARITY = 0.75;
+    GLOBAL_SEMANTIC_SIMILARITY = 0.72;
+    RECIPROCAL_NEIGHBOURS = 2;
+    CandidateComponents = class {
+      parent = /* @__PURE__ */ new Map();
+      root(id) {
+        const trail = [];
+        let current = id;
+        for (; ; ) {
+          const parent = this.parent.get(current);
+          if (parent === void 0) {
+            this.parent.set(current, current);
+            break;
+          }
+          if (parent === current) break;
+          trail.push(current);
+          current = parent;
+        }
+        for (const member of trail) this.parent.set(member, current);
+        return current;
+      }
+      /** True when this edge connected two components rather than closing a cycle. */
+      join(left, right) {
+        const a = this.root(left);
+        const b = this.root(right);
+        if (a === b) return false;
+        this.parent.set(b, a);
+        return true;
+      }
+    };
   }
 });
 
@@ -2660,6 +3191,86 @@ function restoreUntouchedLines(original, rendered, changed) {
     return before.get(key2) ?? line;
   }).join("\n");
 }
+function yamlErrorLine(error, text) {
+  const message = error instanceof Error ? error.message : String(error);
+  let positioned = null;
+  if (error && typeof error === "object") {
+    const linePos = error.linePos;
+    const line = linePos?.[0]?.line;
+    if (typeof line === "number" && Number.isFinite(line) && line >= 1) positioned = line - 1;
+  }
+  const quote = /Missing closing (["'])quote/i.exec(message)?.[1];
+  if (quote !== void 0) {
+    const lines2 = text.split("\n");
+    const end = positioned ?? lines2.length - 1;
+    for (let i = 0; i <= end; i += 1) {
+      const line = lines2[i] ?? "";
+      const colon = line.indexOf(":");
+      if (colon === -1) continue;
+      const value = line.slice(colon + 1);
+      let count = 0;
+      for (let at = 0; at < value.length; at += 1) {
+        if (value[at] !== quote) continue;
+        let slashes = 0;
+        for (let before = at - 1; before >= 0 && value[before] === "\\"; before -= 1) slashes += 1;
+        if (slashes % 2 === 0) count += 1;
+      }
+      if (count % 2 === 1) return i;
+    }
+  }
+  if (positioned !== null) return positioned;
+  const namedLine = /\bat line (\d+)\b/i.exec(message)?.[1];
+  if (namedLine !== void 0) return Math.max(0, Number(namedLine) - 1);
+  const alias = /alias[^:]*:\s*([^\s]+)/i.exec(message)?.[1];
+  if (alias !== void 0) {
+    const found = text.split("\n").findIndex((line) => line.includes(`*${alias}`));
+    if (found !== -1) return found;
+  }
+  return 0;
+}
+function yamlFieldAt(text, line, fallback) {
+  const stack = [];
+  const lines2 = text.split("\n");
+  const end = Math.min(Math.max(line, 0), Math.max(lines2.length - 1, 0));
+  for (let i = 0; i <= end; i += 1) {
+    const match = ANY_INDENTED_KEY_RE.exec(lines2[i] ?? "");
+    if (!match) continue;
+    const whitespace = match[1] ?? "";
+    const indent = whitespace.length;
+    while ((stack.at(-1)?.indent ?? -1) >= indent) stack.pop();
+    stack.push({ indent, key: (match[2] ?? "").trim() });
+  }
+  return stack.length > 0 ? stack.map(({ key: key2 }) => key2).join(".") : fallback;
+}
+function yamlFieldRefusal(text, error, fallback) {
+  const message = error instanceof Error ? error.message : String(error);
+  const localField = yamlFieldAt(text, yamlErrorLine(error, text), fallback);
+  const field = fallback === NAMESPACE2 && localField !== NAMESPACE2 ? `${NAMESPACE2}.${localField}` : localField;
+  const code = error && typeof error === "object" && typeof error.code === "string" ? error.code : "";
+  let change;
+  if (code === "TAB_AS_INDENT" || /tab/i.test(message)) {
+    change = `Replace the tab indentation in ${field} with spaces`;
+  } else if (/alias|anchor/i.test(message)) {
+    change = `Replace the anchor or alias used by ${field} with its value inline`;
+  } else if (code === "DUPLICATE_KEY" || /keys? must be unique/i.test(message)) {
+    change = `Remove or rename the duplicate ${field} field`;
+  } else {
+    change = `Fix ${field} so it is valid YAML (close its quotes or brackets, and quote any value containing a colon)`;
+  }
+  return new PatchError(
+    `the ${field} field could not be rewritten safely: ${message}`,
+    `${change}, then try again. Nothing was written.`
+  );
+}
+function assertReadableFrontmatter(frontmatter) {
+  try {
+    const doc = parseDocument(frontmatter);
+    if (doc.errors[0]) throw doc.errors[0];
+    doc.toJS();
+  } catch (error) {
+    throw yamlFieldRefusal(frontmatter, error, "frontmatter");
+  }
+}
 function renderBlock(fields, existingText) {
   let body;
   if (existingText === null || existingText.trim() === "") {
@@ -2667,6 +3278,7 @@ function renderBlock(fields, existingText) {
   } else {
     try {
       const doc = parseDocument(existingText);
+      if (doc.errors[0]) throw doc.errors[0];
       const changed = /* @__PURE__ */ new Set();
       for (const [key2, value] of Object.entries(fields)) {
         const current = doc.get(key2);
@@ -2680,14 +3292,21 @@ function renderBlock(fields, existingText) {
       }
       body = restoreUntouchedLines(
         existingText,
-        doc.toString({ lineWidth: 0 }).replace(/\n$/, ""),
+        doc.toString({
+          lineWidth: 0,
+          // `yaml` turns a double-quoted scalar containing `\n` into three
+          // physical lines once its JSON representation reaches 40 chars.
+          // `restoreUntouchedLines` then sees the blank middle line, mistakes
+          // the first one for a complete scalar, and restores it while
+          // leaving the continuation behind. Keeping quoted newlines escaped
+          // makes an untouched field one physical line on both sides, so the
+          // byte-preserving restore and the YAML renderer agree on its span.
+          doubleQuotedMinMultiLineLength: Number.POSITIVE_INFINITY
+        }).replace(/\n$/, ""),
         changed
       );
     } catch (err) {
-      throw new PatchError(
-        `the memgineering block in this note could not be rewritten: ${err.message}`,
-        "Its YAML uses something this tool cannot rewrite safely \u2014 most often a tab indent, or an anchor/alias defined outside the block. Re-indent with spaces or inline the value, then try again. Nothing was written."
-      );
+      throw yamlFieldRefusal(existingText, err, NAMESPACE2);
     }
   }
   return [`${NAMESPACE2}:`, ...body.split("\n").map((l) => l === "" ? l : `  ${l}`)];
@@ -2717,6 +3336,7 @@ ${block.join("\n")}
     };
   }
   const fenceBody = fenceMatch[1] ?? "";
+  assertReadableFrontmatter(fenceBody);
   const fenceLines = splitLines(fenceBody);
   const span = findBlock(fenceLines);
   const existing = readNamespace(noteContent);
@@ -2882,7 +3502,7 @@ function reversePatch(content, patch) {
   }
   return null;
 }
-var NAMESPACE2, FENCE_RE, LOOKS_FENCED_RE, PatchError, BLOCK_KEY_RE;
+var NAMESPACE2, FENCE_RE, LOOKS_FENCED_RE, PatchError, BLOCK_KEY_RE, ANY_INDENTED_KEY_RE;
 var init_patch = __esm({
   "../../packages/memory-engine/src/proposal/patch.ts"() {
     "use strict";
@@ -2900,6 +3520,7 @@ var init_patch = __esm({
       }
     };
     BLOCK_KEY_RE = /^([^\s#][^:]*?)\s*:/;
+    ANY_INDENTED_KEY_RE = /^(\s*)([^\s#][^:]*?)\s*:/;
   }
 });
 
@@ -4430,13 +5051,17 @@ 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 ${middleLine(r.path, WIDTH.path)}`));
             }
             printHuman(
-              c.gray(`
-  ${rows.length} note(s). Run without --dry-run to index them.`)
+              c.gray(
+                `
+  ${rows.length} note(s). After the person approves this preview, run again with --yes to index them.`
+              )
             );
             if (refusedWhilePreviewing.length > 0) {
               printHuman(
@@ -4705,8 +5330,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(
@@ -4826,7 +5451,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."));
         }
@@ -4899,13 +5524,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(
@@ -4913,7 +5538,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(
@@ -4955,7 +5580,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."));
         }
@@ -5056,17 +5681,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")
@@ -5074,12 +5701,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":
@@ -7387,11 +8016,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>",
@@ -7463,6 +8092,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,
@@ -7486,9 +8127,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);
@@ -7589,7 +8248,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 () => {
@@ -7601,11 +8260,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 {
@@ -7613,7 +8272,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),
@@ -7629,7 +8288,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,
@@ -7699,7 +8358,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);
@@ -7832,7 +8491,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) {
@@ -7882,7 +8541,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;
@@ -8093,7 +8752,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();
@@ -8117,7 +8776,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",
@@ -8130,7 +8789,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(" ");
@@ -8283,12 +8947,16 @@ 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) {
+function findCloudBrain(brains, named) {
+  return brains.find((brain) => brain.id === named) ?? brains.find((brain) => brain.name === named);
+}
+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 ?? [];
 }
@@ -8360,11 +9028,11 @@ function describeHeldBack(held) {
   return [
     ...heldBackGroups(held).flatMap(
       ({ label, rows }) => rows.map(
-        (r) => `${stripControl(r.path)}  \u2014 ${label}${r.detail === null ? "" : ` (${stripControl(r.detail)})`}`
+        (r) => `${oneLine(r.path, WIDTH.path)}  \u2014 ${label}${r.detail === null ? "" : ` (${oneLine(r.detail, WIDTH.text)})`}`
       )
     ),
     ...held.folders.map(
-      (dir) => `${stripControl(dir)}/  \u2014 an excluded folder, whose contents were never walked`
+      (dir) => `${oneLine(dir, WIDTH.path)}/  \u2014 an excluded folder, whose contents were never walked`
     )
   ];
 }
@@ -8384,7 +9052,7 @@ ${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(`    ${stripControl(r.path)}`));
+      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) {
@@ -8394,7 +9062,8 @@ ${chosenCount} note(s) are not in ${wording.where}, because your rules say so:`
   inside them are not counted above:`
         )
       );
-      for (const dir of held.folders.slice(0, 10)) printHuman(c.gray(`    ${stripControl(dir)}/`));
+      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`));
       }
@@ -8408,7 +9077,11 @@ ${chosenCount} note(s) are not in ${wording.where}, because your rules say so:`
       )
     );
     for (const d of guessed.slice(0, 10)) {
-      printHuman(c.gray(`    ${stripControl(d.path)}  (matched "${stripControl(d.term ?? "?")}")`));
+      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(
@@ -8456,13 +9129,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 oneLineWhole(id);
   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 oneLineWhole(id);
 }
 function matchIds(ref, allIds) {
   const exact = allIds.filter((id) => id === ref);
@@ -8689,14 +9362,127 @@ init_api_client();
 init_credentials();
 init_pending_login();
 init_config();
+init_ui();
 init_vault();
 async function resolveTarget(opts = {}) {
+  if (opts.brain !== void 0) return namedCloudTarget({ ...opts, brain: opts.brain });
   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, WIDTH.title)}\``,
+          `Nothing was read from \`${oneLine(opts.vault, WIDTH.path)}\`, 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;
+  }
+}
+async function namedCloudTarget(opts) {
+  const named = opts.brain;
+  if (named.startsWith("--")) {
+    throw memgError(
+      "invalid_input",
+      `\`--brain\` was given the flag \`${oneLine(named, WIDTH.title)}\` as its name`,
+      "Nothing was read or changed. Put the hosted brain name or id immediately after `--brain`, then pass the other flag separately."
+    );
+  }
+  const clashes = [
+    opts.local === true ? "`--local`" : null,
+    opts.vault !== void 0 ? "`--vault`" : null
+  ].filter((value) => value !== null);
+  if (clashes.length > 0) {
+    throw memgError(
+      "invalid_input",
+      `\`--brain\` cannot be combined with ${clashes.join(" and ")}`,
+      "`--brain <name>` reads an existing brain on the account. `--local` and `--vault <path>` read a folder on this machine. Nothing was read or changed; choose one target kind."
+    );
+  }
+  const base = apiUrl();
+  const credentials = await requireCredentials(base);
+  const brains = await listCloudBrains(credentials.token, base);
+  if (brains.length === 0) {
+    throw memgError(
+      "invalid_input",
+      "this account has no hosted brains",
+      "Nothing was read or changed. `--brain` only names an existing hosted brain; it never creates one."
+    );
+  }
+  const found = findCloudBrain(brains, named);
+  if (!found) {
+    const available = brains.map((brain) => `  ${oneLine(brain.name, WIDTH.title)}  (${oneLine(brain.id, WIDTH.handle)})`).join("\n");
+    throw memgError(
+      "invalid_input",
+      `no hosted brain called "${oneLine(named, WIDTH.title)}"`,
+      `Nothing was read or changed. This account has:
+${available}
+Use one of those names or ids. No brain was created.`
+    );
+  }
+  return { kind: "cloud", brainId: found.id, name: found.name, apiUrl: base };
+}
+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, WIDTH.title)}\``,
+        "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, WIDTH.title)}`).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();
@@ -8788,7 +9574,9 @@ function reindexCommand() {
             )
           );
           for (const d of byContent.slice(0, 10)) {
-            printHuman(c.gray(`    ${stripControl(d.path)}  (${stripControl(d.detail)})`));
+            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`));
@@ -8809,7 +9597,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"));
@@ -8847,7 +9635,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)})`
           )
         );
       }
@@ -8866,7 +9654,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)})`
       )
     );
   }
@@ -8883,18 +9671,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()));
@@ -8982,6 +9791,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();
@@ -9255,10 +10112,14 @@ async function assembleStage(adapter, entry, detail, sectionName) {
 init_vault();
 init_ui();
 function openCommand() {
-  return new Command4("open").description("open one memory, as deeply as you ask").argument("<ref>", "handle, id, path, or exact title").option("--vault <path>", "which brain to read").option("--local", "read the brain on this machine, even when signed in to a hosted one").option("--detail <level>", "card | summary | chunks | full (default: card)").option("--section <name>", "one section (implies --detail chunks)").action(
+  return new Command4("open").description("open one memory, as deeply as you ask").argument("<ref>", "handle, id, path, or exact title").option("--vault <path>", "which brain to read").option("--local", "read the brain on this machine, even when signed in to a hosted one").option(
+    "--brain <name>",
+    "read from one existing hosted brain by name or id, without changing the pointer"
+  ).option("--detail <level>", "card | summary | chunks | full (default: card)").option("--section <name>", "one section (implies --detail chunks)").action(
     async (ref, opts) => {
       const detail = parseDetail(opts.detail, opts.section ? "chunks" : "card");
       const target = await resolveTarget({
+        ...opts.brain === void 0 ? {} : { brain: opts.brain },
         ...opts.local === void 0 ? {} : { local: opts.local },
         ...opts.vault === void 0 ? {} : { vault: opts.vault }
       });
@@ -9279,17 +10140,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);
             }
           }
         });
@@ -9326,7 +10193,7 @@ ${stripControl(found.body)}`);
           ...stage
         },
         human: () => {
-          printHuman(`## ${stripControl(entry.memory.title)}
+          printHuman(`## ${oneLine(entry.memory.title, WIDTH.title)}
 `);
           if (scaffolding) {
             printHuman(
@@ -9339,13 +10206,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(
@@ -9376,13 +10247,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));
             }
@@ -9942,11 +10814,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."));
         }
       });
@@ -10006,10 +10878,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(
@@ -10017,12 +10889,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(`
@@ -10089,18 +10961,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(
@@ -10108,16 +10980,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."
           )
         );
@@ -10141,7 +11013,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)}`));
       }
     }
   });
@@ -10185,7 +11057,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}\``
@@ -10293,20 +11165,22 @@ function renderSummary(p) {
   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)}\``,
+    `- **${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 ${stripControl(p.memory_id ?? p.target)}\` shows what the note says NOW; upgrading the server restores the claim.)`
+        `  \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");
 }
@@ -10422,10 +11296,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)}\``));
     }
@@ -10435,7 +11309,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."));
     }
@@ -10493,9 +11367,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(
           `
@@ -10587,9 +11461,11 @@ function consolidateCommand() {
     [
       "",
       "What it looks for:",
-      "  similar_title    two notes titled with mostly the same words",
-      "  shared_context   two notes in one scope naming the same thing",
+      "  declared_supersession  a replaced note that is still active",
       "  contradiction    a disagreement somebody declared and nobody settled",
+      "  semantic_similarity   calibrated indexed meaning agrees reciprocally",
+      "  shared_context   two notes in one scope naming the same thing",
+      "  similar_title    two notes titled with mostly the same words",
       "  kind_promotion   a note marked as binding but filed as something other",
       "                   than a decision",
       "",
@@ -10618,7 +11494,7 @@ function consolidateCommand() {
         // Present on every answer, not only the empty one. A full list still
         // leaves the reader one step short — the candidates are evidence, and
         // the next command is the thing they cannot derive from evidence.
-        hint: truncated ? `This brain is large enough that detection stopped after ${report.scanned} pairs, so these are candidates rather than all of them. Narrow it \u2014 \`--vault\` a smaller brain, or run again after acting on these \u2014 and treat the list as a sample. Proposals are still written one at a time: \`memgineering propose <action> --memory <id> --claim "\u2026" --reason "\u2026" --excerpt "\u2026"\`.` : candidates.length ? 'None of these is a proposal yet. Decide what each pair means, then: `memgineering propose <action> --memory <id> --claim "\u2026" --reason "\u2026" --excerpt "\u2026"`. A duplicate is two proposals \u2014 supersede on the one that stays, retire on the one it replaces.' : "Nothing looked duplicated, contradicted, or misfiled. Detection reads titles, scope, entities and declared edges \u2014 a brain whose notes carry none of those has little for it to compare. `memgineering recall <topic>` is the way to find near-duplicates by hand."
+        hint: truncated ? `This brain is large enough that detection stopped after ${report.scanned} pairs, so these are candidates rather than all of them. Narrow it \u2014 \`--vault\` a smaller brain, or run again after acting on these \u2014 and treat the list as a sample. Proposals are still written one at a time: \`memgineering propose <action> --memory <id> --claim "\u2026" --reason "\u2026" --excerpt "\u2026"\`.` : candidates.length ? 'None of these is a proposal yet. Decide what each pair means, then: `memgineering propose <action> --memory <id> --claim "\u2026" --reason "\u2026" --excerpt "\u2026"`. An inferred duplicate is two proposals \u2014 supersede the winner and retire the loser. `declared_supersession` already has the winner edge, so only the suggested loser retirement remains.' : "Nothing looked duplicated, contradicted, or misfiled. Detection reads titles, scope, entities and declared edges; a hosted brain also reuses a complete calibrated vector generation, with stricter corroboration when context is absent. `memgineering recall <topic>` remains the broader semantic search."
       },
       human: () => {
         if (candidates.length === 0) {
@@ -10645,7 +11521,7 @@ function consolidateCommand() {
         }
         printHuman(
           c.gray(
-            '\nNone of these is a proposal yet \u2014 nothing has been written.\nDecide what a pair means, then say so:\n  memgineering propose <action> --memory <id> --claim "\u2026" --reason "\u2026" --excerpt "\u2026"\nA duplicate is two proposals: supersede on the one that stays, retire on the one\nit replaces.'
+            '\nNone of these is a proposal yet \u2014 nothing has been written.\nDecide what a pair means, then say so:\n  memgineering propose <action> --memory <id> --claim "\u2026" --reason "\u2026" --excerpt "\u2026"\nAn inferred duplicate is two proposals: supersede the winner and retire the loser.\nA declared_supersession already has its winner edge; only retire the named loser.'
           )
         );
       }
@@ -10656,16 +11532,16 @@ var TITLE_WIDTH = 72;
 function noteLines(id, title, path) {
   const shown = oneLine(title, TITLE_WIDTH);
   return [
-    shown === "" ? `  ${stripControl(id)}` : `  ${stripControl(id)}  ${shown}`,
+    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(`    \`${stripControl(path)}\``)
+    c.gray(`    \`${middleLine(path, WIDTH.path)}\``)
   ];
 }
 function renderCandidate(candidate) {
   const lines2 = [
-    `- **${stripControl(candidate.rule)}** \u2014 ${stripControl(candidate.evidence)}`,
+    `- **${oneLine(candidate.rule, WIDTH.title)}** \u2014 ${oneLine(candidate.evidence, WIDTH.text)}`,
     ...noteLines(candidate.memory_id, candidate.title, candidate.path)
   ];
   if (candidate.other_id !== null) {
@@ -10707,7 +11583,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}`));
@@ -11142,14 +12018,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) + "`"
             )
           );
         }
@@ -11207,8 +12083,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;
         }
@@ -11238,13 +12116,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(
           `
@@ -11264,15 +12142,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}\``));
     }
@@ -11304,8 +12182,12 @@ init_index_build();
 init_vault();
 init_ui();
 function evidenceCommand() {
-  return new Command10("evidence").description("how much a memory has been used, and why it last changed").argument("<ref>", "handle, id, path, or exact title").option("--vault <path>", "which brain to read").option("--local", "read the brain on this machine, even when signed in to a hosted one").action(async (ref, opts) => {
+  return new Command10("evidence").description("how much a memory has been used, and why it last changed").argument("<ref>", "handle, id, path, or exact title").option("--vault <path>", "which brain to read").option("--local", "read the brain on this machine, even when signed in to a hosted one").option(
+    "--brain <name>",
+    "read from one existing hosted brain by name or id, without changing the pointer"
+  ).action(async (ref, opts) => {
     const target = await resolveTarget({
+      ...opts.brain === void 0 ? {} : { brain: opts.brain },
       ...opts.local === void 0 ? {} : { local: opts.local },
       ...opts.vault === void 0 ? {} : { vault: opts.vault }
     });
@@ -11314,7 +12196,11 @@ function evidenceCommand() {
       const report2 = await cloudEvidence(cloud, ref);
       printDual({
         json: { ...report2, brain: { hosted: true, name: target.name } },
-        human: () => renderEvidence(viewFromCloud(report2), { now: /* @__PURE__ */ new Date(), hosted: true })
+        human: () => renderEvidence(viewFromCloud(report2), {
+          now: /* @__PURE__ */ new Date(),
+          hosted: true,
+          brain: target.name
+        })
       });
       return;
     }
@@ -11336,10 +12222,13 @@ function evidenceCommand() {
   });
 }
 function renderEvidence(report, opts) {
-  printHuman(`## evidence: ${stripControl(report.title)}
-`);
-  printHuman(`\`id: ${stripControl(report.id)}\`  \xB7  \`${stripControl(report.path)}\`
+  const brainHeading = opts.brain === void 0 ? "" : ` \u2014 ${oneLine(opts.brain, WIDTH.title)}`;
+  printHuman(`## evidence: ${oneLine(report.title, WIDTH.title)}${brainHeading}
 `);
+  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");
   }
@@ -11389,11 +12278,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(
@@ -11414,7 +12304,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(
@@ -11550,6 +12440,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()) {
@@ -11578,11 +12469,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 {
@@ -11622,7 +12514,7 @@ async function runGuard(payload, contextDirFlag) {
   return JSON.stringify({
     hookSpecificOutput: {
       hookEventName: "PreToolUse",
-      additionalContext: contextFor(claimed.rules, claimed.total)
+      additionalContext: contextFor(claimed.lines, claimed.total)
     }
   });
 }
@@ -11636,16 +12528,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,
@@ -11653,22 +12551,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}
@@ -11699,10 +12595,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 });
@@ -11727,6 +12623,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();
@@ -11739,8 +12646,12 @@ import { Command as Command12 } from "commander";
 init_vault();
 init_ui();
 function logCommand() {
-  return new Command12("log").description("what changed in this brain, and what can still be undone").option("--limit <n>", "how many operations", (v) => parseInt(v, 10), 20).option("--verbose", "include hashes and reverse patches").option("--vault <path>", "which brain to read").option("--local", "read the brain on this machine, even when signed in to a hosted one").action(async (opts) => {
+  return new Command12("log").description("what changed in this brain, and what can still be undone").option("--limit <n>", "how many operations", (v) => parseInt(v, 10), 20).option("--verbose", "include hashes and reverse patches").option("--vault <path>", "which brain to read").option("--local", "read the brain on this machine, even when signed in to a hosted one").option(
+    "--brain <name>",
+    "read one existing hosted brain by name or id, without changing the pointer"
+  ).action(async (opts) => {
     const target = await resolveTarget({
+      ...opts.brain === void 0 ? {} : { brain: opts.brain },
       ...opts.local === void 0 ? {} : { local: opts.local },
       ...opts.vault === void 0 ? {} : { vault: opts.vault }
     });
@@ -11769,7 +12680,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");
@@ -11783,7 +12694,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;
@@ -11905,15 +12817,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)}`
+        )
       );
     }
   }
@@ -11969,7 +12885,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) => {
@@ -12052,6 +12968,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."
+          )
+        );
       }
     });
   });
@@ -12135,12 +13056,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."
       );
     }
@@ -12161,13 +13082,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)" : ""}`
               )
             );
           }
@@ -12182,7 +13103,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 = [];
@@ -12224,7 +13145,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) {
@@ -12276,8 +13197,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 {
@@ -12294,7 +13215,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(
       `
@@ -12392,7 +13313,7 @@ If your notes are in one of those, that rule is why \u2014 nothing here can see
       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 = [];
@@ -12462,7 +13383,9 @@ If your notes are in one of those, that rule is why \u2014 nothing here can see
       },
       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`));
@@ -12480,7 +13403,9 @@ If your notes are in one of those, that rule is why \u2014 nothing here can see
 \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`));
@@ -12502,14 +13427,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.`
       )
     );
@@ -12518,9 +13443,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."
+      "\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) + "`."
     )
   );
 }
@@ -12573,7 +13498,10 @@ init_errors();
 init_vault();
 init_ui();
 function recallCommand() {
-  return new Command18("recall").description("recall memory cards for a question").argument("<query>", "what you want to remember").option("--vault <path>", "which brain to search").option("--local", "search the brain on this machine, even when signed in to a hosted one").option("--scope <scope>", "restrict to one scope").option("--limit <n>", "max cards", (v) => parseInt(v, 10), 8).option(
+  return new Command18("recall").description("recall memory cards for a question").argument("<query>", "what you want to remember").option("--vault <path>", "which brain to search").option("--local", "search the brain on this machine, even when signed in to a hosted one").option(
+    "--brain <name>",
+    "search one existing hosted brain by name or id, without changing the pointer"
+  ).option("--scope <scope>", "restrict to one scope").option("--limit <n>", "max cards", (v) => parseInt(v, 10), 8).option(
     "--detail <level>",
     "title | card | summary | chunks | full (default: card) \u2014 a hosted brain answers title and card only; deeper needs a brain in a folder, or `open <handle>`"
   ).option("--depth <depth>", "exact | standard (default: standard, which also searches bodies)").option("--budget <tokens>", "max estimated size of the answer", (v) => parseInt(v, 10)).action(
@@ -12582,10 +13510,13 @@ function recallCommand() {
       const depth = parseDepth(opts.depth);
       const budget = parseBudget(opts.budget) ?? DEFAULT_TOKEN_BUDGET;
       const target = await resolveTarget({
+        ...opts.brain === void 0 ? {} : { brain: opts.brain },
         ...opts.local === void 0 ? {} : { local: opts.local },
         ...opts.vault === void 0 ? {} : { vault: opts.vault }
       });
+      const answeredBy = target.kind === "cloud" ? target.name : null;
       let rows;
+      let unsearchedBrains = [];
       let isScaffolding;
       let reasons;
       let pathOf;
@@ -12613,6 +13544,9 @@ function recallCommand() {
           budget
         });
         rows = answered.memory_cards.map((card) => ({ card, handle: card.handle, stage: {} }));
+        if (rows.length === 0) {
+          unsearchedBrains = await listCloudBrains(cloud.token, cloud.apiUrl, { retries: 0 }).then((all) => all.filter((b) => b.id !== cloud.brainId)).catch(() => []);
+        }
         isScaffolding = () => false;
         reasons = /* @__PURE__ */ new Map();
         pathOf = () => null;
@@ -12677,6 +13611,7 @@ function recallCommand() {
         json: {
           query,
           detail,
+          ...answeredBy === null ? {} : { brain: { hosted: true, name: answeredBy } },
           // Echoed only when it was asked for. `detail` above is resolved
           // here because this CLI is what assembles the stages, but the depth
           // is the searching brain's to default — and on a hosted brain this
@@ -12709,6 +13644,7 @@ function recallCommand() {
           ...result.truncated === void 0 ? {} : { truncated: result.truncated }
         },
         human: () => {
+          const brainHeading = answeredBy === null ? "" : ` \u2014 ${oneLine(answeredBy, WIDTH.title)}`;
           const reachedSomethingWritten = rows.some(({ card }) => !isScaffolding(card));
           const otherScript = reachedSomethingWritten ? null : entries ? unreachableScript(query, entries) : null;
           const sayWhy = () => {
@@ -12727,12 +13663,12 @@ 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)}
 `)
             );
           };
           if (rows.length === 0) {
-            printHuman(`## recall: ${query}
+            printHuman(`## recall: ${query}${brainHeading}
 `);
             printHuman("_Nothing matched._\n");
             sayDegraded();
@@ -12740,14 +13676,38 @@ function recallCommand() {
               sayWhy();
               return;
             }
+            if (unsearchedBrains.length > 0) {
+              printHuman(
+                c.yellow(
+                  `\u26A0 Only \`${oneLine(answeredBy ?? "", WIDTH.title)}\` was searched \u2014 this account has ${unsearchedBrains.length + 1} brains.`
+                ) + c.gray(
+                  `
+${unsearchedBrains.map(
+                    (brain) => `  memgineering recall ${JSON.stringify(query)} --brain ${JSON.stringify(brain.name)}`
+                  ).join(
+                    "\n"
+                  )}
+  Safe to run \u2014 reading another brain does not change which one this machine points at.
+`
+                )
+              );
+            }
             printHuman(
               c.gray(
-                depth === "exact" ? "`--depth exact` searches the card only \u2014 titles, aliases, entities, summaries and scope \u2014 try `--depth standard` to search note bodies too, or fewer words, or drop --scope." : "Titles, aliases, summaries and note bodies are all searched \u2014 try fewer or broader words, or drop --scope."
+                // "Within this brain" is load-bearing when the warning above
+                // has just said another brain went unsearched. The enumeration
+                // reads as the whole surface — a recheck tester called this
+                // the last line on screen and a false all-clear, sitting below
+                // the one line that says otherwise.
+                (depth === "exact" ? "Within this brain, `--depth exact` searches the card only \u2014 titles, aliases, entities, summaries and scope \u2014 try `--depth standard` to search note bodies too, or fewer words" : "Within this brain, titles, aliases, summaries and note bodies are all searched \u2014 try fewer or broader words") + // Only when the reader actually passed one. Telling somebody
+                // to drop an argument they never supplied cost one tester a
+                // whole command to `--help` to find out it was not their bug.
+                (opts.scope ? ", or drop --scope." : ".")
               )
             );
             return;
           }
-          printHuman(`## recall: ${query}  (${rows.length} cards)
+          printHuman(`## recall: ${query}${brainHeading}  (${rows.length} cards)
 `);
           sayDegraded();
           if (!reachedSomethingWritten) {
@@ -12763,7 +13723,22 @@ function recallCommand() {
           );
           for (const [i, { card, handle: handle2, stage }] of rows.entries()) {
             const mark = reachedSomethingWritten && isScaffolding(card);
-            printHuman(renderCard(i + 1, card, handle2, detail, stage, i === glossOn, mark));
+            printHuman(
+              renderCard(
+                i + 1,
+                card,
+                handle2,
+                detail,
+                stage,
+                i === glossOn,
+                mark,
+                // Only when `--brain` aimed this elsewhere. A recall of the
+                // brain this machine already points at mints handles `open`
+                // resolves by default, and repeating the name there would be
+                // noise on the common path.
+                opts.brain === void 0 ? void 0 : answeredBy ?? void 0
+              )
+            );
           }
           if (result.conflicts.length > 0) {
             printHuman(`### \u26A0 contradictions (${result.conflicts.length})
@@ -12775,13 +13750,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, "  > "));
               }
@@ -12797,8 +13770,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;
@@ -12852,9 +13827,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);
@@ -12869,11 +13843,11 @@ async function stageFor(adapter, entry, detail) {
   if (!entry) return {};
   return assembleStage(adapter, entry, detail);
 }
-function renderCard(n, card, handle2, detail, stage, glossHere = false, scaffolding = false) {
+function renderCard(n, card, handle2, detail, stage, glossHere = false, scaffolding = false, qualifyWith) {
   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 {
@@ -12881,14 +13855,15 @@ 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)}\``);
+    const openLine = qualifyWith === void 0 ? `open: ${oneLine(handle2, WIDTH.handle)}` : `memgineering open ${oneLine(handle2, WIDTH.handle)} --brain ${JSON.stringify(qualifyWith)}`;
+    out.push("", `\`${openLine}\``);
   }
   if (stage.outline && stage.outline.length > 0) {
     out.push("", ...stage.outline.map((h) => `- ${h}`));
@@ -13019,10 +13994,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");
@@ -13034,7 +14009,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;
@@ -13151,6 +14128,9 @@ init_vault();
 init_ui();
 function resurfaceCommand() {
   return new Command20("resurface").description("what is worth having in view right now, without being asked").option("--context-dir <path>", "where the work is happening (default: cwd)").option("--limit <n>", "how many cards", (v) => parseInt(v, 10), 5).option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
+    "--brain <name>",
+    "read one existing hosted brain by name or id, without changing the pointer"
+  ).option(
     "--deadline <ms>",
     "give up and print nothing after this long",
     (v) => parseInt(v, 10)
@@ -13160,11 +14140,16 @@ function resurfaceCommand() {
       await bounded(async () => {
         const contextDir = opts.contextDir ?? process.cwd();
         const where = await resolveTarget({
+          ...opts.brain === void 0 ? {} : { brain: opts.brain },
           ...opts.local === void 0 ? {} : { local: opts.local },
           ...opts.vault === void 0 ? {} : { vault: opts.vault }
         });
         if (where.kind === "cloud") {
-          await resurfaceHosted(where, opts.limit);
+          await resurfaceHosted(
+            where,
+            opts.limit,
+            opts.brain === void 0 ? void 0 : where.name
+          );
           return;
         }
         const { brain, unreachableDefault } = await resolveBrain(opts.vault, contextDir);
@@ -13235,9 +14220,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(
@@ -13251,7 +14234,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));
@@ -13281,7 +14264,7 @@ ${quoteBlock(entry.memory.summary)}`);
     }
   );
 }
-async function resurfaceHosted(where, limit) {
+async function resurfaceHosted(where, limit, qualifyWith) {
   const brain = await openCloudBrain(where);
   const result = await cloudResurface(brain, { limit });
   printDual({
@@ -13293,31 +14276,35 @@ 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)}\`
-`);
+        printHuman(
+          qualifyWith === void 0 ? `
+\`open: ${oneLine(card.handle, WIDTH.handle)}\`
+` : `
+\`memgineering open ${oneLine(card.handle, WIDTH.handle)} --brain ${JSON.stringify(qualifyWith)}\`
+`
+        );
       }
-      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.`
-          )
         )
       );
     }
@@ -13328,8 +14315,12 @@ exists only for a brain on this machine.`
 import { Command as Command21 } from "commander";
 init_ui();
 function rulesCommand() {
-  return new Command21("rules").description("the user\u2019s standing decisions \u2014 what binds you here").option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").action(async (opts) => {
+  return new Command21("rules").description("the user\u2019s standing decisions \u2014 what binds you here").option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").option(
+    "--brain <name>",
+    "read one existing hosted brain by name or id, without changing the pointer"
+  ).action(async (opts) => {
     const where = await resolveTarget({
+      ...opts.brain === void 0 ? {} : { brain: opts.brain },
       ...opts.local === void 0 ? {} : { local: opts.local },
       ...opts.vault === void 0 ? {} : { vault: opts.vault }
     });
@@ -13338,7 +14329,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");
@@ -13350,8 +14341,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(`
@@ -13403,10 +14394,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)}` : ""}`
             )
           );
         }
@@ -13768,7 +14759,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;
@@ -13806,11 +14797,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;
@@ -13896,7 +14887,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) {
@@ -13987,13 +14978,95 @@ 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";
+import stringWidth from "string-width";
+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`}
+`
+        );
+        const shownNames = rows.map((row) => oneLine(row.name, NAME_WIDTH));
+        const shownNameWidth = Math.max(...shownNames.map((name) => stringWidth(name)));
+        for (const [index, row] of rows.entries()) {
+          const shownName = shownNames[index] ?? "";
+          const name = shownName + " ".repeat(shownNameWidth - stringWidth(shownName));
+          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) {
@@ -14012,16 +15085,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
@@ -14056,14 +15137,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(
@@ -14084,7 +15175,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(
@@ -14101,7 +15192,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;
             }
@@ -14110,7 +15203,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(
@@ -14121,6 +15214,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(`
@@ -14187,13 +15288,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 = findCloudBrain(brains, 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({
@@ -14219,9 +15421,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(
@@ -14236,6 +15440,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;
@@ -14289,7 +15495,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 };
@@ -14298,7 +15513,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;
   }
@@ -14308,7 +15524,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());
@@ -14329,6 +15545,7 @@ function buildProgram() {
   program.addCommand(initCommand());
   program.addCommand(linkCommand());
   program.addCommand(useCommand());
+  program.addCommand(brainsCommand());
   program.addCommand(unlinkCommand());
   program.addCommand(reindexCommand());
   program.addCommand(syncRulesCommand());
@@ -14368,8 +15585,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.
@@ -14397,7 +15621,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);
@@ -14414,7 +15638,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}`));
       }
@@ -14422,7 +15646,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);
 }