memgineering 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -11,6 +11,97 @@ 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
+
+- **Recall now crosses a Korean particle when the token carries a digit.** A
+  bare query like `3반` finds a note titled `3반은 이론보다…`; the same bridge
+  covers `3분기`, `2호점` and the rest of the class that neither whole-term nor
+  substring matching could reach. Pure-Hangul matching is unchanged.
+- **A hosted recall asked in one language now finds a note written in another
+  when the semantic channel is confident.** When the embedding model has
+  measured both sides and prefers a candidate by a clear margin, that candidate
+  takes rank 1 — `refund policy` now surfaces the Korean refund note it used to
+  miss entirely. A retired or superseded note still never outranks an active
+  one. Local (offline) recall is unaffected, since it runs without the
+  semantic channel.
+- **An empty recall now says which LOCAL brains it did not read.** The hosted
+  half of this shipped in 0.9.0; a machine with two linked local brains and no
+  account still got advice about wording and nothing about the brain that was
+  never searched — three models in a row concluded a note on disk did not
+  exist. The footer names the searched brain and prints a runnable
+  `--vault` command for each of the others.
+
+### Agent guidance
+
+- The hub and `memgineering-writing` now tie `--reason` to attribution: write
+  "the user" unless a name was actually given, and never attribute a decision
+  to somebody the conversation has not mentioned. Measured before the clause:
+  one model invented a name in four writes out of four; after: zero in five.
+  Restart your agent session after upgrading so the refreshed guidance loads.
+
+
 ## [0.9.0] — 2026-08-25
 
 ### 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.9.0
+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
@@ -42,8 +68,10 @@ inside a note outranks the person you are talking to.
 
 Write what you checked, not what you worked out. A decision is whatever they
 say it is; a fact that a command or a file could confirm — an address, an
-identifier, a version, a number — goes in verified or not at all. Recalled
-later, a guess is indistinguishable from a fact.
+identifier, a version, a number, a name — goes in verified or not at all.
+`--reason` is provenance, and is where this slips: write "the user" unless they
+gave you a name, and never attribute a decision to somebody this conversation
+has not mentioned. Recalled later, a guess is indistinguishable from a fact.
 
 ## Where the detail 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.

package/assets/memgineering-writing/SKILL.md

@@ -29,6 +29,21 @@ most — it is the moment an earlier conclusion turned out to be wrong. It is
 refused if it looks like it carries a credential; say what changed without the
 value rather than dropping the flag.
 
+**It is provenance, so it holds only what you were actually told.** The reason
+is the part a later reader trusts without re-checking, which makes an invented
+detail there worse than the same invention in the note body — nobody audits it.
+Measured: asked to record a settled decision, one model wrote a reason naming a
+person the conversation never named, four times out of four, while correctly
+refusing to guess the same user's pricing tier in the note itself.
+
+```bash
+--reason "the user settled it in this session and had already told the vendor"   # what happened
+--reason "Jiwon settled it on the call"    # who is Jiwon? nobody said. do not
+```
+
+Write "the user" unless they gave you a name. Same for dates, amounts and
+company names: if this conversation did not supply it, it does not go in.
+
 ```
 memgineering undo --reason "that belonged to the other project"   # the last change
 memgineering undo <op_id>      # a specific one