memgineering 0.9.1 → 0.10.0

package/CHANGELOG.md

@@ -11,6 +11,66 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [0.10.0] — 2026-08-26
+
+### Added
+
+- **`memgineering create <name> [--user] [--language] [--about]` — a hosted
+  brain without a folder first.** Creates the brain on the account (claiming a
+  just-approved sign-in on its own), writes the six starter notes, records the
+  answers as real content, asks the index to catch up without dying when it
+  cannot, and points this machine at the result. A taken name is refused with
+  nothing written — unless the brain holds only its own untouched scaffolding,
+  which is an interrupted create, finished by running the same command again.
+- **`onboard` reaches a hosted brain.** Same questions and JSON shape as a
+  folder brain, judged with the server's own emptiness rule; a base note the
+  brain does not hold at all is reported as `missing` with a hint that can
+  succeed, never a revise instruction that would answer `ref_not_found`. The
+  command gained `--brain <name>` and `--local`, resolving the same way every
+  other verb does.
+- **Setup now says how to connect a brain, cloud first.** The report gained a
+  `brain` section telling the agent exactly what to run next in every state —
+  pick one of the account's brains, create one, or carry a folder up — instead
+  of ending at sign-in and leaving the machine brainless.
+
+### Changed
+
+- **An agent writing durable user facts into its own harness memory now gets
+  redirected, once per session, at that exact moment.** The guard watches
+  write-shaped tool calls aimed at an agent's own memory store (Claude Code's
+  `projects/<dir>/memory` today) and says where the shared copy belongs —
+  only on machines that actually have a brain. It never blocks anything.
+- `use --brain` and `brains` refusals no longer name `push --brain` as the
+  only way to make a hosted brain: `create` is the no-upload creator,
+  `push --brain` the carry-a-folder-up one.
+
+### Agent guidance
+
+- The hub now opens with a reflex table: a standing rule runs `remember
+  --rule` NOW, a correction runs `remember`, anything settled runs `recall`
+  first; plus two measured traps spelled out (loading a skill page saves
+  nothing, and a correction that should hold next time takes `--rule`).
+  Measured on the weakest tier: corrections reached the brain as binding
+  rules in 1 of 10 baseline sessions and 4 of 5 with the table. The table
+  then moved to judging INTENT over marker words — the one test is whether
+  the words are meant to bind future sessions, in any language, with the
+  English phrases demoted to examples and a counter-example added, trading
+  weakest-tier literalism for generality on the owner's direction. Restart
+  your agent session after upgrading.
+- **An ambiguous correction no longer becomes a guessed rule.** When the
+  user's words could mean just-this-task or from-now-on, the hub now says:
+  do not guess — record without `--rule`, do the task, and ask in one line
+  whether it should hold. Measured: bare corrections produced guessed binding
+  rules in 2 of 3 baseline sessions and 0 of 5 with the path, with no new
+  questions on clear-cut cases.
+- The `memgineering-setup` skill reorders "Connect a brain" cloud-first —
+  the account's brains, then `create`, then migrating a folder up with
+  `push --brain` + `reindex`, with `link`/`init` as the machine-only path —
+  and adds a section on turning migrated prose into memory (revise reinforce,
+  never inventing a claim the note does not contain). Restart your agent
+  session after upgrading.
+
+
 ## [0.9.1] — 2026-08-25
 
 ### Changed

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.9.1
+version: 0.10.0
 ---
 
 # memgineering
@@ -12,6 +12,35 @@ the `memgineering` CLI by any AI tool that can run it. It outlives this session
 and this tool, so treat it as where what they know actually lives. Never edit
 those files by hand: only the CLI records the change and keeps `undo` working.
 
+## The reflexes — run these the moment the meaning appears
+
+One judgement decides everything in this table, and it is about intent, not
+wording: **is this meant to bind future sessions, or only the thing in front
+of you right now?** Any language, any phrasing — a standing decision often
+arrives with no marker words at all, and marker-looking words are often not
+one ("from now on" said about the next five minutes is a schedule, not a
+rule; an instruction scoped to "this file" or "here" usually ends with the
+task). Judge the meaning, then move:
+
+| what the user meant | run NOW |
+| --- | --- |
+| they settled something that should hold beyond this session (however phrased — e.g. "from now on…", "always…", "never…") | `memgineering remember "<their words>" --rule --reason "<why>"` |
+| they corrected what you made, for this task (e.g. "again", "no, like this", showed the right way) | `memgineering remember "<what turned out right>" --reason "<their correction>"` — and if the correction is meant to hold beyond this session, that is the row above: add `--rule` |
+| they asked about something that sounds already settled (e.g. "what did we decide", "how do we do this again") | `memgineering recall "<their words>"` FIRST, answer second |
+
+When the words could mean just-this-task or from-now-on, do not guess a
+binding rule: record it WITHOUT `--rule`, do the task, and ask in one line
+whether it should hold from now on. A wrong rule silently binds every future
+session; the question costs a second.
+
+These are SHELL commands — run them with your shell tool. Opening or loading a
+memgineering skill page saves nothing; measured: a model passed the command as
+a skill argument, told the user it was saved, and nothing was stored. Done
+means the CLI printed `Remembered.` and an undo id.
+
+Durable facts about the user never go into this tool's own memory files or
+directories — the brain is the one store every tool they use shares.
+
 ## When to reach for it
 
 - **Anything that sounds already settled** — a past decision, their setup, their
