npm - mnemos-capture - Versions diffs - 1.2.1 → 1.4.0 - Mend

mnemos-capture 1.2.1 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md CHANGED Viewed

@@ -1,360 +1,439 @@
-<p align="center">
-  <img src="public/logo.png" alt="Mnemos" width="120" />
-</p>
+<div align="center">
+  <br>
+  <a href="https://mnemos-capture.vercel.app">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="public/mnemos-hero-dark.gif">
+      <img src="public/mnemos-hero-light.gif" width="160" height="160" alt="xkg">
+    </picture>
+  </a>
+  <br>
+  <br>
+  <p>
+    <a href="https://www.npmjs.com/package/mnemos-capture"><img src="https://img.shields.io/npm/v/mnemos-capture?color=1c74d8&labelColor=000820&style=flat" alt="npm" /></a>
+    <img src="https://img.shields.io/badge/MCP-compatible-9dd8f5?labelColor=000820&style=flat" alt="MCP" />
+    <img src="https://img.shields.io/badge/license-MIT-f0f4f8?labelColor=000820&style=flat" alt="MIT" />
+  </p>
+</div>
+## xkg
+Humans are constantly exposed to useful knowledge, domain expertise, and external input. But there is no bridge between what humans know and what their AI workers know and do.
+xkg is the knowledge graph for AI workers that bridges human knowledge into context they can use.
+## Table of Contents
+- [xkg](#xkg)
+- [How it works](#how-it-works)
+- [Start here](#start-here)
+- [Connect your AI workers](#connect-your-ai-workers)
+  - [On the web](#on-the-web)
+    - [Claude](#claude)
+    - [ChatGPT](#chatgpt)
+    - [Grok](#grok)
+  - [In the terminal](#in-the-terminal)
+    - [Cursor](#cursor)
+    - [VS Code](#vs-code)
+    - [Codex](#codex)
+    - [Gemini CLI](#gemini-cli)
+    - [Claude Code](#claude-code)
+    - [Claude Desktop](#claude-desktop)
+    - [Anything MCP](#anything-mcp)
+- [Workflow](#workflow)
+- [What's inside](#whats-inside)
+- [Your context stays in GitHub](#your-context-stays-in-github)
+- [CLI](#cli)
+- [Roadmap](#roadmap)
+- [License](#license)
-<h1 align="center">Mnemos</h1>
+## How it works
-<p align="center">
-  <img src="https://img.shields.io/npm/v/mnemos-capture" alt="npm" />
-  <img src="https://img.shields.io/badge/license-MIT-blue" alt="License" />
-  <img src="https://img.shields.io/badge/MCP-compatible-green" alt="MCP" />
-</p>
+You find useful stuff, you capture through the web app, then xkg connects it into a knowledge graph, and makes it available to the AI workers you already use.
-<p align="center"><strong>Capture anything. Your agents apply it.</strong></p>
+xkg will continuously compound that knowledge over time — keeping AI workers' context up to date as human knowledge evolves.
-<p align="center">
-  Humans consume information. Agents execute information.<br/>
-  <em>Mnemos converts one into the other.</em>
-</p>
-<p align="center">A knowledge pipeline that turns what you learn into actionable context for AI agents.</p>
+> [!IMPORTANT]
+> We are migrating from **mnemos** / **Xmu** to **xkg**. The app URL, this GitHub repo, and the npm package still say `mnemos-capture`. Sorry for the inconvenience.
----
+## Start here
-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.
+You do not need a terminal to start.
-**Mnemos bridges that gap.**
+### 1. Create your account
-Capture an insight once. Mnemos extracts it, stores it as plain Markdown in your own GitHub repository, indexes it, and serves it to any MCP-compatible agent.
+Open **[mnemos-capture.vercel.app](https://mnemos-capture.vercel.app)** and sign in with GitHub.
-Then it goes further. At session start, Mnemos briefs your agent on what matters right now, surfaces relevant knowledge in context, synthesizes reusable rules, and turns insights into implementation plans.
+xkg will:
-> **The result isn't another knowledge base.** It's a system that transforms what you learn into what your agents can execute.
+1. Create a **private** GitHub repo for your knowledge (you can opt to make it public)
+2. Ask for your LLM provider API key — Anthropic, OpenAI, or Google. Your key, your cost.
+3. Let you set a PIN (6+ characters) for quick unlock on this device
+4. Show your **xkg API key** once — save it if you want to connect an AI worker
-<p align="center"><sub>Works with <strong>Claude Code</strong> · <strong>Codex</strong> · <strong>Cursor</strong> · <strong>Gemini</strong> · and any MCP-compatible assistant.</sub></p>
+That's the whole setup. No repo to clone. No database. No CLI required.
+### 2. Capture something
-## Get started
+In the app, paste a URL, a note, a doc excerpt, a transcript, or an idea, then hit **Capture**.
-### 1. Sign up (30 seconds)
+xkg extracts the **core idea**, **key takeaways**, **where to apply it**, and the **capture type**, then commits Markdown to your GitHub repo.
-Go to **[mnemos-capture.vercel.app](https://mnemos-capture.vercel.app)** → **Sign in with GitHub**.
+On a phone: open the app → **Share → Add to Home Screen**. It runs like a native app.
-During setup, Mnemos will:
+### 3. Connect a worker (optional)
-- Create a knowledge repo in your GitHub account — plain Markdown files, no proprietary format
-- 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
+Skip this if you only want the app today. When you're ready, pick your tool under [Connect your AI workers](#connect-your-ai-workers). Capture now, connect later — the knowledge is already in your repo.
-No config files. No repos to clone. No CLI setup required.
+## Connect your AI workers
-### 2. Connect to your AI assistant
+xkg is LLM-agnostic. Any worker that speaks MCP can use the same knowledge.
-When you finish onboarding, Mnemos generates a personal **MCP API key** — copy it.
+Two primitives:
-**Claude Code:**
-```bash
-claude mcp add mnemos -- npx -y mnemos-capture@latest serve-mcp --key <your-mcp-key>
+```text
+https://mnemos-capture.vercel.app/api/mcp
 ```
-**Any MCP-compatible client** (Cursor, Continue, Gemini CLI, etc.) — point it at the stdio proxy:
 ```bash
-npx -y mnemos-capture@latest serve-mcp --key <your-mcp-key>
+npx -y mnemos-capture@latest serve-mcp --key YOUR_API_KEY
 ```
-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.
+The CLI binary is **`xkg`** (also `xmu` and `mnemos-capture`). `npx` still uses the package name `mnemos-capture`. An MCP server already registered as `xmu` or `mnemos` keeps working.
-### 3. Capture something
+**On the web** — paste the URL (no terminal). **In the terminal** — run the command. Finish xkg onboarding first, then ask: *list my inbox* or *brief me*.
-Open the app on any device — phone, tablet, or desktop. Paste any content and hit **Capture**. Or capture directly from your agent:
+### On the web
-```
-capture "The Mom Test — don't ask if your idea is good, ask about their life."
-```
+Name the connector `xkg`, paste `https://mnemos-capture.vercel.app/api/mcp`, sign in with GitHub when asked.
-That's it. Your knowledge is now indexed and available to every agent session.
+#### Claude
+1. Settings → Connectors → Add custom connector
-## How it works
+#### ChatGPT
-```mermaid
-flowchart TD
-    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:#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
-```
+1. Settings → Plugins → Browse plugins
+2. Name it xkg
+3. Paste `https://mnemos-capture.vercel.app/api/mcp`
+4. Sign in with GitHub when asked
-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.
+#### Grok
+1. Open [grok.com/connectors](https://grok.com/connectors) → New Connector → Custom
-## What you can feed it
+### In the terminal
-If it's text, Mnemos can extract insight from it. No manual tagging required.
+The same command works in every CLI — Cursor, Codex, Gemini CLI, VS Code, Claude Code, or anything that can launch a local MCP server:
-- **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
+```bash
+npx -y mnemos-capture@latest serve-mcp --key YOUR_API_KEY
+```
+Register that command in the tool you use.
-## Example capture
+#### Cursor
-Paste a research post about error observability. This is what lands in your repo:
+Add this to `.cursor/mcp.json` (project) or `~/.cursor/mcp.json` (all projects):
-```markdown
----
-date: 2026-06-05
-source: Error Context First — Observability for AI Systems
-url: https://example.com/error-context
-type: post
-source_type: url
-tags: observability, error-handling, ai-agents, debugging
-status: inbox
-lowConfidence: false
----
+```json
+{
+  "mcpServers": {
+    "xkg": {
+      "command": "npx",
+      "args": ["-y", "mnemos-capture@latest", "serve-mcp", "--key", "YOUR_API_KEY"]
+    }
+  }
+}
+```
-# Error Context First — Observability for AI Systems
+Or Cursor Settings → MCP → Add new MCP server, same command.
-## Core idea
-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.
+#### VS Code
-## Key takeaways
-- 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
+Add this to `.vscode/mcp.json`:
-## Applied to
-Add handler-name prefixes to every catch block in your agent's tool pipeline.
+```json
+{
+  "servers": {
+    "xkg": {
+      "command": "npx",
+      "args": ["-y", "mnemos-capture@latest", "serve-mcp", "--key", "YOUR_API_KEY"]
+    }
+  }
+}
 ```
-`source_type` is auto-detected (`url` / `note` / `paste`). `lowConfidence` flags short or ambiguous input for review before acting on it.
+GitHub Copilot Chat in VS Code uses the same file.
+#### Codex
-## Knowledge lifecycle
+Codex CLI — add this to `~/.codex/config.toml`:
-```
-  ┌─────────┐
-  │  Capture │
-  └────┬─────┘
-       ▼
-  ┌─────────┐     ┌──────────┐
-  │  Inbox   │────▶│  Applied  │   Insight used — plan executed, rule added, code changed
-  └────┬─────┘     └──────────┘
-       │
-       ├──────────▶┌──────────┐
-       │           │ Archived  │   Reviewed, not actionable right now
-       │           └──────────┘
-       │
-       └──────────▶┌──────────┐
-                   │ Deleted   │   Not useful, permanently removed
-                   └──────────┘
+```toml
+[mcp_servers.xkg]
+command = "npx"
+args = ["-y", "mnemos-capture@latest", "serve-mcp", "--key", "YOUR_API_KEY"]
 ```
-All captures are tracked in `INDEX.md` — a master table your agents search across your entire knowledge base. Generated plans land in `plans/`.
+Codex App: Settings → MCP → add the same `npx` command.
+#### Gemini CLI
-## Session hooks
+```bash
+gemini mcp add xkg npx -y mnemos-capture@latest serve-mcp --key YOUR_API_KEY
+```
-`serve-mcp` writes a `SessionStart` hook to `~/.claude/settings.json` on first run. Every session opens with your inbox count:
+#### Claude Code
-```
-Mnemos: 4 captures in inbox — run list_inbox to review
+```bash
+claude mcp add xkg -- npx -y mnemos-capture@latest serve-mcp --key YOUR_API_KEY
 ```
-### Briefing mode
+Or the URL, no API key:
-Opt in for a structured briefing instead of a count:
+```bash
+claude mcp add --transport http xkg https://mnemos-capture.vercel.app/api/mcp
+```
+Optional session hooks (MCP works without them):
 ```bash
-npx -y mnemos-capture@latest setup-hooks --key YOUR_KEY --briefing
+npx -y mnemos-capture@latest setup-hooks --key YOUR_API_KEY --briefing --vault
 ```
-At session start, Mnemos collects your project context — branch, recent commits, CLAUDE.md excerpt — and returns:
+Hooks are local files — they run in the CLI and editor extensions, not in the browser.
+#### Claude Desktop
-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
+Settings → Developer → Edit Config. Add the same `npx` block to `claude_desktop_config.json`, then fully restart:
+```json
+{
+  "mcpServers": {
+    "xkg": {
+      "command": "npx",
+      "args": ["-y", "mnemos-capture@latest", "serve-mcp", "--key", "YOUR_API_KEY"]
+    }
+  }
+}
 ```
-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
+#### Anything MCP
-Run generate_plan with selected_captures: ["inbox/2026-06-05-error-context-first.md"]
+If the tool can launch a local process, register the same `npx` command. If it has **custom connectors** instead, paste the URL (that's the [web](#on-the-web) path).
+```json
+{
+  "mcpServers": {
+    "xkg": {
+      "command": "npx",
+      "args": ["-y", "mnemos-capture@latest", "serve-mcp", "--key", "YOUR_API_KEY"]
+    }
+  }
+}
 ```
-### Vault mode (PreToolCall hook)
+No MCP support yet? Capture in the [xkg app](https://mnemos-capture.vercel.app) and connect later.
-Surfaces relevant captures *before* you edit a file — not just at session start:
+## Workflow
-```bash
-npx -y mnemos-capture@latest setup-hooks --key YOUR_KEY --vault
-```
+<p align="center">
+  <img src="public/flow-workflow.svg" width="720" alt="Docs and notes → Capture → GitHub Markdown → Brief → Plan → Execute → Mark applied" />
+</p>
-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.
+1. **Capture** — Paste anything text-based: papers, docs, posts, GitHub repos, notes, decisions, ideas, transcripts. xkg detects a URL, a short note, or longer text. No manual tagging.
-Opt-in only — not installed by default because it fires on every file edit.
+   From a connected worker:
-### Compatibility
+   ```text
+   capture "The Mom Test: don't ask if your idea is good. Ask about the person's real behavior, current workflow, and past spending."
+   ```
-| 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 |
+2. **Brief** — At the start of a work session, ask your worker for a briefing. xkg looks at your project (branch, recent commits, `CLAUDE.md`, repo context) and ranks captures that could help now: **why** it matters, **what** applying it could achieve, **where** it could land. You decide what to apply.
-MCP tools work everywhere. For unsupported surfaces, add to `CLAUDE.md`:
+3. **Plan** — Select the captures you want and ask your worker to call `generate_plan`. Each plan is Markdown: codebase mapping, implementation steps with effort tiers (`simple`, `complex`, `architectural`), and a verification checklist.
-> At session start, call `list_inbox` to surface pending captures.
+4. **Execute** — Hand the plan to your worker in the current session, or run it in an isolated git worktree:
+   ```bash
+   npx -y mnemos-capture@latest config set agent "claude -p"
+   npx -y mnemos-capture@latest kos --key YOUR_API_KEY
+   ```
-## MCP tools
+   `kos` creates a worktree, loads the plan as the contract, launches the assistant you configured, and prints the verification checklist when it finishes.
-Mnemos exposes 15 tools via MCP:
+   ```bash
+   npx -y mnemos-capture@latest config set agent "codex exec"
+   ```
-### Capture
+### Example capture
-| Tool | What it does |
-|------|-------------|
-| `capture` | Extracts insight from any pasted content. Auto-detects source type, flags low-confidence input, auto-links to related captures. |
+```text
+The Mom Test: don't ask if your idea is good. Ask about the person's real behavior, current workflow, and past spending.
+```
-### Discover
+```markdown
+---
+date: 2026-06-05
+source: The Mom Test note
+type: note
+tags: customer-discovery, product, research
+status: inbox
+---
-| Tool | What it does |
-|------|-------------|
-| `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. |
+# The Mom Test
-### Apply
+## Core idea
-| 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. |
+Do not ask people to judge your idea. Ask about their real life,
+recent behavior, current workaround, and what they have already
+tried or paid for.
-### Plan
+## Key takeaways
-| 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. |
+- Avoid compliments and future promises
+- Ask about specific past behavior
+- Look for existing pain, workarounds, and spending
-### Synthesize
+## Where to apply
-| 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. |
+Discovery interview scripts, landing page tests, and product
+validation prompts.
+```
-### Curate
+Plain Markdown in a repo you own. Readable, editable, versioned, portable.
-| Tool | What it does |
-|------|-------------|
-| `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. |
+## What's inside
+You don't have to memorize these. Ask in plain language: "save this", "what do I have on payments?", "brief me for this repo".
+| Tool | What it does |
+| --- | --- |
+| `capture` | Save new knowledge from pasted text or a URL |
+| `list_inbox` | List captures waiting for review |
+| `search_captures` | Keyword search across your captures |
+| `read_capture` | Read a capture in full |
+| `recall` | Find relevant context from a description of your task |
+| `briefing` | Get project-specific recommendations |
+| `generate_plan` | Turn selected captures into an implementation plan |
+| `list_plans` | List or read saved plans |
+| `apply_capture` | Mark a capture as applied |
+| `archive_capture` | Archive a capture |
+| `delete_capture` | Delete a capture |
+| `apply_to_context` | Get file-level suggestions for the current task |
+| `synthesize` | Combine related captures into reusable rules |
+| `get_rules` | Retrieve those rules |
+| `curate` | Review and clean up captures |
+| `vault_scan` | Find relevant context for what you're about to edit |
 ## CLI
+No global install required. The binary is **`xkg`** (also `xmu` and `mnemos-capture`). Via npx:
+```bash
+npx -y mnemos-capture@latest <command>
 ```
-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.
+| Command | What it does |
+| --- | --- |
+| `npx -y mnemos-capture@latest` | Open the hosted app |
+| `serve-mcp --key YOUR_API_KEY` | Run the local MCP proxy |
+| `setup-hooks --key YOUR_API_KEY [--briefing] [--vault]` | Install Claude Code hooks |
+| `config set agent "claude -p"` | Set which assistant `kos` should drive |
+| `kos --key YOUR_API_KEY` | Implement the latest plan in an isolated worktree |
+| `inbox-check --key YOUR_API_KEY [--briefing]` | Debug the session hook |
+| `vault-check --key YOUR_API_KEY` | Debug the vault hook |
+| `help` | Show help |
+## Your context stays in GitHub
+Captures live as structured Markdown in **your** GitHub repository. Private by default.
+- **No lock-in** — clone it, move it, delete xkg, keep the files
+- **No proprietary format** — every capture is a readable `.md` file
+- **No training on your data** — captures are sent only to the LLM provider you chose, with the key you supplied, to extract the insight you asked for
+- **Any tool can read it** — anything that reads Git or speaks MCP
+- **BYOK** — your provider, your key, your cost
+- **Never commit your xkg API key** to source control
-## Mobile
+### What xkg stores, and where
-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.
+The whole point of this repo being public is that you can check these claims rather than trust them.
+**Your captures are never stored by xkg.** They are written straight to your own GitHub repo as Markdown (`src/lib/github.ts`). There is no captures table. Delete the app and your knowledge is untouched.
-## Your data, your storage
+**The database holds only account plumbing** (`src/lib/db.ts`):
-Your knowledge lives in a GitHub repo you own. Plain Markdown files, version-controlled, portable.
+| Stored | What it is |
+| --- | --- |
+| `github_id`, `github_username` | who you are |
+| `github_token` | encrypted (`src/lib/crypto.ts`) |
+| `github_repo` | the *name* of your hub, not its contents |
+| `pin_hash` | salted scrypt (`src/lib/pin.ts`) |
+| `api_key` | hashed — not recoverable |
+| `llm_provider`, `llm_api_key` | encrypted |
+| `token_version` | bumped to revoke everything |
+| login attempts, OAuth clients/codes, refresh-token ids | auth plumbing |
-- **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
-- **Any tool can access it** — anything that reads Git or speaks MCP works with your knowledge base
-- **BYOK** — your provider, your key, your cost
+When you capture, the server talks to exactly three kinds of destination:
+1. **GitHub** — to write the capture into your repo
+2. **Your LLM provider**, with *your* key — Anthropic, OpenAI, or Google
+3. **The page you captured** — if you paste a bare URL, so the model reads real content. Only http/https, never an internal address
+No analytics, no telemetry, no third-party tracking.
+### How your credentials are stored
+| Secret | How it's stored |
+| --- | --- |
+| GitHub token | Encrypted at rest (AES-256-GCM). Uses the `repo` scope, required to read and write a **private** knowledge hub |
+| Your LLM API key | Encrypted at rest (AES-256-GCM) |
+| Your MCP API key | Hashed — never recoverable, not even by xkg |
+| Your PIN | Salted scrypt hash |
+Your MCP key is shown exactly once. If you lose it, generate a new one.
+**PIN unlock is device-bound.** It only works on a device that has already signed in with GitHub. A PIN on its own is not enough to reach your account.
+**Revoking access.** Generating a new MCP key invalidates the old key, every signed-in session, and every connected MCP client. Sessions also expire after 30 days.
 ## Cost
-Mnemos is BYOK — you bring your own API key, Mnemos never charges you for inference.
+xkg is BYOK. You bring your own API key. xkg never charges you for inference.
-Extraction runs on a fast, low-cost model (Claude Haiku 4.5 by default) with prompt caching and input truncation:
+Extraction runs on a fast, low-cost model (Claude Haiku 4.5 by default):
 | Usage | Estimated monthly cost |
-|-------|----------------------|
+| --- | --- |
 | 50 captures/month | ~$0.15 |
 | 100 captures/month | ~$0.30 |
 | 200 captures/month | ~$0.60 |
-Briefing and plan generation use your configured model and only run when you explicitly invoke them.
-## Tech stack
-Next.js · TypeScript · Vercel Postgres · GitHub OAuth · GitHub Content API · MCP protocol · Anthropic SDK · Tailwind CSS · Vitest
+Briefing, planning, and synthesis only run when you ask for them.
 ## Roadmap
-- **`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
+- **Learning Graph** — Applied work feeds the next brief. The graph compounds.
+- **Knowledge Graph for Teams** — One graph the team and their AI workers share and compound.
+- **Chrome extension** — Capture from the page you are on, without leaving the browser.
+- **Voice memo** — Speak it. xkg turns it into a capture.
+Working on the code? See [CONTRIBUTING.md](CONTRIBUTING.md).
-## Built by
-[Sofía Padrón Valdez](https://github.com/Soph20) — builder, AI systems architect.
+## License
+[MIT License](./LICENSE)
-## Citation
+If you use xkg in published work:
-```
+```bibtex
 @misc{2026mnemos,
-    title        = {Mnemos: A Knowledge Pipeline for AI Agents},
-    author       = {Sofia Padron Valdez},
-    year         = 2026,
-    journal      = {GitHub repository},
-    publisher    = {GitHub},
-    howpublished = {\url{https://github.com/Soph20/mnemos-capture}}
-    }
+  title        = {xkg: A Knowledge Graph for AI workers},
+  author       = {Sofia Padron Valdez},
+  year         = 2026,
+  journal      = {GitHub repository},
+  publisher    = {GitHub},
+  howpublished = {\url{https://github.com/Soph20/mnemos-capture}}
+}
 ```
-## License
-[MIT License - see LICENSE file for details](./LICENSE)

package/dist/cli/config.js CHANGED Viewed

@@ -1,28 +1,56 @@
 /**
- * Mnemos CLI config — stores which AI assistant kos should drive, and an
- * optional API key, in ~/.mnemos/config.json. Provider/agent-agnostic: the
- * user tells Mnemos the exact command to launch their assistant.
+ * xkg CLI config — stores which AI assistant kos should drive, and an
+ * optional API key, in ~/.xkg/config.json.
+ * Falls back to ~/.xmu/config.json then ~/.mnemos/config.json.
  */
 import { homedir } from "os";
 import { join } from "path";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
-const CONFIG_DIR = join(homedir(), ".mnemos");
-const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function xkgDir() {
+    return join(homedir(), ".xkg");
+}
+function xmuDir() {
+    return join(homedir(), ".xmu");
+}
+function mnemosDir() {
+    return join(homedir(), ".mnemos");
+}
+function xkgPath() {
+    return join(xkgDir(), "config.json");
+}
+function xmuPath() {
+    return join(xmuDir(), "config.json");
+}
+function mnemosPath() {
+    return join(mnemosDir(), "config.json");
+}
+/** Path we currently read from: xkg, then xmu, then mnemos. */
+function readPath() {
+    if (existsSync(xkgPath()))
+        return xkgPath();
+    if (existsSync(xmuPath()))
+        return xmuPath();
+    if (existsSync(mnemosPath()))
+        return mnemosPath();
+    return xkgPath();
+}
 const ALLOWED_FIELDS = ["agent", "key"];
 export function readConfig() {
-    if (!existsSync(CONFIG_PATH))
+    const path = readPath();
+    if (!existsSync(path))
         return {};
     try {
-        return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+        return JSON.parse(readFileSync(path, "utf-8"));
     }
     catch {
         return {};
     }
 }
 export function writeConfig(cfg) {
-    if (!existsSync(CONFIG_DIR))
-        mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+    const dir = xkgDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(xkgPath(), JSON.stringify(cfg, null, 2) + "\n");
 }
 export function setConfigField(field, value) {
     if (!ALLOWED_FIELDS.includes(field)) {
@@ -32,21 +60,21 @@ export function setConfigField(field, value) {
     cfg[field] = value;
     writeConfig(cfg);
 }
-/** Route `mnemos config <set|get> ...`. */
+/** Route `xkg config <set|get> ...`. */
 export function runConfigCommand(args) {
     const action = args[0];
     if (action === "set") {
         const field = args[1];
         const value = args.slice(2).join(" ");
         if (!field || !value) {
-            console.error('Usage: mnemos config set <field> <value>');
-            console.error('  e.g. mnemos config set agent "claude -p"');
+            console.error("Usage: xkg config set <field> <value>");
+            console.error('  e.g. xkg config set agent "claude -p"');
             process.exit(1);
         }
         try {
             setConfigField(field, value);
             console.log(`Set ${field} = ${value}`);
-            console.log(`Saved to ${CONFIG_PATH}`);
+            console.log(`Saved to ${xkgPath()}`);
         }
         catch (err) {
             console.error(err instanceof Error ? err.message : String(err));
@@ -65,6 +93,6 @@ export function runConfigCommand(args) {
         }
         return;
     }
-    console.error("Usage: mnemos config set|get <field> [value]");
+    console.error("Usage: xkg config set|get <field> [value]");
     process.exit(1);
 }

package/dist/cli/hooks.js CHANGED Viewed

@@ -108,7 +108,7 @@ export function setupHooks(apiKey, opts = {}) {
     settings.hooks = { ...hooks, SessionStart: filtered };
     writeSettings(settings);
     if (!opts.silent) {
-        console.log("Mnemos inbox hook installed.");
+        console.log("xkg inbox hook installed.");
         console.log(`Location: ${CLAUDE_SETTINGS_PATH}`);
         if (opts.briefing) {
             console.log("At the start of each Claude Code session you'll see a full project briefing.");
@@ -151,7 +151,7 @@ export function setupPreToolHook(apiKey, opts = {}) {
     settings.hooks = { ...hooks, PreToolCall: filtered };
     writeSettings(settings);
     if (!opts.silent) {
-        console.log("Mnemos vault hook installed (PreToolCall).");
+        console.log("xkg vault hook installed (PreToolCall).");
         console.log("Your knowledge vault will surface relevant captures as you edit files.");
     }
 }
@@ -279,7 +279,7 @@ export async function inboxCheck(apiKey, opts = {}) {
             process.stdout.write(displayText + "\n");
             if (applyNow.length > 0) {
                 const filenames = applyNow.map((s) => `'${s.filename}'`).join(", ");
-                process.stdout.write(`\n---\nMnemos: ${applyNow.length} insight${applyNow.length === 1 ? "" : "s"} ready to apply now.\n` +
+                process.stdout.write(`\n---\nxkg: ${applyNow.length} insight${applyNow.length === 1 ? "" : "s"} ready to apply now.\n` +
                     `Run generate_plan with selected_captures: [${filenames}] to get a full implementation plan.\n`);
             }
             return;
@@ -294,7 +294,7 @@ export async function inboxCheck(apiKey, opts = {}) {
             return;
         const count = parseInt(match[1], 10);
         if (count > 0) {
-            process.stdout.write(`Mnemos: ${count} capture${count === 1 ? "" : "s"} in inbox — run list_inbox to review\n`);
+            process.stdout.write(`xkg: ${count} capture${count === 1 ? "" : "s"} in inbox — run list_inbox to review\n`);
         }
     }
     catch {

package/dist/cli/index.js CHANGED Viewed

@@ -52,7 +52,7 @@ async function main() {
         const keyIdx = args.indexOf("--key");
         const apiKey = keyIdx !== -1 ? args[keyIdx + 1] : readConfig().key;
         if (!apiKey) {
-            console.error("No API key. Pass --key YOUR_KEY or store it: mnemos config set key YOUR_KEY");
+            console.error("No API key. Pass --key YOUR_KEY or store it: xkg config set key YOUR_KEY");
             process.exit(1);
         }
         const planIdx = args.indexOf("--plan");
@@ -62,13 +62,13 @@ async function main() {
     }
     // Default: open the hosted app
     console.log("");
-    console.log("  Mnemos — Knowledge capture for agentic workflows\n");
+    console.log("  xkg — A knowledge graph for your AI workers\n");
     console.log(`  Open ${HOSTED_URL} to start capturing.`);
     console.log("");
     console.log("  First time? Sign in with GitHub — setup takes 30 seconds.");
     console.log("");
-    console.log("  Connect to Claude Code:");
-    console.log("  claude mcp add mnemos -- npx -y mnemos-capture@latest serve-mcp --key YOUR_API_KEY");
+    console.log("  Connect an AI worker:");
+    console.log("  claude mcp add xkg -- npx -y mnemos-capture@latest serve-mcp --key YOUR_API_KEY");
     console.log("");
     // Try to open the URL in the default browser
     const { exec } = await import("child_process");
@@ -77,31 +77,33 @@ async function main() {
 }
 function printHelp() {
     console.log(`
-  Mnemos — Knowledge capture for agentic workflows
+  xkg — A knowledge graph for your AI workers
   Usage:
-    npx mnemos-capture                                         Open Mnemos in your browser
-    npx mnemos-capture serve-mcp --key KEY                     Start the MCP server for Claude Code
-    npx mnemos-capture setup-hooks --key KEY                   Install inbox count hook (fast)
-    npx mnemos-capture setup-hooks --key KEY --briefing        Install full briefing hook (uses LLM)
-    npx mnemos-capture setup-hooks --key KEY --vault           Install vault hook (PreToolCall)
-    npx mnemos-capture setup-hooks --key KEY --briefing --vault  Install both hooks
-    npx mnemos-capture config set agent "claude -p"            Set which AI assistant kos drives
-    npx mnemos-capture kos --key KEY [--plan FILE]             Implement a plan in an isolated worktree
-    npx mnemos-capture help                                    Show this help
+    xkg                                                        Open xkg in your browser
+    xkg serve-mcp --key KEY                                    Start the MCP server for your AI worker
+    xkg setup-hooks --key KEY                                  Install inbox count hook (fast)
+    xkg setup-hooks --key KEY --briefing                       Install full briefing hook (uses LLM)
+    xkg setup-hooks --key KEY --vault                          Install vault hook (PreToolCall)
+    xkg setup-hooks --key KEY --briefing --vault               Install both hooks
+    xkg config set agent "claude -p"                           Set which AI worker kos drives
+    xkg kos --key KEY [--plan FILE]                            Implement a plan in an isolated worktree
+    xkg help                                                   Show this help
-  MCP tools (via your AI assistant):
+    npx -y mnemos-capture@latest …                             Same CLI, via the published package
+  MCP tools (via your AI worker):
     briefing          — Session-start briefing with ranked insights to apply
     generate_plan     — Turn selected captures into a full implementation plan
     list_plans        — List or read saved implementation plans
     vault_scan        — Scan all captures for relevance to current activity
     curate            — Validate URLs and flag stale captures
-  kos — implement plans with your own AI assistant (model-agnostic):
-    1. Tell Mnemos which assistant to drive (once):
-         mnemos config set agent "claude -p"      # or "codex exec", "aider --yes --message"
+  kos — implement plans with your own AI worker (model-agnostic):
+    1. Tell xkg which assistant to drive (once):
+         xkg config set agent "claude -p"      # or "codex exec", "aider --yes --message"
     2. Generate a plan via the generate_plan MCP tool.
-    3. Run: mnemos kos --key YOUR_KEY
+    3. Run: xkg kos --key YOUR_KEY
        kos creates an isolated git worktree, hands the plan to your assistant,
        and reports the branch + the plan's Verification Checklist when done.
@@ -112,7 +114,7 @@ function printHelp() {
     4. Start capturing!
   Connect to Claude Code:
-    claude mcp add mnemos -- npx -y mnemos-capture@latest serve-mcp --key YOUR_API_KEY
+    claude mcp add xkg -- npx -y mnemos-capture@latest serve-mcp --key YOUR_API_KEY
   The @latest tag ensures every Claude Code session uses the most recent
   published version. serve-mcp also self-upgrades on startup as a safety net

package/dist/cli/kos.js CHANGED Viewed

@@ -1,8 +1,8 @@
 /**
- * kos — Mnemos' Knowledge Operations orchestrator.
+ * kos — mnemos' Knowledge Operations orchestrator.
  *
- * Drives whatever AI assistant the user configured (`mnemos config set agent ...`)
- * to implement a generated plan in an isolated git worktree. Mnemos owns the
+ * Drives whatever AI assistant the user configured (`xkg config set agent ...`)
+ * to implement a generated plan in an isolated git worktree. mnemos owns the
  * harness-independent parts: fetching the plan, the worktree, and reporting the
  * Verification Checklist. The assistant is a black box — model-agnostic by design.
  */
@@ -54,10 +54,10 @@ function run(cmd, cwd) {
 export async function kos(apiKey, opts = {}) {
     const cfg = readConfig();
     if (!cfg.agent) {
-        console.error("No agent configured. Tell Mnemos which AI assistant to drive:\n");
-        console.error('  mnemos config set agent "claude -p"               # Claude Code');
-        console.error('  mnemos config set agent "codex exec"              # Codex');
-        console.error('  mnemos config set agent "aider --yes --message"   # Aider');
+        console.error("No agent configured. Tell xkg which AI worker to drive:\n");
+        console.error('  xkg config set agent "claude -p"               # Claude Code');
+        console.error('  xkg config set agent "codex exec"              # Codex');
+        console.error('  xkg config set agent "aider --yes --message"   # Aider');
         process.exit(1);
     }
     // 1. Resolve the plan — explicit filename, or the newest saved plan
@@ -77,7 +77,7 @@ export async function kos(apiKey, opts = {}) {
         repoRoot = run("git rev-parse --show-toplevel");
     }
     catch {
-        console.error("mnemos kos must be run inside a git repository.");
+        console.error("xkg kos must be run inside a git repository.");
         process.exit(1);
         return;
     }

package/dist/cli/mcp-server.js CHANGED Viewed

@@ -1,12 +1,20 @@
-// MCP server that runs locally via stdio and proxies to the hosted Mnemos API.
-// Used by Claude Code: claude mcp add mnemos -- npx mnemos-capture serve-mcp --key <api-key>
-const HOSTED_URL = "https://mnemos-capture.vercel.app/api/mcp";
+// MCP server that runs locally via stdio and proxies to the hosted API.
+// Used by Claude Code: claude mcp add xkg -- npx mnemos-capture serve-mcp --key <api-key>
+const DEFAULT_HOSTED_URL = "https://mnemos-capture.vercel.app/api/mcp";
+/** Override for pointing the proxy at a local instance during development. */
+const HOSTED_URL = process.env.XKG_API_URL ?? process.env.XMU_API_URL ?? process.env.MNEMOS_API_URL ?? DEFAULT_HOSTED_URL;
 function sendMessage(msg) {
     process.stdout.write(`${JSON.stringify(msg)}\n`);
 }
+/** In-flight proxied requests, so shutdown can wait for them. */
+const pending = new Set();
+function rpcError(id, message) {
+    sendMessage({ jsonrpc: "2.0", id, error: { code: -32603, message } });
+}
 async function proxyToHosted(apiKey, msg) {
+    let res;
     try {
-        const res = await fetch(HOSTED_URL, {
+        res = await fetch(HOSTED_URL, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
@@ -14,16 +22,49 @@ async function proxyToHosted(apiKey, msg) {
             },
             body: JSON.stringify(msg),
         });
-        const data = (await res.json());
-        sendMessage(data);
     }
     catch (err) {
-        sendMessage({
-            jsonrpc: "2.0",
-            id: msg.id,
-            error: { code: -32603, message: err instanceof Error ? err.message : "Proxy error" },
-        });
+        const detail = err instanceof Error ? err.message : "unknown error";
+        rpcError(msg.id, `Could not reach xkg at ${HOSTED_URL}: ${detail}`);
+        return;
+    }
+    const body = await res.text().catch(() => "");
+    const result = interpretResponse(res.status, res.headers.get("content-type"), body);
+    if ("error" in result) {
+        rpcError(msg.id, result.error);
+        return;
     }
+    sendMessage(result.data);
+}
+/**
+ * Turn a raw HTTP reply into either parsed JSON-RPC data or a useful message.
+ *
+ * Parsing straight to JSON turns any non-JSON reply — an HTML error page from a
+ * 500, a proxy block page, a login redirect — into "Unexpected token '<'",
+ * which says nothing about what actually happened. Reporting the status and a
+ * snippet makes the real cause visible in the MCP client.
+ *
+ * Exported for testing; this is the logic worth covering, not the stdio plumbing.
+ */
+export function interpretResponse(status, contentType, body) {
+    const type = contentType ?? "";
+    if (!type.includes("application/json")) {
+        const snippet = body.trim().slice(0, 200).replace(/\s+/g, " ");
+        return {
+            error: `xkg returned a non-JSON response (HTTP ${status}${type ? `, ${type}` : ""})${snippet ? `: ${snippet}` : ""}`,
+        };
+    }
+    try {
+        return { data: JSON.parse(body) };
+    }
+    catch {
+        return { error: `xkg returned malformed JSON (HTTP ${status}).` };
+    }
+}
+/** Track a proxied request so shutdown can await it. */
+function track(p) {
+    pending.add(p);
+    void p.finally(() => pending.delete(p));
 }
 export async function serveMcp() {
     // Parse --key flag
@@ -31,7 +72,7 @@ export async function serveMcp() {
     const keyIdx = args.indexOf("--key");
     const apiKey = keyIdx !== -1 ? args[keyIdx + 1] : undefined;
     if (!apiKey) {
-        process.stderr.write("\nMnemos MCP server requires an API key.\n");
+        process.stderr.write("\nxkg MCP server requires an API key.\n");
         process.stderr.write("Usage: npx -y mnemos-capture@latest serve-mcp --key <your-api-key>\n\n");
         process.stderr.write("Get your API key at: https://mnemos-capture.vercel.app/onboard\n\n");
         process.exit(1);
@@ -56,7 +97,7 @@ export async function serveMcp() {
     catch {
         // Non-fatal — hook setup should never block the MCP server from starting
     }
-    process.stderr.write("Mnemos MCP server starting (proxying to hosted instance)...\n");
+    process.stderr.write("xkg MCP server starting (proxying to hosted instance)...\n");
     let buffer = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
@@ -72,12 +113,17 @@ export async function serveMcp() {
                 // Handle notifications/initialized locally (no response needed)
                 if (msg.method === "notifications/initialized")
                     continue;
-                void proxyToHosted(apiKey, msg);
+                track(proxyToHosted(apiKey, msg));
             }
             catch {
                 process.stderr.write(`Failed to parse: ${line}\n`);
             }
         }
     });
-    process.stdin.on("end", () => process.exit(0));
+    // Wait for in-flight requests before exiting: exiting immediately on stdin
+    // close discards responses that were still being fetched, so the client sees
+    // silence rather than an answer or an error.
+    process.stdin.on("end", () => {
+        void Promise.allSettled([...pending]).then(() => process.exit(0));
+    });
 }

package/dist/cli/version-check.js CHANGED Viewed

@@ -59,7 +59,7 @@ export async function maybeSelfUpgrade() {
     const latest = await getLatestVersion();
     if (!latest || !isNewer(latest, current))
         return false;
-    process.stderr.write(`Mnemos: upgrading to v${latest} (was v${current})...\n`);
+    process.stderr.write(`xkg: upgrading to v${latest} (was v${current})...\n`);
     const child = spawn("npx", ["-y", `mnemos-capture@${latest}`, ...process.argv.slice(2)], {
         stdio: "inherit",
         env: { ...process.env, MNEMOS_UPGRADED: "1" },

package/package.json CHANGED Viewed

@@ -1,10 +1,12 @@
 {
   "name": "mnemos-capture",
-  "version": "1.2.1",
-  "description": "Capture anything. Your agents apply it. A knowledge pipeline that ingests the outside world and makes it directly actionable by any AI agent over MCP.",
+  "version": "1.4.0",
+  "description": "xkg — Turn what you discover into context your AI workers can use. Capture once, then brief, plan, and execute with any MCP-compatible tool.",
   "type": "module",
   "bin": {
-    "mnemos-capture": "./dist/cli/index.js"
+    "mnemos-capture": "./dist/cli/index.js",
+    "xkg": "./dist/cli/index.js",
+    "xmu": "./dist/cli/index.js"
   },
   "scripts": {
     "dev": "next dev",
@@ -14,10 +16,14 @@
     "prepublishOnly": "npm run build:cli",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:e2e": "playwright test"
+    "test:e2e": "playwright test",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit"
   },
   "keywords": [
     "ai",
+    "xkg",
+    "xmu",
     "knowledge",
     "capture",
     "claude",
@@ -41,24 +47,26 @@
     "README.md"
   ],
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.36.3",
+    "@anthropic-ai/sdk": "^0.127.0",
     "@vercel/postgres": "^0.10.0",
-    "next": "^16.1.6",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0"
+    "next": "^16.3.5",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0"
   },
   "devDependencies": {
-    "@playwright/test": "^1.61.1",
-    "@types/node": "^20",
-    "@types/react": "^19",
-    "@types/react-dom": "^19",
-    "autoprefixer": "^10.4.21",
+    "@playwright/test": "^1.62.1",
+    "@types/node": "^26",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "autoprefixer": "^10.6.1",
+    "eslint": "^9.39.5",
+    "eslint-config-next": "^16.3.5",
     "postcss": "^8.5.3",
     "tailwindcss": "^3.4.17",
-    "typescript": "^5",
-    "vitest": "^4.1.8"
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.1"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20.9"
   }
 }