memgineering 0.23.1 → 0.24.0

package/CHANGELOG.md

@@ -11,6 +11,60 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [0.24.0] — 2026-09-12
+
+### Added
+
+- **`memgineering rescope <ref>` changes which project a memory binds in.**
+  `scope` decides which of the two rule budgets a decision is drawn from — it
+  is the field that answers "does this bind me here" — and nothing could write
+  it. Moving one meant `supersede`, which retires the loser, so folding a
+  project-scoped rule into an unscoped one would have made the rule vanish
+  everywhere except the project it was scoped to.
+  Two flags, deliberately: `--scope <project>` narrows or moves,`--global`
+  widens. A rule that stops naming a project starts binding in every project,
+  and that is the change hardest to notice afterwards, so it is spelled rather
+  than being what happens when the scope is left off.
+- **`memgineering expire <ref> --until <date>` gives a memory an end date, and
+  does not retire it.** Until that date it is current; after it, recall still
+  returns it — one step below what is current, and labelled. Recall has always
+  understood this; only the writer was missing. Reach for it when a memory was
+  always going to run out, rather than when a decision has been overtaken.
+- **A hosted brain's rule list says how fresh each rule is** (`freshness` on
+  `POST /rules`), so an agent handed a rule whose end date has passed is told
+  so rather than reading it as current.
+
+### Fixed
+
+- **Retiring a rule now stops it being pushed to agents on a hosted brain.**
+  The rule list filtered "is it marked as a rule" and nothing else, while the
+  local one has always dropped retired rules — putting a decision somebody
+  retired in front of an agent as binding is the tool arguing with them.
+  `retire` writes the status and leaves the marking alone, so nothing else
+  caught it: on a hosted brain, which is what a signed-in machine reads,
+  retiring a rule did not stop the before-edit hook showing it.
+- **A date written into a note that states no claim is no longer ignored.**
+  Freshness read `valid_until` only off a stated claim, and most notes state
+  none — so an end date in such a note was read by nothing at all.
+- **An upgrade now tells your agent that its guidance went stale.** The only
+  thing that ever said so was a `postinstall` script, and npm 12 blocks install
+  scripts by default — measured on 12.0.2, all it prints is `1 package had
+  install scripts blocked`, which does not say what the blocked script would
+  have said. So on that npm an upgrade left a new binary beside the hub and
+  skills an older release wrote, in `~/.claude`, `~/.codex` and `~/.gemini`,
+  and both halves reported success. The CLI now says it itself, before any
+  command, on a channel npm cannot block: run `memgineering setup` once and it
+  goes quiet. It stays out of `guard`, which runs on every file edit.
+
+### Agent guidance
+
+`memgineering-rules` and `memgineering-writing` both changed: there are now
+three ways a rule stops applying rather than two (`--no-rule`, `retire`,
+`expire`), and `rescope` is how a rule moves between projects. **Restart your
+agent session after upgrading** so the new guidance is loaded — or run
+`memgineering setup`, which the CLI will now ask for by itself when the
+installed guidance is older than the binary.
+
 ## [0.23.1] — 2026-09-11
 
 ### Fixed

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.23.1
+version: 0.24.0
 ---
 
 # memgineering

package/assets/memgineering-rules/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: memgineering-rules
-description: Use when the user settles something they expect to hold next time — a colour they will not use, a step never to skip, a way things get named here — or when you want to see what already binds you in this folder. A decision does not have to be announced as a rule to be one. Triggers include "from now on", "always", "never", "don't do that again", "let's go with X from here", "we always do it this way", "what rules do I have". Covers remember --rule, rules, and what the before-edit hook shows.
+description: Use when the user settles something they expect to hold next time — a colour they will not use, a step never to skip, a way things get named here — or when you want to see what already binds you in this folder. A decision does not have to be announced as a rule to be one. Triggers include "from now on", "always", "never", "don't do that again", "let's go with X from here", "we always do it this way", "what rules do I have" — and, for moving one, "that should apply everywhere", "not just this project", "all my projects", "only in this repo from now on". Covers remember --rule, rules, rescope, and what the before-edit hook shows.
 type: skill
 allowed-tools: Bash(memgineering:*)
 ---
