@iamem/amem 0.1.0

package/dist/workspace-setup.js

@@ -0,0 +1,55 @@
+import { buildContext, renderContextMarkdown } from "./context.js";
+import { insertUsageEvent } from "./db.js";
+import { metricsFromPacket } from "./estimate.js";
+import { applyProposal } from "./proposal.js";
+import { parseWorkspaceSlug } from "./repo-identity.js";
+export function provisionWorkspace(repo, platform = repo.platform || "app") {
+    const slug = parseWorkspaceSlug(repo.remote_url) ?? repo.repo_name;
+    const applied = applyProposal(repo.id, {
+        claims: [
+            {
+                id: "claim.workspace_binding",
+                kind: "structure",
+                text: `${slug} is a named amem workspace (not a git repo). Query it with workspace=${slug}. Memory stays in ~/.amem on this machine.`,
+                code_anchors: [slug],
+                source_ref: "workspace-setup",
+            },
+            {
+                id: "claim.workspace_use",
+                kind: "constraint",
+                text: `Any LLM client should retrieve amem context for workspace ${slug} before a model call, and remember durable outcomes after. Use POST /api/context and POST /api/remember, or the amem CLI.`,
+                code_anchors: [slug],
+                source_ref: "workspace-setup",
+            },
+        ],
+    });
+    const query = `What should I know about the ${slug} workspace?`;
+    const started = Date.now();
+    const packet = buildContext(repo.id, query, { rootPath: repo.root_path });
+    const markdown = renderContextMarkdown(packet);
+    const metrics = metricsFromPacket(packet, markdown);
+    insertUsageEvent({
+        repoId: repo.id,
+        platform,
+        query,
+        claimIds: metrics.claimIds,
+        anchorsCount: metrics.anchorsCount,
+        claimsCount: metrics.claimsCount,
+        packetTokens: metrics.packetTokens,
+        estimatedTokensSaved: metrics.estimatedTokensSaved,
+        localMs: Math.max(0, Date.now() - started),
+        estimatedMsSaved: metrics.estimatedMsSaved,
+        kind: metrics.kind,
+    });
+    const hay = markdown.toLowerCase();
+    const contextOk = hay.includes(slug.toLowerCase()) && hay.includes("workspace");
+    return {
+        workspace: slug,
+        seeded: applied.claims,
+        contextOk,
+        checks: [
+            `seeded ${applied.claims} starter facts`,
+            contextOk ? "context check: ok" : "context check: failed",
+        ],
+    };
+}

package/docs/agent-install-prompt.md

@@ -0,0 +1,41 @@
+# Agent install prompt (amem)
+
+Paste this into Cursor or Claude Code from inside the repository you want remembered:
+
+`````txt
+Install local personal amem memory for this repo.
+
+Privacy rules (non-negotiable):
+- Memory must stay on this machine under ~/.amem
+- Do not write memory contents into the product git history
+- Do not create PRs or shared docs that contain memory claims
+- Do not upload or sync memory anywhere
+
+Steps:
+1. Ask me whether the platform is `cursor` or `claude` (pick the agent you are).
+   Other hosts also work: windsurf | continue | aider | zed.
+2. From a checkout of the amem tool (or after npm link / global install), run:
+   ```bash
+   npm install -g .
+   # or: npm link
+   amem setup --personal
+   amem init --platform <cursor|claude>
+   amem doctor
+   amem status
+   ```
+   If amem is already on PATH, skip install and just run setup/init/doctor/status.
+3. Prefer the `amem-bootstrap` skill to seed a small baseline proposal, then:
+   ```bash
+   amem propose validate <proposal.json>
+   amem propose diff <proposal.json>
+   amem propose apply <proposal.json>
+   amem context "What should I know before changing this repository?"
+   ```
+4. Confirm in one short paragraph: platform installed, DB path, claim count, and that memory is local-only.
+5. Suggest `amem ui` — Setup scans local git repos; Memory shows pending session / miss→learn drafts (approve/dismiss), edit/pin/delete; optional login service keeps the UI on localhost after reboot.
+6. Optional: `amem init --personal` for cross-repo prefs; `amem lock` / `amem backup schedule` for encrypt-at-rest and local encrypted backups (still no cloud).
+7. Every MCP host must follow the remember contract (`amem recipe` or docs/remember-contract.md): call `amem_context` first, then `amem_remember` after durable outcomes. Do not treat a successful read as a substitute for writing.
+
+Do not echo proprietary prompting strategy into claims. Store only durable repo facts with file anchors.
+When correcting an old fact under a new claim id, use `"supersedes": ["claim.old_id"]`.
+`````

