memgineering 0.22.0 → 0.23.1

package/CHANGELOG.md

@@ -11,6 +11,76 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [0.23.1] — 2026-09-11
+
+### Fixed
+
+- **The rules a hook shows now include the sentence that says what to do.**
+  `memgineering guard` quoted each rule's `summary`, which is the note's text
+  cut at 200 characters — so a rule long enough to describe a problem before
+  prescribing an answer arrived with the answer removed. Measured across 24
+  sessions: of six rules planted as global rules, five were cut immediately
+  before their prescription, and every session holding one of them walked into
+  the trap its own rule described. The hook now quotes the rule as written, and
+  when it still has to shorten one it elides the MIDDLE, keeping the opening and
+  the closing instruction.
+- **A short list of rules is now read further than a long one.** The width is a
+  budget shared across the whole block rather than a fixed cap per line, so two
+  standing decisions arrive in full where ten are abbreviated. Ten rules cost
+  exactly what ten rules cost before — nothing here prints more than it used to.
+
+### Added
+
+- **A hosted brain sends the rule, not just the card.** `POST /rules` gained a
+  `text` field carrying the rule as written; a client older than this ignores it
+  and keeps rendering `summary`, and a server older than this makes the new
+  client fall back to `summary` as well. Deploy the server first to get the
+  benefit; neither order breaks anything.
+
+## [0.23.0] — 2026-09-09
+
+### Added
+
+- **`revise <ref> --no-rule` on its own now takes a marking back and asks for
+  nothing else.** It used to require `--claim`, because `revise` is a verb
+  about conclusions — so unbinding a rule meant restating a conclusion that had
+  not changed, from text `open` hands back truncated, with `--summary`
+  defaulting to whatever you passed. Unbinding thirteen rules on a real hosted
+  brain was only possible by reading the note bodies out of the database. The
+  conclusion, the summary and the title now come back byte for byte, and
+  `undo` reverses it. Adding a claim, a summary, a title, a date, an explicit
+  `--action` or a boundary word still makes it an ordinary revise —
+  except `--action reinforce`, which means "the same conclusion" and is
+  therefore what unbinding already says.
+
+### Changed
+
+- **`consolidate` no longer assumes which way an unclassified rule should
+  go.** A memory marked as binding with no kind was answered "raise this to a
+  decision". Measured on a real brain, 55 of 57 standing rules had no kind and
+  thirteen of them were not rules at all — every one was told to become a
+  decision, which would have made the mistake harder to see. Such a note is now
+  reported as `binding_unclassified` and names both moves: classify it, or stop
+  it binding. Only somebody who reads the note can say which.
+- **`consolidate` shares its page between the signals it found.** One rule used
+  to take the whole list — 55 of 57 candidates — so a duplicate and a
+  contradiction underneath got one line each, and raising `--limit` returned
+  more of the same rule. Candidates now alternate across the rules that found
+  something, and the answer carries `by_rule` totals, which the page itself can
+  no longer tell you.
+- **`rules` against a hosted brain now lists the rules scoped to other
+  projects**, under their own heading, as the local one already did. They are
+  still never shown to an agent working here. Without the list there was no
+  surface anywhere on which to notice a scope with a typo in it — such a rule
+  binds nothing and appears nowhere.
+
+### Agent guidance
+
+`memgineering-rules` and `memgineering-writing` both changed: how to take a
+marking back and how it differs from `retire`, the two budgets no longer
+crowding out project rules, and the new consolidation signals. Restart your
+agent session after upgrading so it reads them.
+
 ## [0.22.0] — 2026-09-09
 
 ### Added

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.22.0
+version: 0.23.1
 ---
 
 # memgineering

package/assets/memgineering-rules/SKILL.md

@@ -146,11 +146,19 @@ a long list is fewer rules, not a longer one.
 
 Two consequences worth knowing before you mark things:
 
