memgineering 0.8.0 → 0.9.0

package/dist/index.js

@@ -181,10 +181,29 @@ 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));
@@ -216,7 +235,7 @@ var init_ui = __esm({
       /** A vault path. Longer, because the tail is the part that identifies it. */
       path: 120,
       /** An id or an `open:` handle. */
-      handle: 64,
+      handle: 128,
       /** A claim, a summary, a server hint — a sentence rather than a label. */
       text: 200
     };
@@ -247,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),
@@ -264,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"]);
@@ -644,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,
@@ -658,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
@@ -676,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 = [];
@@ -790,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),
@@ -1397,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);
@@ -1416,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);
       }
     }
@@ -1441,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);
@@ -1452,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",
@@ -1494,6 +1548,7 @@ var init_search = __esm({
       "\uAED8"
     ];
     HANGUL = /[\uac00-\ud7a3]/;
+    ONE_SYLLABLE_TOPIC_TERMS = /* @__PURE__ */ new Set(["\uD0A4"]);
   }
 });
 
@@ -1511,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);
@@ -1573,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";
@@ -1599,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);
@@ -1620,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]));
@@ -1712,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";
@@ -1742,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,
@@ -1984,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,
@@ -2017,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;
 }
@@ -2064,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;
@@ -2083,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;
@@ -2102,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,
@@ -2151,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;
+      }
+    };
   }
 });
 
@@ -2686,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() === "") {
@@ -2693,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);
@@ -2706,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}`)];
@@ -2743,6 +3336,7 @@ ${block.join("\n")}
     };
   }
   const fenceBody = fenceMatch[1] ?? "";
+  assertReadableFrontmatter(fenceBody);
   const fenceLines = splitLines(fenceBody);
   const span = findBlock(fenceLines);
   const existing = readNamespace(noteContent);
@@ -2908,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";
@@ -2926,6 +3520,7 @@ var init_patch = __esm({
       }
     };
     BLOCK_KEY_RE = /^([^\s#][^:]*?)\s*:/;
+    ANY_INDENTED_KEY_RE = /^(\s*)([^\s#][^:]*?)\s*:/;
   }
 });
 
@@ -4460,11 +5055,13 @@ Nothing was indexed. This is what WOULD be stored:
               printHuman(
                 c.gray(`    ${oneLine(r.summary ?? "(no summary \u2014 title only)", WIDTH.text)}`)
               );
-              printHuman(c.gray(`    from ${oneLine(r.path, WIDTH.path)}`));
+              printHuman(c.gray(`    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(
@@ -8350,6 +8947,9 @@ var cloudRules = (brain, args = {}) => call(brain, "POST", "/rules", {
 var cloudReindex = (brain, args = {}) => call(brain, "POST", "/reindex", {
   ...args.rebuild === true ? { rebuild: true } : {}
 });
+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",
@@ -8529,13 +9129,13 @@ function isOpaqueId(id) {
   return id.length === OPAQUE_ID_LENGTH && /^[0-9ABCDEFGHJKMNPQRSTVWXYZ]+$/.test(id);
 }
 function displayHandle(id, allIds) {
-  if (!isOpaqueId(id)) return oneLine(id, WIDTH.handle);
+  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 oneLine(id, WIDTH.handle);
+  return oneLineWhole(id);
 }
 function matchIds(ref, allIds) {
   const exact = allIds.filter((id) => id === ref);
@@ -8765,14 +9365,15 @@ 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 && cloud.kind === "cloud") {
       if (opts.vault !== void 0) {
         throw memgError(
           "invalid_input",
-          `\`--vault\` names a folder on this machine, and this machine reads the hosted brain \`${oneLine(cloud.name, 72)}\``,
-          `Nothing was read from \`${oneLine(opts.vault, 120)}\`, and nothing was changed.
+          `\`--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>\`
@@ -8792,6 +9393,49 @@ brain silently reported another.`
     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 {
@@ -8802,13 +9446,13 @@ async function accountAwareRefusal() {
       if (!cloud || cloud.api_url !== base) return null;
       return memgError(
         "not_signed_in",
-        `this machine is signed out of \`${oneLine(cloud.name, 72)}\``,
+        `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, 72)}`).join("\n");
+    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",
@@ -9468,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 }
       });
@@ -10813,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",
       "",
@@ -10844,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) {
@@ -10871,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.'
           )
         );
       }
@@ -10886,7 +11536,7 @@ function noteLines(id, title, path) {
     // Backticked, as it was before the title moved onto the row above it. This
     // output is read by agents as markdown, and a path outside code formatting
     // is a path they have to guess the extent of.
-    c.gray(`    \`${oneLine(path, WIDTH.path)}\``)
+    c.gray(`    \`${middleLine(path, WIDTH.path)}\``)
   ];
 }
 function renderCandidate(candidate) {
@@ -11532,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 }
     });