package/docs/backlog.md

@@ -0,0 +1,59 @@
+# amem backlog (next)
+
+Updated after completing the Feature Map **Later** phase (local embedding model + license/attest SKU).
+
+## Shipped recently
+
+- FTS retrieval, claim staleness, supersede/conflict
+- Session-end **draft capture** + Memory approve/dismiss
+- Memory **edit / delete / pin / search**
+- Login service on **macOS + Linux + Windows**
+- **Miss → learn** drafts after empty context lookups
+- **Claim-kind ranking** + **Why:** explainability in context packets
+- **`amem propose diff`** before apply
+- Claude Code hooks call full `amem hook` pipeline
+- **`amem setup`** / npx-ready package metadata
+- Thin installers: **Windsurf, Continue, Aider, Zed**
+- Cross-repo **personal** prefs workspace (`amem init --personal`)
+- Optional **AES-256-GCM lock/unlock** + encrypted **backup** / schedule
+- On-device **hashing embeddings** hybrid with FTS
+- Smarter multi-turn draft compaction + **`auto_apply_kinds`** policy
+- **CI + pack:check** for `npx @iamem/amem setup` (release workflow on `v*` tags; see `docs/npm-release.md`)
+- **Remember contract** — `amem recipe`, `GET /api/recipe`, MCP `amem_recipe`, Setup copy card
+- **Memory / header chrome** — lock indicator, backup status + schedule, **Personal** switcher
+- **Draft quality scoring** — confidence 0–100; reject noisy session-end drafts; Memory “Reject noisy”
+- **Conflict UI** — structured supersede suggestions; apply requires `resolve=supersede|keep` when facts overlap
+- **Savings export** — `amem usage export` / Stats JSON · markdown · PDF (proxy, not a bill)
+- **Richer host adapters** — Continue `mcpServers/amem.yaml`, Zed HTTP `url`, doctor health for continue/zed/windsurf
+- **Local n-gram embedder** — Pro/IT; no model download, no cloud API (`amem embed use ngram`)
+- **License + IT attest SKU** — vendor-signed license only; IT attest adds vault/host packet
+
+- **Auto-capture** — high-quality session-end facts apply without `amem_remember`
+- **Restore** — `amem restore --file` + vault UI path (encrypted or plaintext backup)
+- **Hygiene** — Pro: unused decay, near-duplicate merge, Memory Review inbox
+- **External embedder** — Pro: local stdin/stdout command (Ollama, llama.cpp, your script)
+- **IT pack** — `amem it-pack` + `amem doctor --sbom` (deny-default policy, MDM plist, offboard)
+- **Pin → Cursor rules** — Pro: `amem rules sync` writes `.cursor/rules/amem-pinned.mdc`
+
+## Open
+
+- First npm publish of `@iamem/amem` (org `@iamem` already exists; need valid `NPM_TOKEN` / `npm login`, then tag `v0.1.0` or `npm publish --access public`).
+- Prompt-pack before/after Stats benchmark; restore wizard polish; IT seat pack.
+- Decide one-time vs subscription (offline files cannot revoke on cancel unless you add `expires_at` and re-issue).
+- Optional vendored ONNX/MiniLM weights in a paid pack (external command is the local hook today).
+
+## Shipped (go-to-market / upsell)
+
+- Public Checkout at **getamem.com** (tryamem redirects); Stripe live webhook.
+- Mailtrap **live send** (`MAILTRAP_USE_TESTING=false`); thank-you download still works if mail fails.
+- Package renamed to `@iamem/amem` (CLI binary still `amem`); shop install copy updated.
+- UI **Apply license** (paste/drop) + **Turn on Pro retrieval** checklist.
+- Memory **retrieval showdown** (free hash vs Pro n-gram) + top-bar **Try retrieval**.
+- Remember-contract guidance: prefer durable kinds; avoid `session` spam.
+- **Hygiene auto-cleanup** — `accept-safe`, weekly OS schedule, soft paywall banner at ~200 facts / noisy dups (free preview; apply stays Pro).
+
+## Explicit non-goals (keep)
+
+- Cloud/team sync, shared org brain, hosted RAG
+- Exact Cursor/Anthropic billing integration
+- Writing memory into product git history

