memgineering 0.14.0 → 0.15.1

package/CHANGELOG.md

@@ -11,12 +11,93 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [0.15.1] — 2026-08-29
+
+### Fixed
+
+- The 128-character cap on `scope` and `asked_from` is now spelled once, in
+  the engine both sides already read, instead of living as three hand-copies
+  that each admitted nothing would catch their drift. Same number everywhere;
+  no behaviour change.
+
+### Agent guidance
+
+- The hub's reflex table gains a fourth row: a vague opening — a new folder,
+  "where were we", picking work back up — is now a `memgineering resurface`
+  reflex, not just a bullet further down. Measured before and after on a
+  fast-tier model in the lab: the same session that skipped resurface twice
+  runs it first with the row in place, and the project-aware opening lands.
+  Restart your agent session after upgrading so the new hub is what gets read.
+
+## [0.15.0] — 2026-08-29
+
+### Added
+
+- **A folder knows which project it is.** `memgineering project` names the
+  project the current folder counts as — derived from the git remote
+  (`owner/repo`), else the checkout's folder name, else nothing; worktrees
+  and subfolders of one checkout answer the same. `memgineering project
+<name>` binds your own name to the repository and `--unset` returns to the
+  derived one. Renaming does not move history: what was recalled under the
+  old name stays recorded there, and the command says so whenever it
+  changes anything. Derivation reads `.git/config` directly — no
+  subprocess, so the session-start hook's deadline is never spent on it.
+- **A note remembers the project it was born in.** `remember` inside a
+  project folder stamps that project as the note's `scope` automatically.
+  An explicit `--scope` still wins; the new `--no-scope` writes a
+  machine-wide note on purpose — rules especially, since a rule stamped
+  with one project's scope drops out of another project's `--scope`
+  recalls. A derived name the server would refuse (over 128 chars, or
+  nothing once normalized) is skipped silently and the note is written
+  unscoped — an ambient signal never fails a command. The `YYYY-MM` noise
+  scope that path inference used to give observations is gone for new
+  notes.
+- **Reads say where they were asked from — as a name, never a path.**
+  recall, open and resurface now send `asked_from`, the folder's project
+  name, and a hosted brain records it beside what was returned. The local
+  event log records the same name next to the `context_dir` it always
+  kept. The working directory itself still never leaves the machine; the
+  privacy page names the new field, what it holds, and its 90-day window.
+- **A hosted resurface finally ranks by "asked about here."** When the
+  session's folder names a project, the hosted ranking weighs what was
+  asked about in that project first — the same weight a folder brain has
+  always given "in this folder" — and says so honestly: `ranked_by` gains
+  `asked about in this project`, a card's reason reads `recalled 2× in
+this project`, and the footer names which project those words mean. A
+  brain with no history yet ranks exactly as before and claims nothing.
+
+### Changed
+
+- The hosted resurface footer no longer claims a hosted brain cannot know
+  where a question was asked from. It now tells one of three truths: which
+  project the ranking used; that this folder names no project, so nothing
+  was sent; or that the server was sent the signal and does not rank by
+  project yet. `resurface --json` carries `asked_from` so a machine reader
+  can tell those cases apart too.
+
+### Compatibility
+
+- An older server ignores `asked_from` entirely (unknown fields are
+  dropped); the CLI reads the three-entry `ranked_by` and says the server
+  does not rank by project yet, rather than letting the silence read as an
+  empty folder signal. An older CLI against the new server sends nothing
+  and behaves exactly as before. Event lines written before the field
+  existed still parse and still rank.
+
+### Agent guidance
+
+- `memgineering-recall` (what the project signal means and which footer to
+  trust), `memgineering-writing` (the automatic scope stamp, and
+  `--no-scope` for machine-wide rules) and `memgineering-setup` (the
+  `project` verb) were updated. Restart your agent session after upgrading
+  so the new guidance is what gets read.
+
 ## [0.14.0] — 2026-08-29
 
 ### Added
 
 - **A hosted brain's base files can finally be written.** `memgineering
-  base-write 01_BASE/USER.md --input <file|-|text>` fills or replaces the
+base-write 01_BASE/USER.md --input <file|-|text>` fills or replaces the
   body of a `01_BASE/` file on a hosted brain — the files `onboard` points
   at, which until now could only be filled on a folder and left a hosted
   brain reading as a blank form forever. The `memgineering:` block above

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.14.0
+version: 0.15.1
 ---
 
 # memgineering
