mnemos-capture 1.1.0 → 1.2.0

package/README.md

@@ -10,11 +10,15 @@
   <img src="https://img.shields.io/badge/MCP-compatible-green" alt="MCP" />
 </p>
 
-<p align="center"><strong>A knowledge pipeline for AI agents.<br />Capture anything — your agents retrieve and apply it.</strong></p>
+<p align="center"><strong>Capture anything. Your agents apply it.</strong></p>
 
-Your agents only know what they were trained on. They don't know what you read this morning, what framework you found last week, or what idea you had at midnight.
+<p align="center">A knowledge pipeline that ingests the outside world and makes it directly actionable by any AI agent — over MCP.</p>
 
-Mnemos bridges that gap. It's a knowledge base that grows in real time and plugs directly into any agent via MCP — so every insight you capture is immediately available to every agent you use.
+Your agent only knows what it was trained on. It doesn't know the article you read this morning, the framework you found last week, or the decision you made last sprint. **Your AI agent finally knows what you've been reading.**
+
+Mnemos is the pipeline between the two. Capture any insight once — Mnemos extracts it, stores it as plain Markdown in your own GitHub repo, and serves it to your agent over MCP. Then it goes further: at session start it briefs your agent on what matters right now, turns insights into implementation plans, and hands them to whatever assistant you run — Claude Code, Codex, Cursor, Gemini, anything MCP-compatible.
+
+It's not a second brain, a vault, or a note-taking app — those store knowledge for *you* to read later. Mnemos makes knowledge your **agent acts on now**.
 
 
 ## Get started
