memgineering 0.14.0 → 0.15.0

package/CHANGELOG.md

@@ -11,12 +11,75 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [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.0
 ---
 
 # memgineering

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