memgineering 0.7.4 → 0.7.5

package/CHANGELOG.md

@@ -11,6 +11,93 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [0.7.5] — 2026-08-23
+
+### Fixed
+
+- **The approval list now shows the claim — what the note would say — above the
+  reason it is being changed.** `proposals approve` has no confirmation step: it
+  applies the change and shows the diff afterwards, so the list is the only
+  place a decision is made, and it was carrying the argument for a change while
+  withholding the change itself. Cut to one line on screen; whole under
+  `--json`. Null for `retire`, `unretire` and `reclassify`, which assert no
+  conclusion. Showing it for a **hosted** brain needs the brain server deployed
+  as well; against an older server the row says the claim is unavailable rather
+  than rendering as though the action had none. Brains in a folder need nothing.
+- **`consolidate` candidates name their notes.** A row gave an id and a path,
+  which say which FILE a candidate is about and nothing about what it says — so
+  you could not tell which notes a candidate was even about without opening both.
+  The row still does not carry their claims: deciding which of a pair is right
+  means reading them, and the row is what tells you which two to read.
+  Titles are cut at 72 characters with an ellipsis, so a short title and a
+  truncated one are never confusable. (Characters, not columns — a Korean title
+  is about twice as wide on screen.)
+- **`reindex` reports what it left out.** It listed notes refused for their name
+  or their content and said nothing about ones a `.memgignore` rule or a symlink
+  kept out of the index, so "✓ rebuilt 3 note(s)" could not answer "where is my
+  note". It now prints the same four-rule block `push` prints. `--json` gains
+  `not_indexed`, `denied_explicitly`, `excluded_by_rule` and `skipped_symlinks`
+  — the count is `not_indexed` rather than push's `not_sent`, because nothing is
+  sent from here.
+- **A title or claim cut mid-emoji no longer comes out as broken text.** The
+  truncation counted UTF-16 units, so a cut landing between the halves of a
+  surrogate pair emitted a lone surrogate. It counts characters now.
+- **A rule that excludes a FOLDER now names the folder.** `push` and `reindex`
+  both stop walking at an excluded directory, so the notes inside are never
+  enumerated — and both reported a held-back count of zero and printed nothing
+  else, so a brain whose entire archive was excluded looked exactly like a brain
+  that lost nothing. The count is still an honest floor; `excluded_folders` in
+  `--json` and a named line on screen say what it is a floor of.
+- **Note text is stripped of C1 controls and bidi format characters, on both
+  sides.** Only the `ESC`-introduced escape sequences were removed. A terminal in
+  8-bit mode reads U+009B and U+009D as the same two introducers with no `ESC`
+  byte; U+0085 is a line break, which broke the one-line guarantee the new title
+  and claim rows depend on; and a bidi override can make a line display in an
+  order its bytes do not have. U+2028 and U+2029 go too — `quoteBlock` splits on
+  `\n` alone, so a note containing one could resume outside the quote that marks
+  it as the note's words rather than the tool's. Escape sequences are read by
+  ECMA-48's grammar now rather than run to the next plausible-looking byte, so a
+  stray marker costs a few characters instead of the rest of the line. Measured:
+  one character before pure Hangul, two before `launchctl 로 한다`, five before
+  `21 August`, six before `123 abc` — against the whole remainder before. U+0085,
+  U+2028 and U+2029 are translated to a newline rather than dropped, so a break
+  in a stored note stays a break instead of welding the words on either side.
+- **Security: text pasted out of a terminal or a chat window can now be refused,
+  and a hidden character can no longer sneak a password past the check that looks
+  for one.** If a proposal or a `--reason` is rejected for carrying invisible
+  formatting, nothing was saved — retype the words as plain text and run it again.
+  What was wrong: the check read normalised text, and normalising could not
+  win: deleting the marker left its parameters between a label and its value,
+  and consuming the sequence deleted label characters instead — each fix opened
+  the other hole. The screen now refuses a proposal whose prose contains an
+  escape or control introducer at all, which has no such seam. The same rule now
+  guards `--reason` on every write verb: that text goes into the ledger, which is
+  permanent and travels with the brain. Note text itself is still stored rather
+  than refused — blocking a save is the worse trade on the main write path, where
+  the commonest source of a stray control byte is a mis-decoded file — and is
+  protected instead by the credential detector, which now reads the text with
+  control introducers removed as well as with them left in, so a label split by a
+  hidden byte is still seen as a label. That widening cuts both ways and the
+  second half is worth knowing: a note ALREADY on disk whose text hides a label
+  this way is now refused on READ, where 0.7.4 read it fine. Both codes involved
+  are weak ones, so `.memgallow` overrules them. The two copies of the normaliser are
+  hardened and a parity test compares them as source, because they had already
+  drifted once.
+
+### Changed
+
+- `reindex` lists markdown only where it used to list every denied path, on
+  screen and in `denied_by_name` alike, matching `push`. A denied `.env` was
+  never a note anybody expected in a note index.
+- `push`'s nothing-to-upload error no longer tells someone to check their path
+  when the path was right and their own folder rule emptied the brain.
+
+### Agent guidance
+
+`memgineering-writing` and `memgineering-setup` describe the claim row and what
+`reindex` now reports. Restart your agent session after upgrading so it picks
+them up.
+
 ## [0.7.4] — 2026-08-19
 
 ### Changed