@@ -26,141 +30,120 @@ Go to **[mnemos-capture.vercel.app](https://mnemos-capture.vercel.app)** → **S
 During setup, Mnemos will:
 
 - Create a knowledge repo in your GitHub account — plain Markdown files, no proprietary format
-- Ask for your Anthropic API key — your key, stored per-user, Mnemos never pays for your API calls
+- Ask for your API key (your provider, your key — Mnemos never pays for your API calls)
 - Set a PIN so you can unlock the app quickly on mobile
 
 No config files. No repos to clone. No CLI setup required.
 
-### 2. Capture something
-
-Open the app on any device — phone, tablet, or desktop. Paste any content and hit **Capture**.
+### 2. Connect to your AI assistant
 
-The result is a structured Markdown file, auto-committed to your GitHub knowledge repo and immediately available to your agents.
+When you finish onboarding, Mnemos generates a personal **MCP API key** — copy it.
 
-### 3. Connect to Claude Code
-
-After signing up, you get an MCP API key. Run this once on your machine:
+**Claude Code:**
+```bash
+claude mcp add mnemos -- npx -y mnemos-capture@latest serve-mcp --key <your-mcp-key>
+```
 
+**Any MCP-compatible client** (Cursor, Continue, Gemini CLI, etc.) — point it at the stdio proxy:
 ```bash
-claude mcp add mnemos -- npx -y mnemos-capture@latest serve-mcp --key <your-api-key>
+npx -y mnemos-capture@latest serve-mcp --key <your-mcp-key>
 ```
 
-Your agent confirms the connection and can immediately access your knowledge base.
+The proxy forwards your agent's MCP tool calls to the hosted Mnemos API. Nothing is stored locally — your knowledge lives in your GitHub repo.
 
-> `npx -y mnemos-capture@latest serve-mcp` runs a lightweight local process that bridges Claude Code to the Mnemos API. The `@latest` tag guarantees you always run the most recently published version. As a safety net, the MCP server also self-upgrades on startup: if a newer version is on npm, it respawns under `npx @latest` automatically — so existing users who registered without `@latest` pick up updates on their next session. No data is stored locally — everything lives in your GitHub repo.
+### 3. Capture something
 
-**Proactive inbox notifications (automatic).** The first time the MCP server starts, Mnemos silently installs a `SessionStart` hook in `~/.claude/settings.json`. From then on, every new Claude Code session opens with a short reminder:
+Open the app on any device — phone, tablet, or desktop. Paste any content and hit **Capture**. Or capture directly from your agent:
 
 ```
-Mnemos: 3 captures in inbox — run list_inbox to review
-```
-
-Your agent sees this before the conversation begins and can proactively surface pending captures instead of waiting for you to ask. The hook is skipped if one already exists, so rotating keys or upgrading modes is always safe — your configuration is never overwritten silently.
-
-**Upgrade to a full session briefing (optional).** If you want more than a count — an LLM-composed briefing grounded in your current git branch, recent commits, and `CLAUDE.md` — run:
-
-```bash
-npx -y mnemos-capture@latest setup-hooks --key <your-api-key> --briefing
+capture "The Mom Test — don't ask if your idea is good, ask about their life."
 ```
 
-Each session now starts with a focused summary: which captures are relevant to what you're working on right now, which synthesized rules apply, and what's waiting in your inbox. Adds ~5s to session start (calls `briefing` on the hosted API, uses your Anthropic key).
-
-**Where the hook runs.** `SessionStart` hooks fire anywhere Claude Code reads your local settings — CLI, VS Code / JetBrains extensions, and the desktop app. For Claude Code on the web or other MCP clients (Cursor, etc.), the MCP tools (`list_inbox`, `briefing`, `recall`, …) still work — you just won't get the proactive nudge automatically. Add a line to that project's `CLAUDE.md` like `"At session start, call list_inbox to surface pending captures"` for a portable alternative.
-
-### 4. Connect to any MCP-compatible agent
-
-Your knowledge lives in a standard GitHub repo. Any agent that can read Git or speak MCP can access it — no lock-in, no custom integration required.
+That's it. Your knowledge is now indexed and available to every agent session.
 
 
 ## How it works
 
 ```mermaid
 flowchart TD
-    A["Article / research /\ntranscript / idea"] -->|paste| B["Mnemos\n(web / mobile / CLI)"]
-    B -->|extracts insights| C["Structured knowledge\n+ where to apply it"]
-    C -->|auto-commit| D["Your GitHub repo\n(Markdown)"]
-    D -->|MCP| E["Agent retrieves\n& surfaces to you"]
-    E -->|you decide| F{"Apply?"}
-    F -->|yes| G["Applied to\nyour workflow"]
-    F -->|no| H["Stays in\nknowledge base"]
+    A["Article / research /\ntranscript / idea"] -->|paste| B["Mnemos\n(web / mobile / agent)"]
+    B -->|extracts insight| C["Structured Markdown\ncommitted to your repo"]
+    C -->|session start| D["Briefing\nranked suggestions + plan"]
+    D -->|generate_plan| E["Implementation plan\nsaved to plans/"]
+    E -->|mnemos kos| F["Your AI assistant\nexecutes in isolated worktree"]
+    F -->|verify| G["Branch ready\nto review & merge"]
 
     style A fill:#1a1a2e,stroke:#444,color:#fff
     style B fill:#2A62C6,stroke:#1a4a9e,color:#fff
-    style C fill:#d4a843,stroke:#b8912e,color:#fff
-    style D fill:#2d8a4e,stroke:#1e6b3a,color:#fff
-    style E fill:#1a1a2e,stroke:#444,color:#fff
-    style F fill:#2A62C6,stroke:#1a4a9e,color:#fff
+    style C fill:#2d8a4e,stroke:#1e6b3a,color:#fff
+    style D fill:#d4a843,stroke:#b8912e,color:#fff
+    style E fill:#2A62C6,stroke:#1a4a9e,color:#fff
+    style F fill:#1a1a2e,stroke:#444,color:#fff
     style G fill:#2d8a4e,stroke:#1e6b3a,color:#fff
-    style H fill:#1a1a2e,stroke:#444,color:#fff
 ```
 
-1. **You paste content** — an article, a research paper, a thread, a transcript, your own ideas. Anything text-based.
-2. **Mnemos extracts the insight** — Claude Haiku 4.5 pulls the core idea (not a summary), identifies key takeaways, and tags where it could apply in your work. All automatic.
-3. **It's committed to your repo** — a structured Markdown file lands in your GitHub knowledge repo, searchable and version-controlled.
-4. **Your agents retrieve it** — Claude Code or any MCP-compatible agent can search your knowledge base and surface the right insight when it's relevant. You review, you decide what gets applied.
+1. **Capture** — paste anything text-based. Mnemos extracts the core idea, key takeaways, where to apply it, and auto-detects whether it's a URL, short note, or long paste. Committed to your GitHub repo as structured Markdown.
+2. **Brief** — at session start, the `--briefing` flag sends your project context (branch, recent commits, CLAUDE.md) to Mnemos. It returns ranked suggestions — *why* each insight matters now, *what* applying it achieves, *where* in your codebase.
+3. **Plan** — `generate_plan` reads your selected captures and produces a structured Markdown plan: Codebase Mapping table, per-file steps with effort tiers (`simple` / `complex` / `architectural`), and a Verification Checklist.
+4. **Execute** — `mnemos kos` (coming) creates an isolated git worktree, launches your configured AI assistant with the plan as its contract, and runs the verification checklist when it's done.
+
+
+## What you can feed it
 
-### Example output
+If it's text, Mnemos can extract insight from it. No manual tagging required.
 
-Paste a research post about multi-agent systems. This is what gets committed to your repo:
+- **Research papers and preprints** — new models, architectures, evaluation methods
+- **Framework and library docs** — patterns, APIs, integration approaches worth keeping
+- **Technical threads and writeups** — the argument or finding, not the noise
+- **Optimization techniques** — prompt engineering, caching strategies, latency improvements
+- **Your own ideas** — architecture decisions, workflow changes, things you want your agents to act on later
+- **Transcripts and talks** — signal extracted, ready to apply
+
+
+## Example capture
+
+Paste a research post about error observability. This is what lands in your repo:
 
 ```markdown
 ---
-date: 2026-04-01
-source: Why Multi-Agent Systems Outperform Single-Agent Loops
-url: https://example.com/multi-agent-systems
+date: 2026-06-05
+source: Error Context First — Observability for AI Systems
+url: https://example.com/error-context
 type: post
-tags: multi-agent, orchestration, agent-design, ai-architecture
+source_type: url
+tags: observability, error-handling, ai-agents, debugging
 status: inbox
+lowConfidence: false
 ---
 
-# Why Multi-Agent Systems Outperform Single-Agent Loops
+# Error Context First — Observability for AI Systems
 
 ## Core idea
-Decomposing complex tasks across specialized agents reduces error propagation
-and improves output quality — a single orchestrator routing to focused subagents
-consistently outperforms one generalist agent handling everything sequentially.
+Opaque error messages make every fix a guess. Adding source context to every
+error — which handler, which step, which input — turns debugging from archaeology
+into a directed search.
 
 ## Key takeaways
-- Specialized agents outperform generalist agents on tasks requiring depth over breadth
-- Parallel execution across subagents reduces total latency by 40-60% on multi-step tasks
-- Orchestrator-subagent patterns improve error isolation — one agent failing doesn't
-  collapse the entire workflow
-
-## Quotes
-> "The bottleneck in complex agentic tasks is not model capability — it's
-> error propagation across sequential steps."
+- Every catch block should prefix messages with where it came from
+- "The string did not match the expected pattern" is useless; "[github-write] ..." is actionable
+- Instrument before you fix — opaque errors cause repeated misdiagnoses
 
 ## Applied to
-Evaluate your current single-agent workflows for tasks that could be decomposed
-into parallel subagent calls — prioritize anything with 3+ sequential steps.
+Add handler-name prefixes to every catch block in your agent's tool pipeline.
 ```
 
-Every field is designed to help your agents find and apply the right knowledge at the right time. The **"Applied to"** field is the most important — it connects the insight to a concrete action in your work.
-
-
-## What you can feed it
-
-If it's text, Mnemos can extract insight from it. You don't need to categorize or tag anything yourself — that happens automatically.
-
-- **Research papers and preprints** — new models, architectures, evaluation methods
-- **Framework and library docs** — patterns, APIs, integration approaches worth keeping
-- **Optimization techniques** — prompt engineering, caching strategies, latency improvements
-- **Technical threads and writeups** — the argument or finding, not the noise
-- **Your own ideas** — workflow improvements, architecture decisions, things you want your agents to act on later
-- **Transcripts and talks** — the signal extracted, ready to apply
+`source_type` is auto-detected (`url` / `note` / `paste`). `lowConfidence` flags short or ambiguous input for review before acting on it.
 
 
 ## Knowledge lifecycle
 
-Knowledge that sits unreviewed rots. Mnemos forces a decision: apply it, save it for later, or discard it.
-
 ```
   ┌─────────┐
   │  Capture │
   └────┬─────┘
        ▼
   ┌─────────┐     ┌──────────┐
-  │  Inbox   │────▶│  Applied  │   You used the insight in your workflow
+  │  Inbox   │────▶│  Applied  │   Insight used — plan executed, rule added, code changed
   └────┬─────┘     └──────────┘
        │
        ├──────────▶┌──────────┐
@@ -172,67 +155,152 @@ Knowledge that sits unreviewed rots. Mnemos forces a decision: apply it, save it
                    └──────────┘
 ```
 
-**How it works in practice:**
+All captures are tracked in `INDEX.md` — a master table your agents search across your entire knowledge base. Generated plans land in `plans/`.
+
 
-1. **Capture** — every new capture lands in `inbox/`. After each capture, Mnemos tells you how many items are waiting for review.
-2. **Review** — use `list_inbox` to see what's in your inbox (with summaries), and `read_capture` to read the full content of any capture.
-3. **Apply** — when you've used an insight (added it to a project file, changed a workflow, created a rule), use `apply_capture` to move it to `applied/`. This closes the loop — the knowledge is now part of your system.
-4. **Archive** — reviewed it but it's not actionable right now? Use `archive_capture` to move it to `archived/`. It stays searchable but out of your inbox.
-5. **Delete** — not useful? Use `delete_capture` to permanently remove it.
+## Session hooks
 
-All captures are tracked in `INDEX.md` — a master table your agents use to search across your entire knowledge base.
+`serve-mcp` writes a `SessionStart` hook to `~/.claude/settings.json` on first run. Every session opens with your inbox count:
+
+```
+Mnemos: 4 captures in inbox — run list_inbox to review
+```
+
+### Briefing mode
+
+Opt in for a structured briefing instead of a count:
+
+```bash
+npx -y mnemos-capture@latest setup-hooks --key YOUR_KEY --briefing
+```
+
+At session start, Mnemos collects your project context — branch, recent commits, CLAUDE.md excerpt — and returns:
+
+1. Ranked suggestions with `why`, `benefit`, `where`, and whether to apply now
+2. Relevant synthesized rules
+3. A `generate_plan` prompt pre-loaded with the captures to apply
+
+```
+3 insights to apply now:
+
+1. error-context-first → src/app/api/capture/route.ts
+   Why: Your current branch rewrites the capture pipeline and all catch blocks are opaque
+   Benefit: Every error will identify its source in < 1 line
+
+Run generate_plan with selected_captures: ["inbox/2026-06-05-error-context-first.md"]
+```
+
+### Vault mode (PreToolCall hook)
+
+Surfaces relevant captures *before* you edit a file — not just at session start:
+
+```bash
+npx -y mnemos-capture@latest setup-hooks --key YOUR_KEY --vault
+```
+
+Before every `Edit`, `Write`, or `MultiEdit` tool call, Mnemos scans your vault for captures scoring ≥ 0.7 relevance to the file you're about to touch. Each capture is surfaced at most once per session.
+
+Opt-in only — not installed by default because it fires on every file edit.
+
+### Compatibility
+
+| Surface | Hook fires |
+|---|---|
+| Claude Code CLI, VS Code / JetBrains extensions, desktop app | Yes |
+| Claude Code on the web | No — `~/.claude/settings.json` is local only |
+| Cursor / other MCP clients | No — distinct hook systems |
+
+MCP tools work everywhere. For unsupported surfaces, add to `CLAUDE.md`:
+
+> At session start, call `list_inbox` to surface pending captures.
 
 
 ## MCP tools
 
-Mnemos exposes 7 tools via MCP, organized by what you're doing:
+Mnemos exposes 15 tools via MCP:
 
 ### Capture
 
 | Tool | What it does |
 |------|-------------|
-| `capture` | Extracts insight from any pasted content and commits a structured Markdown file to your repo. This is the entry point — everything starts here. |
+| `capture` | Extracts insight from any pasted content. Auto-detects source type, flags low-confidence input, auto-links to related captures. |
 
 ### Discover
 
 | Tool | What it does |
 |------|-------------|
-| `list_inbox` | Shows your unprocessed captures with summaries — title, type, tags, and core idea. Up to 10 at a time. Use this to see what's waiting for your review. |
-| `search_captures` | Searches your knowledge base by keyword or tag. Finds relevant captures across inbox, applied, and archived — so your agent can pull the right knowledge when it's needed. |
-| `read_capture` | Reads the full Markdown of any capture. Use this to see the complete insight, takeaways, and context before deciding what to do with it. |
+| `list_inbox` | Unprocessed captures with summaries — title, type, tags, core idea. |
+| `search_captures` | Keyword + tag search across inbox, applied, and archived. |
+| `read_capture` | Full Markdown of any capture. |
+| `recall` | Semantic search — describe your task, get the most relevant captures back. More powerful than keyword search. |
+
+### Apply
+
+| Tool | What it does |
+|------|-------------|
+| `apply_capture` | Moves inbox → applied. Records how and where knowledge was used, which plan drove it, and what changed. Triggers rule re-synthesis. |
+| `archive_capture` | Moves inbox → archived. Reviewed but not actionable now. |
+| `delete_capture` | Permanently removes a capture and its index entry. |
+| `apply_to_context` | Paste task + stack + code snippet → get concrete, file-level suggestions for applying your captured knowledge. |
+
+### Plan
+
+| Tool | What it does |
+|------|-------------|
+| `briefing` | Session-start briefing: ranked suggestions with `applyNow` flags, relevant rules, and a `generate_plan` prompt. Requires `project_context`. |
+| `generate_plan` | Reads selected captures + optional codebase files → structured Markdown plan with Codebase Mapping table, effort tiers per step, and Verification Checklist. Saved to `plans/`. |
+| `list_plans` | Lists saved plans, or reads a specific plan in full. |
+
+### Synthesize
+
+| Tool | What it does |
+|------|-------------|
+| `synthesize` | Distills captures on a tag into actionable rules. Updates `RULES.md`. |
+| `get_rules` | Returns synthesized rules — filtered by tag or all. Use to populate `CLAUDE.md` or a system prompt. |
 
-### Manage
+### Curate
 
 | Tool | What it does |
 |------|-------------|
-| `apply_capture` | Moves a capture from inbox to applied. Marks it as used — you can add a note about where you applied it (e.g., "Added as a rule in CLAUDE.md"). |
-| `archive_capture` | Moves a capture from inbox to archived. It's been reviewed but isn't actionable right now. Stays searchable, out of your inbox. |
-| `delete_capture` | Permanently removes a capture and its index entry. For mistakes or captures that aren't useful. |
+| `curate` | Validates inbox captures: HEAD-checks URLs (404/410 → stale), flags low-confidence extractions. Optional `auto_archive`. Batch cap: 20 files. |
+| `vault_scan` | Scans the full vault for captures relevant to your current activity (score ≥ 0.7). Used by the vault hook. |
+
+
+## CLI
 
-The web UI and MCP use the same pipeline. The web UI is for capturing on the go. MCP is for your agents — they retrieve and manage captures without you touching the browser.
+```
+mnemos-capture                                              Open hosted app
+mnemos-capture serve-mcp --key KEY                         Run local MCP proxy (auto-installs hook)
+mnemos-capture setup-hooks --key KEY [--briefing] [--vault] Install session hooks
+mnemos-capture inbox-check --key KEY [--briefing]          Debug what the hook runs
+mnemos-capture vault-check --key KEY                       Debug what the vault hook runs
+mnemos-capture help                                        Show help
+```
+
+All commands run via `npx -y mnemos-capture@latest <subcommand>`. `@latest` forces npm to resolve against the registry on every invocation.
 
 
 ## Mobile
 
-Open Mnemos in your phone's browser, tap **Share → Add to Home Screen**. It runs full-screen like a native app.
+Open Mnemos in your phone's browser → **Share → Add to Home Screen**. Runs full-screen like a native app. Capture while reading — your agents have it by the time you sit down to work.
 
-Capture on the go — reading an article on your phone at lunch? Capture it. Your agents have it by the time you sit down to work.
 
 ## Your data, your storage
 
 Your knowledge lives in a GitHub repo you own. Plain Markdown files, version-controlled, portable.
 
-- **No lock-in** — clone it, search it, move it, delete Mnemos tomorrow and your repo stays exactly where it is
+- **No lock-in** — clone it, move it, delete Mnemos and your repo stays exactly where it is
 - **No proprietary format** — every capture is a readable `.md` file
-- **No training on your data** — Mnemos never reads your captures for any purpose other than serving them back to you and your agents
+- **No training on your data** — Mnemos never reads your captures for any purpose other than serving them back to you
 - **Any tool can access it** — anything that reads Git or speaks MCP works with your knowledge base
+- **BYOK** — your provider, your key, your cost
 
 
 ## Cost
 
-Mnemos uses your own Anthropic API key (BYOK). You bring your key, Mnemos never charges you for API calls.
+Mnemos is BYOK — you bring your own API key, Mnemos never charges you for inference.
 
-Extraction runs on **Claude Haiku 4.5** with prompt caching and input truncation, optimized for minimal token usage:
+Extraction runs on a fast, low-cost model (Claude Haiku 4.5 by default) with prompt caching and input truncation:
 
 | Usage | Estimated monthly cost |
 |-------|----------------------|
@@ -240,28 +308,29 @@ Extraction runs on **Claude Haiku 4.5** with prompt caching and input truncation
 | 100 captures/month | ~$0.30 |
 | 200 captures/month | ~$0.60 |
 
-Less than $1/month for heavy use.
+Briefing and plan generation use your configured model and only run when you explicitly invoke them.
 
 
 ## Tech stack
 
-Next.js · TypeScript · Claude Haiku 4.5 · Anthropic SDK · GitHub OAuth · Vercel Postgres · GitHub Content API · MCP protocol · Tailwind CSS
+Next.js · TypeScript · Vercel Postgres · GitHub OAuth · GitHub Content API · MCP protocol · Anthropic SDK · Tailwind CSS · Vitest
+
 
 ## Roadmap
 
-- Chrome extension for one-click capture from anywhere in the browser
-- URL auto-fetch — paste a link, Mnemos fetches and extracts
-- Multi-provider support (OpenAI, Google — schema is ready)
+- **`mnemos kos`** — CLI orchestrator: creates isolated git worktree, launches your configured AI assistant with the plan as its contract, runs the Verification Checklist, reports the branch
+- **Provider abstraction** — bring your OpenAI, Google, or any OpenAI-compatible key; Mnemos routes accordingly
+- **Chrome extension** — one-click capture from anywhere in the browser
 - Voice memo capture
 
 
 ## Built by
 
-[Sofía Padrón Valdez](https://github.com/Soph20) — builder, AI systems architect. 
+[Sofía Padrón Valdez](https://github.com/Soph20) — builder, AI systems architect.
+
 
 ## Citation
 
-If you use this repository in your agentic workflows, please consider citing as follows:
 ```
 @misc{2026mnemos,
     title        = {Mnemos: A Knowledge Pipeline for AI Agents},

package/dist/cli/__tests__/config.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, readFileSync, existsSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+describe("config", () => {
+    let tmpDir;
+    let configPath;
+    let origHome;
+    beforeEach(() => {
+        tmpDir = mkdtempSync(join(tmpdir(), "mnemos-config-test-"));
+        configPath = join(tmpDir, ".mnemos", "config.json");
+        origHome = process.env["HOME"];
+        process.env["HOME"] = tmpDir;
+        // Module-level CONFIG_DIR is computed from homedir() at import — reset cache
+        vi.resetModules();
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+        process.env["HOME"] = origHome;
+    });
+    it("returns an empty object when no config exists", async () => {
+        const { readConfig } = await import("../config.js");
+        expect(readConfig()).toEqual({});
+    });
+    it("writes and reads back the agent field", async () => {
+        const { setConfigField, readConfig } = await import("../config.js");
+        setConfigField("agent", "claude -p");
+        expect(readConfig().agent).toBe("claude -p");
+        expect(existsSync(configPath)).toBe(true);
+    });
+    it("persists the agent command verbatim, including flags", async () => {
+        const { setConfigField } = await import("../config.js");
+        setConfigField("agent", "aider --yes --message");
+        const saved = JSON.parse(readFileSync(configPath, "utf-8"));
+        expect(saved.agent).toBe("aider --yes --message");
+    });
+    it("preserves other fields when updating one", async () => {
+        const { setConfigField, readConfig } = await import("../config.js");
+        setConfigField("key", "mnemos_abc123");
+        setConfigField("agent", "codex exec");
+        const cfg = readConfig();
+        expect(cfg.key).toBe("mnemos_abc123");
+        expect(cfg.agent).toBe("codex exec");
+    });
+    it("throws on an unknown config field", async () => {
+        const { setConfigField } = await import("../config.js");
+        expect(() => setConfigField("provider", "openai")).toThrow(/Unknown config field/);
+    });
+});