package/docs/enterprise-endpoint.md

@@ -0,0 +1,98 @@
+# amem enterprise endpoint (IT route)
+
+Personal memory stays on the laptop. IT governs **install, policy, attestation, and offboarding** — not a shared cloud brain.
+
+## What security review gets
+
+| Guarantee | How to verify |
+| --- | --- |
+| No telemetry | Forced `telemetry = false`; attest report |
+| No network egress from amem | Attest: `network_egress: "none"` |
+| Localhost UI only | Binds `127.0.0.1` only |
+| Memory permissions | `~/.amem` mode `0700` |
+| Secret hygiene | Builtin + policy `deny_claim_patterns` on propose |
+| Export control | `allow_export = false` in system policy |
+| Platform allowlist | `allowed_platforms` |
+| Repo allowlist | `allowed_remote_hosts` |
+| Draft auto-apply | `auto_apply_kinds` (default empty = Memory approve only) |
+| Optional at-rest encryption | User/local `amem lock` + encrypted `amem backup` (still no sync) |
+| License SKU | Vendor-signed `amem-license.json` only (`amem license apply`). Self-issued /dev unlocks are rejected. IT tier adds vault/host fields to attest |
+
+## IT pack (one folder for the security ticket)
+
+```bash
+amem it-pack --out ~/Desktop/amem-it-pack
+amem doctor --sbom --out ~/Desktop/amem-it-pack/sbom.json
+amem doctor --attest --json
+```
+
+The pack includes deny-by-default `policy.toml`, an MDM plist stub, `mdm-offboard.sh`, and a CycloneDX-lite SBOM. Signed installers still need your org’s cert — amem does not upload binaries.
+
+## Install (DevEx / IT)
+
+1. Ship a pinned amem build (internal npm, pkg, or `npm link` from a mirrored clone). Node 20+ required (`better-sqlite3`).
+2. Deploy policy:
+
+```bash
+sudo mkdir -p /etc/amem
+sudo cp templates/policy.example.toml /etc/amem/policy.toml
+sudo chmod 644 /etc/amem/policy.toml
+```
+
+3. Optional MDM: install binary + copy policy + run doctor on first login.
+4. End users typically run `amem setup` then `amem ui` (or `amem service install` for login auto-start on macOS / Linux / Windows).
+
+## Attestation (ticket attachment)
+
+```bash
+amem doctor --attest
+# machine-readable only:
+amem doctor --attest --json
+```
+
+Attach the JSON to security / IT tickets. It includes effective policy, memory path/mode, and install health.
+
+HTTP (local UI only): `GET /api/attest`
+
+## Policy knobs
+
+See [templates/policy.example.toml](../templates/policy.example.toml).
+
+| Key | Effect |
+| --- | --- |
+| `allow_export` | Blocks `amem export` when false |
+| `ui_enabled` | Blocks `amem ui` when false |
+| `allowed_platforms` | Restricts `init` / setup (cursor, claude, windsurf, …) |
+| `allowed_remote_hosts` | Restricts which git remotes can init/apply |
+| `deny_claim_patterns` | Extra regexes blocked in claim text/anchors |
+| `auto_apply_kinds` | Draft kinds that may auto-apply without Memory approve (empty = never) |
+
+Hard stops (not overridable): telemetry stays off; UI bind forced to loopback.
+
+## Local UI / MCP CORS threat model
+
+`amem ui` binds **127.0.0.1 only**. HTTP responses (including MCP) set `Access-Control-Allow-Origin: *` so local hosts (Cursor, Claude, browser tools) can call the loopback API without a special Origin.
+
+That is not a remote public API:
+
+- Nothing in `~/.amem` is uploaded or synced.
+- Binding is loopback-only — LAN/WAN clients cannot reach the UI by default.
+- Treat any process on the same machine as potentially able to call `127.0.0.1:7843` while the UI is running (same as any local MCP server).
+
+## Offboarding
+
+```bash
+amem wipe --all --yes
+```
+
+Deletes all local repos in the DB and removes `~/.amem` (memory, sessions, user policy, local backups under that home). Safe to run from MDM logout scripts — see [scripts/mdm-offboard.sh](../scripts/mdm-offboard.sh).
+
+If the DB was locked (`graph.db.enc`), wipe still removes the amem home after unlock/offboard per your runbook; prefer unlocking or wiping the whole home directory.
+
+## Support checklist
+
+- Pin Node 20+ and amem version in the internal package
+- Re-run `amem doctor --attest` after Cursor / Claude Code / host updates
+- Keep `/etc/amem/policy.toml` root-owned
+- Do not commit personal exports or encrypted backup blobs to product git history
+- Leave `auto_apply_kinds` empty unless DevEx intentionally allows low-risk kinds