package/assets/MEMGINEERING.md

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

package/assets/memgineering-setup/SKILL.md

@@ -282,7 +282,19 @@ and needs no model anywhere; that is a decision, not a gap.
 by hand in the ordinary case — writes keep the index in step on their own.
 `memgineering reindex` reaches either kind of brain: on a hosted one it backfills
 what is missing and clears stored rows for notes the brain has since been told
-not to read, reporting both; `--local` forces the folder brain. `--rebuild`
+not to read, reporting both; `--local` forces the folder brain. On a brain in a
+FOLDER it also names what it left out — notes a deny name, a `.memgignore` rule
+or a symlink kept from the index, and any folder a rule excluded whole — so "3
+notes rebuilt" is never the whole answer when a fourth was dropped. A hosted
+reindex cannot say that: the rules are applied on the machine that pushed, so
+the server only ever saw what arrived.
+
+Under `--json` that is `not_indexed` with `denied_by_name`, `denied_explicitly`,
+`excluded_by_rule`, `skipped_symlinks` and `excluded_folders`. **Read the count
+together with `excluded_folders`**: a rule that names a folder stops the walk at
+the folder, so nothing inside it is ever counted — `not_indexed: 0` beside a
+non-empty `excluded_folders` means the count is a floor, not the answer. `push`
+reports the same set with its total under `not_sent`. `--rebuild`
 exists for one situation only, where an embedding model changed the shape of its
 answers without changing its name and the index has to be laid down again.
 

package/assets/memgineering-writing/SKILL.md

@@ -140,8 +140,11 @@ only the last of them touches a note.
 memgineering consolidate        # what looks worth merging or reclassifying — reads only
 ```
 
-It returns pairs with the evidence that caught them and the action it would
-suggest, under four rules: `similar_title`; `shared_context`, one scope naming
+Each candidate names its notes — id, title, path — so you can tell WHICH notes
+it is about without opening them. It does not carry their claims, so deciding
+which of a pair is right still means reading them: two notes can share a title
+and hold opposite conclusions, which is exactly the case a proposal exists for. It returns them with the evidence that caught them and the action it
+would suggest, under four rules: `similar_title`; `shared_context`, one scope naming
 the same thing; `contradiction`, a disagreement nobody settled; and
 `kind_promotion`, a note marked as binding but filed as something other than a
 decision.
@@ -179,6 +182,14 @@ memgineering proposals reject <id>
 memgineering proposals rebase <id>
 ```
 
+**Read the list before you approve.** A row carries the claim — what the note
+would say — above the reason it is being changed. Three actions assert no
+conclusion and so have none: `retire`, `unretire` and `reclassify`. A row with no
+claim line is one of those, not a row that lost something. There is no confirmation step:
+`approve` applies the change and shows you the diff afterwards, so the list is
+where the decision is actually made. The claim is cut to one line on screen and
+whole under `--json`.
+
 `approve` is the only command in this flow that writes to a note, and it goes
 through the ledger like every other write — one `undo` away from not having
 happened. `approve` and `reject` each take `--reason`, and it is kept.

package/dist/index.js

