memgineering 0.25.2 → 0.26.0

package/CHANGELOG.md

@@ -11,6 +11,78 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [0.26.0] — 2026-10-10
+
+### Changed
+
+- **The before-edit check costs almost nothing after its first answer in a
+  session.** On a machine signed in to a hosted brain, the `PreToolUse` hook
+  started node on every file tool an agent used — about 110 ms each, measured
+  (about 490 ms on 0.21.0 and earlier, which also asked the server each time).
+  On macOS and Linux it is now a short shell script in front of
+  `memgineering guard` that answers a session already shown its rules from a
+  marker `guard` leaves: about 20 ms. Everything it is not sure of — the first
+  call, a folder brain, a brain switch, a sign-out, a path into an agent's own
+  memory folder — still goes to `memgineering guard`, 5–14 ms slower than
+  before. Windows keeps the plain `memgineering guard` command.
+- **A hosted brain with no rules is asked at most every two minutes**, not on
+  every tool call. A rule written on this machine with `remember --rule` or
+  `revise --rule` reaches the next tool call; one written elsewhere — another
+  machine, a chat app's connector — arrives within two minutes.
+- **On a folder brain, `guard` reads the brain once per session, not on every
+  tool call.** It takes the session's turn before reading and hands it back
+  when the brain had no rules, so a rule written later in the session still
+  arrives. A read that outlives the hook's five-second limit now costs that
+  session's rules from that brain, instead of five seconds on every tool call.
+
+### Added
+
+- **`memgineering update` brings memgineering's own hooks along.** The first
+  time the new version runs — the next agent session's start, or any command you
+  type — it rewrites the hook commands memgineering installed in Claude Code's
+  `settings.json` and Codex's `hooks.json` to this version's shape, and says so
+  once. Only a command exactly as memgineering shipped it is changed: matchers,
+  timeouts, other tools' hooks, a command you edited, a hook you removed, a
+  symlinked or unparseable settings file all stay as they are (the last two are
+  mentioned once). Codex runs a changed hook only after you trust it, so it asks
+  you to review it at its next start; until you do (press `t`), neither
+  memgineering hook runs in Codex.
+
+### Agent guidance
+
+- `memgineering-setup`: an update refreshes memgineering's own hook commands
+  in Claude Code and Codex by itself — nothing to re-run after an update — and
+  a changed Codex hook asks for one review, which is worth relaying with the
+  key.
+
+## [0.25.3] — 2026-10-06
+
+### Fixed
+
+- **`onboard` no longer asks again for a base note you filled in with prose.**
+  On a hosted brain, a `USER.md` or other `01_BASE/` note whose prompt you
+  replaced with your own sentences still counted as unfilled, so `onboard` told
+  the agent to ask the same questions and write the body again — over what you
+  had written. A note counts as filled once its body is your words, prose or
+  bullets. Hosted `resurface` no longer labels such a note "not filled in yet"
+  either.
+- **`onboard` keeps asking about a note whose body is still the prompt**, even
+  after a `revise` put a claim in its frontmatter. On a folder brain this used
+  to take the note off the list. The same goes for a note whose prompt was
+  deleted and nothing written in its place.
+- **A starter note saved with Windows line endings (CRLF) or a byte-order mark
+  is still recognised as the untouched template** by `recall`, `resurface` and
+  `onboard`. `revise`'s "the body is still the prompt" warning now notices it
+  too.
+
+### Agent guidance
+
+- `memgineering-writing` and `onboard`'s `how_to_write`: `onboard` lists the
+  base notes whose body has not been written yet, and editing one directly is
+  right only while that is so.
+- `memgineering-recall`: a card marked `not filled in yet` is exactly what
+  `init` wrote, line endings aside.
+
 ## [0.25.2] — 2026-10-05
 
 Small fixes found by an independent review of 0.25.0 and 0.25.1. Nothing here

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.25.2
+version: 0.26.0
 ---
 
 # memgineering

package/assets/memgineering-recall/SKILL.md

@@ -205,7 +205,7 @@ next brain, and three of them said it out loud. Reading another brain does not
 move the machine's pointer.
 
 **Cards that are not answers.** A card marked `not filled in yet` is one of the
-five `01_BASE/` files, still byte-for-byte what `init` wrote. Nobody has answered
+five `01_BASE/` files, still exactly what `init` wrote (line endings aside). Nobody has answered
 it, so it is evidence of nothing — do not quote it back as what they think. When
 every card carries that mark, recall says so above them (`--json`:
 `scaffolding: true`), and that is the moment to offer to fill them in rather

package/assets/memgineering-setup/SKILL.md

@@ -12,11 +12,11 @@ allowed-tools: Bash(memgineering:*)
 Answer this from here, not from a guess. The line is capability, not brand, so
 it does not move as products come and go:
 
-|                                                              |                                                                                                                                                                                  |
-| ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Any tool that can run a shell command**                    | Reads and writes the same brain. Nothing has to be built for a tool that does not exist yet.                                                                                     |
-| **A chat app that takes a custom MCP connector, no shell**   | Reads and writes the **hosted** brain on their account through `https://mcp.memgineering.com/mcp`, once they add that connector in the app and sign in with Google. Not a folder brain. |
-| **Neither**                                                  | **Not yet.**                                                                                                                                                                     |
+|                                                            |                                                                                                                                                                                         |
+| ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Any tool that can run a shell command**                  | Reads and writes the same brain. Nothing has to be built for a tool that does not exist yet.                                                                                            |
+| **A chat app that takes a custom MCP connector, no shell** | Reads and writes the **hosted** brain on their account through `https://mcp.memgineering.com/mcp`, once they add that connector in the app and sign in with Google. Not a folder brain. |
+| **Neither**                                                | **Not yet.**                                                                                                                                                                            |
 
 `memgineering setup` writes its guidance into the agent tools it finds on the
 machine, and `setup --dry-run` names the ones it actually found rather than
@@ -182,6 +182,15 @@ answered, and the trust is recorded per hook CONTENT
 so an upgrade that changes a hook asks again. Somebody who is not told this
 reads the silence as an install that did not take.
 
+**An update brings the hooks along.** The first `resurface` (session start)
+after an update — or the next command anybody types — replaces memgineering's
+own hook commands with the new version's, in both Claude Code and Codex, and
+says so once. It replaces only a command memgineering itself shipped: a hook
+someone edited (an absolute path, say), a removed hook, a symlinked or
+unreadable settings file are left exactly as they are, and the last two are
+named once. When a Codex hook changed this way, Codex asks for the review
+above again at its next start — relay that, with the key.
+
 Grok is the case worth knowing, because the obvious guess is wrong: it has
 hooks, more events than either of those two, and `~/.grok/hooks/` needs no
 trust prompt — but a hook there cannot say anything to the model. Measured

package/assets/memgineering-writing/SKILL.md

@@ -359,7 +359,7 @@ so an empty one costs something every time.
 memgineering onboard
 ```
 
-Says which are still untouched and what to ask for each. Run it first rather
+Says which still have no body written and what to ask for each. Run it first rather
 than working from a script — asking somebody a question they already answered is
 its own kind of forgetting. They may also ask outright ("set up my memory", "fill in my profile"); same job.
 
@@ -404,7 +404,7 @@ always true and you have only just been told them, so dating them today is wrong
 in the one field a memory store exists to get right.
 
 **This is the ONE place you edit a brain file directly** — `01_BASE/` only, and
-only while it is still the template. After that first pass these are theirs like
+only while its body has not been written yet. After that first pass these are theirs like
 any other note.
 
 **Do not invent an answer to move on, and do not fill a file because it is