package/docs/license.md

@@ -0,0 +1,54 @@
+# amem license SKU
+
+Memory still never leaves the laptop. A license only unlocks **local** extras.
+
+| Tier | What it unlocks |
+| --- | --- |
+| **free** | Memory UI, MCP, stats, backups |
+| **pro** | Local n-gram or **external** embedder, hygiene (inbox + weekly schedule + accept-safe), pin → Cursor rules |
+| **it** | Pro + richer `amem doctor --attest` packet (the exclusive). `amem it-pack` templates are available on Free. |
+
+There is no license server and no telemetry. Pro/IT requires a **vendor-signed** `amem-license.json` (Ed25519). Self-issued / `--dev` unlocks are not accepted.
+
+## Buy + apply
+
+Prices (one-time, live): **Pro $12**, **IT $49** at [getamem.com](https://getamem.com). After pay, download `amem-license.json` from the thank-you page.
+
+**Apply in the UI (recommended):** open `amem ui` → Plans or Setup → paste the JSON or choose the file → Apply license. Then **Turn on Pro retrieval** (n-gram + reindex). Memory tab has a **retrieval showdown** (free hash vs Pro n-gram).
+
+Or from a terminal:
+
+```bash
+amem license apply --file ~/Downloads/amem-license.json
+amem license status
+amem embed use ngram && amem embed reindex
+amem hygiene
+amem hygiene --accept-safe
+amem hygiene schedule
+amem rules sync
+```
+
+The published CLI has no Stripe keys. A separate **shop** process (not shipped on npm) runs Checkout and emails a signed JSON via Mailtrap. See [shop/README.md](../shop/README.md).
+
+```bash
+# seller (this repo, not published) — local only
+cd shop && npm install && npm start
+stripe listen --forward-to localhost:8788/webhook
+```
+
+Or issue one file yourself with the vendor private key (never commit it):
+
+```bash
+amem license keys --out-dir shop/.data
+AMEM_LICENSE_PRIVKEY=… amem license issue --tier pro --subject acme --out acme.json
+amem license apply --file acme.json
+```
+
+Verify uses the public key in `src/license.ts` (override with `AMEM_LICENSE_PUBKEY` in tests only).
+
+## Clear
+
+```bash
+amem license clear
+amem embed use hash
+```

package/docs/npm-release.md

@@ -0,0 +1,38 @@
+# npm release
+
+Published package: **`@iamem/amem`** (CLI binary name stays `amem`).
+
+```bash
+npx @iamem/amem setup
+# or
+npm i -g @iamem/amem && amem setup
+```
+
+Unscoped `amem` is blocked on the registry (“too similar” to existing packages). The scoped name is the supported install path.
+
+`better-sqlite3` ships its own prebuilds. Users need **Node.js 20+**. If a prebuild is missing, npm falls back to compiling (needs a C++ toolchain: Xcode CLT on macOS, `build-essential` on Debian/Ubuntu).
+
+## What CI does
+
+- `.github/workflows/ci.yml` — `npm test` + `npm run pack:check` on Node 20 and 22 (macOS + Ubuntu).
+- `.github/workflows/release.yml` — on a `v*` tag, publish to npm if `NPM_TOKEN` is set.
+
+This repo does **not** auto-publish on every push.
+
+## Release checklist
+
+1. `npm test` and `npm run pack:check` are green locally.
+2. Bump `version` in `package.json`.
+3. Commit, tag, push:
+
+   ```bash
+   git tag v0.1.0
+   git push origin main --tags
+   ```
+
+4. Ensure `NPM_TOKEN` repo secret is an Automation token with publish rights to `@iamem`.
+5. Confirm `npx @iamem/amem setup` from a folder that is not this checkout.
+
+## Pack contents
+
+`package.json#files` includes `dist`, `ui-static`, `docs`, `skills`, and `scripts/mdm-offboard.sh`. Native code is pulled in as the `better-sqlite3` dependency — do not vendor it.

package/docs/remember-contract.md

@@ -0,0 +1,42 @@
+# amem remember contract (v1)
+
+Generic MCP host recipe. Same tools for every client — do not fork per product.
+
+## Connect
+
+Keep `amem ui` running, then attach:
+
+`http://127.0.0.1:7843/mcp?workspace=<slug>`
+
+GUI hosts often cannot see Homebrew on PATH. Prefer the HTTP URL over a bare `amem` command.
+
+Print this from any machine with amem installed:
+
+```bash
+amem recipe
+# or: curl -s http://127.0.0.1:7843/api/recipe
+```
+
+Hosts can also call the `amem_recipe` MCP tool.
+
+## Tools
+
+- `amem_context` (read) — Before exploring files or sending a large prompt. Pass `workspace=<slug>`.
+- `amem_remember` (write) — After a durable outcome: a decision, constraint, owner, or gotcha that should survive this chat.
+- `amem_recipe` (meta) — If you are unsure when to read or write — fetch this contract.
+
+## Rules
+
+- Must: Call `amem_context` at the start of a task. Do not treat a successful read as a substitute for writing later.
+- Must: Call `amem_remember` when the user confirms a durable fact, or when you discover a constraint that the next session will need.
+- Must: Memory stays on this machine under `~/.amem`. Do not upload claims, paste them into shared docs, or commit them to product git.
+- Must: Never remember passwords, API keys, tokens, or private key material.
+- Must: Store repo or workspace facts with file anchors — not proprietary prompting strategy.
+- Must: Prefer kinds constraint, gotcha, structure, howto, or owner. Use kind=session only for short-lived chat takeaways — session spam drowns retrieval.
+- Must: Named workspaces are not git repos. Always pass the workspace slug on context and remember.
+
+## Example
+
+1. `amem_context` query="What should I know before changing auth?" workspace=my-app
+2. Do the work, verify files.
+3. `amem_remember` text="Auth mode is checked in src/auth.ts before Drive sync" workspace=my-app kind=constraint anchors=["src/auth.ts"]

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@iamem/amem",
+  "version": "0.1.0",
+  "description": "Local personal agent memory for Cursor and Claude Code. Private to your machine — never shared.",
+  "type": "module",
+  "bin": {
+    "amem": "dist/cli.js"
+  },
+  "main": "dist/cli.js",
+  "exports": {
+    ".": "./dist/cli.js"
+  },
+  "preferGlobal": true,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "skills",
+    "templates",
+    "docs",
+    "ui-static",
+    "scripts/mdm-offboard.sh"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepare": "npm run build",
+    "amem": "node dist/cli.js",
+    "smoke": "node scripts/smoke.mjs",
+    "pack:check": "npm run build && node scripts/check-pack.mjs",
+    "prepublishOnly": "npm test && node scripts/check-pack.mjs",
+    "test": "npm run build && node --test --test-concurrency=1 test/**/*.test.mjs",
+    "test:all": "npm run test && npm run smoke && node scripts/check-pack.mjs",
+    "shop": "node shop/server.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "agent-memory",
+    "cursor",
+    "claude-code",
+    "local",
+    "sqlite"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sslugic/amem.git"
+  },
+  "homepage": "https://github.com/sslugic/amem#readme",
+  "bugs": {
+    "url": "https://github.com/sslugic/amem/issues"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.11.1"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.15.0",
+    "typescript": "^5.8.0"
+  }
+}