@@ -150,12 +150,23 @@ Two consequences worth knowing before you mark things:
   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>
+- **Three 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.
+  drops to the bottom of recall, labelled. `memgineering expire <ref> --until
+<date>` says it held until then: it KEEPS binding and recall keeps returning
+  it, ranked below what is current and labelled from that date. Reach for the
+  first when the marking was the mistake, the second when the decision has been
+  overtaken, and the third when it was always going to run out.
+- **`memgineering rescope <ref>` changes WHERE a rule binds, not whether it
+  does.** `--scope <project>` binds it in that project alone — agents working
+  anywhere else stop being shown it. `--global` binds it everywhere, which is
+  the change hardest to notice afterwards, so it has a flag of its own rather
+  than being what happens when you leave the scope off. Nothing the note says
+  changes either way, and `memgineering undo` reverses it.
+  Ask before widening: a rule the user wrote about one repository, made global,
+  arrives in every session they open.
 - **`--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

package/assets/memgineering-writing/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: memgineering-writing
-description: Use when you learn something durable and should record it, when a conclusion you already recorded turns out to have changed, when something needs undoing or retiring, when the brain has filled up with near-duplicates that want tidying, or when the user's `01_BASE/` files are still empty and only a conversation can fill them. Triggers include "remember this", "that didn't work", "this worked instead", "that's not right anymore", "undo that", "looks good", "set up my memory", "fill in my profile", "stop reading that note", "clean up my notes", "these two say the same thing", "is this a duplicate", "move my memories over", "bring my notes from the other tool", "don't save that", "never store that". Covers remember, revise, undo, log, retire, exclude, onboard, the consolidate/propose/approve flow, carrying facts in from another store, storage boundaries, and what to say before writing.
+description: Use when you learn something durable and should record it, when a conclusion you already recorded turns out to have changed, when something needs undoing or retiring, when the brain has filled up with near-duplicates that want tidying, or when the user's `01_BASE/` files are still empty and only a conversation can fill them. Triggers include "remember this", "that didn't work", "this worked instead", "that's not right anymore", "undo that", "looks good", "set up my memory", "fill in my profile", "stop reading that note", "clean up my notes", "these two say the same thing", "is this a duplicate", "move my memories over", "bring my notes from the other tool", "don't save that", "never store that", "that's only true until <date>", "it stops being true after", "don't tell me that forever". Covers remember, revise, undo, log, retire, expire, exclude, onboard, the consolidate/propose/approve flow, carrying facts in from another store, storage boundaries, and what to say before writing.
 type: skill
 allowed-tools: Bash(memgineering:*)
 ---
@@ -203,17 +203,26 @@ it>"`.
 This rewrites only the memory block in frontmatter. The prose is the user's;
 neither the command nor you should rewrite it uninvited.
 
-## Retiring versus excluding
+## Retiring versus expiring versus excluding
 
 ```
 memgineering retire <ref> --reason "the date moved"   # no longer current, still visible
+memgineering expire <ref> --until 2026-10-31 --reason "the phase ends then"  # NOT retired
 memgineering exclude path/to/note.md --reason "it has someone's phone number in it"   # stop reading it
 memgineering retract --actor "mcp:ChatGPT" --since 2026-09-01        # SHOWS what one writer / window wrote
 memgineering retract --actor "mcp:ChatGPT" --since 2026-09-01 --yes  # retires all of it, one ledger row each
 ```
 
 Retiring keeps the note in recall, ranked last and labelled. Excluding takes it
-out of the index and never touches the file. If the user says "delete", ask
+out of the index and never touches the file.
+
+**`expire` is not a retirement, and the difference only shows up later.** It
+gives a memory an end date: until then it is current, and after it recall still
+returns it — one step below what is current, labelled with the date. Reach for
+it when the memory was always going to run out ("Phase 1 lands by the end of
+October", a key that rotates, a plan with a deadline in it) rather than when a
+decision has been overtaken. Retiring such a note says something untrue about
+it; leaving it says something untrue too. If the user says "delete", ask
 which they mean.
 
 ## Tidying up a brain: detect, draft, approve