@@ -11542,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;
     }
@@ -11564,7 +12222,8 @@ function evidenceCommand() {
   });
 }
 function renderEvidence(report, opts) {
-  printHuman(`## evidence: ${oneLine(report.title, WIDTH.title)}
+  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)}\`
@@ -11987,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 }
     });
@@ -12835,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(
@@ -12844,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;
@@ -12875,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;
@@ -12939,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
@@ -12971,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 = () => {
@@ -12994,7 +13668,7 @@ function recallCommand() {
             );
           };
           if (rows.length === 0) {
-            printHuman(`## recall: ${query}
+            printHuman(`## recall: ${query}${brainHeading}
 `);
             printHuman("_Nothing matched._\n");
             sayDegraded();
@@ -13002,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) {
@@ -13025,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})
@@ -13130,7 +13843,7 @@ 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))}` : "";
@@ -13149,7 +13862,8 @@ function renderCard(n, card, handle2, detail, stage, glossHere = false, scaffold
   }
   if (detail !== "title") {
     if (card.summary) out.push("", quoteBlock(card.summary));
-    out.push("", `\`open: ${oneLine(handle2, WIDTH.handle)}\``);
+    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}`));
@@ -13414,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)
@@ -13423,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);
@@ -13542,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({
@@ -13570,9 +14292,13 @@ async function resurfaceHosted(where, limit) {
         else if (card.why.length > 0) printHuman(oneLine(card.why.join(" \xB7 "), WIDTH.text));
         if (card.summary) printHuman(`
 ${quoteBlock(card.summary)}`);
-        printHuman(`
+        printHuman(
+          qualifyWith === void 0 ? `
 \`open: ${oneLine(card.handle, WIDTH.handle)}\`
-`);
+` : `
+\`memgineering open ${oneLine(card.handle, WIDTH.handle)} --brain ${JSON.stringify(qualifyWith)}\`
+`
+        );
       }
       printBlock(
         c.gray(
@@ -13589,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 }
     });
@@ -14252,6 +14982,7 @@ The text from before that change is still on this machine: ${join23(snapshotDir(
 init_errors();
 init_api_client();
 import { Command as Command25 } from "commander";
+import stringWidth from "string-width";
 init_config();
 init_ui();
 var NAME_WIDTH = 48;
@@ -14305,8 +15036,11 @@ function brainsCommand() {
           `## ${rows.length} brain${rows.length === 1 ? "" : "s"} on ${credentials.display_name === null ? "this account" : `${oneLine(credentials.display_name, NAME_WIDTH)}\u2019s account`}
 `
         );
-        for (const row of rows) {
-          const name = oneLine(row.name, NAME_WIDTH).padEnd(NAME_WIDTH);
+        const 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(
@@ -14596,7 +15330,7 @@ async function pointAtHosted(named, opts, path) {
       "Nothing was changed. `memgineering push --brain <name>` creates one and fills it from a folder on this machine."
     );
   }
-  const found = brains.find((b) => b.id === named) ?? brains.find((b) => b.name === named);
+  const found = findCloudBrain(brains, named);
   if (!found) {
     throw memgError(
       "invalid_input",