@duetso/agent 0.2.5 → 0.3.0

package/README.md

@@ -56,7 +56,7 @@ Two things that don't get a section of their own below, but that follow from the
 
 ### Memory, woven in
 
-Memory and compaction are the same primitive: observational memory _is_ how context survives between turns. The runner observes its own transcript, reflects when observations grow, and writes durable rows to PGlite — text observations for messages and images alike, so screenshots and UI captures stay recallable on later turns without re-attaching bytes. Each turn's prompt prefix is a frozen two-layer pack (long-term cross-session memory + this session's compaction summary), rebuilt only at compaction events so the provider's prompt cache survives turn-over-turn. Anything that didn't make the pack stays reachable through `recall_memory` — hybrid retrieval over pgvector cosine similarity and tsvector keyword search, fused via Reciprocal Rank Fusion, with optional paraphrased query expansion. Embeddings run in a background worker so foreground turns never block.
+Memory and compaction are the same primitive: observational memory _is_ how context survives between turns. The runner observes its own transcript, reflects when observations grow, and writes durable rows to PGlite — text observations for messages and images alike, so screenshots and UI captures stay recallable on later turns without re-attaching bytes. Each turn's prompt prefix is frozen between deliberate refresh points: curated memory files load from the project ancestry at session start or explicit skills reload, while long-term and current-session observations rebuild at compaction events. That separation keeps trained knowledge deterministic, prevents it from displacing observational memory, and preserves the provider's prompt cache turn-over-turn. Database observations outside the frozen prefix stay reachable through `recall_memory` — hybrid retrieval over pgvector cosine similarity and tsvector keyword search, fused via Reciprocal Rank Fusion, with optional paraphrased query expansion. Embeddings run in a background worker so foreground turns never block.
 
 ### Relays: keep the agent working until the job is done
 
@@ -245,6 +245,9 @@ bun run test         # runs the test suite inside Docker
 
 Use `bun run test` and `bun run eval`, not raw `bun test`, as the source of truth. File-writing tests and evals run in Docker so focused host runs cannot create `.duet`, PGlite databases, or home-directory skill fixtures in the checkout.
 
+Paid evaluation infrastructure and its separate verification commands live in
+the [SWE-bench benchmark](benchmarks/swebench/README.md).
+
 The pre-commit hook runs `format`, `check-types`, and `lint`.
 
 </details>
@@ -385,16 +388,16 @@ All three share one **canonical memory JSON object** (`--json`), so a consumer p
 
 - Timestamps are ISO 8601 strings (e.g. `2026-07-06T00:00:00.000Z`); date-only fields (`observedDate`, `referencedDate`) stay `YYYY-MM-DD`.
 - `source` is a flat string — one of `user | agent | system | api | import` (`system` is the training-origin value).
-- `sessionId` is the session that authored the row: writable on `add` via `--session <id>`, filterable on `memory`/`recall` via `--session`, and echoed on output (absent on legacy rows).
-- Two ranking scores are always named explicitly, never a generic `score`: `packScore` (recency × priority × kind bias, present everywhere) and `relevanceScore` (query-relevance, RRF-fused — present only in `memory recall` results).
+- `sessionId` is the session that authored an observational row: writable on DB-backed `add`, filterable on `memory`/`recall`, and echoed on DB output (absent on legacy rows and file memories).
+- Observational JSON names both ranking axes explicitly: `packScore` (recency × priority × kind bias) and `relevanceScore` (query relevance, present only in `memory recall`). File-store JSON reports its slug and store path instead because those records are inherited context, not ranked recall rows.
 
 Command-specific notes:
 
 - **`duet memory` (query):** `--json` emits a bare array ordered by pack score; `--source` and `--session` narrow the set alongside `--type`, `--priority`, `--from`, and `--to`.
 - **`duet memory recall`:** query text comes from `--query <q>` or positional args. `--scope session|global` requires `--session <id>` to compare against; `all` (default) ignores it. `--json` emits a bare array ordered best-first, each row carrying both `packScore` and `relevanceScore`.
-- **`duet memory add`:** added rows are always `note` kind. `--source` defaults to `user`; `--session <id>` stamps the row (omit to leave it global). Content comes from positional args or stdin, and empty input is a usage error. `--json` emits one canonical object (`packScore` and `lastUsedAt` present, `relevanceScore` absent).
+- **`duet memory add`:** added memories are always `note` kind. Flagless writes go to the nearest ancestor `.agents/memories`; pass `--db` to retain observational-row ranking, embedding, and session attribution. Content comes from positional args or stdin, and empty input is a usage error.
 
-Every memory command accepts `--db <absolute-path>` (default `~/.duet/memory.db`) and `--wait <seconds>` (lock-wait budget, default 30; `0` fails immediately). Exit codes are stable for scripting: `0` success, `64` usage or validation error (unknown flag, bad value, empty input), `75` memory-DB lock-wait budget exhausted, and `1` for anything else.
+DB-backed memory commands accept `--db <absolute-path>` and `--wait <seconds>`. `memory add` also accepts a single `--store`; `memory recall` deliberately rejects stores because file memories are already loaded into agent context. Exit codes are stable for scripting: `0` success, `64` usage or validation error, `75` memory-DB lock-wait budget exhausted, and `1` for anything else.
 
 </details>
 