-- **Global habits crowd out project decisions.** A rule that has been recalled
-  in other folders outranks a project rule written yesterday that nobody has
-  reached for. If a user's own working preferences fill all eight slots, a new
-  a rule written for the folder they are in may never be shown. Keep the
-  standing set small.
-- **A retired rule stops being shown.** `memgineering retire <ref>` is the way
-  out when a decision no longer holds — it stays visible in recall, ranked last
-  and labelled, but it stops binding.
+- **Global habits used to crowd out project decisions**, and the two budgets
+  are why they no longer can: a rule scoped to the project has its own room and
+  cannot lose every slot to whatever the user has been reaching for lately. It
+  still pays to keep the standing set small — ten is what a session reads.
+- **Two ways out, and they are not the same.** `memgineering revise <ref>
+--no-rule --reason "…"` says it was never a rule: it stops being shown before
+  an edit, and stays a perfectly ordinary current memory that recall returns.
+  `memgineering retire <ref>` says it no longer holds: it stops binding AND
+  drops to the bottom of recall, labelled. Reach for the first when the marking
+  was the mistake and the second when the decision has been overtaken.
+- **`--no-rule` on its own asks for nothing else.** No claim, no summary — the
+  conclusion, the summary and the title come back byte for byte, which is the
+  whole reason it exists. It used to go through `revise`, which requires a
+  claim, so taking a marking back meant restating a conclusion nobody had
+  changed, from text this CLI hands back truncated. Do not restate anything;
+  `memgineering undo` reverses it.

package/assets/memgineering-writing/SKILL.md

@@ -235,19 +235,30 @@ 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 seven rules: `declared_supersession`, a replaced note still
+suggest, under eight rules: `declared_supersession`, a replaced note still
 active; `contradiction`, a disagreement nobody settled; `semantic_similarity`,
 indexed meaning agreeing reciprocally; `shared_context`, one scope naming the
-same thing; `similar_title`; and the two directions of one disagreement between
-a note's `binding` flag and its `kind` — `kind_promotion`, a binding note with
-no kind at all, where the marking was deliberate and the classification never
-happened; and `rule_demotion`, a binding note the author classified as a fact,
-a procedure, an episode or a goal. That second one is two deliberate fields
-contradicting each other, and the marking is the one to doubt: measured on a
-real brain, 13 of 54 binding notes were a fact, a piece of state or a procedure,
-each standing over every session as a decision nobody made. Its suggestion is
-`memgineering revise <id> --no-rule --reason "…"`, which already exists — there
-is no new verb for taking a marking back. Semantic detection reuses a complete, calibrated hosted
+same thing; `similar_title`; and three that read a note against itself, where
+its `binding` flag and its `kind` disagree. `rule_demotion` is a binding note
+the author classified as a fact, a procedure, an episode or a goal — two
+deliberate fields contradicting each other, and the marking is the one to
+doubt. `binding_unclassified` is a binding note with no kind at all, and it
+names BOTH moves rather than picking one, because the tool reads fields and not
+prose: it is either a decision nobody classified or something that was never a
+rule, and only somebody who reads it can say which. (`kind_promotion` remains
+in the vocabulary and no longer fires.)
+
+That neutrality was measured rather than chosen for balance. On a real brain,
+55 of 57 binding notes had no kind and every one was answered "promote this to
+a decision" — including the thirteen that turned out not to be rules, where
+approving the suggestion would have hardened the mistake.
+
+**The page is shared between the signals.** One rule used to take the whole
+list — 55 of 57 candidates — so the duplicate and the contradiction underneath
+got a line each. Candidates now round-robin across the rules that found
+something, and `by_rule` reports how many each found in total, which the page
+can no longer tell you. Raising `--limit` widens the page rather than returning
+more of one rule. Semantic detection reuses a complete, calibrated hosted
 vector generation and never calls a model during consolidation. Authored
 scope/entity context permits reciprocal neighbours; without it, evidence must
 form a stricter three-note semantic triangle.

package/dist/index.js

@@ -497,6 +497,52 @@ var init_rule_budget = __esm({
   }
 });
 