package/scripts/mdm-offboard.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# IT / MDM offboarding helper — wipe personal amem data for the current user.
+set -euo pipefail
+
+AMEM_BIN="${AMEM_BIN:-amem}"
+
+if command -v "$AMEM_BIN" >/dev/null 2>&1; then
+  "$AMEM_BIN" wipe --all --yes || true
+fi
+
+# Belt-and-suspenders if the CLI was already uninstalled.
+rm -rf "${AMEM_HOME:-$HOME/.amem}"
+
+echo "amem offboard complete for ${USER:-unknown}"

package/skills/amem-bootstrap/SKILL.md

@@ -0,0 +1,83 @@
+---
+description: Seed local personal amem memory for the current repository from durable repo structure facts.
+---
+
+# amem-bootstrap
+
+Create an initial local memory proposal for this repository.
+
+## Privacy
+
+Memory is personal and stored only under `~/.amem` on this machine. Do not commit proposal files, exports, backups, or database copies to shared git remotes.
+
+## Steps
+
+1. Confirm amem is initialized:
+   ```bash
+   amem status
+   ```
+   If not initialized, ask the user which platform (`cursor`, `claude`, or another host) and run:
+   ```bash
+   amem setup --personal
+   amem init --platform <platform>
+   ```
+
+2. Inspect the repo at a high level (README, top-level dirs, obvious entrypoints). Do not dump proprietary prompt strategy into claims.
+
+3. Write a proposal JSON file (for example `/tmp/amem-bootstrap.json`) with durable facts only:
+   - `components`: major subsystems with optional `code_anchor`
+   - `flows`: important workflows
+   - `claims`: concrete facts with at least one `code_anchors` path each
+   - `edges`: link claims→flows and flows→components when useful
+
+Prefer claim kinds: `constraint`, `gotcha`, `owner`, `howto`, `structure` (avoid noisy `session` for bootstrap).
+
+Example shape:
+
+```json
+{
+  "components": [
+    { "id": "component.api", "name": "HTTP API", "code_anchor": "src/api" }
+  ],
+  "flows": [
+    { "id": "flow.request_lifecycle", "name": "Request lifecycle" }
+  ],
+  "claims": [
+    {
+      "id": "claim.api_entry",
+      "kind": "structure",
+      "text": "HTTP handlers live under src/api.",
+      "code_anchors": ["src/api"]
+    }
+  ],
+  "edges": [
+    {
+      "from_id": "claim.api_entry",
+      "from_type": "claim",
+      "to_id": "flow.request_lifecycle",
+      "to_type": "flow",
+      "kind": "about"
+    },
+    {
+      "from_id": "flow.request_lifecycle",
+      "from_type": "flow",
+      "to_id": "component.api",
+      "to_type": "component",
+      "kind": "uses"
+    }
+  ]
+}
+```
+
+When correcting a prior fact under a new claim id, include `"supersedes": ["claim.old_id"]` so the old claim is archived locally.
+
+4. Validate, preview, and apply locally:
+
+```bash
+amem propose validate /tmp/amem-bootstrap.json
+amem propose diff /tmp/amem-bootstrap.json
+amem propose apply /tmp/amem-bootstrap.json
+amem context "What should I know before changing this repository?"
+```
+
+5. Tell the user in one line that baseline local memory was applied. Mention `amem ui` → Memory for future session drafts. Do not print the full proposal unless asked.