@@ -403,21 +406,21 @@ Every memory command accepts `--db <absolute-path>` (default `~/.duet/memory.db`
 
 `duet train <folder>` launches a sub-agent inside the folder, lets it read whatever is there with its native tools (markdown, CSVs, PDFs, spreadsheets, screenshots, source — anything the agent can open), and produces two artifacts:
 
-- **One high-priority manual (user-curated) row** in `~/.duet/memory.db`, tagged `train` and `train:<slug>`. Fresh `duet` sessions load it into their initial memory pack with a ranking boost (via `manualBias`), and writing it as a `manual` row means `duet memory reflect` never compacts it away.
-- **`~/.duet/train/<memory-id>/`** — a hidden archive: a copy of every source file plus a `manifest.json`. Provenance only; the DB row is the source of truth. Deleting the memory via `duet memory` removes the archive too.
+- **One inherited markdown memory** in the nearest ancestor `.agents/memories` store. Explicit `--store` selects a different file store; explicit `--db` retains the legacy high-priority manual-row behavior.
+- **`~/.duet/train/<memory-id>/`** — a hidden archive containing source copies and private provenance. Shareable memory frontmatter references the archive id but never embeds the absolute source folder.
 
 ```bash
-duet train ./snowflake-notes              # writes to ~/.duet/memory.db
+duet train ./snowflake-notes              # writes to the nearest .agents/memories
 duet train ./snowflake-notes --slug snow  # custom slug (default: folder basename)
 duet train ./snowflake-notes --model opus-4.8
 duet train ./snowflake-notes --db /tmp/scratch.db  # write to a throwaway DB instead
 ```
 
-Re-running `train` on the same slug **replaces** the prior row and its archive — there is at most one `train:<slug>` observation at a time.
+Re-running `train` on the same slug **replaces** the prior entry and its archive in the selected backend.
 
 Three things to know:
 
-- **The current session won't see the new memory.** Memory loads at session start. Start a fresh `duet` session to test recall.
+- **The current session won't watch the new memory file.** It appears in a fresh `duet` session, or after a programmatic `reloadSkills()` refreshes disk-backed context.
 - **Synthesis needs an API key.** `DUET_API_KEY` (recommended), or any of the provider keys covered above.
 - **The corpus folder's `.env` is loaded** (so a project folder can supply its own provider credentials). Check folders you didn't author before training them.
 
@@ -539,7 +542,7 @@ The parent runner transcript stays linear across the lifecycle. State-machine co
 
 `TurnRunner` owns memory at runtime. It holds a `MemoryStore` in process, hydrates durable observations from PGlite before the first turn, and subscribes to memory-store events to write future observation changes. After each pi-agent run, the runner observes the latest unobserved transcript suffix, reflects oversized observation logs, emits memory events with generated observation payloads, and waits for durable writes before continuing. Raw conversation messages stay in `TurnState.agent.messages`; memory persistence stores only derived observations/reflections.
 
-The rendered memory section above the message tail is a _frozen_ two-layer pack — long-term cross-session memory ranked into an 8k-token budget and the current session's chronological compaction summary. The pack is rebuilt only at compaction events (initial load, reflector completion, wire-shaping eviction) so observations the observer writes mid-session do not invalidate the prompt cache. The model can still pull specific facts on demand through the default `recall_memory` tool, which runs hybrid vector + keyword search over the same database with optional query expansion.
+The rendered memory section above the message tail is a frozen pack with two independent sources. Curated memory files discovered from the working directory's project ancestry are pinned first and refreshed only at session start or explicit skills reload. Database-backed memory follows as ranked cross-session observations and the current session's chronological compaction summary; those layers rebuild only at compaction events so ordinary observer writes do not invalidate the prompt cache. File memory never enters database ranking, reflection, usage-bump, or recall paths. The model can still pull non-pinned database facts on demand through the default `recall_memory` tool, which runs hybrid vector + keyword search with optional query expansion.
 
 ```typescript
 import { TurnRunner } from "@duetso/agent";
@@ -550,7 +553,7 @@ const turnRunner = new TurnRunner({
 });
 ```
 
-By default, both `duet` (TUI/run) and `duet --rpc` store durable observations in `~/.duet/memory.db`. Override the path with `--db <path>` (the flag is accepted in both modes and is ignored when `--incognito` is also set), or run with `--incognito` (or `-i`) to set `memoryDbPath: false`, which disables observational memory and compaction for that session. `duet --rpc` bypasses `SessionManager`, so it has no session of its own; pass `duet --rpc --session <id>` to attribute every observation written during the RPC process to a caller-owned session (one RPC process is one logical session). Omit it to leave those writes unattributed. Programmatic callers can pass `memoryDbPath: false` or provide a custom `memoryDbPath`. The CLI's `SessionManager` is a convenience layer that stores session snapshots under `~/.duet/sessions`, but the runner owns memory hydration, pi-turn observation/reflection, compaction, and observation persistence.
+By default, both `duet` (TUI/run) and `duet --rpc` store durable observations in `~/.duet/memory.db`. Override the path with `--db <path>` (the flag is accepted in both modes and is ignored when `--incognito` is also set), or run with `--incognito` (or `-i`) to disable both observational database memory and curated file memory for that session. `duet --rpc` bypasses `SessionManager`, so it has no session of its own; pass `duet --rpc --session <id>` to attribute every observation written during the RPC process to a caller-owned session (one RPC process is one logical session). Omit it to leave those writes unattributed. Programmatic callers can control the two sources independently with `memoryDbPath` and `memoryStores`. The CLI's `SessionManager` is a convenience layer that stores session snapshots under `~/.duet/sessions`, but the runner owns memory hydration, pi-turn observation/reflection, compaction, and observation persistence.
 
 > [!WARNING]
 > We strongly recommend running with a `memoryDbPath` (the default). Compaction is implemented as part of the observational memory pipeline: raw transcript content is replaced by observations/reflections that the observer and reflector write to the durable store. Without a database, the runner skips that pipeline entirely — there is no compaction, the transcript grows unbounded against the raw model context window, and long sessions will eventually hit a provider context-length error. `memoryDbPath: false` is appropriate for short-lived scripts, tests, and incognito runs that stay well under the model window.

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@duetso/agent",
-    "version": "0.2.5",
+    "version": "0.3.0",
     "description": "An opinionated full-stack agent turn runner with native memories, interrupts, and multi-agent orchestration",
     "keywords": [
         "agent",
@@ -32,6 +32,10 @@
             "types": "./dist/src/index.d.ts",
             "import": "./dist/src/index.js"
         },
+        "./memory-store": {
+            "types": "./dist/src/memory/store/index.d.ts",
+            "import": "./dist/src/memory-store.js"
+        },
         "./package.json": "./package.json"
     },
     "publishConfig": {
@@ -39,11 +43,11 @@
     },
     "scripts": {
         "setup": "bash scripts/setup-docker.sh",
-        "build": "tsc",
+        "build": "tsc && bun build src/memory/store/index.ts --target node --format esm --outfile dist/src/memory-store.js",
         "check-types": "tsc --noEmit",
         "cli": "bun src/cli.ts",
         "dev": "tsc --watch",
-        "eval": "docker run --rm -v \"$PWD:/src:ro\" -w /work -e HOME=/tmp/home -e DUET_TEST_IN_DOCKER=1 -e DUET_API_KEY -e ANTHROPIC_API_KEY -e OPENAI_API_KEY -e EVAL_MODEL -e JUDGE_MODEL -e COVERAGE_THRESHOLD oven/bun:1.3.11 sh -lc 'cp -R /src/. /work && bun install --frozen-lockfile && bun test ./evals/*.eval.ts'",
+        "eval": "docker run --rm -v \"$PWD:/src:ro\" -w /work -e HOME=/tmp/home -e DUET_TEST_IN_DOCKER=1 -e DUET_API_KEY -e ANTHROPIC_API_KEY -e OPENAI_API_KEY -e EVAL_MODEL -e EVAL_ADVISOR_THINKING -e JUDGE_MODEL -e COVERAGE_THRESHOLD oven/bun:1.3.11 sh -lc 'cp -R /src/. /work && bun install --frozen-lockfile && bun test ./evals/*.eval.ts'",
         "format": "oxfmt --write --no-error-on-unmatched-pattern",
         "format:check": "oxfmt --check --no-error-on-unmatched-pattern",
         "lint": "oxlint src/",
@@ -51,6 +55,7 @@
         "test": "docker run --rm -v \"$PWD:/src:ro\" -w /work -e HOME=/tmp/home -e DUET_TEST_IN_DOCKER=1 oven/bun:1.3.11 sh -lc 'apt-get update -qq && apt-get install -y -qq git >/dev/null && cp -R /src/. /work && bun install --frozen-lockfile && bun test ./test/*.test.ts'",
         "test:swebench": "bash benchmarks/swebench/test.sh",
         "example": "bun examples/basic.ts",
+        "example:memory-store": "bun examples/memory-store.ts",
         "example:state-machine": "bun examples/state-machine.ts",
         "example:tui-playground": "bun examples/tui-playground.ts",
         "prepare": "husky",

package/dist/src/cli/help.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../../src/cli/help.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,IAAI,CAAC;AAEjD,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CA6FtD;AAED,wBAAgB,cAAc,IAAI,IAAI,CAqBrC;AAED,wBAAgB,YAAY,IAAI,IAAI,CAsBnC;AAED,wBAAgB,eAAe,IAAI,IAAI,CAqBtC;AAED,wBAAgB,eAAe,IAAI,IAAI,CA4DtC;AAED,wBAAgB,kBAAkB,IAAI,IAAI,CA8BzC;AAED,wBAAgB,qBAAqB,IAAI,IAAI,CAwC5C;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAuC7C;AAED,wBAAgB,cAAc,IAAI,IAAI,CAsCrC;AAED,wBAAgB,cAAc,IAAI,IAAI,CAgErC;AAED,wBAAgB,qBAAqB,IAAI,IAAI,CAiB5C;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAe1D"}
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../../src/cli/help.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,IAAI,CAAC;AAEjD,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CA6FtD;AAED,wBAAgB,cAAc,IAAI,IAAI,CAqBrC;AAED,wBAAgB,YAAY,IAAI,IAAI,CAsBnC;AAED,wBAAgB,eAAe,IAAI,IAAI,CAqBtC;AAED,wBAAgB,eAAe,IAAI,IAAI,CA4DtC;AAED,wBAAgB,kBAAkB,IAAI,IAAI,CAgCzC;AAED,wBAAgB,qBAAqB,IAAI,IAAI,CA0C5C;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAuC7C;AAED,wBAAgB,cAAc,IAAI,IAAI,CAsCrC;AAED,wBAAgB,cAAc,IAAI,IAAI,CA0ErC;AAED,wBAAgB,qBAAqB,IAAI,IAAI,CAiB5C;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAe1D"}

package/dist/src/cli/help.js

@@ -233,14 +233,14 @@ export function printMemoryAddHelp() {
 duet memory add — Write a single user-added note memory
 
 USAGE
-  duet memory add [options] <content>
-  echo "<content>" | duet memory add [options]
+  duet memory add [options] [--store <folder> | --db <file>] <content>
+  echo "<content>" | duet memory add [options] [--store <folder> | --db <file>]
 
 DESCRIPTION
-  Stores a note memory into the same ~/.duet/memory.db the runner reads, so
-  it surfaces in the next session. Notes get a small ranking bump above
-  reflections (far below a 'duet train' corpus) and stay eligible for
-  'duet memory reflect' compaction, folding like any observation once aged.
+  Stores a note in exactly one backend. With no backend flag, the note is
+  written to the nearest ancestor .agents/memories directory (created on
+  demand). --store writes a markdown memory file; --db retains the legacy
+  observational-row behavior. Passing more than one backend is a usage error.
 
   Content comes from the positional arguments, or from stdin when none are
   given so longer memories can be piped in.
@@ -251,9 +251,11 @@ OPTIONS
   --session <id>           Stamp the row's authoring session; omit to leave it
                            global/unattributed
   --tag <tag>              Attach a label; repeat to add several
-  --db <path>              Memory database path (default: ~/.duet/memory.db)
-  --json                   Emit the stored memory as one canonical JSON object
-                           (with packScore) instead of the confirmation line
+  --store <folder>         Memory-file directory to write
+  --db <file>              PGlite file to write instead of a memory store
+  --json                   Emit the stored memory as JSON instead of the
+                           confirmation line (DB rows include packScore;
+                           file rows include slug + store provenance)
   --wait <seconds>         Seconds to wait for the cross-process open-lock
                            (default: 30; 0 fails immediately)
   -h, --help               Show this help
@@ -295,6 +297,8 @@ OPTIONS
   --json                   Emit a bare JSON array of canonical memory objects
                            (best-first) with packScore + relevanceScore
   --db <path>              Memory database path (default: ~/.duet/memory.db)
+                           This command is DB-only; --store is rejected because
+                           store memories are already loaded into agent context
   --wait <seconds>         Seconds to wait for the cross-process open-lock
                            (default: 30; 0 fails immediately)
   -h, --help               Show this help
@@ -384,11 +388,13 @@ export function printTrainHelp() {
 duet train — Ingest a project corpus into one durable memory observation
 
 USAGE
-  duet train <folder> [--slug <name>] [--model <name>] [--db <path>] [--wait <seconds>]
-  duet train list [--db <path>] [--json] [--wait <seconds>]
-  duet train show <slug> [--db <path>] [--json] [--wait <seconds>]
-  duet train update <slug> --content-file <path> [--db <path>] [--json] [--wait <seconds>]
-  duet train delete <slug> [--db <path>] [--json] [--wait <seconds>]
+  duet train <folder> [--slug <name>] [--model <name>]
+             [--store <folder> | --db <file>] [--wait <seconds>]
+  duet train list [--store <folder>]... [--db <file>]... [--json] [--wait <seconds>]
+  duet train show <slug> [--store <folder>]... [--db <file>]... [--json] [--wait <seconds>]
+  duet train update <slug> --content-file <path>
+             [--store <folder>]... [--db <file>]... [--json] [--wait <seconds>]
+  duet train delete <slug> [--store <folder>]... [--db <file>]... [--json] [--wait <seconds>]
 
 DESCRIPTION
   Launches a duet agent with the corpus folder as its working directory.
@@ -399,15 +405,23 @@ DESCRIPTION
 
     .duet-train.json  — structured handoff with headline + observation.
 
-  'train' then persists the synthesis into ~/.duet/memory.db as a manual
-  (user-curated) row (tagged 'train' and 'train:<slug>'), archives the
-  corpus under ~/.duet/train/<memory-id>/, removes the handoff file, and
-  prints the observation content to stdout so what you see is what landed
-  in memory.
+  'train' then persists the synthesis into exactly one backend and archives
+  the corpus under ~/.duet/train/<memory-id>/. With no backend flag it writes
+  a markdown file under the nearest ancestor .agents/memories directory,
+  creating that directory when needed. --db retains the legacy manual-row
+  behavior. Passing more than one backend to create is a usage error.
+
+  Reads accept repeatable --store and --db flags. Any explicit backend flags
+  replace discovery; stores are consulted in flag order before DBs. Without
+  flags, reads union inherited stores from cwd toward the filesystem root,
+  then ~/.duet/memory.db. Duplicate slugs resolve to the first source, while
+  surviving entries are listed newest-first. show/update/delete use that same
+  first-source precedence.
 
   The management subcommands all key on the user-facing <slug> (resolved
   to the underlying row internally):
-    list    — every training (one row per slug), joined to its archive
+    list    — every visible store entry or DB training (one row per slug),
+              joined to its archive
               manifest to show slug, headline, model, file count, date,
               and memory id.
     show    — the same metadata plus the full synthesized observation text
@@ -419,17 +433,17 @@ DESCRIPTION
     delete  — permanently remove the row and its corpus archive.
   Pass --json to any of them for machine-readable output.
 
-  Subsequent runs against the same slug replace the prior row in place,
-  so the memory pool does not bloat. Writing the row as a manual row
-  earns it a ranking boost in the memory pack (via manualBias) and exempts
-  it from 'duet memory reflect' compaction; deleting it via 'duet memory'
-  also removes its archive. Note: train loads the corpus folder's .env (for provider
-  credentials), so check folders you did not author before training.
+  Subsequent runs against the same slug replace the prior target entry, so
+  the memory pool does not bloat. On --db, the legacy manual row keeps its
+  ranking boost and reflection exemption. Note: train loads the corpus
+  folder's .env (for provider credentials), so check folders you did not
+  author before training.
 
 OPTIONS
   --slug <name>            Override the corpus slug (default: sanitized folder basename)
   --model <name>           Model used by the synthesis sub-agent (default: same resolution as 'duet run')
-  --db <path>              Memory database path (default: ~/.duet/memory.db)
+  --store <folder>         Memory-file directory; repeat on read/manage commands
+  --db <file>              PGlite path; repeat on read/manage commands
   --wait <seconds>         Seconds to wait for the cross-process open-lock
                            (default: 30; 0 fails immediately)
   -h, --help               Show this help

package/dist/src/cli/help.js.map

@@ -1 +1 @@
-{"version":3,"file":"help.js","sourceRoot":"","sources":["../../../src/cli/help.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAExE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,CAAC;AAEjD,MAAM,UAAU,YAAY,CAAC,WAAmB;IAC9C,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;gDAuBkC,WAAW;;;;;;;;;;;;;gHAaqD,+BAA+B;;;;;oFAK3D,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDxG,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;wEAY0D,qBAAqB;;;;;;;CAO5F,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,YAAY;IAC1B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;yDAa2C,qBAAqB;;;;;;IAM1E,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC;CAChC,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;CAmBb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Db,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,kBAAkB;IAChC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Bb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,sBAAsB;IACpC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Db,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;CAeb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,WAAmB;IAClD,OAAO,CAAC,GAAG,CAAC;oCACsB,WAAW;;;;;;;;;;;;CAY9C,CAAC,CAAC;AACH,CAAC"}
+{"version":3,"file":"help.js","sourceRoot":"","sources":["../../../src/cli/help.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAExE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,CAAC;AAEjD,MAAM,UAAU,YAAY,CAAC,WAAmB;IAC9C,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;gDAuBkC,WAAW;;;;;;;;;;;;;gHAaqD,+BAA+B;;;;;oFAK3D,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDxG,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;wEAY0D,qBAAqB;;;;;;;CAO5F,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,YAAY;IAC1B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;yDAa2C,qBAAqB;;;;;;IAM1E,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC;CAChC,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;CAmBb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Db,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,kBAAkB;IAChC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Bb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,sBAAsB;IACpC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwEb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;CAeb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,WAAmB;IAClD,OAAO,CAAC,GAAG,CAAC;oCACsB,WAAW;;;;;;;;;;;;CAY9C,CAAC,CAAC;AACH,CAAC"}

package/dist/src/cli/memory-add.d.ts

@@ -1,7 +1,11 @@
 import { type EmbedFn } from "../memory/embedding.js";
+import { type MemorySourceFlags } from "../memory/store/sources.js";
 import type { ObservationPriority, ObservationSource } from "../types/memory.js";
 type SourceKind = ObservationSource["kind"];
 interface AddCommandOptions {
+    /** Explicit backend flags; empty means flagless store discovery. */
+    sourceFlags: MemorySourceFlags;
+    /** Compatibility projection for callers that inspect a single selected DB. */
     dbPath: string;
     /** Positional content joined with spaces; empty when the caller pipes via stdin instead. */
     content: string;
@@ -11,7 +15,7 @@ interface AddCommandOptions {
     tags: string[];
     /** Session that authored the row; omitted leaves the row global/unattributed. */
     sessionId?: string;
-    /** Emit one canonical memory JSON object instead of the human line. */
+    /** Emit the selected backend's JSON record instead of the human line. */
     json: boolean;
     waitBudgetMs?: number;
 }
@@ -20,6 +24,8 @@ interface AddCommandIO {
     stdin: NodeJS.ReadableStream & {
         isTTY?: boolean;
     };
+    /** Working directory used for relative paths and flagless source discovery. */
+    cwd?: string;
     /**
      * Embedding client for the synchronous insert-time embed. Defaults to
      * the Duet endpoint client; tests inject a stub (or a throwing one) to
@@ -28,21 +34,20 @@ interface AddCommandIO {
     embed?: EmbedFn;
 }
 /**
- * Run `duet memory add` — write a single user-added note row into the same
- * `~/.duet/memory.db` the runner reads from, so it surfaces in the next
- * session. Stored as `kind: "note"` with no `sessionId`, so it lands in the
- * cross-session global pack with a small `noteBias` bump (above reflections,
- * far below a `duet train` corpus) and stays eligible for `duet memory
- * reflect` compaction, folding like any other observation once aged.
+ * Run `duet memory add` — write one curated note to a memory-file store or
+ * the legacy observational DB. Flagless writes create the nearest agent's
+ * `.agents/memories` directory. DB notes retain their ranking, reflection,
+ * session-attribution, and synchronous-embedding behavior; file notes retain
+ * priority/source/tags in frontmatter and are loaded through store context.
  *
  * Content comes from the positional arguments, or from stdin when none are
  * given so callers can pipe longer text (`echo "…" | duet memory add`).
  *
- * The embedding is written synchronously alongside the row (no backfill
- * worker runs in this one-shot process), so `duet memory recall` and the
- * next session's `recall_memory` reach it semantically right away. When
- * embeddings are unavailable the add still succeeds and the next runner's
- * backfill pass embeds the row.
+ * For DB targets, the embedding is written synchronously alongside the row
+ * (no backfill worker runs in this one-shot process), so `duet memory recall`
+ * and the next session's `recall_memory` reach it semantically right away.
+ * When embeddings are unavailable the add still succeeds and the next
+ * runner's backfill pass embeds the row.
  */
 export declare function runMemoryAddCommand(args: string[], io?: AddCommandIO): Promise<void>;
 /**
@@ -50,6 +55,6 @@ export declare function runMemoryAddCommand(args: string[], io?: AddCommandIO):
  * when `--help` was handled. Pure (no I/O) so it can be unit-tested; stdin
  * fallback for empty content happens later in {@link resolveContent}.
  */
-export declare function parseMemoryAddArgs(args: string[]): AddCommandOptions | undefined;
+export declare function parseMemoryAddArgs(args: string[], cwd?: string): AddCommandOptions | undefined;
 export {};
 //# sourceMappingURL=memory-add.d.ts.map

package/dist/src/cli/memory-add.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-add.d.ts","sourceRoot":"","sources":["../../../src/cli/memory-add.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAG7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAOjF,KAAK,UAAU,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;AAE5C,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,4FAA4F;IAC5F,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,yEAAyE;IACzE,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,iFAAiF;IACjF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC,cAAc,GAAG;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IACnD;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EAAE,EACd,EAAE,GAAE,YAA+D,GAClE,OAAO,CAAC,IAAI,CAAC,CA0Cf;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,iBAAiB,GAAG,SAAS,CA+DhF"}
+{"version":3,"file":"memory-add.d.ts","sourceRoot":"","sources":["../../../src/cli/memory-add.ts"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAG7E,OAAO,EAAkB,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAGpF,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAYjF,KAAK,UAAU,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;AAE5C,UAAU,iBAAiB;IACzB,oEAAoE;IACpE,WAAW,EAAE,iBAAiB,CAAC;IAC/B,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;IACf,4FAA4F;IAC5F,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,yEAAyE;IACzE,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,iFAAiF;IACjF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC,cAAc,GAAG;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IACnD,+EAA+E;IAC/E,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EAAE,EACd,EAAE,GAAE,YAA+D,GAClE,OAAO,CAAC,IAAI,CAAC,CAkDf;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,GAAE,MAAsB,GAC1B,iBAAiB,GAAG,SAAS,CAiE/B"}

package/dist/src/cli/memory-add.js

@@ -1,35 +1,48 @@
+import { randomBytes } from "node:crypto";
 import { createEmbeddingClient } from "../memory/embedding.js";
+import { createMemoryId } from "../memory/id.js";
+import { listStore, writeEntry } from "../memory/store/store.js";
+import { resolveSources } from "../memory/store/sources.js";
 import { appendObservation } from "../memory/storage.js";
 import { DEFAULT_MEMORY_DB_PATH } from "../session/session-manager.js";
 import { printMemoryAddHelp } from "./help.js";
 import { toMemoryJson } from "./memory-json.js";
 import { scoreObservation, withMemorySession } from "./memory-db.js";
 import { PRIORITIES, parseEnum, SOURCES } from "./memory-query.js";
-import { fail, resolveUserPath, usageError } from "./shared.js";
+import { lexMemorySourceFlags, requireSingleExplicitWriteTarget, requireWriteTarget, } from "./memory-sources.js";
+import { fail, usageError } from "./shared.js";
 /**
- * Run `duet memory add` — write a single user-added note row into the same
- * `~/.duet/memory.db` the runner reads from, so it surfaces in the next
- * session. Stored as `kind: "note"` with no `sessionId`, so it lands in the
- * cross-session global pack with a small `noteBias` bump (above reflections,
- * far below a `duet train` corpus) and stays eligible for `duet memory
- * reflect` compaction, folding like any other observation once aged.
+ * Run `duet memory add` — write one curated note to a memory-file store or
+ * the legacy observational DB. Flagless writes create the nearest agent's
+ * `.agents/memories` directory. DB notes retain their ranking, reflection,
+ * session-attribution, and synchronous-embedding behavior; file notes retain
+ * priority/source/tags in frontmatter and are loaded through store context.
  *
  * Content comes from the positional arguments, or from stdin when none are
  * given so callers can pipe longer text (`echo "…" | duet memory add`).
  *
- * The embedding is written synchronously alongside the row (no backfill
- * worker runs in this one-shot process), so `duet memory recall` and the
- * next session's `recall_memory` reach it semantically right away. When
- * embeddings are unavailable the add still succeeds and the next runner's
- * backfill pass embeds the row.
+ * For DB targets, the embedding is written synchronously alongside the row
+ * (no backfill worker runs in this one-shot process), so `duet memory recall`
+ * and the next session's `recall_memory` reach it semantically right away.
+ * When embeddings are unavailable the add still succeeds and the next
+ * runner's backfill pass embeds the row.
  */
 export async function runMemoryAddCommand(args, io = { stdout: process.stdout, stdin: process.stdin }) {
-    const options = parseMemoryAddArgs(args);
+    const cwd = io.cwd ?? process.cwd();
+    const options = parseMemoryAddArgs(args, cwd);
     if (!options)
         return;
     const content = await resolveContent(options.content, io);
+    const sources = await resolveSources(options.sourceFlags, cwd);
+    const writeTarget = requireWriteTarget(sources);
+    if (writeTarget.kind === "store") {
+        if (options.sessionId)
+            usageError("--session is only supported with --db <file>.");
+        await writeStoreNote(writeTarget.path, content, options, io);
+        return;
+    }
     const embed = io.embed ?? createEmbeddingClient();
-    const observation = await withMemorySession(options.dbPath, (session) => appendObservation(session, {
+    const observation = await withMemorySession(writeTarget.path, (session) => appendObservation(session, {
         kind: "note",
         priority: options.priority,
         source: { kind: options.source },
@@ -39,7 +52,7 @@ export async function runMemoryAddCommand(args, io = { stdout: process.stdout, s
         ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
     }, { embed }), { waitBudgetMs: options.waitBudgetMs });
     if (!observation) {
-        fail(`Could not write memory to ${options.dbPath} (lock contention).`);
+        fail(`Could not write memory to ${writeTarget.path} (lock contention).`);
     }
     if (options.json) {
         // Score with a single `now`; on insert `lastUsedAt == createdAt`, so the
@@ -57,8 +70,9 @@ export async function runMemoryAddCommand(args, io = { stdout: process.stdout, s
  * when `--help` was handled. Pure (no I/O) so it can be unit-tested; stdin
  * fallback for empty content happens later in {@link resolveContent}.
  */
-export function parseMemoryAddArgs(args) {
-    let dbPath = DEFAULT_MEMORY_DB_PATH;
+export function parseMemoryAddArgs(args, cwd = process.cwd()) {
+    const sourceArgs = lexMemorySourceFlags(args, cwd);
+    requireSingleExplicitWriteTarget(sourceArgs.flags);
     let priority = "medium";
     let source = "user";
     let sessionId;
@@ -66,35 +80,32 @@ export function parseMemoryAddArgs(args) {
     const tags = [];
     let waitBudgetMs;
     const contentParts = [];
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
+    for (let i = 0; i < sourceArgs.args.length; i++) {
+        const arg = sourceArgs.args[i];
         switch (arg) {
-            case "--db":
-                if (!args[i + 1] || args[i + 1]?.startsWith("-"))
-                    usageError(`Missing value for ${arg}`);
-                dbPath = resolveUserPath(args[++i]);
-                break;
             case "--priority":
-                priority = parseEnum(args[++i], PRIORITIES, arg);
+                priority = parseEnum(sourceArgs.args[++i], PRIORITIES, arg);
                 break;
             case "--source":
-                source = parseEnum(args[++i], SOURCES, arg);
+                source = parseEnum(sourceArgs.args[++i], SOURCES, arg);
                 break;
             case "--session":
-                if (!args[i + 1] || args[i + 1]?.startsWith("-"))
+                if (!sourceArgs.args[i + 1] || sourceArgs.args[i + 1]?.startsWith("-")) {
                     usageError(`Missing value for ${arg}`);
-                sessionId = args[++i];
+                }
+                sessionId = sourceArgs.args[++i];
                 break;
             case "--json":
                 json = true;
                 break;
             case "--tag":
-                if (!args[i + 1] || args[i + 1]?.startsWith("-"))
+                if (!sourceArgs.args[i + 1] || sourceArgs.args[i + 1]?.startsWith("-")) {
                     usageError(`Missing value for ${arg}`);
-                tags.push(args[++i]);
+                }
+                tags.push(sourceArgs.args[++i]);
                 break;
             case "--wait": {
-                const raw = args[++i];
+                const raw = sourceArgs.args[++i];
                 const seconds = Number(raw);
                 if (!raw || !Number.isFinite(seconds) || seconds < 0) {
                     usageError(`Invalid --wait value: ${raw} (expected non-negative number of seconds)`);
@@ -113,7 +124,8 @@ export function parseMemoryAddArgs(args) {
         }
     }
     return {
-        dbPath,
+        sourceFlags: sourceArgs.flags,
+        dbPath: sourceArgs.flags.dbs[0] ?? DEFAULT_MEMORY_DB_PATH,
         content: contentParts.join(" ").trim(),
         priority,
         source,
@@ -147,4 +159,51 @@ async function readStream(stream) {
     }
     return Buffer.concat(chunks).toString("utf8");
 }
+async function writeStoreNote(storeDir, content, options, io) {
+    const slug = await createNoteSlug(storeDir, content);
+    const id = createMemoryId();
+    const createdAt = Date.now();
+    const stored = await writeEntry(storeDir, {
+        slug,
+        version: 1,
+        id,
+        kind: "note",
+        createdAt,
+        priority: options.priority,
+        source: options.source,
+        tags: options.tags,
+        content,
+    });
+    if (options.json) {
+        io.stdout.write(`${JSON.stringify({
+            slug: stored.slug,
+            id: stored.id,
+            kind: stored.kind,
+            createdAt: new Date(stored.createdAt).toISOString(),
+            content: stored.content,
+            priority: options.priority,
+            source: options.source,
+            tags: options.tags,
+            store: stored.storeDir,
+        }, null, 2)}\n`);
+        return;
+    }
+    const tagSuffix = options.tags.length > 0 ? ` [${options.tags.join(", ")}]` : "";
+    io.stdout.write(`Added ${options.priority}-priority memory ${stored.id} as ${stored.slug} (${new Date(createdAt)
+        .toISOString()
+        .slice(0, 10)})${tagSuffix}\n`);
+}
+async function createNoteSlug(storeDir, content) {
+    const words = content
+        .toLowerCase()
+        .match(/[a-z0-9]+/g)
+        ?.slice(0, 5) ?? [];
+    const stem = (words.join("-") || "note").slice(0, 48).replace(/-+$/g, "") || "note";
+    const existing = new Set((await listStore(storeDir)).map((entry) => entry.slug));
+    while (true) {
+        const slug = `${stem}-${randomBytes(3).toString("hex")}`;
+        if (!existing.has(slug))
+            return slug;
+    }
+}
 //# sourceMappingURL=memory-add.js.map

package/dist/src/cli/memory-add.js.map

@@ -1 +1 @@
-{"version":3,"file":"memory-add.js","sourceRoot":"","sources":["../../../src/cli/memory-add.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"memory-add.js","sourceRoot":"","sources":["../../../src/cli/memory-add.ts"],"names":[],"mappings":"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"}

package/dist/src/cli/memory-recall.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-recall.d.ts","sourceRoot":"","sources":["../../../src/cli/memory-recall.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAC7E,OAAO,EAAwB,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAG7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAMtD,UAAU,oBAAoB;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,WAAW,CAAC;IACnB,+EAA+E;IAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,+EAA+E;IAC/E,MAAM,EAAE,OAAO,CAAC;IAChB,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,eAAe;IACvB,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,MAAM,EAAE,EACd,EAAE,GAAE,eAA4C,GAC/C,OAAO,CAAC,IAAI,CAAC,CAiDf;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,oBAAoB,GAAG,SAAS,CAuGtF;AAOD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,WAAW,EAAE,GAAG,MAAM,CA4CrE"}
+{"version":3,"file":"memory-recall.d.ts","sourceRoot":"","sources":["../../../src/cli/memory-recall.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAC7E,OAAO,EAAwB,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAG7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAMtD,UAAU,oBAAoB;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,WAAW,CAAC;IACnB,+EAA+E;IAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,+EAA+E;IAC/E,MAAM,EAAE,OAAO,CAAC;IAChB,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,eAAe;IACvB,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,MAAM,EAAE,EACd,EAAE,GAAE,eAA4C,GAC/C,OAAO,CAAC,IAAI,CAAC,CAiDf;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,oBAAoB,GAAG,SAAS,CA4GtF;AAOD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,WAAW,EAAE,GAAG,MAAM,CA4CrE"}

package/dist/src/cli/memory-recall.js

@@ -75,6 +75,9 @@ export function parseMemoryRecallArgs(args) {
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         switch (arg) {
+            case "--store":
+                usageError("duet memory recall does not support --store; use --db <file>. " +
+                    "Store memories are loaded into context automatically.");
             case "--db":
                 if (!args[i + 1] || args[i + 1]?.startsWith("-"))
                     usageError(`Missing value for ${arg}`);