@@ -23,9 +52,6 @@ those files by hand: only the CLI records the change and keeps `undo` working.
   what you did and said it was right: `memgineering remember "<it>" --reason
 "<why>"`. Reversible by design, so do not ask permission for ordinary
   observations.
-- **They settled something that should hold next time** — "from now on",
-  "never", "we always do it this way" — the same verb with `--rule`, which puts
-  it in front of an agent before it edits a file rather than after someone asks.
 - **A new folder, or "where were we"** — `memgineering resurface`, no query.
 - **Their notes have piled up** — duplicates, notes that disagree:
   `memgineering consolidate` finds candidates and changes nothing; a change is

package/assets/memgineering-setup/SKILL.md

@@ -130,6 +130,60 @@ set nothing up, so wait for it rather than reporting done.
 
 ## 2. Connect a brain
 
+Signed in — the default — a brain belongs on the account, where every machine
+and every tool they use reads the same one. Three openings; run
+`memgineering brains` first to learn which one you are in:
+
+**The account already holds brains** — list, ask which, point:
+
+```
+memgineering brains                     # what it holds, with note counts
+memgineering use --brain work           # nothing is uploaded by switching
+```
+
+**The account holds nothing and there are no notes here** — make one:
+
+```
+memgineering create work --user "Rayul" --language Korean --about "one line"
+```
+
+Agree the NAME with the user first, and ask the three base questions in their
+language — what to call them, which language to answer in, one line about who
+they are. Every flag except the name is optional: leave out what they do not
+want to say. `create` makes the brain on the account, writes the six starter
+notes, records those answers as real content, points this machine at it, and
+its output says how many base files are still empty templates —
+`memgineering onboard` prints what to ask for the rest, and it now reaches a
+hosted brain too. Its `--json` may also report `missing`: base notes the brain
+does not hold at all, with a `missing_hint` naming the way to put them there —
+never a revise instruction that cannot succeed.
+
+A name the account already holds is refused with nothing written — `use
+--brain <name>` points at it instead, or agree a different name. The one
+exception is a brain holding nothing but its own untouched scaffolding: that
+is an interrupted `create`, and running the same command again finishes it.
+
+**They already keep notes in a folder on this machine** — carry them up
+instead of starting empty:
+
+```
+memgineering push --brain work          # folder → account; deletes nothing local
+memgineering reindex                    # makes the moved notes searchable by meaning
+```
+
+### Migrating notes that were never memgineering notes
+
+`push` carries files; it does not turn prose into memory. After a migration,
+offer — do not sweep — a pass over the notes they actually care about: ask
+WHICH matter, `memgineering open` each, then
+`memgineering revise <path> --action reinforce --claim "<one factual line the
+note itself contains>" --summary "<what recall should show>"`. Never write a
+claim the note does not contain: a guessed fact recalled later is
+indistinguishable from something they said. One `reindex` at the end covers
+the whole batch.
+
+### Machine-only (they chose `--no-login`)
+
 **They already keep notes somewhere:**
 
 ```
@@ -201,8 +255,9 @@ It moves the one hosted brain this machine reads and touches no notes — `push`
 and `pull` are what move those. It does not create: an unknown name is refused
 with the account's list, because pointing at a brain that does not exist would
 have every recall answer from an empty one, and from the outside that looks like
-the notes are gone. Before this, `push --brain <name>` was the only thing that
-could move the pointer, so switching meant uploading a folder first.
+the notes are gone. Making a NEW brain is `create <name>` (empty, scaffolded)
+or `push --brain <name>` (filled from a folder) — both point this machine at
+the result on their own.
 
 It refuses a folder path, `--default` or `--here` in the same call. Those bind a
 folder; this is one setting for the whole machine.