package/skills/amem-update-working-memory/SKILL.md

@@ -0,0 +1,54 @@
+---
+description: Save durable learnings from the current session into local personal amem memory.
+---
+
+# amem-update-working-memory
+
+Extract durable engineering facts from this session and store them in local amem memory.
+
+## Privacy
+
+- Write only to the local amem database via the CLI.
+- Do not create shared docs, PRs, or commits that contain memory contents.
+- Do not store secrets, tokens, credentials, or private personal data.
+- Do not store proprietary company LLM instruction text — only durable repo facts (constraints, ownership, gotchas, workflows).
+
+After useful exploratory or implementation work that produced durable knowledge about this repository.
+
+Usage logging: every `amem context` call already records an estimated token savings event locally. If you later know a better avoided-token number from the agent UI, you may run:
+
+```bash
+amem usage report --platform <cursor|claude> --saved <n>
+```
+
+Session-end / miss→learn drafts may already be waiting in Memory (`amem ui`). Prefer approving those when they match this session; use this skill for higher-quality curated claims.
+
+## Steps
+
+1. Check binding:
+   ```bash
+   amem status
+   ```
+   If uninitialized, stop and ask the user to run `amem init` (or `amem setup`).
+
+2. Draft a small proposal JSON (prefer `/tmp/amem-update-<date>.json`) with only new or corrected durable claims. Prefer updating existing claim ids when correcting prior memory. When a new claim replaces an old one under a **new** id, set `"supersedes": ["claim.old_id"]` (or an edge with `kind: "supersedes"`) so the old claim leaves retrieval.
+
+3. Every claim must include at least one `code_anchors` path that exists in the repo. Prefer kinds `constraint`, `gotcha`, `owner`, `howto`, `structure`. If validate prints **conflict warnings** (shared anchors + similar text), resolve them with `supersedes` or by updating the existing id.
+
+4. Validate, preview, and apply:
+
+```bash
+amem propose validate /tmp/amem-update-<date>.json
+amem propose diff /tmp/amem-update-<date>.json
+amem propose apply /tmp/amem-update-<date>.json
+```
+
+5. Optionally verify:
+
+```bash
+amem context "<short keywords from the new claims>"
+```
+
+Confirm the packet shows **Why:** ranking factors and that new claims appear.
+
+6. Reply briefly with how many claims/flows/components were saved. Keep claim text out of chat unless the user asks.

