memgineering 0.21.0 → 0.23.0

package/CHANGELOG.md

@@ -11,6 +11,95 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [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
+
+- **`consolidate` now asks whether a rule is a rule.** It already proposed
+  raising a binding memory to a decision; it never proposed the other
+  direction. A memory marked as binding but classified as a fact or a
+  procedure is now surfaced as a candidate to stop binding — audited against a
+  real brain, 13 of 54 standing rules were a fact, a status, or a
+  troubleshooting procedure rather than anything an agent should obey.
+
+### Changed
+
+- **`rules` and the before-edit hook now fill two budgets, not one list.**
+  Rules that hold everywhere and rules that hold only in this project are drawn
+  separately and labelled, so a project's own rules can no longer be pushed out
+  by more-used general ones. Measured before the change on a brain with 54
+  rules: not one project-scoped rule reached the hook in its own project.
+- **A rule write has to say what it binds.** `remember --rule` now records a
+  scope. The CLI fills it from the project you are in, so a rule written at a
+  terminal is unaffected; a caller that sends neither a scope nor a project —
+  an MCP tool call, a direct API write — is refused and told to send the
+  project name, or `global` for a rule that must hold everywhere. `global` is
+  stored as no scope at all, which is what such a rule already looked like.
+  Ordinary `remember` is unchanged: an observation with no scope is a normal
+  observation.
+
+### Fixed
+
+- **The before-edit hook no longer pays for the network on every tool call.**
+  It claims the session's turn before asking the server rather than after, so
+  the second and later calls in a session return without a round-trip. It
+  spoke once per session already; it now costs once per session too.
+- **`init` scaffolds the folder `remember` actually writes to.** New brains
+  were laid out with `20_TIMELINE/observations/` while writes went to
+  `_observations/`, leaving the scaffolded folder empty and a second one beside
+  it. Existing notes are not moved.
+
+### Agent guidance
+
+The bundled hub and sub-skills changed: the hub now hands the install job to
+`memgineering registry pull` outright instead of describing it, and the rules
+skill covers the two budgets and the scope a rule now carries. Restart your
+agent session after upgrading so it re-reads them.
+
 ## [0.21.0] — 2026-09-08
 
 ### 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.21.0
+version: 0.23.0
 ---
 
 # memgineering

package/assets/memgineering-rules/SKILL.md

@@ -85,12 +85,23 @@ alone earned — not that the top card is a rule, and not that it never could be
 since the engine noticing a note is decision-shaped is weaker evidence than its
 author saying it binds.
 
-One difference is worth knowing rather than discovering. The before-edit hook
-reads a brain **on this machine**, so on a machine pointed at a hosted brain it
-shows the local folder's rules, not the hosted brain's — a network call on the
-path of every file write is not a trade this makes. `memgineering rules` shows
-whichever brain the machine is pointed at; add `--local` to see what the hook
-will actually deliver.
+**Rules arrive in two budgets, not one list.** What a session is shown is the
+strongest few that hold everywhere, plus the strongest few scoped to the project
+it is standing in — ten in total, and each half gives its unused room to the
+other, so a brain with nothing scoped still fills the list. Rules scoped to a
+DIFFERENT project are not shown to an agent working here at all; they bind
+there. `memgineering rules` lists them separately under "scoped to other
+projects", which is the one place to notice a scope with a typo in it — such a
+rule binds nowhere and would otherwise appear nowhere.
+
+Before the split there was one list ranked by use, and it did not work: measured
+in a real repository, every slot went to rules about other things and a rule
+written that morning about that project's own layout ranked 49th of 54.
+
+The before-edit hook and `memgineering rules` read the same brain — the hosted
+one when this machine is pointed at it, the folder on disk otherwise — so what
+the hook will deliver is what the command shows. Add `--local` to read the
+folder on this disk specifically.
 
 ## What the user's agent actually sees
 
@@ -135,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

@@ -33,14 +33,34 @@ memgineering remember "we always squash before merging" --rule --no-scope \
   --reason "they said from now on, about every repo — not this one"
 ```
 
-- `--no-scope` for anything meant to hold machine-wide, rules especially: a
-  rule stamped with one project's scope drops out of another project's
-  `recall --scope` answers.
+- `--no-scope` for a decision that genuinely holds in every project — a
+  security rule, a way of writing commits, something about the person rather
+  than the work. It is a real answer, not the safe one: use it when it is true.
 - `--scope <name>` when the note is ABOUT a project you are not standing in.
 
+**Prefer the project scope for a rule that is about one project.** `--no-scope`
+used to be the advice for rules in general, on the reasoning that a scoped rule
+drops out of other projects' answers — it does, and that is now the point. Rules
+reach a session in two budgets, one for what holds everywhere and one for the
+project in front of it, so a scoped rule is no longer competing with every other
+rule in the brain for the same few slots. Measured before the split: in a real
+repository all the slots went to rules about other things, and a rule written
+that morning about that project's own layout ranked 49th of 54 — present,
+enforced by nothing, invisible to the session it existed to stop.
+
 `--scope` and `--no-scope` together are refused — they answer the same
 question both ways.
 
+**A rule has to say what it binds, and one of the two is required.** A `--rule`
+write is refused when nothing names a scope and nothing can be derived — a
+folder that is not a repository and has no bound project. Add `--scope "<the
+project>"` or `--no-scope`, and retry; nothing was written. On the hosted API
+(`brain_remember`, or `POST /remember` directly) the same refusal applies with
+no derivation at all: send `scope`, or `"scope": "global"` for one that really
+does hold everywhere. `global` is reserved and is stored as no scope, which is
+what a machine-wide rule already looks like — so there is only ever one
+spelling of it to search for.
+
 **`--reason` on every write.** It goes in the ledger and is the only part of the
 record that still means anything six months later. Every write verb takes it:
 `remember`, `revise`, `retire`, `exclude`, `undo`. The one on `undo` matters
@@ -215,11 +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 six 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 `kind_promotion`, a binding note filed as something
-other than a decision. Semantic detection reuses a complete, calibrated hosted
+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 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

@@ -277,13 +277,17 @@ var init_errors = __esm({
 
 // ../../packages/memory-engine/src/schema.ts
 import { z } from "zod";
-var MappingModeSchema, ScopeSourceSchema, SCOPE_LIMIT, TELEMETRY_ERROR_KINDS, TELEMETRY_MESSAGE_LIMIT, TelemetryErrorPayloadSchema, ProvenanceSchema, MemoryStatusSchema, ClaimConfidenceSchema, MemoryKindSchema, ClaimSchema, MemorySchema, RelationTypeSchema, RelationSourceSchema, RelationSchema;
+function isGlobalScope(scope) {
+  return scope != null && scope.trim().toLowerCase() === GLOBAL_SCOPE;
+}
+var MappingModeSchema, ScopeSourceSchema, SCOPE_LIMIT, GLOBAL_SCOPE, TELEMETRY_ERROR_KINDS, TELEMETRY_MESSAGE_LIMIT, TelemetryErrorPayloadSchema, 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"]);
     SCOPE_LIMIT = 128;
+    GLOBAL_SCOPE = "global";
     TELEMETRY_ERROR_KINDS = [
       "network_unreachable",
       "server_error",
@@ -444,6 +448,55 @@ var init_schema = __esm({
   }
 });
 
+// ../../packages/memory-engine/src/layout.ts
+var OBSERVATIONS_DIR;
+var init_layout = __esm({
+  "../../packages/memory-engine/src/layout.ts"() {
+    "use strict";
+    OBSERVATIONS_DIR = "_observations";
+  }
+});
+
+// ../../packages/memory-engine/src/rule-budget.ts
+function ruleLane(scope, project) {
+  if (scope == null || scope.trim() === "" || isGlobalScope(scope)) return "global";
+  if (project === null) return "elsewhere";
+  return scope.trim().toLowerCase() === project.trim().toLowerCase() ? "project" : "elsewhere";
+}
+function declaredScopeOf(memory) {
+  return memory.provenance.scopeSource === "explicit" ? memory.scope : null;
+}
+function splitRuleBudget(ranked, scopeOf, project, budget = DEFAULT_RULE_BUDGET) {
+  const globalLane = [];
+  const projectLane = [];
+  const elsewhere = [];
+  for (const item of ranked) {
+    const lane = ruleLane(scopeOf(item), project);
+    if (lane === "global") globalLane.push(item);
+    else if (lane === "project") projectLane.push(item);
+    else elsewhere.push(item);
+  }
+  const total = budget.global + budget.project;
+  const globalRoom = Math.max(budget.global, total - Math.min(projectLane.length, budget.project));
+  const projectRoom = Math.max(budget.project, total - Math.min(globalLane.length, budget.global));
+  return {
+    global: globalLane.slice(0, globalRoom),
+    project: projectLane.slice(0, projectRoom),
+    elsewhere,
+    // Everything either budget COULD have shown, so "5 of 12" is honest about
+    // the cap without counting another project's rules as things withheld.
+    eligible: globalLane.length + projectLane.length
+  };
+}
+var DEFAULT_RULE_BUDGET;
+var init_rule_budget = __esm({
+  "../../packages/memory-engine/src/rule-budget.ts"() {
+    "use strict";
+    init_schema();
+    DEFAULT_RULE_BUDGET = { global: 5, project: 5 };
+  }
+});
+
 // ../../packages/memory-engine/src/boundary.ts
 function normalizeForMatch(value) {
   return value.normalize("NFC").replace(ZERO_WIDTH, "").replace(WHITESPACE_RUN, " ").trim();
@@ -2182,8 +2235,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;
@@ -2212,6 +2268,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"]);
@@ -2407,7 +2478,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",
@@ -2443,12 +2514,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)) {
@@ -2796,19 +2897,38 @@ function kindPromotions(entries) {
   const out = [];
   for (const entry of entries) {
     if (entry.memory.binding !== true) continue;
-    if (entry.memory.kind === "decision") continue;
+    const kind = entry.memory.kind;
+    if (kind !== void 0 && RULE_SHAPED_KINDS.has(kind)) continue;
+    if (kind === void 0) {
+      out.push({
+        candidate: {
+          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 and left unclassified \u2014 either a decision nobody classified, or something that was never a rule",
+          suggested_action: "decide",
+          suggested_kind: null
+        },
+        confidence: 4
+      });
+      continue;
+    }
     out.push({
       candidate: {
-        rule: "kind_promotion",
+        rule: "rule_demotion",
         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"
+        evidence: `marked as binding but classified as ${kind} \u2014 the author said it is not a decision, so it may not be a rule`,
+        suggested_action: "unmark_rule",
+        suggested_kind: null
       },
       confidence: 4
     });
@@ -2915,7 +3035,7 @@ function* pairsFrom(buckets, budget) {
     }
   }
 }
-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 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, RULE_SHAPED_KINDS, CandidateComponents;
 var init_detect = __esm({
   "../../packages/memory-engine/src/proposal/detect.ts"() {
     "use strict";
@@ -2926,7 +3046,9 @@ var init_detect = __esm({
       "semantic_similarity",
       "shared_context",
       "similar_title",
-      "kind_promotion"
+      "kind_promotion",
+      "rule_demotion",
+      "binding_unclassified"
     ];
     DEFAULT_LIMIT = 50;
     DEFAULT_PAIR_BUDGET = 2e5;
@@ -2936,6 +3058,7 @@ var init_detect = __esm({
     SHARED_ENTITY_SEMANTIC_SIMILARITY = 0.75;
     GLOBAL_SEMANTIC_SIMILARITY = 0.72;
     RECIPROCAL_NEIGHBOURS = 2;
+    RULE_SHAPED_KINDS = /* @__PURE__ */ new Set(["decision", "preference"]);
     CandidateComponents = class {
       parent = /* @__PURE__ */ new Map();
       root(id) {
@@ -3178,12 +3301,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`), {
@@ -3239,10 +3362,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. */
@@ -3347,6 +3470,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;
@@ -3436,6 +3569,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`);
@@ -3733,6 +3870,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)
   );
@@ -4051,6 +4228,8 @@ var init_src = __esm({
   "../../packages/memory-engine/src/index.ts"() {
     "use strict";
     init_schema();
+    init_layout();
+    init_rule_budget();
     init_boundary();
     init_markdown_mapping();
     init_build();
@@ -4482,6 +4661,7 @@ var BrainSchema, ConfigSchema, EMPTY_CONFIG;
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
+    init_src();
     init_atomic();
     init_brand();
     BrainSchema = z8.object({
@@ -4495,8 +4675,11 @@ var init_config = __esm({
        * place for observations in its layout, while a folder someone has kept
        * notes in for years does not — and picking one for them is how a tool
        * starts rearranging a vault it promised only to read.
+       *
+       * The DEFAULT is shared with everything else that writes an observation, and
+       * is not a second opinion about where they go — see `OBSERVATIONS_DIR`.
        */
-      observationsDir: z8.string().min(1).default("_observations")
+      observationsDir: z8.string().min(1).default(OBSERVATIONS_DIR)
     });
     ConfigSchema = z8.object({
       brain: z8.object({
@@ -4629,7 +4812,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";
@@ -4719,6 +4902,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 }
@@ -4730,7 +4917,12 @@ var init_cloud_brain = __esm({
       ...askedFromField(args.askedFrom)
     });
     cloudRules = (brain, args = {}) => call(brain, "POST", "/rules", {
-      ...args.limit === void 0 ? {} : { limit: args.limit }
+      ...args.limit === void 0 ? {} : { limit: args.limit },
+      // The server cannot see this machine's folders, so the project it is
+      // standing in has to be told. Omitted rather than sent as null when there
+      // is none: absent means "fill the global budget only", which is what a
+      // folder that names no project should get.
+      ...args.project == null ? {} : { project: args.project }
     });
     cloudReindex = (brain, args = {}) => call(brain, "POST", "/reindex", {
       ...args.rebuild === true ? { rebuild: true } : {}
@@ -5542,14 +5734,14 @@ function initCommand() {
         brain: canonicalRoot2,
         folders: FOLDERS,
         files: Object.keys(files(opts.name)),
-        observations_dir: OBSERVATIONS_DIR,
+        observations_dir: OBSERVATIONS_DIR2,
         indexed
       },
       human: () => {
         printHuman(`Created a brain at \`${canonicalRoot2}\`.
 `);
         printHuman(`- \`01_BASE/\` \u2014 five files your agent reads first`);
-        printHuman(`- \`${OBSERVATIONS_DIR}/\` \u2014 where \`remember\` writes`);
+        printHuman(`- \`${OBSERVATIONS_DIR2}/\` \u2014 where \`remember\` writes`);
         printHuman(`- nine more folders, ready when you need them
 `);
         printHuman(c.gray("The five base files are empty templates.\n"));
@@ -5589,7 +5781,7 @@ async function createBrain(path, name) {
   brains.push({
     root: canonicalRoot2,
     linkedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    observationsDir: OBSERVATIONS_DIR
+    observationsDir: OBSERVATIONS_DIR2
   });
   await saveConfig({ ...cfg, brain: withDefaultBrain({ ...cfg.brain, brains }) });
   return { root: canonicalRoot2, indexed: built.entries.length };
@@ -5634,7 +5826,7 @@ function files(name) {
       "| Folder | What lives here |",
       "| --- | --- |",
       "| `10_ENTITIES/` | People, projects, systems \u2014 one note each |",
-      "| `20_TIMELINE/` | What happened, when. `observations/` is written by the agent |",
+      "| `20_TIMELINE/` | What happened, when |",
       "| `30_ACTIONS/` | Open work and decisions waiting on something |",
       "| `40_KNOWLEDGE/` | Conclusions worth keeping: how things work, why they were decided |",
       "| `50_SKILLS/` | Procedures \u2014 the steps for doing a thing again |",
@@ -5642,6 +5834,10 @@ function files(name) {
       "| `70_SOURCES/` | Where something came from: links, papers, transcripts |",
       "| `80_SHAREABLE/` | Notes you would be willing to publish |",
       "| `90_ARCHIVE/` | Kept, but no longer current |",
+      `| \`${OBSERVATIONS_DIR2}/\` | Written by the agent \u2014 what \`remember\` records |`,
+      "",
+      "An underscore in front means the folder is the agent's: it is written",
+      "and rewritten without asking. A number in front means it is yours.",
       ""
     ].join("\n"),
     "01_BASE/CRITICAL_FACTS.md": base(
@@ -5701,30 +5897,33 @@ function files(name) {
     )
   };
 }
-var OBSERVATIONS_DIR, FOLDERS;
+var OBSERVATIONS_DIR2, FOLDERS;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
+    init_src();
     init_adapter();
     init_errors();
     init_config();
     init_index_build();
     init_vault();
     init_ui();
-    OBSERVATIONS_DIR = "20_TIMELINE/observations";
+    OBSERVATIONS_DIR2 = OBSERVATIONS_DIR;
     FOLDERS = [
       "00_HUB",
       "01_BASE",
       "10_ENTITIES",
       "20_TIMELINE",
-      "20_TIMELINE/observations",
       "30_ACTIONS",
       "40_KNOWLEDGE",
       "50_SKILLS",
       "60_TEMPLATES",
       "70_SOURCES",
       "80_SHAREABLE",
-      "90_ARCHIVE"
+      "90_ARCHIVE",
+      // Last rather than in numeric order, because it is not in that order: the
+      // numbered folders are the person's and this one is the agent's.
+      OBSERVATIONS_DIR2
     ];
   }
 });
@@ -6163,7 +6362,7 @@ var init_link = __esm({
     init_index_build();
     init_vault();
     init_ui();
-    DEFAULT_OBSERVATIONS_DIR = "_observations";
+    DEFAULT_OBSERVATIONS_DIR = OBSERVATIONS_DIR;
   }
 });
 
@@ -12539,6 +12738,14 @@ function rememberCommand() {
       const neverStore = parseNeverStore(opts.neverStore);
       const binding = opts.rule === true || neverStore.length > 0;
       const scope = await scopeToWrite(opts.scope);
+      if (binding && scope === void 0 && !said.noScope) {
+        throw memgError(
+          "invalid_input",
+          "a rule needs a scope, and this folder does not suggest one",
+          'Nothing was written. This folder is not a repository and has no bound project name, so there is nothing to stamp. Add `--scope "<the project>"` for a decision about one thing, or `--no-scope` for one that has to hold everywhere.'
+        );
+      }
+      const wireScope = scope ?? (binding ? GLOBAL_SCOPE : void 0);
       const target = await resolveTarget({
         ...opts.local === void 0 ? {} : { local: opts.local },
         ...opts.vault === void 0 ? {} : { vault: opts.vault }
@@ -12547,7 +12754,7 @@ function rememberCommand() {
         const cloud = await openCloudBrain(target);
         const written = await cloudRemember(cloud, {
           text: body,
-          ...scope ? { scope } : {},
+          ...wireScope ? { scope: wireScope } : {},
           ...rationale ? { reason: rationale } : {},
           ...binding ? { rule: true } : {},
           ...neverStore.length > 0 ? { neverStore } : {},
@@ -12846,10 +13053,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(
@@ -12869,11 +13079,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;
     }
@@ -12885,7 +13108,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
     );
@@ -13077,6 +13303,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(
@@ -13770,8 +14020,15 @@ function consolidateCommand() {
       "  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",
+      "  kind_promotion   a note marked as binding with no kind at all \u2014 the",
+      "                   marking is deliberate, the classification never happened",
+      "  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:",
@@ -13785,11 +14042,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
@@ -13813,6 +14072,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(`
@@ -13854,7 +14126,21 @@ function renderCandidate(candidate) {
     );
   }
   lines2.push(
-    candidate.suggested_kind === null ? c.gray(`  suggested: ${candidate.suggested_action}`) : c.gray(`  suggested: ${candidate.suggested_action} --kind ${candidate.suggested_kind}`)
+    // `unmark_rule` is not a proposal action and deliberately is not one: taking
+    // a marking BACK is `revise --no-rule`, which already exists, and inventing
+    // 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"`) : (
+      // 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");
 }
@@ -15475,7 +15761,7 @@ init_src();
 init_index_build();
 init_ui();
 init_vault();
-var RULE_LIMIT = 8;
+var RULE_LIMIT = DEFAULT_RULE_BUDGET.global + DEFAULT_RULE_BUDGET.project;
 async function collectRules(vault, contextDir, now = /* @__PURE__ */ new Date()) {
   const { brain, unreachableDefault } = await resolveBrain(vault, contextDir);
   const adapter = await openBrainOrExplain(brain.root);
@@ -15493,11 +15779,21 @@ async function collectRules(vault, contextDir, now = /* @__PURE__ */ new Date())
       here: (event) => isInside(event.context_dir, contextDir)
     }).map((r) => [r.entry.memory.id, r.score])
   );
-  const rules = declared.map((entry) => ({ entry, score: order.get(entry.memory.id) ?? 0 })).sort((a, b) => b.score - a.score || a.entry.memory.id.localeCompare(b.entry.memory.id));
+  const ranked = declared.map((entry) => ({ entry, score: order.get(entry.memory.id) ?? 0 })).sort((a, b) => b.score - a.score || a.entry.memory.id.localeCompare(b.entry.memory.id));
+  const project = await projectOf(contextDir).then((p) => p.name).catch(() => null);
+  const split = splitRuleBudget(ranked, (r) => declaredScopeOf(r.entry.memory), project);
   return {
     brainRoot: brain.root,
-    rules: rules.slice(0, RULE_LIMIT),
-    total: rules.length,
+    // Global first: they hold here too, and they are the ones a reader is most
+    // likely to already know, so the project's own decisions land last and
+    // closest to the work.
+    rules: [
+      ...split.global.map((rule) => ({ ...rule, lane: "global" })),
+      ...split.project.map((rule) => ({ ...rule, lane: "project" }))
+    ],
+    elsewhere: split.elsewhere.map((rule) => ({ ...rule, lane: "elsewhere" })),
+    total: ranked.length,
+    project,
     ...unreachableDefault ? { unreachableDefault } : {}
   };
 }
@@ -15508,6 +15804,17 @@ function renderRuleLine(text, width = RULE_WIDTH) {
 function renderRuleLines(rules) {
   return rules.map(({ entry }) => renderRuleLine(entry.memory.summary ?? entry.memory.title));
 }
+function renderRuleGroups(rules, project) {
+  const globals = rules.filter((rule) => rule.lane === "global");
+  const scoped = rules.filter((rule) => rule.lane === "project");
+  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));
+    return out;
+  }
+  return renderRuleLines(rules);
+}
 
 // src/commands/guard.ts
 init_deadline();
@@ -15576,11 +15883,16 @@ async function runStopGuard(payload, contextDirFlag) {
   });
 }
 async function claimRules(sessionId, contextDir) {
-  const hosted = await hostedRuleLines().catch(() => null);
-  if (hosted !== null) {
-    if (hosted.lines.length === 0) return null;
-    if (!await claimSession(sessionId, hosted.brainId)) return null;
-    return { lines: hosted.lines, total: hosted.total };
+  const where = await resolveTarget({}).catch(() => null);
+  if (where?.kind === "cloud") {
+    if (!await claimSession(sessionId, where.brainId)) return null;
+    const hosted = await hostedRuleLines(where, contextDir).catch(() => null);
+    if (hosted !== null) {
+      if (hosted.lines.length > 0) return { lines: hosted.lines, total: hosted.total };
+      await releaseSession(sessionId, where.brainId);
+      return null;
+    }
+    await releaseSession(sessionId, where.brainId);
   }
   const collected = await collectRules(void 0, contextDir).catch(() => null);
   if (collected === null) return null;
@@ -15599,7 +15911,7 @@ async function claimRules(sessionId, contextDir) {
     limit: RULE_LIMIT,
     returnedIds: rules.map((r) => r.entry.memory.id)
   });
-  return { lines: renderRuleLines(rules), total };
+  return { lines: renderRuleGroups(rules, collected.project), total };
 }
 function contextFor(lines2, total) {
   return `${rulesQuoted(lines2, total)}
@@ -15662,11 +15974,14 @@ async function misdeliveryNotice(toolName, filePath, sessionId) {
   if (!await claimSession(sessionId, "\0misdelivery")) return null;
   return 'This file is this harness\u2019s own memory \u2014 no other tool the user works with will ever read it. Durable facts about the user belong in their brain, which every tool shares: memgineering remember "<the fact>" --reason "<why>" (add --rule if they stated a standing rule). Write it there instead, or in addition.';
 }
-async function claimSession(sessionId, brain) {
-  const marker = join18(
+function markerFor(sessionId, brain) {
+  return join18(
     guardDir(),
     `${createHash7("sha256").update(`${sessionId}\0${brain}`).digest("hex").slice(0, 32)}`
   );
+}
+async function claimSession(sessionId, brain) {
+  const marker = markerFor(sessionId, brain);
   try {
     await mkdir11(guardDir(), { recursive: true, mode: 448 });
     await writeFile9(marker, "", { flag: "wx", mode: 384 });
@@ -15676,6 +15991,9 @@ async function claimSession(sessionId, brain) {
   void pruneOldMarkers();
   return true;
 }
+async function releaseSession(sessionId, brain) {
+  await unlink3(markerFor(sessionId, brain)).catch(() => void 0);
+}
 var MARKER_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 async function pruneOldMarkers() {
   try {
@@ -15690,15 +16008,24 @@ async function pruneOldMarkers() {
   } catch {
   }
 }
-async function hostedRuleLines() {
-  const where = await resolveTarget({});
-  if (where.kind !== "cloud") return null;
-  const { rules, total } = await cloudRules(await openCloudBrain(where));
-  return {
-    lines: rules.map((r) => renderRuleLine(r.summary ?? r.title)),
-    total,
-    brainId: where.brainId
-  };
+async function hostedRuleLines(where, contextDir) {
+  const project = await projectOf(contextDir).then((p) => p.name).catch(() => null);
+  const { rules, total } = await cloudRules(await openCloudBrain(where), { project });
+  const grouped = groupHostedLines(rules, project);
+  return { lines: grouped, total };
+}
+function groupHostedLines(rules, project) {
+  const line = (r) => renderRuleLine(r.summary ?? r.title);
+  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);
+  return [
+    "Everywhere:",
+    ...globals.map(line),
+    "",
+    `In ${project ?? "this project"}:`,
+    ...scoped.map(line)
+  ];
 }
 
 // src/program.ts
@@ -21118,13 +21445,28 @@ function rulesCommand() {
       ...opts.vault === void 0 ? {} : { vault: opts.vault }
     });
     if (where.kind === "cloud") {
-      const { rules: rules2, total: total2 } = await cloudRules(await openCloudBrain(where));
+      const project2 = await projectOf().then((p) => p.name).catch(() => null);
+      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 },
+        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(
@@ -21135,11 +21477,32 @@ function rulesCommand() {
           }
           for (const rule of rules2) {
             printHuman(`- ${oneLine(rule.summary ?? rule.title, WIDTH.text)}`);
-            printHuman(c.gray(`  \`open: ${oneLine(rule.handle, WIDTH.handle)}\``));
+            const lane = rule.lane === "project" ? oneLine(project2 ?? "this project", WIDTH.title) : "global";
+            printHuman(
+              c.gray(
+                `  \`open: ${oneLine(rule.handle, WIDTH.handle)}\`${rule.lane ? `  \xB7  ${lane}` : ""}`
+              )
+            );
           }
-          if (total2 > rules2.length) {
+          if (shownOf > rules2.length) {
             printHuman(c.gray(`
-${total2 - rules2.length} more not shown.`));
+${shownOf - rules2.length} more not shown.`));
+          }
+          if (elsewhere2.length > 0) {
+            printHuman(`
+### scoped to other projects  (${elsewhere2.length})
+`);
+            printHuman(
+              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."
@@ -21148,12 +21511,9 @@ ${total2 - rules2.length} more not shown.`));
       });
       return;
     }
-    const { rules, total, unreachableDefault, brainRoot } = await collectRules(
-      opts.vault,
-      process.cwd()
-    );
-    const allIds = rules.map((r) => r.entry.memory.id);
-    if (rules.length === 0) {
+    const { rules, elsewhere, total, project, unreachableDefault, brainRoot } = await collectRules(opts.vault, process.cwd());
+    const allIds = [...rules, ...elsewhere].map((r) => r.entry.memory.id);
+    if (rules.length === 0 && elsewhere.length === 0) {
       const hint = unreachableDefault ? `Your default brain is not on disk right now: ${unreachableDefault}
 This answered from \`${brainRoot}\` instead, so rules you wrote in the missing one are not shown \u2014 they are not lost. If it moved, \`memgineering use --default <new path>\`. If it is gone for good, \`memgineering unlink ${unreachableDefault}\`.` : 'Nothing here binds you yet. When the user decides something that should hold \u2014 a colour they will not use, a step never to skip \u2014 record it with `memgineering remember "<the decision>" --rule --reason "<why>"`, and it will be shown before the next edit.';
       printDual({
@@ -21178,27 +21538,52 @@ This answered from \`${brainRoot}\` instead, so rules you wrote in the missing o
           scope: entry.memory.scope,
           path: entry.path
         })),
+        elsewhere: elsewhere.map(({ entry }) => ({
+          id: entry.memory.id,
+          handle: displayHandle(entry.memory.id, allIds),
+          title: entry.memory.title,
+          summary: entry.memory.summary,
+          scope: entry.memory.scope,
+          path: entry.path
+        })),
         total,
-        ...total > RULE_LIMIT ? {
-          hint: `${total} rules are declared and ${RULE_LIMIT} are shown. A list this long is not read before an edit \u2014 retire the ones that no longer decide anything with \`memgineering retire <handle>\`.`
+        project,
+        ...total > rules.length ? {
+          hint: `${total} rules are declared and ${rules.length} are shown${project === null ? "" : ` for \`${project}\``}. Up to ${RULE_LIMIT} fit at once, split between rules that hold everywhere and rules scoped to this project; anything scoped to a DIFFERENT project is not shown here and binds there instead. If the number is high because old decisions never got retired, \`memgineering retire <handle>\`.`
         } : {}
       },
       human: () => {
-        printHuman(`## rules  (${rules.length}${total > rules.length ? ` of ${total}` : ""})
-`);
-        for (const { entry } of rules) {
+        printHuman(
+          `## rules  (${rules.length}${total > rules.length ? ` of ${total}` : ""}${project === null ? "" : `  \xB7  ${oneLine(project, WIDTH.title)}`})
+`
+        );
+        for (const { entry, lane } of rules) {
           printHuman(`- ${oneLine(entry.memory.summary ?? entry.memory.title, WIDTH.text)}`);
           printHuman(
             c.gray(
-              `  \`open: ${displayHandle(entry.memory.id, allIds)}\`${entry.memory.scope ? `  \xB7  ${oneLine(entry.memory.scope, WIDTH.title)}` : ""}`
+              `  \`open: ${displayHandle(entry.memory.id, allIds)}\`  \xB7  ${lane === "project" ? oneLine(project ?? "this project", WIDTH.title) : "global"}`
             )
           );
         }
+        if (elsewhere.length > 0) {
+          printHuman(`
+### scoped to other projects  (${elsewhere.length})
+`);
+          printHuman(c.gray("Not shown to an agent working here. They bind where they say.\n"));
+          for (const { entry } of elsewhere) {
+            printHuman(`- ${oneLine(entry.memory.summary ?? entry.memory.title, WIDTH.text)}`);
+            printHuman(
+              c.gray(
+                `  \`open: ${displayHandle(entry.memory.id, allIds)}\`  \xB7  ${oneLine(entry.memory.scope ?? "", WIDTH.title)}`
+              )
+            );
+          }
+        }
         printHuman("");
         printHuman(
           c.gray(
-            total > RULE_LIMIT ? `${total} declared, ${rules.length} shown \u2014 a list this long stops being read.
-Retire what no longer decides anything: \`memgineering retire <handle>\`.` : "These are decisions, not suggestions. Follow them without being asked, and say\nso if what you are about to do goes against one."
+            total > rules.length ? `${total} declared, ${rules.length} shown here. Rules scoped to another project bind there, not here.
+If the rest are decisions that no longer decide anything: \`memgineering retire <handle>\`.` : "These 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.21.0",
+  "version": "0.23.0",
   "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",