minnimemory 1.0.0-beta.2 → 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,428 @@
+# Changelog
+
+All notable changes to the `minnimemory` package. Dates are publish dates; an entry that has not
+been published yet says `unreleased` and gets its date on the day it goes out.
+
+## 1.1.0 - 2026-10-06
+
+- Kept: the memory-folder list header still says "Read one file, not its siblings." Dropping it
+  made the agent search the routed file instead of opening it, and a measured working session
+  saved 15% instead of 27%.
+- Fixed: an `@import` written with a Windows drive-letter path (`@C:/...` or `@C:\...`) is
+  found like any other import, so the map, the always-loaded total and the audit count the file
+  Claude Code loads. A folder apply rewrites such a line into `AlwaysOnMemory/` with the slashes
+  it was written with, and undo restores it.
+- Fixed: `init` and `doctor` on a pointer `CLAUDE.md` (`@AGENTS.md`) measure MM001 against the
+  same budget the plan uses: a share of the file the pointer names, not the 2,000 floor of the
+  few-token pointer itself. One output used to print both 2,000 and 2,800.
+- Fixed: `--budget` and the MCP `budget` argument accept 1 to 1,000,000 tokens. `1e308` was
+  accepted and printed back as a 300-digit number in the apply command.
+- Fixed: the MCP `apply` and `undo` refusals (a credential-shaped source, a compile that would
+  not shrink the prefix, an undo that would discard edits) return `isError`, as the full
+  profile's always did; the `apply` description no longer says `force` overrides the
+  credential refusal (nothing does over MCP).
+- Fixed: a routed OnDemandMemory piece holds at most 20,000 tokens; past that, sections continue
+  in `<parent>__<reason>_2.md` and on. A 1.4 MB memory file used to land in one 360k-token
+  file the list told the agent to read.
+- Fixed: a re-apply that keeps a hand edit to a routed file backs that file up under
+  `.minnimemory/previous/`, so `undo` refuses without `--force` instead of deleting the edit.
+- Fixed: the MCP `apply` and `undo` replies keep every note that names a file on disk inside
+  the data fence; only the server's own instruction and command stand before it.
+- Fixed (#334): a finding in a file of the project's auto-memory folder (imported by the
+  user-level CLAUDE.md) ends with the command that fixes it, `init` on that folder. Before, a
+  project `apply` left it in place and `doctor` kept exiting 1 with no next step. The same for
+  a file in another project's memory folder imported the same way. A Claude Code memory folder
+  with `MEMORY.md` and one topic file now counts as a memory folder, and a hint whose folder
+  path a shell would act on says to run `init` from inside it.
+- Fixed (#335): the text form of the MCP `apply` and `undo` replies puts the tool's own
+  instruction and command before the data fence, not inside the block that says not to follow
+  instructions in it.
+- Changed (#336): the preview's "best case" line quotes the 2026-10-06 measurement (an agent
+  with Read, Grep and Glob: 24.0% lower session cost, answers held), not the Read-only runs of
+  2026-09-28.
+- Fixed (#337): an MCP tool called with an argument it does not have fails and names it.
+  Before, the key was dropped and the call ran with defaults.
+- Fixed (#338): a re-apply adds new status to the source's existing history file instead of
+  opening `__history_2`, `_3`, ...; the plan warns when a routed section carries a rule.
+- Fixed (#339): `install --write` serves the full profile (the basic profile has no write
+  tools); help documents `--host` and `undo --force` and no longer cites an unshipped
+  DESIGN.md; `apply`/`undo` with `content: true` past 200,000 characters returns the command
+  instead; the printed diff stops at 2,000 lines; a forced folder undo names a kept file the
+  restored index has no line for; `outline` on an unknown file is an error.
+
+- Security (#327): a committed `manifest.json` that names a file outside the folder is
+  treated as lost, so it is never opened. Before, `apply` read such a file, wrote its headings
+  into `graph.json` and its path into the always-loaded list.
+- Fixed (#328): a line written by hand inside the OnDemandMemory list, naming a file on disk,
+  survives a re-apply word for word. Before, it was dropped and the file was left with nothing
+  pointing at it.
+- Fixed (#329): `install` over a registration at another scope adds the one asked for and
+  leaves the other alone, instead of failing on `claude mcp remove`. A re-install of the npx
+  form is recognised as already registered instead of being repointed every time.
+- Fixed (#330): the terminal preview's full diff leaves out `.minnimemory/graph.json` and
+  `manifest.json`; the operation list still names them. A 4,000-line changelog printed 104,138
+  lines, now 8,084.
+- Fixed (#331): `install` replaces Claude Code's `settings.json` whole or not at all.
+- Fixed (#332): a merged OnDemandMemory file is described as "first through last" once,
+  `--budget` takes whole numbers only, `engines` is `node >=18.3` (the CLI uses
+  `util.parseArgs`), and the lockfile no longer pins dependency versions with advisories.
+
+- Fixed (#298): `doctor --budget 2000` is used as given, not replaced by the compiled or
+  default budget. Before, an explicit 2,000 read as "no budget given", so MM001 measured
+  against another number than the summary line printed, and `doctor --budget 2000 --ci`
+  passed a file it called over budget. With no `--budget`, MM001 still reads the compiled
+  budget, and the summary line now prints the budget MM001 used.
+- Fixed (#303): the memory map no longer calls a `CLAUDE.md` that only mentions `AGENTS.md` a
+  pointer while listing `AGENTS.md` as not loaded. The setup block says the host names the file
+  but does not import it, and the not-loaded line says to make `CLAUDE.md` hold `@AGENTS.md`.
+- Fixed (#304): apply after a host rename names the renamed backup
+  (`CLAUDE.md.bak -> AGENTS.md.bak`) and says the host was renamed, over MCP too.
+- Docs (#299): the 40 percent saving holds only above the 2,000-token floor, about 3,300
+  tokens of host file.
+- Added: the memory map that opens `init` starts with a `setup` block: the host file, the file
+  it points at when it is only a pointer, the one file `apply` rewrites, and whether it is
+  compiled. When the project holds an `AGENTS.md` that Claude Code does not load, the map ends
+  with a `not loaded by Claude Code` group naming each one and the reason. `init --json` and
+  the MCP reply carry both as `setup` and `notLoaded`.
+- Fixed: a compiled host file renamed afterwards (`CLAUDE.md` to `AGENTS.md`, with or without
+  a pointer left behind) is the same host. Before, `doctor` reported the old name as missing or
+  edited and said to re-apply, `apply` answered "nothing to apply", and the two never agreed.
+  Now `doctor` reports the rename once, one `apply` carries the manifest and the backups over
+  to the new name, and `undo` restores the original into the file that holds the memory now.
+- Fixed (#297): a pointer `CLAUDE.md` rewritten by hand, so that it no longer reaches the
+  compiled file, is reported as drift. `doctor` names both files and says what to do (put the
+  pointer back, or `undo` and then `apply`); `apply` writes nothing and says the same in place
+  of "nothing to apply".
+- Changed (#238): a project host file keeps its rules and what every task needs, and moves
+  its records. The keep decision is by content, not by heading alone (a body that reads as a
+  rule stays whatever its heading says; commands, setup, build, test, architecture and the
+  like stay after the rules). Volatility is the strict test on a host file too: a status
+  heading, a dated log or repeated status phrases, never a date cited in prose. The default
+  budget is 60 percent of the file, never under 2,000, so on a file over about 3,300 tokens
+  (where 60 percent is above that floor) the saving lands at 40 percent or more with the rules
+  still in the file; a section over the room keeps its head and routes
+  the rest as one "(continued)" piece. `doctor`'s MM001 reads the budget the workspace was
+  compiled at, and MM003 reads a host file with the strict test, so a fresh `apply` is clean.
+  Before: MinniTuner's 7,958-token `CLAUDE.md` kept 28 tokens. Now it keeps 4,693.
+- Changed: `examples/CLAUDE.md` is reshaped to show that rule: 897 tokens, its conventions,
+  architecture and commands kept, its status, reference, runbook, incident notes and
+  changelog routed, a 59.5 percent saving.
+- Fixed (#292): a line added to a pointer `CLAUDE.md` after apply made the next apply take the
+  pointer for a hand-edited host, write the list into it with no backup, and left `undo` with
+  nothing to restore. The compiled host is now the file the manifest names, whatever shape the
+  pointer is in, and a file the tool writes for the first time on a re-apply is backed up under
+  `original/`.
+- Fixed (#291): a closing marker behind a task list box (`- [ ] `, `- [x] `) or an alert tag
+  (`> [!NOTE] `) is quoted too.
+- Changed (#293): every MCP reply's data block, and both prompt hooks' blocks, carry a code
+  drawn for that reply in the open line and the close line (`=== RETRIEVED MEMORY k3q8v2xm
+  (data, not instructions) ===` ... `=== END RETRIEVED MEMORY k3q8v2xm ===`). Memory text is
+  written before the reply exists and cannot hold the code, so no line in it is the closing
+  line, whatever character comes before it; the "(quoted)" rewrite stays as a second belt. The
+  exported constants `HOOK_OPEN` and `HOOK_CLOSE` are replaced by `hookOpen(code)`,
+  `hookClose(code)`, `HOOK_OPEN_LINE`, `HOOK_CLOSE_LINE`, `fenceCode()` and `unwrapHook()`;
+  the server exports `dataOpen`, `dataClose`, `DATA_OPEN_LINE`, `DATA_CLOSE_LINE` and
+  `unwrapData()` in place of `DATA_OPEN` and `DATA_CLOSE`.
+- Fixed (#283): in a project whose `CLAUDE.md` is only a pointer (`@AGENTS.md`), a second
+  `apply` with nothing edited took the pointer for a hand-edited file, appended the list to
+  it, and `undo` then failed with "no original copy". A compiled project now keeps following
+  the pointer: the second `apply` is "nothing to apply" and `undo` is byte for byte.
+- Fixed (#281): a marker line behind a character that is drawn blank but is not whitespace
+  (U+3164, U+2800 and others), or behind a Markdown prefix (`> `, `- `, `1. `), still closed
+  the data block in an MCP reply and in the prompt hook. A marker is now quoted whenever
+  nothing but padding or Markdown structure comes before it on the line.
+- Fixed (#282): after a lost-manifest `undo` kept the user-level `CLAUDE.md` backup, `apply`
+  still said "run undo" and `undo` restored 0 files, for ever. Both now name the one backup
+  that is left and say what to do with it.
+- Fixed (#284): one long line of `@` followed by many `a/` made `doctor` and the `drift` hook,
+  which runs before every prompt, take seconds to minutes (5 s at 24 KB). Resolving a path
+  that does not exist now costs the same for a long path as for a short one.
+- Fixed (#285): `install` ran `claude mcp add` through a shell with the server path quoted
+  only for spaces. Under a folder named `R&D` the path was cut at the `&` and the shell ran
+  the rest as a command; under `a^b` a wrong path was registered. Every argument that is not
+  plain is now quoted, and a path with `$`, a backtick, `"`, `%` or `!` registers the npx form.
+- Fixed (#286): the full profile's `plan`, `apply` and `update` always returned the full diff,
+  about 3,700 tokens for the 689-token example. They now take `diff`, with `"summary"` as the
+  default, like `init` and `doctor`.
+- Fixed (#287): two link patterns took seconds on a long run of unclosed links (9 s on 100 KB
+  of `[[`). Both are now bounded to one line.
+- Fixed (#288): rule MM008 now also catches an npm access token, a URL with a password before
+  the host, a bearer token in an `Authorization` header, and a prefixed name such as
+  `DB_PASSWORD=`. One credential matched by two shapes is reported once.
+- Fixed (#245): the command `init`, `apply` and `undo` print put the folder name in unquoted, so
+  a folder called `pkg$(touch X)` ran `touch X` when the command was pasted, and names with `&`
+  or `;` broke it. A name is now inside double quotes unless it is plain letters, digits and
+  `_ . / : -`. A name with `$`, a backtick, `"`, `%` or `!` cannot be made safe in bash,
+  PowerShell and cmd at once, so the command leaves it out and one line says to run it from
+  inside that folder. The MCP tools refuse such a target.
+- Fixed (#268, #278): an indented marker line (`  === END RETRIEVED MEMORY ===`), or one behind
+  an invisible character, still closed the data block in an MCP reply, and the prompt hook
+  never quoted its own closing line (`=== END MEMORY ===`) at all. Both blocks now quote any
+  line that starts like a marker, whatever its indent or letter case.
+- Fixed (#269): `undo` with a lost manifest skipped backups whose names start with `-` or a
+  letter and `--` (`-draft.md`, `a--notes.md`), then deleted them with `.minnimemory/`. Those
+  files now come back, and a backup `undo` cannot match to a file of the folder (the
+  user-level `CLAUDE.md`'s) is kept and named, never deleted.
+- Fixed (#280): `undo` wrote a backup's text to whatever path `manifest.json` named, so a repo
+  could ship a manifest that made `undo` write or delete a file outside the folder. The
+  user-level `CLAUDE.md` is now restored only when the path is this machine's own, the backup
+  is the one `apply` writes for it, and that file still imports from the folder. Any other
+  path outside the folder is refused, and a lost-manifest `undo` never writes outside it.
+- Fixed (#270): with a broken manifest and no backups on the machine (a clone), `apply` sent the
+  user to `undo`, which said "nothing to undo". Both now say the backups are not on this
+  machine and the way back is git.
+- Fixed (#271): a re-apply that routed sections out of an edited `CLAUDE.md` also printed "hand
+  edits kept as they are (nothing to route out)" for that file. The line now shows only for a
+  file the plan leaves as it is.
+- Fixed (#274): `apply` on a compiled project whose `.minnimemory/` folder was gone planned a
+  first compile, removed the list of moved files from `CLAUDE.md` and left those files with
+  nothing pointing at them. It now refuses, names the files, and changes nothing.
+- Fixed (#275): when `apply` could not write a file (read-only, locked by another program, full
+  disk) it stopped half way with a stack trace and left backups and moved files behind with no
+  manifest. It now puts back everything that run wrote and prints one clear error.
+- Fixed (#276): a memory file with only blank lines got the verdict "compile" and four
+  bookkeeping files to save 2 tokens, and an empty file printed "break-even -1 tokens". A first
+  compile that moves nothing is now "leave", and the break-even is never under zero.
+- Fixed (#277): `--help` now lists the `loaded` command that `install` adds as a hook.
+- Fixed (#246): with `.minnimemory/manifest.json` missing or unreadable (a git conflict is
+  enough), `apply` planned a first compile, backed up the trimmed file over the real original
+  and dropped the list. It now refuses and changes nothing; `apply` never writes over a backup
+  under `original/`; `doctor` names the state once instead of advising a re-apply; and `undo`
+  (with `--force`, since it cannot see edits) restores every backup from `original/`.
+- Fixed (#247): `undo` listed `.claude/` (and `.claude/OnDemandMemory/`) for deletion even when
+  it held the project's settings or a hand-written file, and told a host that cannot run
+  commands to delete every listed path. A folder is now listed only when everything in it
+  leaves with the undo.
+- Fixed (#248): memory text holding the data block's own closing line ended the block early in
+  every read tool's reply. Such a line is now shown with "(quoted)" and a note; the JSON form
+  is unchanged.
+- Fixed (#249, full profile): `update` wrote a first compile that `apply` had refused; it now
+  re-applies only. The server instructions name exactly the tools loaded; `plan` lost its dead
+  `update` option; `doctor` refuses an unknown rule id; `apply`'s description matches what it does.
+- Fixed (#250): one routed file deleted by hand made `recall` fail for every question. It is
+  now skipped and named, `modules` marks it missing, and the advice says to re-apply, not
+  "rerun init".
+- Changed (#251): `undo`, MM011 and the README now say plainly that undo works only on the
+  machine that ran `apply` (the backups are gitignored); on a clone the way back is git history.
+- Fixed (#252): a re-apply's plan said "saves -2 tokens" and "costs 7,924 more than today". It
+  now says "verdict: re-apply" with the before and after size, and no break-even.
+- Fixed (#253): a re-apply after a hand edit backed the host file up twice.
+- Fixed (#254): a very small file gained a made-up "<title> overview" heading, a "kept out"
+  line for a section that stayed, and a negative break-even. None of the three appear now.
+- Fixed (#255): MCP replies named terminal flags and commands (`--budget`, `--force`,
+  `--allow-secrets`, `node ... apply`); they now name the tool's options and `apply()`. The
+  terminal output is unchanged. The auto-memory install hint is built in `commands.ts`.
+- Added (#256): `init` with `format: "json"` (MCP) and `init --json` (terminal) carry the
+  memory map under `map`.
+- Fixed (#257): `content: true`'s text form used a three-backtick fence for every file, so a
+  file with its own code block broke the split. Each fence is now longer than any run inside.
+- Changed: the preview no longer uses one label for two totals. `doctor`'s check says
+  `all always-loaded files`; the plan says `always-loaded, files this plan rewrites`. Scripts
+  that read the old `always-loaded prefix:` line need the new text.
+- Changed: a compile plan now says its saving is a best case (kept only on turns that open none
+  of the moved files) and cites the measured sessions.
+- Added: a plan warning when a file keeps under a tenth of its tokens, so rules going out with
+  the rest are visible. Routing itself is unchanged.
+- Fixed: the `minnimemory` command printed nothing on Linux and macOS when run through npm's
+  symlink (`npx -y minnimemory --version`). It now compares real paths. `install` registers the
+  real file, not the symlink. 1.0.0 has this bug, so it needs a new release.
+- Fixed: MM002 no longer calls a table of paths and commands a directory listing.
+- Fixed: `apply` drops list keywords from the end so the lines it writes stay under the MM006
+  cap (120 characters, one keyword at least). Lines already under the cap are unchanged.
+- Fixed: diff headers no longer show `a//home/...` for an absolute path.
+- Added (tests only, no change to the package): the compatibility test. Each release saves its
+  compiled sample repo as a fixture (`scripts/save-compat-fixture.mjs`, run on the bundled
+  build), and `tests/compat.test.ts` checks this build still reads every fixture inside the
+  support window of 6 months or 3 minor versions: `doctor` has no high finding, and every
+  routed piece is still listed and found. A release that breaks one must be a major. The
+  Minni orchestrator's launcher relies on it (Suite/MinniHQ/docs/DESIGN.md 0.9). The
+  fixture for 1.0.0 is saved.
+
+## 1.0.0 - 2026-09-27
+
+The first stable release. Prepared 2026-09-22, published 2026-09-27 as `latest`; `1.0.0-beta.2`
+(2026-09-18) stays on the `beta` tag.
+
+- Changed (2026-09-27): `init` opens with the map of every file Claude Code loads for the
+  project, from Claude Code's documented rules: managed policy, user `CLAUDE.md` and
+  `~/.claude/rules/`, `CLAUDE.md` / `.claude/CLAUDE.md` / `CLAUDE.local.md` here and in every
+  folder above, `AGENTS.md` when no `CLAUDE.md` exists, recursive and `paths:`-scoped rules,
+  subfolder files, imports and auto memory, each with when it loads, whose it is and its tokens.
+  `--map` prints only the map.
+- Added: `install` registers an `InstructionsLoaded` hook (`minnimemory loaded`) that records what
+  Claude Code actually loads per project, machine-local; `init` checks its map against it and
+  `doctor` reports a file Claude loaded that the map missed (MM016). `install --remove` removes it.
+- Fixed: the always-loaded total now counts user rules, the managed policy file, parent folders'
+  CLAUDE files and nested rules, and no longer counts `paths:`-scoped rules; a host at
+  `.claude/CLAUDE.md` is found and compiled with its manifest at the project root.
+
+- Fixed (2026-09-27, macOS dev run): the auto-memory folder and the load log are found the way
+  Claude Code keys them. A project reached through a symlink (macOS `/tmp` and `/var` point into
+  `/private`, or a `~/dev` linked to another drive) is keyed by its real path, with the path as
+  typed as a fallback; a git worktree, and any folder inside it, shares the main checkout's
+  folder, as the Claude Code memory docs say. Before, both missed that memory. doctor's note on a
+  repo's own `autoMemoryDirectory` now says Claude Code does use it in a trusted folder and that
+  minnimemory still does not follow it (the 2026-09-26 security decision stands).
+- Fixed (2026-09-27, end-to-end dev run): an `@path` import line in a section apply routes out
+  now stays in the always-loaded file, under `## Imports`. Claude Code follows imports only from
+  files it loads at session start, so a routed import had silently stopped its file loading.
+
+- Fixed (2026-09-27, hands-on audit of the map): `AGENTS.md` is read when the only CLAUDE file
+  above is the user's own `~/.claude/CLAUDE.md` or an excluded one (the map was empty for an
+  AGENTS.md repo under the home folder). Printed commands use forward slashes, so Git Bash no
+  longer strips a Windows target path. The map says when its subfolder scan stopped at its cap;
+  `doctor` and the drift hook skip that scan, and MM016 builds the map only once a load log
+  exists (doctor on a 6,000-folder tree: 4.3 s to 0.2 s). `loaded` resolves a relative path
+  against the session's folder, and the map ignores logged files that no longer exist.
+
+- Fixed (2026-09-27, messy-developer live proof): a hand edit apply has nothing to route out of (a
+  sorted rule file, or `MEMORY.md` outside its list) is kept byte for byte and taken as the new
+  baseline, so the MM010 drift it raised clears; before, `apply` said "nothing to apply" and the
+  drift never cleared. The accepted file is backed up under `previous/`, so `undo` still names it.
+  `undo` with `force: true` over MCP returns a command that carries `--force`.
+- Fixed (2026-09-27, pre-publish audit): a project host file's budget is now that file's alone.
+  The user-level `~/.claude/CLAUDE.md`, its imports, the auto-memory index and `.claude/rules`
+  stay in MM001 (the audit line) but no longer enter the plan's before/after, share or manifest, so a machine with a
+  large user-level memory no longer compiles every project `CLAUDE.md` down to its title line,
+  and the MCP server's plan (made without the user-level host unless launched with
+  `--include-auto-memory`) hashes the same as the CLI's, so the printed `apply --plan` runs.
+- Fixed: `install` quotes the arguments it hands the shell on Windows, so a cli path with a
+  space (`C:\Users\First Last\...`) registers as one argument and the server starts.
+- Fixed: a source that is not valid UTF-8 is refused instead of rewritten (and backed up) with
+  replacement characters; a CRLF source is rewritten with CRLF.
+- Fixed: `undo` refuses without `--force` when a compiled file was edited since the last apply
+  or the workspace was re-applied since the first, naming what it would discard.
+- Fixed: MM008 also recognises `sk-proj-` OpenAI keys, AWS secret access keys and plain
+  `password:`/`api_key=` assignments that look like a real value.
+- Fixed: `.minnimemory/.gitignore` (replacing `original/.gitignore`) keeps `original/`,
+  `previous/` and the drift stamp out of git; a re-apply of an older workspace adds it.
+- Fixed: the memory-folder plan no longer says "nothing here is volatile" beside a routed
+  history piece, or offers a budget that saves a negative number; the CLI's dry-run line prints
+  the apply command on its own line; `install` warns when it registers a copy in the npx cache;
+  a `--budget -5` error says how to write it.
+
+- Changed (2026-09-27, workflow audit): over MCP, `apply` and `undo` return the command to run
+  (`npx -y minnimemory apply --plan <hash> [target]`, `npx -y minnimemory undo [target]`) and
+  the operation list with paths and line deltas, never file content, unless called with
+  `content: true` (for a host that cannot run commands). An `apply` on the example file went
+  from about 3,500 tokens to about 240; on an 85-file memory folder from about 13,400 to about
+  300 (moves are grouped by destination). The command names the target whenever it is not the server root (absolute for the
+  auto-memory folder) and always uses the `npx` form, so it runs as printed; the CLI's `init`
+  and `doctor` print the same real command (`init` used to print a literal `<hash>`).
+- New (2026-09-27): verdict `sort`. A memory-folder plan that recompiles no always-loaded file
+  and only moves loose topic files says so, with what the sort costs or saves per turn, instead
+  of "compile ... saves -173 tokens".
+- Changed (2026-09-27, MCP live proof): the operations block prints paths relative to the root
+  the header names, groups backups and moves per destination folder, and `doctor`/`init` over
+  MCP show four findings per rule (`format: "json"` keeps every one). On a real 78-file memory
+  folder a summary `doctor` went from about 11,000 tokens to about 3,500 and `apply` from about
+  3,300 to about 900. The CLI prints the same shorter block.
+- Fixed (2026-09-27, MCP live proof): `apply` is a fixed point. The command `apply` returns
+  (and the CLI's next-step line) carries the budget the plan was made with, `--force` on a leave
+  verdict and the CLI's own `--profile`/`--episodic-json`, so the hash is recomputed from the
+  same plan (a real agent got "the plan on disk no longer matches" for a plan made at `--budget
+  12000`). The plan's `after` now counts the user-level CLAUDE.md import lines growing by
+  `AlwaysOnMemory/`. The manifest records the budget it was applied with, and a re-apply with no
+  `--budget` or the same one leaves every undrifted compiled source alone instead of re-sharing
+  the pool over the trimmed sizes and trimming again; a different `--budget` recompiles.
+- Fixed (2026-09-27, MCP live proof): `install` writes the user-scope drift hook into the
+  Claude Code config dir's `settings.json` (`CLAUDE_CONFIG_DIR` when set), not always `~/.claude`;
+  under a relocated config dir it wrote the hook into the wrong file. The commands the tool
+  prints call the installed copy directly (`node "<path>/cli.js" apply ...`) when the CLI knows
+  where it runs from, so the plan hash is recomputed by the build that made it; `npx -y
+  minnimemory` is the fallback.
+- Fixed (2026-09-27, live proof): a memory saved into a topic file the sort only moved is no
+  longer reported as drift by `doctor` or the drift hook; MM010 checks the files the tool
+  rewrote and the routed pieces, as DESIGN.md 6.11 decision 3 always said. The sorted index's
+  header now names the folder its paths are relative to (in full for the machine-local Claude
+  Code memory folder), after the live proof's agent resolved `OnDemandMemory/pc_setup.md`
+  against the project directory first and wasted two reads.
+- Fixed (2026-09-27): the drift hook now also checks the project's Claude Code auto-memory
+  folder, whose `.minnimemory/` lives outside the project; it never fired there before. The
+  hook costs about 0.15 s per prompt (was 0.35 s): the CLI loads the MCP SDK only for the
+  `mcp` command.
+- Changed (2026-09-27): `install` registers the MCP server as a direct call to the installed
+  copy (`node "<path>/cli.js" mcp`), the same form as the drift hook, so Claude Code does not
+  re-resolve the package through `npx` on every launch; a registration that runs a different
+  command is repointed on the next `install` without `--force`. `npx -y minnimemory mcp` stays
+  the form for other hosts' JSON snippets and when `install` cannot tell where it runs from.
+- Fixed (2026-09-27): `apply` renders its report before writing, so every write shows its real
+  line delta (was `+0 -0`) and an empty `diff:` header no longer appears; it ends with what it
+  wrote and the undo command. `doctor`'s drift lines and the MCP error for an unflagged
+  `auto-memory` target name the exact command to run next.
+- First stable release. Same four verbs as the betas: `doctor`, `init`, `apply`, `undo`, in the
+  terminal and over MCP (`--profile basic`, the default); the seven-tool `--profile full` is unchanged.
+- New: `init` and `doctor` are one preview. Both print the audit, then a unified diff of every
+  file `apply` would write, then the next step ("run apply", or "nothing to apply"). `doctor`
+  keeps its CI exit code. `init` is the first-time name, `doctor` the returning one.
+- New: memory folders compile. `apply`/`undo` on an index plus topic files, or on a
+  project's Claude Code auto-memory folder, used to answer "nothing to compile"; now every
+  always-loaded topic file the index (or the user-level host) imports sorts into
+  `AlwaysOnMemory/`, trimmed in place; every other topic file sorts into `OnDemandMemory/`,
+  untouched; routed pieces join it there, one piece per parent per reason
+  (`<parent>__history.md`, `<parent>__detail.md`), not one per section. A project root goes
+  through the same engine: the host file is trimmed in place, routed pieces land in
+  `.claude/OnDemandMemory/`. `undo` puts every file back byte for byte, including a workspace
+  compiled by the pre-reorganization layout (manifest v4/v5), which `doctor` now names as such
+  and `apply`/`init` refuse ("run undo, then apply") rather than compile over it. DESIGN.md 6.10.
+- New: `apply` returns operations (copy, move, write, delete) instead of full file content for a
+  backup or a sorted move, and carries a `plan` hash plus the exact `npx -y minnimemory apply --plan
+  <hash> [target]` command; the CLI's `apply` gains `--plan <hash>` and refuses when the plan on disk no
+  longer matches. Drift (MM010) tracks only what the tool wrote: a file saved into
+  `AlwaysOnMemory/`/`OnDemandMemory/` by hand is not drift. DESIGN.md 6.11.
+- New: `doctor`/`init` take `diff: "summary"` (default over MCP) or `"full"`: the plan table plus
+  one line per file (action, path, lines added/removed), with the import rewrite and every move/
+  delete still shown in full. The CLI keeps the full diff by default. DESIGN.md 6.10.
+- New (revised 2026-09-27): on a memory folder the import is the placement decision. Every
+  stable section of an imported file is a candidate to stay, whatever its heading says;
+  "volatile" means a status heading, a changelog-shaped body or repeated status phrases, never
+  a date cited in a rule's rationale (`doctor`'s MM003 reads imported files the same way). With
+  no `--budget` every stable section stays and only volatile sections move; when nothing is
+  volatile the plan says so and names what a lower budget would save, from a real second plan.
+  A lower `--budget` is shared fairly (a file that fits an equal share stays whole, the largest
+  files split the rest) and a heading-less file over its share keeps its leading paragraphs and
+  routes the rest as `<name>__detail.md`. A single host file keeps the flat 2,000 default. The
+  first cut (a proportional share of half the sources, hint-matched headings, the lenient
+  volatility scorer) hollowed the maintainer's own rule files to frontmatter shells. DESIGN.md
+  6.10, decision 8.
+- New: the always-loaded count includes `.claude/rules/*.md` and `CLAUDE.local.md`, which Claude
+  Code also auto-loads beside the host file, alongside the user-level `~/.claude/CLAUDE.md` and
+  its imports (behind `--include-auto-memory` over MCP; always in the terminal).
+- Changed: when a project has no memory file but its auto-memory folder exists and was not
+  included, the error names the folder and the flag instead of listing places it did not look.
+- Changed: over MCP, `apply` and `undo` accept the `auto-memory` target behind
+  `--include-auto-memory`, like `doctor` and `init`; paths outside the server root come back
+  absolute, with the folder named.
+- Changed: `undo` gains `--force` (`force: true` over MCP) for a memory folder whose routed
+  files were edited since the last apply.
+- Changed (2026-09-27): `install` writes the drift hook as a direct call to the installed CLI (`node "<path>/cli.js" drift`) instead of `npx -y minnimemory drift`: about 0.3 s per prompt instead of 1.3 to 1.7 s. An existing npx entry is updated in place; re-run `install` after an upgrade. `init()`'s MCP description is one line (basic tools/list 986 -> 940 tokens). The plan's verdict line states the per-turn arithmetic: the saving on a turn with no routed file open and the extra cost on a turn with every routed file open.
+- Fixed (2026-09-27): `doctor`, `apply` and `undo` given the host file's path on a compiled workspace now read that workspace (they used to see a bare file, plan to strip its fenced list, and find nothing to undo). apply's write guard for a memory folder allows exactly the user-level host file outside the folder, not its whole directory. The MEMORY.md-as-host message points at `doctor`/`apply` on the folder. Dead write-protocol module and five unreachable exports removed. README, GUIDE and the site transcript regenerated from a real 1.0.0 run.
+- New: `minnimemory drift`, a Claude Code `UserPromptSubmit` hook that prints one short notice when
+  a memory file changed since the last `apply`, once per change, nothing when clean.
+  `minnimemory install` turns it on by default now; `--no-hook` opts out.
+- New: `minnimemory install --remove` removes the MCP registration and the drift hook `install`
+  added, leaving every other key and every other hook in Claude Code's settings untouched; every
+  successful `install` path prints the next step in one line.
+- New: the `apply` refusal on a source too small to benefit (verdict "leave"), in the CLI and
+  over MCP, shows the always-loaded token count before and after, and the break-even figure.
+- Removed: the compiler no longer adds section anchors to the OnDemandMemory list. They raised the
+  always-loaded prefix on every turn against a saving that was only ever projected, and no freshly
+  compiled workspace could produce one. Compiled output is otherwise unchanged. `doctor`'s MM014
+  stays, so a workspace compiled by an earlier version still gets told what its anchor lines cost.
+- The package ships as a minified bundle (`pkg/`) with one public declaration file. Behaviour is
+  unchanged.
+- The generated instruction block carries a one-line MinniAI copyright notice, and the LICENSE
+  gains a clause on the generated instructions. The LICENSE no longer calls itself a beta license.
+- Claude Code is the only supported host; the README no longer documents other hosts.
+- README rewritten terminal-first: install, first doctor, apply, undo, then use, commands,
+  security and license.
+
+## 1.0.0-beta.2 - 2026-09-18
+
+- `minnimemory install` registers the server with Claude Code in one command; running the bare
+  package with no TTY starts the server, so MCP hosts can launch it directly.
+- Shipped comments and strings scrubbed of internal paths; a leak check runs before every publish.
+
+## 1.0.0-beta.1 - 2026-09-17
+
+- First public release on npm.

package/LICENSE

@@ -1,39 +1,45 @@
-MinniMemoryMCP License (Beta)
-
-Copyright (c) 2026 MinniAI. All rights reserved.
-
-1. Grant. MinniAI gives you a free, non-exclusive, non-transferable, revocable
-   license to install and run this software package (the "Software"),
-   unmodified, for your own use. Use inside your own company or for your own
-   commercial projects is allowed.
-
-2. Restrictions. You may not:
-   (a) copy, redistribute, sublicense, sell, rent or host the Software for
-       others;
-   (b) modify, translate or create derivative works of the Software;
-   (c) reverse engineer, decompile or disassemble the Software, except where
-       applicable law forbids this restriction;
-   (d) remove or alter any copyright or license notice in the Software.
-
-3. Your files. The files the Software reads or writes on your machine (memory
-   files such as CLAUDE.md, the .minnimemory folder, backups) are yours.
-   MinniAI claims no rights in them. The Software makes no network calls and
-   sends nothing off your machine.
-
-4. Beta software. This is a pre-release version. Features, output and
-   behaviour may change between versions without notice.
-
-5. No warranty. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
-   KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-   Back up your files before using write features such as --allow-write.
-
-6. Limitation of liability. IN NO EVENT SHALL MINNIAI BE LIABLE FOR ANY
-   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
-   OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
-   THE USE OF OR OTHER DEALINGS IN THE SOFTWARE.
-
-7. Termination. This license ends automatically if you break any of its
-   terms. When it ends, stop using the Software and delete your copies.
-
-8. Contact. https://minniai.com
+MinniMemoryMCP License
+
+Copyright (c) 2026 MinniAI. All rights reserved.
+
+1. Grant. MinniAI gives you a free, non-exclusive, non-transferable, revocable
+   license to install and run this software package (the "Software"),
+   unmodified, for your own use. Use inside your own company or for your own
+   commercial projects is allowed.
+
+2. Restrictions. You may not:
+   (a) copy, redistribute, sublicense, sell, rent or host the Software for
+       others;
+   (b) modify, translate or create derivative works of the Software;
+   (c) reverse engineer, decompile or disassemble the Software, except where
+       applicable law forbids this restriction;
+   (d) remove or alter any copyright or license notice in the Software.
+
+3. Your files. The files the Software reads or writes on your machine (memory
+   files such as CLAUDE.md, the .minnimemory folder, backups) are yours.
+   MinniAI claims no rights in them. The Software makes no network calls and
+   sends nothing off your machine.
+
+4. Generated instructions. The instruction text, rule text and structure
+   that the Software writes into your memory files (the "Generated
+   Instructions") are MinniAI's copyrighted work. You may keep and use them
+   in memory files on machines you control, for your own or your company's
+   AI agents. You may not extract, republish, redistribute or sell the
+   Generated Instructions, include them in another product or service, or
+   use them, in whole or in part, as training or evaluation data for a
+   machine learning model.
+
+5. No warranty. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+   KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+   Back up your files before using write features such as --allow-write.
+
+6. Limitation of liability. IN NO EVENT SHALL MINNIAI BE LIABLE FOR ANY
+   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
+   OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+   THE USE OF OR OTHER DEALINGS IN THE SOFTWARE.
+
+7. Termination. This license ends automatically if you break any of its
+   terms. When it ends, stop using the Software and delete your copies.
+
+8. Contact. https://minniai.com