memgineering 0.4.2 → 0.6.0

package/NOTICE

@@ -9,6 +9,28 @@ terms. This NOTICE file must be included in redistributions and derivative
 works, per section 4(d) of that license.
 
 
+BUNDLED FONT
+------------
+
+The install screen (`memgineering setup --web`) carries a typeface inside the
+program rather than fetching one. It is served over loopback under a policy
+that allows no outbound request, so a webfont either arrives in the document or
+does not arrive at all.
+
+  Jua
+  Copyright 2018 The BM JUA Project Authors
+  (https://github.com/googlefonts/jua)
+  Licensed under the SIL Open Font License, Version 1.1
+  (http://scripts.sil.org/OFL)
+
+What ships is a SUBSET — 431 of the face's 2,520 glyphs, being the characters
+the install screen's headings contain in Korean and English. It is embedded as
+a WOFF2 in the program's own code and is not offered for download, sold, or
+distributed on its own. The OFL permits both the subsetting and the embedding;
+this notice is the attribution it asks for in return. The font is not renamed,
+and no Reserved Font Name is claimed.
+
+
 UPDATES AND SUPPORT
 -------------------
 

package/README.md

@@ -3,16 +3,25 @@
 One memory for the AI you connect.
 
 Your notes stay in a folder you own. Every agent you use — Claude Code, Codex,
-Gemini — reads and writes the same brain through one CLI, so what you told one
+Antigravity — reads and writes the same brain through one CLI, so what you told one
 of them is there for the next one, tomorrow, and in whatever tool you move to
 after that.
 
+**You do not have to run any of this yourself.** Ask whichever agent you are
+already talking to — "install memgineering and set it up" — and it does the
+whole thing, asking you only what it genuinely cannot decide.
+
+<details>
+<summary>The commands, for the agent (or for you, if you prefer a terminal)</summary>
+
 ```bash
 npm i -g memgineering
-memgineering setup
+memgineering setup --agent              # or --web to choose the settings on a screen
 memgineering link ~/Documents/Notes     # or: memgineering init ~/brain
 ```
 
+</details>
+
 ## What it does
 
 ```bash
@@ -131,6 +140,7 @@ can register it to run automatically when a Claude Code session starts.
 | `init <path>`                       | create a brain, laid out and ready                    |
 | `link <path>`                       | read notes you already keep                           |
 | `use [brain]`                       | bind this folder to one brain                         |
+| `push` · `pull`                     | carry a brain to your account, and back down again    |
 | `unlink` · `reindex` · `sync-rules` | brain housekeeping                                    |
 | `log`                               | what changed, and what can still be undone            |
 | `retire` · `unretire`               | mark a memory no longer current, or current again     |
@@ -148,13 +158,27 @@ Every command takes `--json`.
 | `MEMGINEERING_JSON=1`      | force JSON output without the flag                  |
 | `MEMGINEERING_NO_UPDATE=1` | skip the version check for one run                  |
 
-## What is coming
+## A brain that is not on this machine
+
+A brain can also live in a memgineering account, so the same memory reaches
+every tool and device you sign in from. Nothing about the local path went away —
+`--local` reads the folder on this disk whether or not you are signed in.
+
+```bash
+memgineering push                 # carry this folder up, note by note
+memgineering pull ~/my-brain      # bring it back down, as markdown
+```
+
+The pair is deliberately asymmetric in the same direction: **`push` never
+deletes anything here, and `pull` never overwrites anything here.** A file
+already at that path is left alone and reported, so an interrupted transfer is
+finished by running the command again and a mistyped folder costs you nothing.
 
-**0.2.0 — cloud brains.** Today a brain is a folder on this machine. Next it
-can also live in a memgineering account, so the same memory reaches ChatGPT,
-Claude on the web, and anywhere a browser goes. The local path is not going
-away: what syncs is your originals, your ledger and your rules — never a
-vendor's copy of your notes.
+What `pull` writes is your notes, at the paths they had, including the ones your
+rules exclude — excluded means "stop reading this", not "this is no longer
+yours" — with `.memgignore` alongside them so the scoping survives the trip.
+It is a folder of markdown, not yet a brain: `memgineering link` is what makes
+it one, and it shows you what it would read first.
 
 ## Licence
 

package/assets/MEMGINEERING.md

@@ -1,150 +1,54 @@
 ---
 name: memgineering
-description: Use whenever the user refers to something they told you before, asks what was decided, or tells you something worth keeping. 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.
+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.2.0
+version: 0.5.0
 ---
 
 # memgineering
 
-The user has a **brain** — a folder of their own notes that every AI tool they
-use can read and write through the `memgineering` CLI. It outlives this
-session and this tool. Treat it as the place where what they know actually
-lives, and this conversation as temporary.
+The user has a **brain** — a folder of their own notes, read and written through
+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.
 
 ## When to reach for it
 
-**Start a session by asking what you are missing.** Before working in an
-unfamiliar folder, or when someone opens with "where were we", "what should I
-know", "I've been away":
-
-```
-memgineering resurface
-```
-
-No query — it ranks by what has been recalled here before, how recently, and
-which of their core notes have gone unread. It is the answer to a vague
-question that recall cannot serve, because there is nothing to search for yet.
-
-**Fill in their base files when they are still empty.** `init` leaves five
-files in `01_BASE/` as templates, and `resurface` marks an untouched one
-`not filled in yet`. What goes in them — who they are, how they want answers,
-what to ask before doing — only comes out of a conversation, and every session
-starts from zero until it exists. Offer once, ask one question at a time; the
-`memgineering-memory` skill has the questions and how to write the answers.
-They can also ask for it directly — "set up my memory", "내 정보 채워줘" — and
-that is the same job.
-
-```
-memgineering onboard
-```
-
-Says which are still untouched and what to ask for each.
-
-**Recall before answering** anything that sounds like it was settled before:
-
-- "what did we decide about…", "how do I deploy this again", "왜 이렇게 했더라"
-- any question about _their_ project, setup, preferences, or past reasoning
-- before repeating advice you have no evidence they wanted
-
-```
-memgineering recall "<the question, in their words>"
-```
-
-You get cards: title, one-line summary, and an `open:` handle. Open the one
-that matters rather than all of them.
-
-```
-memgineering open <handle>                 # claims behind the card
-memgineering open <handle> --detail full   # the whole note
-```
-
-`open` also takes a note's exact title or its path, so you do not need to
-recall first when you already know what you want.
-
-**Check the evidence before trusting an old memory,** or when two of them
-disagree:
-
-```
-memgineering evidence <handle>
-```
-
-How often it has been surfaced, how often anyone read it, when it last changed
-and why. **Newer does not win**: a rule that has stood for eleven months has
-eleven months of nobody contradicting it behind it. Use whether it was actually
-reached for, not its date.
-
-**Remember when you learn something durable** — a decision, a constraint, a
-correction the user made, how something actually works:
-
-```
-memgineering remember "deploys are manual — launchctl by hand, no CD" --reason "watched it twice"
-```
-
-No approval step, by design. It is recorded and reversible (`memgineering
-undo`), so the cost of a wrong entry is one command, not a permanent mistake.
-Do not ask permission for ordinary observations — write them.
-
-**Always pass `--reason`.** Every write verb takes it and it goes in the ledger.
-It is the only part of a record that still means anything to whoever reads it
-six months from now, and it is refused if it looks like it carries a credential.
-
-**Revise when a conclusion changes:**
-
-```
-memgineering revise <handle> --claim "Deploying is manual now." --summary "manual only"
-```
-
-## What to raise with the user rather than just doing
-
-The tool does not gate writes; your judgement does. Tell them — plainly, once
-— when:
-
-- the change touches `01_BASE/` (their identity, preferences, boundaries,
-  tooling). The output marks these `⚠ critical target`.
-- you are recording something they said in passing that they may not want kept
-- what you learned contradicts a memory that is currently marked current
-
-Everything else: write it and mention it in a sentence.
-
-## Depth costs context — ask for what you need
-
-`recall` returns cards, not notes, so calling it often is cheap. Reach for more
-only when a summary is not enough:
-
-| depth              | what you get                                    |
-| ------------------ | ----------------------------------------------- |
-| `--detail card`    | title + summary (default)                       |
-| `--detail summary` | + the note's headings                           |
-| `--detail chunks`  | + every section, or one with `--section <name>` |
-| `--detail full`    | the whole note                                  |
-
-`recall "<q>" --limit 1 --detail full` is "find the best match and read it" in
-one call.
-
-## At the start of a session
-
-```
-memgineering resurface
-```
-
-Ranks by what has been recalled in this folder before, how recently, and which
-of their base notes have gone unread. No query needed — this is the one that
-tells you what you should already know here.
-
-## Rules
-
-- **Never edit brain files directly.** Use the CLI: it records what changed and
-  keeps `undo` working. A hand edit is invisible to that.
-- **Never invent a handle.** They come from `recall`, `resurface` or `open`.
-- **Full ids in durable places.** The short handle is for this conversation;
-  when you save a reference in your own memory or a document, use the full `id:`
-  that `open` prints.
-- **Nothing matched is a real answer.** Say the brain has nothing on it rather
-  than filling the gap with a guess.
-- **Their notes are theirs.** `revise` only touches the memory block in
-  frontmatter; prose is never rewritten by this tool, and should not be
-  rewritten by you without being asked.
-
-If `memgineering: command not found`, install with `npm i -g memgineering`,
-then `memgineering setup`.
+- **Anything that sounds already settled** — a past decision, their setup, their
+  preferences, or before repeating advice you have no evidence they wanted:
+  `memgineering recall "<their words>"`
+- **Write it down when any of these happens** — something turned out to work a
+  particular way; a choice got made, by them or by you; an attempt failed, and
+  what finally worked instead; they said "let's do it this way"; they looked at
+  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.
+
+`--reason` on every write: it is the only part of the record that still means
+anything six months later, and it is refused if it looks like a credential.
+
+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.
+
+## Where the detail is
+
+`memgineering-memory` is the map — which verb answers which question. It points
+at four skills, each of which also loads on its own when its topic comes up:
+
+- `memgineering-recall` — recall, open, evidence, resurface, how much to ask for
+- `memgineering-writing` — remember, revise, undo, retire, exclude, `01_BASE/`
+- `memgineering-rules` — decisions that bind, and the before-edit hook
+- `memgineering-setup` — installing, which tools this reaches, accounts, moving a brain
+
+Tools with a SKILL.md description-matcher (Claude Code, Codex, Grok) auto-load these.
+Tools without one (e.g. Antigravity): READ `<tool-home>/skills/memgineering-<name>/SKILL.md`
+when its topic comes up.
+
+If `memgineering: command not found`, install with `npm i -g memgineering`, then
+`memgineering setup`.