@@ -26,19 +26,19 @@ rule; an instruction scoped to "this file" or "here" ends with the task). Judge
 | 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 |
+| they opened vaguely — a new folder, "where were we", picking work back up | `memgineering resurface` FIRST — no query; answer from it |
 
 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 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.
+These are SHELL commands — run them with your shell tool; measured: a model
+passed one as a skill argument and told the user it was saved when 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 —
-the brain is the one store every tool they use shares.
+Durable user facts never go in this tool's own memory files — the brain is
+the store every tool they use shares.
 
 ## When to reach for it
 
@@ -51,7 +51,6 @@ the brain is the one store every tool they use shares.
   what you did and said it was right: `memgineering remember "<it>" --reason
 "<why>"`. Reversible by design, so do not ask permission for ordinary
   observations — but first `open boundaries`: it says what never to store.
-- **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; changes are
   proposed, then approved by them.

package/assets/memgineering-recall/SKILL.md

@@ -215,6 +215,16 @@ and which base notes have gone unread — what you should already know here befo
 they have to tell you again. It is the answer to a vague opening that recall
 cannot serve, because there is nothing to search for yet.
 
+On a hosted brain the folder counts too, as a name rather than a path: the CLI
+sends the folder's project — `owner/repo` from the git remote, or whatever
+`memgineering project` shows — and the server ranks what was asked about in
+that project first. The response says so itself: `ranked_by` gains `asked about
+in this project`, a card's reason reads `recalled 2× in this project`, and the
+footer names which project those words mean. Trust the footer over your
+assumption in the other cases as well — it says when this folder names no
+project (nothing was sent), and when the server does not rank by project yet
+(it was sent and ignored). A path never leaves the machine either way.
+
 ## Deciding which one to trust
 
 ```

package/assets/memgineering-setup/SKILL.md

@@ -255,6 +255,24 @@ memgineering use --default ~/brains/work
 Inside a repository `use` writes a relative path, so it can be committed and
 resolves for a teammate who links the same brain.
 
+### Which project a folder is
+
+```
+memgineering project                    # what this folder answers to, and how it was decided
+memgineering project acme/site          # bind a name of your own to this repository
+memgineering project --unset            # back to the derived name
+```
+
+Derived without asking: the git remote's `owner/repo`, else the checkout's
+folder name, else nothing — a folder outside any repository names no project
+until somebody sets one. The name follows the repository, so worktrees and
+subfolders of one checkout answer the same. It is what `remember` stamps as a
+note's scope and what the reads send as `asked_from`, so a hosted resurface
+can rank what was asked about here — as a name; the folder's path never
+leaves the machine. Renaming does not move history: what was recalled under
+the old name stays recorded there and the new name starts fresh, which the
+command says out loud whenever it changes anything.
+
 **An account can hold several hosted brains. `brains` lists them and
 `use --brain <name>` switches.**
 

package/assets/memgineering-writing/SKILL.md

@@ -22,6 +22,25 @@ trade is permission-before for correction-after, and every write records how to
 reverse it. Do not ask permission for ordinary observations — write them, and
 mention it in a sentence.
 
+**A note born in a project folder carries that project as its `scope`** — the
+name comes from the git remote (`owner/repo`), or from the folder's binding
+(`memgineering project` shows it). The stamp is automatic; an explicit
+`--scope` beats it; a folder that names no project writes exactly what it
+always wrote. Two flags are worth reaching for on purpose:
+
+```
+memgineering remember "we always squash before merging" --rule --no-scope \
+  --reason "they said from now on, about every repo — not this one"
+```
+
+- `--no-scope` for anything meant to hold machine-wide, rules especially: a
+  rule stamped with one project's scope drops out of another project's
+  `recall --scope` answers.
+- `--scope <name>` when the note is ABOUT a project you are not standing in.
+
+`--scope` and `--no-scope` together are refused — they answer the same
+question both ways.
+
 **`--reason` on every write.** It goes in the ledger and is the only part of the
 record that still means anything six months later. Every write verb takes it:
 `remember`, `revise`, `retire`, `exclude`, `undo`. The one on `undo` matters