+// ../../packages/memory-engine/src/rule-text.ts
+function ruleTextOf(entry) {
+  const intro = (entry.chunks ?? []).find((chunk) => chunk.label === null)?.text.trim();
+  if (intro !== void 0 && intro !== "") return intro;
+  return entry.memory.summary ?? entry.memory.title;
+}
+function ruleWidthFor(count) {
+  if (count <= 0) return RULE_WIDTH_MIN;
+  const share = Math.floor(RULE_BLOCK_BUDGET / count);
+  return Math.min(RULE_WIDTH_MAX, Math.max(RULE_WIDTH_MIN, share));
+}
+function rulePassage(text, max) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  const chars = [...flat];
+  if (chars.length <= max) return flat;
+  if (max <= 1) return "\u2026";
+  const budget = max - 1;
+  if (budget < 2) return `${chars.slice(0, budget).join("")}\u2026`;
+  const tailBudget = Math.min(budget - 1, Math.max(1, Math.floor(budget * 0.6)));
+  const tail = [...trailingSentences(flat, tailBudget)];
+  const head = chars.slice(0, budget - tail.length).join("").trimEnd();
+  return `${head}\u2026${tail.join("")}`;
+}
+function trailingSentences(flat, budget) {
+  const starts = [...flat.matchAll(/[.!?。！？](?=\s)/g)].map(
+    (match) => match.index + match[0].length
+  );
+  let best = null;
+  for (let i = starts.length - 1; i >= 0; i -= 1) {
+    const candidate = flat.slice(starts[i]).trim();
+    if ([...candidate].length > budget) break;
+    if (candidate !== "") best = candidate;
+  }
+  if (best !== null) return best;
+  return [...flat].slice(-budget).join("");
+}
+var RULE_WIDTH_MIN, RULE_WIDTH_MAX, RULE_BLOCK_BUDGET;
+var init_rule_text = __esm({
+  "../../packages/memory-engine/src/rule-text.ts"() {
+    "use strict";
+    RULE_WIDTH_MIN = 200;
+    RULE_WIDTH_MAX = 600;
+    RULE_BLOCK_BUDGET = RULE_WIDTH_MIN * 10;
+  }
+});
+
 // ../../packages/memory-engine/src/boundary.ts
 function normalizeForMatch(value) {
   return value.normalize("NFC").replace(ZERO_WIDTH, "").replace(WHITESPACE_RUN, " ").trim();
@@ -2235,8 +2281,11 @@ function isLifecycleAction(action) {
 function isClassifyAction(action) {
   return action === "reclassify";
 }
+function isBindingAction(action) {
+  return action === "unbind";
+}
 function carriesNoClaim(action) {
-  return isLifecycleAction(action) || isClassifyAction(action);
+  return isLifecycleAction(action) || isClassifyAction(action) || isBindingAction(action);
 }
 function isAccepted(value) {
   return typeof value === "object" && value !== null && value[ACCEPTED] === true;
@@ -2265,6 +2314,21 @@ var init_schema2 = __esm({
       "retire",
       "unretire",
       "reclassify",
+      /**
+       * A memory stops binding. Nothing else about it changes.
+       *
+       * It exists because there was no way to do this without saying something
+       * else. Taking a marking back meant `revise --claim`, which is a verb about
+       * conclusions — so unbinding thirteen rules on a real hosted brain required
+       * restating thirteen conclusions the author had not changed, from text the
+       * CLI hands back TRUNCATED. The person doing it read the note bodies out of
+       * the database to avoid corrupting them, which is not a thing a user can do.
+       *
+       * One direction on purpose. `unbind` that could also bind would be a name
+       * that lies half the time; marking something as a rule is already reachable
+       * (`remember --rule`, or a `revise` that is genuinely saying something new).
+       */
+      "unbind",
       "ignore"
     ]);
     StorableActionSchema = ProposalActionSchema.exclude(["ignore"]);
@@ -2460,7 +2524,7 @@ var init_schema2 = __esm({
         path: ["source_excerpt"]
       }
     ).refine((p) => carriesNoClaim(p.action) || p.claim !== null, {
-      message: "only retire, unretire and reclassify may omit the claim",
+      message: "only retire, unretire, reclassify and unbind may omit the claim",
       path: ["claim"]
     }).refine((p) => isClassifyAction(p.action) === (p.proposed_kind !== null), {
       message: "proposed_kind belongs to reclassify, and reclassify requires one",
@@ -2496,12 +2560,42 @@ function detectConsolidation(entries, opts = {}) {
     ...titles
   ];
   const out = rankCandidates(scored);
+  const limit = opts.limit ?? DEFAULT_LIMIT;
   return {
-    candidates: out.slice(0, opts.limit ?? DEFAULT_LIMIT),
+    candidates: shareTheList(out, limit),
+    by_rule: countByRule(out),
     scanned: budget.scanned,
     truncated: budget.truncated
   };
 }
+function shareTheList(ranked, limit) {
+  const lanes = /* @__PURE__ */ new Map();
+  for (const candidate of ranked) {
+    const lane = lanes.get(candidate.rule);
+    if (lane) lane.push(candidate);
+    else lanes.set(candidate.rule, [candidate]);
+  }
+  const out = [];
+  const queues = [...lanes.values()];
+  let round = 0;
+  for (; ; ) {
+    let added = false;
+    for (const queue of queues) {
+      if (out.length >= limit) return out;
+      const next = queue[round];
+      if (next === void 0) continue;
+      out.push(next);
+      added = true;
+    }
+    if (!added) return out;
+    round += 1;
+  }
+}
+function countByRule(ranked) {
+  const out = {};
+  for (const candidate of ranked) out[candidate.rule] = (out[candidate.rule] ?? 0) + 1;
+  return out;
+}
 function titleTerms(title) {
   const out = /* @__PURE__ */ new Set();
   for (const term of terms(title)) {
@@ -2854,16 +2948,16 @@ function kindPromotions(entries) {
     if (kind === void 0) {
       out.push({
         candidate: {
-          rule: "kind_promotion",
+          rule: "binding_unclassified",
           memory_id: entry.memory.id,
           path: entry.path,
           title: entry.memory.title,
           other_id: null,
           other_path: null,
           other_title: null,
-          evidence: "marked as binding but left unclassified \u2014 a memory that binds is a decision",
-          suggested_action: "reclassify",
-          suggested_kind: "decision"
+          evidence: "marked as binding and left unclassified \u2014 either a decision nobody classified, or something that was never a rule",
+          suggested_action: "decide",
+          suggested_kind: null
         },
         confidence: 4
       });
@@ -2999,7 +3093,8 @@ var init_detect = __esm({
       "shared_context",
       "similar_title",
       "kind_promotion",
-      "rule_demotion"
+      "rule_demotion",
+      "binding_unclassified"
     ];
     DEFAULT_LIMIT = 50;
     DEFAULT_PAIR_BUDGET = 2e5;
@@ -3252,12 +3347,12 @@ function commit(prepared, input, opts = {}) {
   if (carriesNoClaim(parsed.action)) {
     if (parsed.claim !== null) {
       throw Object.assign(new Error(`${parsed.action} does not take a claim`), {
-        hint: isClassifyAction(parsed.action) ? `${parsed.action} says what sort of memory this is, not what it says. To change the conclusion too, use supersede.` : `${parsed.action} changes whether a memory is current, not what it says. To change the conclusion too, use supersede.`
+        hint: isClassifyAction(parsed.action) ? `${parsed.action} says what sort of memory this is, not what it says. To change the conclusion too, use supersede.` : isBindingAction(parsed.action) ? `${parsed.action} takes a marking back and leaves the conclusion exactly as it is \u2014 that is the whole reason it exists. To change what the note says as well, use supersede.` : `${parsed.action} changes whether a memory is current, not what it says. To change the conclusion too, use supersede.`
       });
     }
   } else if (parsed.claim === null) {
     throw Object.assign(new Error(`${parsed.action} needs a claim`), {
-      hint: "Only retire, unretire and reclassify may omit it. They change a memory's standing or its classification rather than its content."
+      hint: "Only retire, unretire, reclassify and unbind may omit it. They change a memory's standing, its classification or whether it binds, rather than its content."
     });
   } else if ((parsed.action === "supersede" || parsed.action === "create") && parsed.claim.summary === null) {
     throw Object.assign(new Error(`${parsed.action} needs a summary as well as a claim`), {
@@ -3313,10 +3408,10 @@ var init_commit = __esm({
        */
       memory_id: z5.string().min(1).nullable().default(null),
       /**
-       * Omitted by `retire` / `unretire` / `reclassify`, which change a memory's
-       * standing or its classification rather than what it says. Checked below with
-       * the other action rules so the error can name the action instead of pointing
-       * at a field.
+       * Omitted by `retire` / `unretire` / `reclassify` / `unbind`, which change a
+       * memory's standing, its classification or whether it binds — rather than
+       * what it says. Checked below with the other action rules so the error can
+       * name the action instead of pointing at a field.
        */
       claim: ProposedClaimSchema.nullable().default(null),
       /** What `reclassify` is reclassifying this memory AS. Only that action takes one. */
@@ -3421,6 +3516,16 @@ function reclassifyInput(entry, kind, opts = {}) {
     target_path: entry.path
   };
 }
+function unbindInput(entry, opts = {}) {
+  return {
+    action: "unbind",
+    memory_id: entry.memory.id,
+    claim: null,
+    reason: opts.reason ?? "no longer binding",
+    source_excerpt: opts.because ?? entry.memory.summary ?? entry.memory.title,
+    target_path: entry.path
+  };
+}
 function saysNothingNew(entry, input, normalize) {
   const norm = (v) => normalize(v ?? "").trim();
   const claim = input.claim;
@@ -3510,6 +3615,10 @@ function desiredFields(proposal, existing) {
     out["kind"] = proposal.proposed_kind;
     return out;
   }
+  if (isBindingAction(proposal.action)) {
+    delete out["binding"];
+    return out;
+  }
   const claim = proposal.claim;
   if (claim === null) {
     throw new Error(`${proposal.action} reached the patcher with no claim`);
@@ -3807,6 +3916,46 @@ function verifyPatch(patched, proposal, before) {
     }
     return;
   }
+  if (isBindingAction(proposal.action)) {
+    if (mapped.memory.binding === true) {
+      throw new PatchError(
+        "the patched note still reads as binding",
+        "This is a defect in the patcher, not in your note. Nothing was written."
+      );
+    }
+    if (before === void 0) {
+      throw new PatchError(
+        `${proposal.action} cannot be verified without the note it started from`,
+        "This is a defect in the caller, not in your note. Nothing was written."
+      );
+    }
+    const was = mapNoteToMemory({ path: proposal.target.path, content: before, revision: null });
+    if (was.claims[0]?.text !== mapped.claims[0]?.text) {
+      throw new PatchError(
+        `${proposal.action} changed the conclusion, which it must never do`,
+        "Taking a marking back leaves what the note says exactly as it was. Nothing was written."
+      );
+    }
+    if (was.memory.summary !== mapped.memory.summary) {
+      throw new PatchError(
+        `${proposal.action} changed the summary, which it must never do`,
+        "Taking a marking back leaves what the note says exactly as it was \u2014 and the summary is what recall matches on. Nothing was written."
+      );
+    }
+    if (was.memory.title !== mapped.memory.title) {
+      throw new PatchError(
+        `${proposal.action} changed the title, which it must never do`,
+        "Taking a marking back leaves what the note says exactly as it was. Nothing was written."
+      );
+    }
+    if (was.memory.status !== mapped.memory.status) {
+      throw new PatchError(
+        `${proposal.action} changed the status, which it must never do`,
+        "A memory that no longer binds is still current. To take it out of the answers as well, use retire. Nothing was written."
+      );
+    }
+    return;
+  }
   const supersedes = new Set(
     mapped.relations.filter((r) => r.type === "supersedes").map((r) => r.to)
   );
@@ -4127,6 +4276,7 @@ var init_src = __esm({
     init_schema();
     init_layout();
     init_rule_budget();
+    init_rule_text();
     init_boundary();
     init_markdown_mapping();
     init_build();
@@ -4709,7 +4859,7 @@ async function createCloudBrain(token, baseUrl, name) {
   });
   return res.body;
 }
-var call, askedFromField, cloudRecall, cloudOpen, cloudEvidence, cloudRemember, cloudUndo, cloudLog, cloudPutNote, cloudListNotes, cloudRevise, cloudBaseWrite, cloudLifecycle, cloudExclude, RANKED_BY_PROJECT, rankedOnProject, cloudResurface, cloudRules, cloudReindex;
+var call, askedFromField, cloudRecall, cloudOpen, cloudEvidence, cloudRemember, cloudUndo, cloudLog, cloudPutNote, cloudListNotes, cloudRevise, cloudBaseWrite, cloudLifecycle, cloudUnbind, cloudExclude, RANKED_BY_PROJECT, rankedOnProject, cloudResurface, cloudRules, cloudReindex;
 var init_cloud_brain = __esm({
   "src/lib/cloud-brain.ts"() {
     "use strict";
@@ -4799,6 +4949,10 @@ var init_cloud_brain = __esm({
       ref: args.ref,
       ...args.reason === void 0 ? {} : { reason: args.reason }
     });
+    cloudUnbind = (brain, args) => call(brain, "POST", "/unbind", {
+      ref: args.ref,
+      ...args.reason === void 0 ? {} : { reason: args.reason }
+    });
     cloudExclude = (brain, mode, args) => call(brain, "POST", `/${mode}`, {
       path: args.path,
       ...args.reason === void 0 ? {} : { reason: args.reason }
@@ -12946,10 +13100,13 @@ function yamlString(value) {
 
 // src/commands/revise.ts
 function reviseCommand() {
+  const said = { action: false };
   return new Command7("revise").description("change a memory's conclusion, and record how to undo it").argument("<ref>", "handle, id, path, or exact title").option("--claim <text>", "what is now true").option("--summary <text>", "the one line recall will show (defaults to the claim)").option("--title <text>", "the heading recall shows above it (unchanged when omitted)").option(
     "--valid-from <iso>",
     "when this became true (defaults: supersede = now, otherwise unchanged)"
-  ).option("--action <kind>", "reinforce | supersede | conflict", "supersede").option("--rule", "this memory is now a decision that binds, not a fact to look up").option("--no-rule", "it no longer binds \u2014 an ordinary memory again").option("--never-store <words>", "replace this note\u2019s boundary words (comma-separated)").option("--no-never-store", "this note no longer declares a boundary").option(
+  ).option("--action <kind>", "reinforce | supersede | conflict", "supersede").on("option:action", () => {
+    said.action = true;
+  }).option("--rule", "this memory is now a decision that binds, not a fact to look up").option("--no-rule", "it no longer binds \u2014 an ordinary memory again").option("--never-store <words>", "replace this note\u2019s boundary words (comma-separated)").option("--no-never-store", "this note no longer declares a boundary").option(
     "--never-store-add <words>",
     "add words to this note\u2019s boundary, keeping the ones already there"
   ).option("--contradicts <ids...>", "memories this disagrees with").option("--reason <text>", "why this change is right").option("--because <text>", "the passage from the note that justifies it").option("--input <json>", "the whole change as JSON (file path, `-`, or inline)").option("--dry-run", "show the diff and write nothing").option("--vault <path>", "which brain to write to").option("--local", "use the brain on this machine, even when signed in to a hosted one").addHelpText(
@@ -12969,11 +13126,24 @@ function reviseCommand() {
     ].join("\n")
   ).action(async (ref, opts) => {
     const added = boundaryAddition(opts);
+    const bareUnbind = opts.rule === false && // `reinforce` is the one action that AGREES with unbinding: it means
+    // "the same conclusion", which is exactly what is being said. A fresh
+    // agent reaches for it unprompted — measured in the Round, the first
+    // session typed `--no-rule --action reinforce`, was refused for
+    // having no claim, and then supplied one, writing a `claim:` key the
+    // note never had. That is the failure this release exists to remove,
+    // reproduced by the guard meant to be careful. `supersede` and
+    // `conflict` still disqualify: both assert something new.
+    (!said.action || opts.action === "reinforce") && opts.claim === void 0 && opts.summary === void 0 && opts.title === void 0 && opts.validFrom === void 0 && opts.contradicts === void 0 && opts.input === void 0 && opts.neverStore === void 0 && opts.neverStoreAdd === void 0;
     const where = await resolveTarget({
       ...opts.local === void 0 ? {} : { local: opts.local },
       ...opts.vault === void 0 ? {} : { vault: opts.vault }
     });
     if (where.kind === "cloud") {
+      if (bareUnbind) {
+        await unbindHosted(where, ref, opts);
+        return;
+      }
       await reviseHosted(where, ref, opts, added);
       return;
     }
@@ -12985,7 +13155,10 @@ function reviseCommand() {
     const built = await openIndex(adapter, brain.root);
     const entry = resolveRef(built.entries, ref);
     const widened = widenedBoundary(entry.memory.never_store, added, ref);
-    const input = await buildCommitInput(entry, opts, widened);
+    const input = bareUnbind ? unbindInput(entry, {
+      ...opts.reason === void 0 ? {} : { reason: opts.reason },
+      ...opts.because === void 0 ? {} : { because: opts.because }
+    }) : await buildCommitInput(entry, opts, widened);
     const rationale = sanitizeRationale(
       input.reason === NO_REASON_GIVEN ? null : input.reason ?? null
     );
@@ -13177,6 +13350,30 @@ Undo: \`${undoHint(applied.record.op_id, opts)}\``));
     });
   });
 }
+async function unbindHosted(where, ref, opts) {
+  if (opts.dryRun === true) {
+    throw memgError(
+      "invalid_input",
+      "--dry-run is not supported for `--no-rule` on a hosted brain",
+      "Taking a marking back writes one key and leaves everything else byte for byte, so there is no diff worth previewing. Run it without `--dry-run`, and `memgineering undo` reverses it. Nothing was sent."
+    );
+  }
+  const brain = await openCloudBrain(where);
+  const result = await cloudUnbind(brain, {
+    ref,
+    ...opts.reason === void 0 ? {} : { reason: opts.reason }
+  });
+  printDual({
+    json: result,
+    human: () => {
+      printHuman(`Unbound \`${oneLine(result.target, WIDTH.path)}\`.
+`);
+      printHuman(c.gray(oneLine(result.note, WIDTH.text)));
+      printHuman(c.gray(`
+  \`memgineering undo ${oneLine(result.op_id, WIDTH.handle)}\``));
+    }
+  });
+}
 async function reviseHosted(where, ref, opts, added) {
   if (opts.input) {
     throw memgError(
@@ -13875,6 +14072,10 @@ function consolidateCommand() {
       "  rule_demotion    a note marked as binding but classified as a fact, a",
       "                   procedure, an episode or a goal \u2014 the author said it is",
       "                   not a decision, so the MARKING is the field to doubt",
+      "  binding_unclassified   a note marked as binding with no kind at all. Two",
+      "                   fields, agreeing on nothing: it is either a decision",
+      "                   nobody classified or something that was never a rule,",
+      "                   and only somebody who reads it can say which",
       "",
       "Nothing here becomes a proposal on its own. Read a candidate, decide what it",
       "means, then say so:",
@@ -13888,11 +14089,13 @@ function consolidateCommand() {
       limit === void 0 ? {} : { limit }
     ) : await detectLocally(where.brain.root, limit);
     const { candidates, truncated } = report3;
+    const byRule = Object.entries(report3.by_rule ?? {}).sort((a, b) => b[1] - a[1]);
     printDual({
       json: {
         candidates,
         count: candidates.length,
         scanned: report3.scanned,
+        by_rule: report3.by_rule ?? {},
         // Reported rather than left to be inferred from a short list. A run
         // that stopped early and said nothing would be indistinguishable from
         // a brain with little to find, which is the one thing the reader
@@ -13916,6 +14119,19 @@ function consolidateCommand() {
         printHuman(`## ${candidates.length} worth a look
 `);
         for (const candidate of candidates) printHuman(renderCandidate(candidate));
+        const held = byRule.filter(
+          ([rule, total]) => total > candidates.filter((c2) => c2.rule === rule).length
+        );
+        if (held.length > 0) {
+          printHuman(
+            c.gray(
+              `
+${held.map(([rule, total]) => `${rule}: ${total}`).join("  \xB7  ")}
+Found in total \u2014 the list above shows a few of each, so one noisy signal
+cannot bury the rest. \`--limit\` raises the page.`
+            )
+          );
+        }
         if (truncated) {
           printHuman(
             c.yellow(`
@@ -13962,7 +14178,16 @@ function renderCandidate(candidate) {
     // a second door to the same field would give a brain two ways to record one
     // change. So the suggestion names the command rather than a verb this CLI
     // does not have.
-    candidate.suggested_action === "unmark_rule" ? c.gray(`  suggested: memgineering revise ${candidate.memory_id} --no-rule --reason "\u2026"`) : candidate.suggested_kind === null ? c.gray(`  suggested: ${candidate.suggested_action}`) : c.gray(`  suggested: ${candidate.suggested_action} --kind ${candidate.suggested_kind}`)
+    candidate.suggested_action === "unmark_rule" ? c.gray(`  suggested: memgineering revise ${candidate.memory_id} --no-rule --reason "\u2026"`) : (
+      // BOTH moves, because the tool genuinely cannot tell. It used to print
+      // one — "promote this to a decision" — for every unclassified rule,
+      // including the thirteen on a real brain that were not rules at all.
+      candidate.suggested_action === "decide" ? c.gray(
+        `  suggested: read it, then one of
+    memgineering propose reclassify --memory ${candidate.memory_id} --kind decision --reason "\u2026" --excerpt "\u2026"
+    memgineering revise ${candidate.memory_id} --no-rule --reason "\u2026"`
+      ) : candidate.suggested_kind === null ? c.gray(`  suggested: ${candidate.suggested_action}`) : c.gray(`  suggested: ${candidate.suggested_action} --kind ${candidate.suggested_kind}`)
+    )
   );
   return lines2.join("\n");
 }
@@ -15619,26 +15844,31 @@ async function collectRules(vault, contextDir, now = /* @__PURE__ */ new Date())
     ...unreachableDefault ? { unreachableDefault } : {}
   };
 }
-var RULE_WIDTH = 200;
+var RULE_WIDTH = RULE_WIDTH_MIN;
 function renderRuleLine(text, width = RULE_WIDTH) {
-  return quoteBlock(oneLine(text, width));
+  return quoteBlock(rulePassage(oneLineWhole(text), width));
 }
-function renderRuleLines(rules) {
-  return rules.map(({ entry }) => renderRuleLine(entry.memory.summary ?? entry.memory.title));
+function renderRuleLines(rules, width = ruleWidthFor(rules.length)) {
+  return rules.map(({ entry }) => renderRuleLine(ruleTextOf(entry), width));
 }
 function renderRuleGroups(rules, project) {
   const globals = rules.filter((rule) => rule.lane === "global");
   const scoped = rules.filter((rule) => rule.lane === "project");
+  const width = ruleWidthFor(rules.length);
   const out = [];
   if (globals.length > 0 && scoped.length > 0) {
-    out.push("Everywhere:", ...renderRuleLines(globals), "");
-    out.push(`In ${oneLine(project ?? "this project", WIDTH.title)}:`, ...renderRuleLines(scoped));
+    out.push("Everywhere:", ...renderRuleLines(globals, width), "");
+    out.push(
+      `In ${oneLine(project ?? "this project", WIDTH.title)}:`,
+      ...renderRuleLines(scoped, width)
+    );
     return out;
   }
-  return renderRuleLines(rules);
+  return renderRuleLines(rules, width);
 }
 
 // src/commands/guard.ts
+init_src();
 init_deadline();
 init_cloud_brain();
 function guardCommand() {
@@ -15837,7 +16067,8 @@ async function hostedRuleLines(where, contextDir) {
   return { lines: grouped, total };
 }
 function groupHostedLines(rules, project) {
-  const line = (r) => renderRuleLine(r.summary ?? r.title);
+  const width = ruleWidthFor(rules.length);
+  const line = (r) => renderRuleLine(r.text ?? r.summary ?? r.title, width);
   const globals = rules.filter((r) => r.lane === "global");
   const scoped = rules.filter((r) => r.lane === "project");
   if (globals.length === 0 || scoped.length === 0) return rules.map(line);
@@ -21268,16 +21499,27 @@ function rulesCommand() {
     });
     if (where.kind === "cloud") {
       const project2 = await projectOf().then((p) => p.name).catch(() => null);
-      const { rules: rules2, total: total2, eligible } = await cloudRules(await openCloudBrain(where), {
-        project: project2
-      });
+      const {
+        rules: rules2,
+        total: total2,
+        eligible,
+        elsewhere: elsewhere2 = []
+      } = await cloudRules(await openCloudBrain(where), { project: project2 });
       const shownOf = eligible ?? rules2.length;
       printDual({
-        json: { brain: where.name, hosted: true, rules: rules2, total: total2, project: project2, eligible: shownOf },
+        json: {
+          brain: where.name,
+          hosted: true,
+          rules: rules2,
+          elsewhere: elsewhere2,
+          total: total2,
+          project: project2,
+          eligible: shownOf
+        },
         human: () => {
           printHuman(`## rules \u2014 ${oneLine(where.name, WIDTH.title)}  (${total2})
 `);
-          if (rules2.length === 0) {
+          if (rules2.length === 0 && elsewhere2.length === 0) {
             printHuman("_Nothing is marked as a rule in this brain._\n");
             printHuman(
               c.gray(
@@ -21299,12 +21541,21 @@ function rulesCommand() {
             printHuman(c.gray(`
 ${shownOf - rules2.length} more not shown.`));
           }
-          if (total2 > shownOf) {
+          if (elsewhere2.length > 0) {
+            printHuman(`
+### scoped to other projects  (${elsewhere2.length})
+`);
             printHuman(
-              c.gray(
-                `${total2 - shownOf} more belong to other projects and are not shown here \u2014 they bind there.`
-              )
+              c.gray("Not shown to an agent working here. They bind where they say.\n")
             );
+            for (const rule of elsewhere2) {
+              printHuman(`- ${oneLine(rule.summary ?? rule.title, WIDTH.text)}`);
+              printHuman(
+                c.gray(
+                  `  \`open: ${oneLine(rule.handle, WIDTH.handle)}\`  \xB7  ${oneLine(rule.scope ?? "", WIDTH.title)}`
+                )
+              );
+            }
           }
           printHuman(
             "\nThese are decisions, not suggestions. Follow them without being asked, and say\nso if what you are about to do goes against one."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memgineering",
-  "version": "0.22.0",
+  "version": "0.23.1",
   "private": false,
   "description": "One memory for the AI you connect. Recall, remember, and revise a brain your agents share — stored in your own folder.",
   "license": "Apache-2.0",