package/templates/cursor-rule.mdc

@@ -0,0 +1,23 @@
+---
+description: Use local personal amem memory before broad codebase exploration
+globs:
+alwaysApply: true
+---
+
+<!-- Generated by amem. Safe to commit: contains no memory contents. -->
+
+# amem local memory
+
+amem injects matching local memory into Cursor automatically (session start + each prompt). Treat that packet as the first map of this repo.
+
+1. Prefer amem file anchors over broad greps and multi-folder reads.
+2. Still verify current code before editing — memory can be stale. Trust **fresh** claims more; re-check anything marked **stale**.
+3. Use the **Why:** line as ranking explainability, not as proof.
+4. After durable learnings, the stop hook queues a compact **session draft** (and may queue **miss→learn** drafts). Approve in `amem ui` → Memory, or run `amem-update-working-memory` for higher-quality facts.
+5. Cross-repo personal prefs may appear with Why reason `personal` — they are local “how I work” notes, not org wiki.
+
+Do not re-run `amem context` unless the injected packet is empty or clearly wrong.
+
+Memory is personal and stored under `~/.amem` on this machine. Do not commit exports, backups, or database copies to shared remotes.
+
+Open the local UI anytime with `amem ui` (Setup, Memory drafts, Stats).

package/templates/mdm/co.amem.managed.plist

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>PayloadDisplayName</key>
+  <string>amem local memory (IT)</string>
+  <key>PayloadIdentifier</key>
+  <string>co.amem.managed</string>
+  <key>PayloadType</key>
+  <string>Configuration</string>
+  <key>PayloadUUID</key>
+  <string>a1e00000-0000-4000-8000-000000000001</string>
+  <key>PayloadVersion</key>
+  <integer>1</integer>
+  <key>PayloadOrganization</key>
+  <string>Your org — wrap this in MDM; amem never phones home</string>
+  <key>PayloadContent</key>
+  <array>
+    <dict>
+      <key>PayloadType</key>
+      <string>com.apple.ManagedClient.preferences</string>
+      <key>PayloadIdentifier</key>
+      <string>co.amem.managed.policy</string>
+      <key>PayloadUUID</key>
+      <string>a1e00000-0000-4000-8000-000000000002</string>
+      <key>PayloadEnabled</key>
+      <true/>
+      <key>PayloadDisplayName</key>
+      <string>Deploy /etc/amem/policy.toml via your MDM file payload</string>
+    </dict>
+  </array>
+</dict>
+</plist>