memgineering 0.21.0 → 0.22.0

package/CHANGELOG.md

@@ -11,6 +11,51 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [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.22.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
 

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,19 @@ 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 seven 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
 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();
@@ -2796,19 +2849,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: "kind_promotion",
+          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"
+        },
+        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 +2987,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 +2998,8 @@ var init_detect = __esm({
       "semantic_similarity",
       "shared_context",
       "similar_title",
-      "kind_promotion"
+      "kind_promotion",
+      "rule_demotion"
     ];
     DEFAULT_LIMIT = 50;
     DEFAULT_PAIR_BUDGET = 2e5;
@@ -2936,6 +3009,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) {
@@ -4051,6 +4125,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 +4558,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 +4572,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({
@@ -4730,7 +4810,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 +5627,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 +5674,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 +5719,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 +5727,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 +5790,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 +6255,7 @@ var init_link = __esm({
     init_index_build();
     init_vault();
     init_ui();
-    DEFAULT_OBSERVATIONS_DIR = "_observations";
+    DEFAULT_OBSERVATIONS_DIR = OBSERVATIONS_DIR;
   }
 });
 
@@ -12539,6 +12631,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 +12647,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 } : {},
@@ -13770,8 +13870,11 @@ 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",
       "",
       "Nothing here becomes a proposal on its own. Read a candidate, decide what it",
       "means, then say so:",
@@ -13854,7 +13957,12 @@ 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"`) : 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 +15583,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 +15601,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 +15626,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 +15705,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 +15733,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 +15796,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 +15813,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 +15830,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,9 +21267,13 @@ 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 } = 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, total: total2, project: project2, eligible: shownOf },
         human: () => {
           printHuman(`## rules \u2014 ${oneLine(where.name, WIDTH.title)}  (${total2})
 `);
@@ -21135,11 +21288,23 @@ 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 (total2 > shownOf) {
+            printHuman(
+              c.gray(
+                `${total2 - shownOf} more belong to other projects and are not shown here \u2014 they bind there.`
+              )
+            );
           }
           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 +21313,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 +21340,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.22.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",