@@ -120,32 +120,46 @@ function stripControl(input) {
   let out = "";
   for (let i = 0; i < input.length; i++) {
     const code = input.charCodeAt(i);
-    if (code === 27) {
-      const next = input[i + 1];
-      if (next === "]") {
-        let j = i + 2;
-        while (j < input.length && input.charCodeAt(j) !== 7 && !(input.charCodeAt(j) === 27 && input[j + 1] === "\\")) {
-          j++;
-        }
-        if (input.charCodeAt(j) === 7) j++;
-        else if (input.charCodeAt(j) === 27) j += 2;
-        i = j - 1;
+    if (code === 27 && input[i + 1] === "]" || code === 157) {
+      const from = code === 157 ? i + 1 : i + 2;
+      let j = from;
+      while (j < input.length && input.charCodeAt(j) !== 7 && input.charCodeAt(j) !== 156 && !(input.charCodeAt(j) === 27 && input[j + 1] === "\\")) {
+        j++;
+      }
+      if (j >= input.length) {
+        i = from - 1;
         continue;
       }
-      if (next === "[") {
-        let j = i + 2;
-        while (j < input.length && !(input.charCodeAt(j) >= 64 && input.charCodeAt(j) <= 126)) {
-          j++;
-        }
+      j += input.charCodeAt(j) === 27 ? 2 : 1;
+      i = j - 1;
+      continue;
+    }
+    if (code === 27 && input[i + 1] === "[" || code === 155) {
+      const from = code === 155 ? i + 1 : i + 2;
+      let j = from;
+      while (j < input.length && input.charCodeAt(j) >= 48 && input.charCodeAt(j) <= 63) j++;
+      while (j < input.length && input.charCodeAt(j) >= 32 && input.charCodeAt(j) <= 47) j++;
+      const final = j < input.length ? input.charCodeAt(j) : -1;
+      if (final >= 64 && final <= 126) {
         i = j;
         continue;
       }
+      i = from - 1;
+      continue;
+    }
+    if (code === 27) {
       i += 1;
       continue;
     }
-    if (code <= 31 && code !== 10 && code !== 9 || code === 127) {
+    if (code === 133 || code === 8232 || code === 8233) {
+      out += "\n";
       continue;
     }
+    if (code <= 31 && code !== 10 && code !== 9 || code === 127) continue;
+    if (code >= 128 && code <= 159) continue;
+    if (code === 1564 || code === 8206 || code === 8207) continue;
+    if (code >= 8234 && code <= 8238) continue;
+    if (code >= 8294 && code <= 8297) continue;
     out += input[i];
   }
   return out;
@@ -153,6 +167,12 @@ function stripControl(input) {
 function quoteBlock(text, prefix = "> ") {
   return stripControl(text).split("\n").map((line) => prefix + line).join("\n");
 }
+function oneLine(text, max) {
+  const flat = stripControl(text).replace(/\s+/g, " ").trim();
+  const chars = [...flat];
+  if (chars.length <= max) return flat;
+  return `${chars.slice(0, Math.max(1, max - 1)).join("").trimEnd()}\u2026`;
+}
 function progress(text) {
   if (isInteractive()) process.stderr.write(kleur.gray(`  ${text}
 `));
@@ -167,12 +187,13 @@ function undoHint(opId, vault) {
 function quoteArg(value) {
   return /^[A-Za-z0-9._\/-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
 }
-var jsonMode, c;
+var jsonMode, CONTROL_INTRODUCER, c;
 var init_ui = __esm({
   "src/ui.ts"() {
     "use strict";
     init_brand();
     jsonMode = false;
+    CONTROL_INTRODUCER = /[\u001b\u009b\u009d]/;
     c = kleur;
   }
 });
@@ -969,10 +990,12 @@ function secretContentHits(text) {
     if (pattern.test(text)) hits.push({ code });
   }
   const plain = stripMarkdownEmphasis(text);
-  if (hasLabelledCredential(text) || hasLabelledCredential(plain)) {
+  const bare = withoutIntroducers(text);
+  const bothWays = (check) => check(text) || check(plain) || bare !== text && (check(bare) || check(stripMarkdownEmphasis(bare)));
+  if (bothWays(hasLabelledCredential)) {
     hits.push({ code: "labelled_credential" });
   }
-  if (hasSpacedCredential(text) || hasSpacedCredential(plain)) {
+  if (bothWays(hasSpacedCredential)) {
     hits.push({ code: "spaced_credential" });
   }
   if (hasCredentialNearPrivateIp(text)) hits.push({ code: "credential_near_private_ip" });
@@ -1003,7 +1026,7 @@ function isExplicitlyDenied(relPath, deny = EMPTY_DENY_LIST) {
 function isNameAllowlisted(relPath, allow = EMPTY_DENY_LIST) {
   return isExplicitlyDenied(relPath, allow);
 }
-var SENSITIVE_NAME_TERMS, foldForMatch, FOLDED_TERMS, SECRET_CONTENT_PATTERNS, CREDENTIAL_LABEL, LABEL_TAIL, LABEL_QUALIFIER, SEPARATOR, HEADER_CELL_IS_LABEL, stripMarkdownEmphasis, LABELLED_CREDENTIAL_RE, SPACED_CREDENTIAL_RE, LOOKS_LIKE_A_CREDENTIAL, FINANCIAL_NUMBER_RE, SHORT_SECRET_RE, PRIVATE_IP_RE, ACCESS_WORD_RE, VALUE_IS_NOT_A_SECRET, DeniedReadError, WEAK_CODES, isWeakSecretCode, EMPTY_DENY_LIST;
+var SENSITIVE_NAME_TERMS, foldForMatch, FOLDED_TERMS, SECRET_CONTENT_PATTERNS, CREDENTIAL_LABEL, LABEL_TAIL, LABEL_QUALIFIER, SEPARATOR, HEADER_CELL_IS_LABEL, stripMarkdownEmphasis, LABELLED_CREDENTIAL_RE, SPACED_CREDENTIAL_RE, LOOKS_LIKE_A_CREDENTIAL, FINANCIAL_NUMBER_RE, SHORT_SECRET_RE, PRIVATE_IP_RE, ACCESS_WORD_RE, VALUE_IS_NOT_A_SECRET, DeniedReadError, WEAK_CODES, isWeakSecretCode, withoutIntroducers, EMPTY_DENY_LIST;
 var init_deny = __esm({
   "../../packages/storage-adapter/src/local-file/deny.ts"() {
     "use strict";
@@ -1123,6 +1146,12 @@ var init_deny = __esm({
       "credential_table"
     ]);
     isWeakSecretCode = (code) => WEAK_CODES.has(code);
+    withoutIntroducers = (text) => (
+      // `ESC [` and `ESC ]` are two characters, so removing the ESC alone would
+      // leave a bracket where the hidden byte was and the label would still not
+      // read as itself.
+      text.replace(/\u001b[[\]]?|[\u009b\u009d]/g, "")
+    );
     EMPTY_DENY_LIST = { entries: [] };
   }
 });
@@ -3129,6 +3158,7 @@ async function walkVault(root, opts = {}) {
   const files2 = [];
   const skippedSymlinks = [];
   const excluded = [];
+  const excludedDirs = [];
   const visit = async (dirAbs, relDir, depth) => {
     if (depth > maxDepth) return;
     let entries;
@@ -3146,6 +3176,7 @@ async function walkVault(root, opts = {}) {
       const isDir = entry.isDirectory();
       if (isExcluded(rel, isDir, opts.ignore)) {
         excluded.push(rel);
+        if (isDir) excludedDirs.push(rel);
         continue;
       }
       if (isDir) {
@@ -3157,7 +3188,7 @@ async function walkVault(root, opts = {}) {
   };
   await visit(rootAbs, "", 0);
   files2.sort();
-  return { files: files2, skippedSymlinks, excluded };
+  return { files: files2, skippedSymlinks, excluded, excludedDirs };
 }
 function resolveInside(root, relPath) {
   if (relPath === "" || relPath.startsWith("/") || relPath.includes("\0")) {
@@ -8275,6 +8306,120 @@ async function createCloudBrain(token, baseUrl, name) {
 // src/commands/brain-admin.ts
 init_config();
 
+// src/lib/held-back.ts
+init_ui();
+var isNote = (p) => /\.(md|markdown)$/i.test(p);
+function heldBack(scan) {
+  const denied = scan.denied ?? [];
+  const byName = denied.filter((d) => d.kind === "name" && isNote(d.path)).map((d) => ({ path: d.path, term: d.term }));
+  const explicitly = denied.filter((d) => d.kind === "explicit" && isNote(d.path)).map((d) => d.path);
+  const byRule = scan.excluded.filter(isNote);
+  const symlinked = scan.skippedSymlinks.filter(isNote);
+  return {
+    total: byName.length + explicitly.length + byRule.length + symlinked.length,
+    folders: scan.excludedDirs ?? [],
+    byName,
+    explicitly,
+    byRule,
+    symlinked
+  };
+}
+function heldBackJson(held, totalKey = "not_sent") {
+  return {
+    // The count's key is the caller's, because `not_sent` is a claim about
+    // sending and `reindex` sends nothing. Naming its total `not_sent` would
+    // have an agent reporting a failed upload from a command that never
+    // contacts a server. `push` keeps the key it has always emitted.
+    [totalKey]: held.total,
+    denied_by_name: held.byName,
+    denied_explicitly: held.explicitly,
+    excluded_by_rule: held.byRule,
+    skipped_symlinks: held.symlinked,
+    // Present so a zero total can be read correctly. A non-empty list here means
+    // the count above is a floor, not the answer — nothing inside these was
+    // walked, so nobody knows how many notes they hold.
+    excluded_folders: held.folders
+  };
+}
+var NAME_GUESS_LABEL = "name looks private";
+function heldBackGroups(held) {
+  return [
+    {
+      label: NAME_GUESS_LABEL,
+      rows: held.byName.map((d) => ({ path: d.path, detail: `matched "${d.term ?? "?"}"` }))
+    },
+    { label: "listed in .memgdeny", rows: held.explicitly.map((p) => ({ path: p, detail: null })) },
+    { label: "excluded by a rule", rows: held.byRule.map((p) => ({ path: p, detail: null })) },
+    {
+      label: "a symlink, which is never followed",
+      rows: held.symlinked.map((p) => ({ path: p, detail: null }))
+    }
+  ];
+}
+function describeHeldBack(held) {
+  return [
+    ...heldBackGroups(held).flatMap(
+      ({ label, rows }) => rows.map(
+        (r) => `${stripControl(r.path)}  \u2014 ${label}${r.detail === null ? "" : ` (${stripControl(r.detail)})`}`
+      )
+    ),
+    ...held.folders.map(
+      (dir) => `${stripControl(dir)}/  \u2014 an excluded folder, whose contents were never walked`
+    )
+  ];
+}
+function printHeldBack(held, wording) {
+  if (held.total === 0 && held.folders.length === 0) return;
+  const guessed = held.byName;
+  const chosen = heldBackGroups(held).filter(({ label }) => label !== NAME_GUESS_LABEL);
+  const chosenCount = chosen.reduce((n, g) => n + g.rows.length, 0);
+  if (chosenCount > 0 || held.folders.length > 0) {
+    printHuman(
+      c.gray(
+        chosenCount === 0 ? `
+Some notes are not in ${wording.where}, because your rules say so:` : `
+${chosenCount} note(s) are not in ${wording.where}, because your rules say so:`
+      )
+    );
+    for (const { label, rows } of chosen) {
+      if (rows.length === 0) continue;
+      printHuman(c.gray(`  ${rows.length} \u2014 ${label}:`));
+      for (const r of rows.slice(0, 10)) printHuman(c.gray(`    ${stripControl(r.path)}`));
+      if (rows.length > 10) printHuman(c.gray(`    \u2026 and ${rows.length - 10} more`));
+    }
+    if (held.folders.length > 0) {
+      printHuman(
+        c.gray(
+          `  ${held.folders.length} excluded folder(s) \u2014 their contents were not walked, so notes
+  inside them are not counted above:`
+        )
+      );
+      for (const dir of held.folders.slice(0, 10)) printHuman(c.gray(`    ${stripControl(dir)}/`));
+      if (held.folders.length > 10) {
+        printHuman(c.gray(`    \u2026 and ${held.folders.length - 10} more`));
+      }
+    }
+  }
+  if (guessed.length > 0) {
+    printHuman(
+      c.yellow(
+        `
+\u26A0 ${guessed.length} note(s) are not in ${wording.where}, held back on this machine by a GUESS about the name:`
+      )
+    );
+    for (const d of guessed.slice(0, 10)) {
+      printHuman(c.gray(`    ${stripControl(d.path)}  (matched "${stripControl(d.term ?? "?")}")`));
+    }
+    if (guessed.length > 10) printHuman(c.gray(`    \u2026 and ${guessed.length - 10} more`));
+    printHuman(
+      c.gray(
+        `  This may be a false alarm \u2014 rename the note, or list it in .memgallow,
+  and ${wording.retry}.`
+      )
+    );
+  }
+}
+
 // src/lib/ledger.ts
 init_deny();
 init_brand();
@@ -8413,6 +8558,13 @@ var RULE_VERSION = 2;
 var RATIONALE_MAX = 500;
 function sanitizeRationale(raw) {
   if (raw == null) return null;
+  if (CONTROL_INTRODUCER.test(raw)) {
+    throw memgError(
+      "invalid_input",
+      "the reason contains a terminal control sequence",
+      "Nothing was saved. The text carries invisible formatting \u2014 usually from pasting out of a terminal, a chat window, or a file that was decoded wrongly \u2014 and stored prose that hides characters can read as something other than what it says. Type the same words in again as plain text and run it once more. Keep --reason: the reason is the part of a memory that still means anything later."
+    );
+  }
   const clean = stripControl(raw).trim();
   if (clean === "") return null;
   const hits = secretContentHits(clean);
@@ -8603,14 +8755,17 @@ function reindexCommand() {
       protectedVault: true
     });
     const scan = await adapter.scan();
-    const nameDenied = (scan.denied ?? []).filter((d) => d.kind !== "explicit");
+    const held = heldBack(scan);
     printDual({
       json: {
         brain: brain.root,
         indexed: built.entries.length,
         cache_dir: built.cacheDir,
         issues: built.issues,
-        denied_by_name: nameDenied.map((d) => ({ path: d.path, term: d.term })),
+        // Carries `denied_by_name` under the key it always had, plus the three
+        // this command used to drop. The total is `not_indexed` rather than
+        // push's `not_sent`: nothing is sent from here.
+        ...heldBackJson(held, "not_indexed"),
         denied_by_content: built.denied.filter((d) => d.reason === "content")
       },
       human: () => {
@@ -8623,14 +8778,21 @@ function reindexCommand() {
             )
           );
         }
+        printHeldBack(held, { where: "the index", retry: "reindex" });
         const byContent = built.denied.filter((d) => d.reason === "content");
-        for (const [label, rows] of [
-          ["name looks private", nameDenied.map((d) => `${d.path}  (matched "${d.term}")`)],
-          ["content looks like a credential", byContent.map((d) => `${d.path}  (${d.detail})`)]
-        ]) {
-          if (rows.length === 0) continue;
-          printHuman(c.yellow(`  ${rows.length} note(s) refused \u2014 ${label}:`));
-          for (const row of rows.slice(0, 10)) printHuman(c.gray(`    ${row}`));
+        if (byContent.length > 0) {
+          printHuman(
+            c.yellow(
+              `
+\u26A0 ${byContent.length} note(s) refused \u2014 content looks like a credential:`
+            )
+          );
+          for (const d of byContent.slice(0, 10)) {
+            printHuman(c.gray(`    ${stripControl(d.path)}  (${stripControl(d.detail)})`));
+          }
+          if (byContent.length > 10) {
+            printHuman(c.gray(`    \u2026 and ${byContent.length - 10} more`));
+          }
         }
       }
     });
@@ -10066,11 +10228,17 @@ function proposalsCommand() {
       opts.all === true ? { all: true } : {}
     ) : await listLocally(where.brain.root, opts.all === true);
     const shown = listed.proposals;
+    const unavailable = shown.filter(
+      (p) => p.claim === void 0 && !carriesNoClaim(p.action)
+    );
+    const rows = shown.map(
+      (p) => p.claim === void 0 && !carriesNoClaim(p.action) ? { ...p, claim: null, claim_unavailable: true } : p
+    );
     printDual({
       json: {
-        proposals: shown,
-        count: shown.length,
-        hint: hintForList(shown.length, listed.total, opts.all === true)
+        proposals: rows,
+        count: rows.length,
+        hint: unavailable.length > 0 ? `${unavailable.length} of these came back without a claim because this brain's server is older than the CLI \u2014 they are marked \`claim_unavailable\`, and \`memgineering open <id>\` shows what each note says now. ${hintForList(shown.length, listed.total, opts.all === true)}` : hintForList(shown.length, listed.total, opts.all === true)
       },
       human: () => {
         if (shown.length === 0) {
@@ -10111,6 +10279,7 @@ function summarize(p) {
     action: p.action,
     memory_id: p.memory_id,
     target: p.target.path,
+    claim: p.claim?.text ?? null,
     reason: p.reason,
     proposed_kind: p.proposed_kind,
     supersedes: p.relations.supersedes,
@@ -10118,12 +10287,24 @@ function summarize(p) {
     expires_at: p.expiresAt
   };
 }
+var CLAIM_WIDTH = 160;
 function renderSummary(p) {
+  const claimless = carriesNoClaim(p.action);
+  const claim = p.claim === void 0 || p.claim === null ? null : oneLine(p.claim, CLAIM_WIDTH);
+  const unavailable = p.claim === void 0 && !claimless;
   const lines2 = [
     `- **${stripControl(p.action)}**${p.proposed_kind ? ` \u2192 ${p.proposed_kind}` : ""}  \`${stripControl(p.target)}\``,
-    `  ${p.id}  ${p.state}`,
-    quoteBlock(p.reason, "  > ")
+    `  ${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.)`
+      )
+    );
+  }
+  lines2.push(quoteBlock(p.reason, "  > "));
   if (p.supersedes.length > 0) {
     lines2.push(c.gray(`  replaces: ${p.supersedes.map(stripControl).join(", ")}`));
   }
@@ -10471,14 +10652,25 @@ function consolidateCommand() {
     });
   });
 }
+var TITLE_WIDTH = 72;
+function noteLines(id, title, path) {
+  const shown = oneLine(title, TITLE_WIDTH);
+  return [
+    shown === "" ? `  ${stripControl(id)}` : `  ${stripControl(id)}  ${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)}\``)
+  ];
+}
 function renderCandidate(candidate) {
   const lines2 = [
     `- **${stripControl(candidate.rule)}** \u2014 ${stripControl(candidate.evidence)}`,
-    `  ${stripControl(candidate.memory_id)}  \`${stripControl(candidate.path)}\``
+    ...noteLines(candidate.memory_id, candidate.title, candidate.path)
   ];
   if (candidate.other_id !== null) {
     lines2.push(
-      `  ${stripControl(candidate.other_id)}  \`${stripControl(candidate.other_path ?? "")}\``
+      ...noteLines(candidate.other_id, candidate.other_title ?? "", candidate.other_path ?? "")
     );
   }
   lines2.push(
@@ -12147,6 +12339,11 @@ init_api_client();
 import { Command as Command17 } from "commander";
 init_vault();
 init_ui();
+var HELD_BACK_WORDING = {
+  where: "the hosted brain",
+  retry: "push again"
+};
+var printHeldBack2 = (held) => printHeldBack(held, HELD_BACK_WORDING);
 function pushCommand() {
   return new Command17("push").description("upload the brain on this machine to your hosted one").option("--vault <path>", "which local brain to upload").option("--brain <name>", "the hosted brain to upload into (created if it does not exist)").option("--dry-run", "list what would be uploaded and send nothing").action(async (opts) => {
     const { brain: local } = await resolveBrain(opts.vault);
@@ -12155,11 +12352,16 @@ function pushCommand() {
     const paths = scan.files.filter(isNote);
     const held = heldBack(scan);
     if (paths.length === 0) {
+      const sawFiles = scan.files.length > 0;
+      const excluded = describeHeldBack(held).slice(0, 10).map((row) => `  ${row}`).join("\n");
       throw memgError(
         "invalid_input",
         `there is nothing to upload in ${local.root}`,
-        held.total === 0 ? "This brain has no markdown notes in it at all. Check the path \u2014 `--vault` takes the folder your notes live in." : `This brain has ${held.total} markdown note(s) and the rules on this machine hold back every one:
-` + describeHeldBack(held).slice(0, 10).map((row) => `  ${row}`).join("\n") + "\nRename one, or list it in .memgallow, if the name is a false alarm."
+        held.total > 0 ? `This brain has ${held.total} markdown note(s) and the rules on this machine hold back every one:
+${excluded}
+Rename one, or list it in .memgallow, if the name is a false alarm.` : held.folders.length > 0 ? `No markdown notes were found. ${held.folders.length} folder(s) were excluded by a rule and never looked inside:
+${excluded}
+If your notes are in one of those, that rule is why \u2014 nothing here can see them. If they are somewhere else, check the path: \`--vault\` takes the folder your notes live in.` : sawFiles ? "There are files here but no markdown notes. Check the path \u2014 `--vault` takes the folder your notes live in." : "This folder is empty. Check the path \u2014 `--vault` takes the folder your notes live in."
       );
     }
     if (opts.dryRun) {
@@ -12179,7 +12381,7 @@ function pushCommand() {
 `);
           for (const path of paths.slice(0, 20)) printHuman(c.gray(`  ${path}`));
           if (paths.length > 20) printHuman(c.gray(`  \u2026 and ${paths.length - 20} more`));
-          printHeldBack(held);
+          printHeldBack2(held);
           printHuman(
             c.gray(
               "\nNothing was sent. What a dry run cannot know is the other screen: a note\nwhose CONTENT looks like a credential is held back \u2014 by this machine before\nsending, and by the server on arrival \u2014 and deciding that needs the bytes,\nwhich this does not read. Those appear in the real run\u2019s summary."
@@ -12284,7 +12486,7 @@ function pushCommand() {
             printHuman(c.gray(`  \u2026 and ${refused.length - 10} more`));
           }
         }
-        printHeldBack(held);
+        printHeldBack2(held);
         printRepoint(repointed, destination);
         printHuman(
           c.gray(
@@ -12322,82 +12524,6 @@ brain before. \`memgineering recall --local\` still reads the folder.`
     )
   );
 }
-var isNote = (p) => /\.(md|markdown)$/i.test(p);
-function heldBack(scan) {
-  const denied = scan.denied ?? [];
-  const byName = denied.filter((d) => d.kind === "name" && isNote(d.path)).map((d) => ({ path: d.path, term: d.term }));
-  const explicitly = denied.filter((d) => d.kind === "explicit" && isNote(d.path)).map((d) => d.path);
-  const byRule = scan.excluded.filter(isNote);
-  const symlinked = scan.skippedSymlinks.filter(isNote);
-  return {
-    total: byName.length + explicitly.length + byRule.length + symlinked.length,
-    byName,
-    explicitly,
-    byRule,
-    symlinked
-  };
-}
-function heldBackJson(held) {
-  return {
-    not_sent: held.total,
-    denied_by_name: held.byName,
-    denied_explicitly: held.explicitly,
-    excluded_by_rule: held.byRule,
-    skipped_symlinks: held.symlinked
-  };
-}
-function heldBackGroups(held) {
-  return [
-    {
-      label: "name looks private",
-      rows: held.byName.map((d) => ({ path: d.path, detail: `matched "${d.term ?? "?"}"` }))
-    },
-    { label: "listed in .memgdeny", rows: held.explicitly.map((p) => ({ path: p, detail: null })) },
-    { label: "excluded by a rule", rows: held.byRule.map((p) => ({ path: p, detail: null })) },
-    {
-      label: "a symlink, which is never followed",
-      rows: held.symlinked.map((p) => ({ path: p, detail: null }))
-    }
-  ];
-}
-function describeHeldBack(held) {
-  return heldBackGroups(held).flatMap(
-    ({ label, rows }) => rows.map(
-      (r) => `${stripControl(r.path)}  \u2014 ${label}${r.detail === null ? "" : ` (${stripControl(r.detail)})`}`
-    )
-  );
-}
-function printHeldBack(held) {
-  if (held.total === 0) return;
-  printHuman(
-    c.yellow(`
-\u26A0 ${held.total} note(s) held back on this machine \u2014 they never reach the brain:`)
-  );
-  for (const { label, rows } of heldBackGroups(held)) {
-    if (rows.length === 0) continue;
-    printHuman(c.gray(`  ${rows.length} \u2014 ${label}:`));
-    for (const r of rows.slice(0, 10)) {
-      printHuman(
-        c.gray(
-          `    ${stripControl(r.path)}${r.detail === null ? "" : `  (${stripControl(r.detail)})`}`
-        )
-      );
-    }
-    if (rows.length > 10) printHuman(c.gray(`    \u2026 and ${rows.length - 10} more`));
-  }
-  if (held.byName.length > 0) {
-    printHuman(
-      c.gray(
-        "  The name list is a GUESS and this may be a false alarm \u2014 rename the note,\n  or list it in .memgallow, and push again."
-      )
-    );
-  }
-  printHuman(
-    c.gray(
-      "  Counted per file. A rule that excludes a whole FOLDER stops the walk there,\n  so notes inside one are not listed above."
-    )
-  );
-}
 async function resolveDestination(named, root) {
   const base = apiUrl();
   const credentials = await requireCredentials(base);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "memgineering",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "private": false,
-  "description": "One memory for the AI you connect. Recall, remember, and revise a brain your agents share — stored in your own folder.",
+  "description": "One memory for the AI you connect. Recall, remember, and revise a brain your agents share \u2014 stored in your own folder.",
   "license": "Apache-2.0",
   "homepage": "https://memgineering.com",
   "repository": {