@cairnkeep/cli 1.0.5 → 1.1.1

package/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+All notable user-facing changes are documented here. This project follows
+[Semantic Versioning](https://semver.org/).
+
+## [1.1.1] - 2026-07-14
+
+### Fixed
+
+- Ship and resolve the default document-RAG sync helper from the npm package,
+  with user-owned XDG config/state paths and legacy-path compatibility.
+- Make repository CI install locked root dependencies before running checks.
+- Make the clean macOS bootstrap test create its target directory explicitly.
+
+### Changed
+
+- Add release-to-npm automation with provenance, tarball, and SBOM artifacts.
+- Document supported clients, platforms, storage placement, and optional data
+  flows more explicitly.
+- Add community contribution, support, and conduct templates.
+
+## [1.1.0] - 2026-07-13
+
+### Added
+
+- Add authenticated remote HTTP memory with stable per-project session routing.
+- Add explicit client routing headers for scopes and document-RAG workspaces.
+- Document local, remote, export, backup, and bearer-token deployment models.
+
+## [1.0.5] - 2026-07-13
+
+### Fixed
+
+- Make the npm tarball install self-contained and verify it on clean systems.
+- Preserve executable permissions and Bash 3.2 portability on macOS.
+- Add backup-first uninstall and SQLite-safe memory export/import guidance.
+
+[1.1.1]: https://github.com/cairnkeep/cairnkeep/compare/v1.1.0...v1.1.1
+[1.1.0]: https://github.com/cairnkeep/cairnkeep/compare/v1.0.5...v1.1.0
+[1.0.5]: https://github.com/cairnkeep/cairnkeep/compare/v1.0.4...v1.0.5

package/CONTRIBUTING.md

@@ -15,7 +15,9 @@ Contributions are welcome through GitHub issues and pull requests.
 
 ## Development setup
 
-The memory server requires Node.js 18 or newer. Node.js 20 is used in CI.
+The memory server requires Node.js 18 or newer. Node.js 22 or 24 is recommended
+for development; current CI uses Node.js 24 and retains a clean Node.js 18
+compatibility boot check.
 
 ```bash
 git clone https://github.com/cairnkeep/cairnkeep.git
@@ -47,3 +49,6 @@ endpoints. They are not part of the default offline test suite.
 
 By contributing, you agree that your contribution is licensed under the
 Apache License 2.0 found in [LICENSE](LICENSE).
+
+Release publishing is maintainer-only and documented in
+[docs/releasing.md](docs/releasing.md).

package/README.md

@@ -1,5 +1,9 @@
 # Cairnkeep
 
+[![CI](https://github.com/cairnkeep/cairnkeep/actions/workflows/ci.yml/badge.svg)](https://github.com/cairnkeep/cairnkeep/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@cairnkeep/cli)](https://www.npmjs.com/package/@cairnkeep/cli)
+[![license](https://img.shields.io/npm/l/@cairnkeep/cli)](LICENSE)
+
 > A durable, harness-agnostic **memory + context layer** for coding agents.
 
 A *cairn* is a stack of stones left as a trail marker for whoever follows; a
@@ -20,6 +24,23 @@ a thin routing seam (`route_check`), both of which delegate to
 [token-miser](https://github.com/cairnkeep/token-miser), a public
 cairnkeep-org sibling project.
 
+## Compatibility
+
+Node.js 22 or 24 is recommended. Node.js 18 and 20 remain compatible for the
+1.x line but are end-of-life upstream; the minimum will move in the next major
+release.
+
+| Client or platform | Support level |
+|---|---|
+| Claude Code on Linux/macOS | Memory server plus commands, agents, hooks, and launchers |
+| OpenCode on Linux/macOS | Memory server plus commands, plugins, hooks, and launchers |
+| Codex CLI | Memory MCP server; no Cairnkeep operating-layer assets |
+| Other MCP clients | Memory and optional domain-knowledge MCP tools |
+| Native Windows | Not supported by the Bash-based installer; use WSL (not yet CI-verified) |
+
+Linux, macOS, Bash 3.2 portability, and a clean Node 18 compatibility install
+are exercised in CI.
+
 ## Components
 
 - **`mcp-memory-server/`** — an MCP server exposing durable, scoped memory
@@ -85,6 +106,19 @@ cd /path/to/project && cairn doctor
 ./.ai/start-claude.sh
 ```
 
+After setup, the basic workflow is intentionally small:
+
+```text
+> /remember Use transactional migrations for schema changes
+Stored as patterns/transactional-migrations.
+
+> /recall transactional migrations
+patterns/transactional-migrations: Use transactional migrations for schema changes
+```
+
+The exact command rendering depends on the client. Any MCP client can call
+`memory_write` and `memory_search` directly.
+
 Prefer working from a clone? Build the server with `cd mcp-memory-server && npm
 install && npm run build`, then use `scripts/sync-claude-assets.sh` and
 `bin/cairn` in place of the installed `cairn`.
@@ -139,8 +173,14 @@ search):
 | `CAIRN_EXPLORE_REPO_ROOT` | Default repo root for `context_explore` when no per-call `repo_root` is given |
 | `CAIRN_EXTRA_SETTINGS` | Optional settings/config file the launcher layers onto the harness (wrapper seam) |
 | `CAIRN_ANYTHINGLLM_SYNC_SCRIPT` | Override path to the domain-knowledge sync script (when the integration lives outside the repo) |
+| `CAIRN_ANYTHINGLLM_PROJECTS_FILE` | Override path to the bundled sync script's project configuration |
+| `CAIRN_ANYTHINGLLM_STATE_FILE` | Override path to the bundled sync script's incremental state |
 
 Without an API key, search degrades gracefully to substring matching.
+There is no Cairnkeep telemetry. Optional extraction, embeddings, document RAG,
+remote memory, and delegated exploration can send content to endpoints you
+configure. Review [Privacy and data flow](docs/privacy-and-data-flow.md) before
+enabling them.
 
 ## More
 
@@ -148,7 +188,9 @@ Without an API key, search degrades gracefully to substring matching.
 - **Building a private overlay** (wrap cairnkeep for your org/provider) — [docs/building-an-overlay.md](docs/building-an-overlay.md)
 - **Full operating guide** — [docs/operating.md](docs/operating.md)
 - **Memory storage and deployment** — [docs/storage.md](docs/storage.md)
+- **Privacy and data flow** — [docs/privacy-and-data-flow.md](docs/privacy-and-data-flow.md)
 - **Git providers** — [docs/git-providers.md](docs/git-providers.md)
+- **Support** — [SUPPORT.md](SUPPORT.md)
 - **Contributing** — [CONTRIBUTING.md](CONTRIBUTING.md)
 - **Security policy** — [SECURITY.md](SECURITY.md)
 

package/docs/building-an-overlay.md

@@ -107,6 +107,13 @@ All optional, all env-gated — a wrapper turns them on by setting the env:
 Point the RAG sync script at your own copy (`CAIRN_ANYTHINGLLM_SYNC_SCRIPT`) so the
 integration scripts live in your overlay, not the core.
 
+For a fleet that shares one trusted HTTP service, have the overlay generate
+project-local Claude Code and OpenCode MCP entries with `X-Cairn-Project`,
+`X-Cairn-Scopes`, and `X-Cairn-AnythingLLM-Workspaces`. This preserves local
+project isolation and workspace defaults while keeping the databases and RAG
+credentials on the server host. Keep bearer tokens in environment-backed
+secret storage, not generated project files.
+
 ## Checklist
 
 - [ ] cairnkeep pinned to a version; no core files copied or patched

package/docs/domain-knowledge.md

@@ -28,7 +28,9 @@ work exactly the same without them.
 |---|---|
 | `ANYTHINGLLM_API_KEY` | **Required** for the domain-knowledge tools. Unset → the tools error at call time (everything else works). |
 | `ANYTHINGLLM_BASE_URL` | AnythingLLM base URL. Default `http://localhost:3001`. |
-| `CAIRN_ANYTHINGLLM_SYNC_SCRIPT` | Path to the document-sync script used by `domain_knowledge_sync`. The core does not bundle one — point this at your own (see below). Unset → `domain_knowledge_sync` uses the in-repo default path. |
+| `CAIRN_ANYTHINGLLM_SYNC_SCRIPT` | Optional path to a custom document-sync script. Unset -> `domain_knowledge_sync` uses the bundled deployment-neutral example. |
+| `CAIRN_ANYTHINGLLM_PROJECTS_FILE` | Optional config path for the bundled sync script. Default `${XDG_CONFIG_HOME:-~/.config}/cairnkeep/anythingllm-projects.json`. |
+| `CAIRN_ANYTHINGLLM_STATE_FILE` | Optional state path for the bundled sync script. Default `${XDG_STATE_HOME:-~/.local/state}/cairnkeep/anythingllm-sync.json`. |
 
 The workspaces the tools target come from the project's **memory config** — the
 first of `.agent/memory.json`, `.opencode/memory.json`, `.claude/memory.json`, or
@@ -45,6 +47,18 @@ first of `.agent/memory.json`, `.opencode/memory.json`, `.claude/memory.json`, o
 configured workspace that is not `engineering-patterns` (the conventional shared
 workspace). With no workspace given and none configured, it errors.
 
+In local stdio mode, that config is read from the client project's working
+directory. In remote HTTP mode, the server cannot read files from the client
+PC. Configure `ANYTHINGLLM_BASE_URL`, `ANYTHINGLLM_API_KEY`, and any sync script
+on the HTTP server host, then send the project workspaces in the
+`X-Cairn-AnythingLLM-Workspaces` session header. See
+[Memory storage and deployment](storage.md#per-project-remote-sessions).
+
+The HTTP server performs queries and runs the sync script on its own host. A
+remote sync script must therefore obtain project documents from a server-side
+checkout, object store, or git host; it cannot read an arbitrary client PC's
+working tree.
+
 ## Setup (query)
 
 ```bash
@@ -61,10 +75,10 @@ returns a grounded answer.
 
 ## Setup (sync / embedding)
 
-`domain_knowledge_sync` shells out to a document-upload/embed script. Because the
-scripts that talk to your AnythingLLM (and any include/exclude rules) are
-deployment-specific, they live in **your** wrapper, not the core — point cairnkeep
-at yours:
+`domain_knowledge_sync` shells out to a document-upload/embed script. Cairnkeep
+ships a deployment-neutral example that reads its project mapping from a config
+file. For deployment-specific authentication, checkout rules, or document
+selection, keep a customized script in your overlay and point Cairnkeep at it:
 
 ```bash
 CAIRN_ANYTHINGLLM_SYNC_SCRIPT=/abs/path/to/your/sync_to_anythingllm.py
@@ -74,11 +88,13 @@ The script receives the workspace slug and is expected to upload + embed the
 project's documents into that AnythingLLM workspace. See
 [building-an-overlay.md](building-an-overlay.md) for the wrapper pattern.
 
-A working, deployment-agnostic starting point lives in
-[`examples/anythingllm/`](../examples/anythingllm/): an incremental
-(sha256-tracked) multi-project sync script plus a config schema. Copy it, adapt
-`anythingllm-projects.json`, and point `CAIRN_ANYTHINGLLM_SYNC_SCRIPT` at your
-copy.
+The bundled default lives in
+[`examples/anythingllm/`](../examples/anythingllm/): an incremental,
+SHA-256-tracked multi-project sync script plus a config schema. Put a customized
+copy of the example JSON at the default user config path, or set
+`CAIRN_ANYTHINGLLM_PROJECTS_FILE`. Existing custom scripts with configuration
+and state beside the script retain that legacy behavior. To customize the
+implementation itself, set `CAIRN_ANYTHINGLLM_SYNC_SCRIPT` to the adapted copy.
 
 ## Not using RAG?
 

package/docs/operating.md

@@ -156,6 +156,8 @@ vendor or host.
 | `ANYTHINGLLM_API_KEY` | Required to enable the optional `domain_knowledge_*` RAG tools (unset → those tools error at call time; nothing else affected). See [domain-knowledge.md](domain-knowledge.md) |
 | `ANYTHINGLLM_BASE_URL` | AnythingLLM base URL for `domain_knowledge_*` (default `http://localhost:3001`) |
 | `CAIRN_ANYTHINGLLM_SYNC_SCRIPT` | Override path to the `domain_knowledge_sync` document-sync script (unset → in-repo default) |
+| `CAIRN_ANYTHINGLLM_PROJECTS_FILE` | Override path to the bundled sync script's project configuration |
+| `CAIRN_ANYTHINGLLM_STATE_FILE` | Override path to the bundled sync script's incremental state |
 
 ### Domain knowledge (RAG via AnythingLLM, opt-in)
 
@@ -267,9 +269,11 @@ is guarded and **fails closed**:
 Requests without a valid bearer token get `401`; requests with an unexpected
 `Host` header get `403`. Keep HTTP mode bound to `127.0.0.1` unless you have a
 specific reason to expose it, and use a long random token. HTTP mode has no
-per-user ACL or tenant isolation, and every client shares the server process's
-`project` database. See [Memory storage and deployment](storage.md) for the
-placement rules, client registration, TLS requirements, and backup boundaries.
+per-user ACL or tenant isolation. Clients may bind sessions to separate project
+databases with validated `X-Cairn-Project` routing metadata, but that metadata
+is not an authorization boundary. See [Memory storage and deployment](storage.md)
+for the placement rules, client registration, TLS requirements, project headers,
+and backup boundaries.
 
 ## The workflow
 

package/docs/privacy-and-data-flow.md

@@ -0,0 +1,49 @@
+# Privacy and data flow
+
+Cairnkeep has no telemetry, analytics collector, hosted control plane, or
+automatic remote-service discovery. A default local stdio installation stores
+memory in SQLite on the machine running the MCP server and makes no model or RAG
+request unless the corresponding endpoint and credential are configured.
+
+## Data flows
+
+| Feature | Data that can leave the server machine | Destination |
+|---|---|---|
+| Local substring search | None | Local SQLite only |
+| Embedding-ranked search | Stored memory values that are not cached, plus the search query | `CAIRN_MEMORY_EMBEDDING_URL` or `CAIRN_LLM_API_URL` |
+| `memory_extract` | The transcript supplied to the tool | `CAIRN_LLM_API_URL` |
+| `domain_knowledge_query` | Workspace slug and query | `ANYTHINGLLM_BASE_URL` |
+| `domain_knowledge_sync` | Files selected by the sync configuration | `ANYTHINGLLM_BASE_URL` |
+| `route_check` | A health request, with no memory or prompt content | `CAIRN_ROUTE_ENDPOINT` |
+| `context_explore` | Repository path and query are passed to the configured local executable | `CAIRN_EXPLORE_BINARY`; any further data flow is controlled by that tool |
+| Remote HTTP memory | MCP requests and responses, including memory content | The explicitly registered Cairnkeep HTTP server |
+
+Model endpoints may be local or remote. Cairnkeep cannot determine a provider's
+retention, training, or logging policy; verify it before sending confidential
+material. Disabling `CAIRN_LLM_API_KEY`, `ANYTHINGLLM_API_KEY`, remote HTTP
+registration, and delegated tools keeps the core memory workflow local.
+
+## Data at rest
+
+Memories are stored in SQLite databases. They are not encrypted by Cairnkeep at
+the application layer. Use operating-system disk encryption, restrictive file
+permissions, encrypted backups, and host access controls appropriate to the
+sensitivity of the material. SQLite `-wal` and `-shm` sidecars and exported
+archives can contain sensitive content too.
+
+Project-scoped and named/global database locations are documented in
+[Memory storage and deployment](storage.md). A remote client stores memory on
+the remote server host; changing a storage environment variable on the client
+does not relocate that server's databases.
+
+## Credentials and transport
+
+Keep API keys and bearer tokens out of repositories and command output. Load
+them from a secret manager or protected environment file. For remote HTTP mode,
+use TLS or an encrypted private network and keep the raw listener on loopback.
+One HTTP bearer token grants access to the entire server; Cairnkeep does not
+provide tenant isolation or per-scope authorization.
+
+Before sharing diagnostics, remove credentials, private endpoints, database
+files, memory values, local paths, and project names. Report vulnerabilities
+through the private channel in [SECURITY.md](../SECURITY.md).

package/docs/releasing.md

@@ -0,0 +1,33 @@
+# Releasing
+
+Publishing is driven by a GitHub Release. Maintainers do not publish the package
+from a workstation.
+
+## Release contract
+
+1. Update the root `package.json` version and `CHANGELOG.md` on a pull request.
+2. Run `npm ci`, `npm run check:public`, and
+   `npm --prefix mcp-memory-server test`.
+3. Merge only after every required CI check passes.
+4. Publish a GitHub Release whose tag is exactly `v<package.json version>`.
+5. The `Publish release` workflow checks out that immutable tag, repeats the
+   tests, and publishes `@cairnkeep/cli` with npm provenance.
+6. The workflow attaches the npm tarball, a CycloneDX SBOM, and SHA-256 checksums
+   to the GitHub Release.
+
+Stable versions must use a stable GitHub Release and publish to npm's `latest`
+tag. SemVer prerelease versions must use a GitHub prerelease and publish to
+`next`. A mismatch fails before publication.
+
+The workflow is safe to rerun: it skips `npm publish` when that exact version is
+already present, then regenerates and replaces the release artifacts.
+
+## Repository configuration
+
+The repository must provide an `NPM_TOKEN` Actions secret authorized to publish
+`@cairnkeep/cli`. Keep that credential out of local files and rotate it according
+to the npm account's security policy. The workflow grants only `contents: write`
+and `id-token: write`; the latter is required for npm provenance.
+
+Treat a published version as immutable. If a release is wrong, fix it in a new
+version rather than moving its tag or replacing the npm package.

package/docs/storage.md

@@ -53,12 +53,34 @@ With this topology, the databases are on the server host, not the client PC.
 Setting `CAIRN_AGENTFS_BASE_DIR` on the client does not redirect a remote
 server; set it in the server service environment.
 
+### Per-project remote sessions
+
+Remote clients can bind an MCP session to a stable project identity and send
+the memory configuration that a local server would read from `memory.json`:
+
+| Header | Purpose |
+|---|---|
+| `X-Cairn-Project` | Kebab-case project identity, up to 64 characters |
+| `X-Cairn-Scopes` | Comma-separated scopes used when a tool reads scope `all` |
+| `X-Cairn-AnythingLLM-Workspaces` | Comma-separated AnythingLLM workspace slugs; the first non-`engineering-patterns` workspace is the default |
+
+When `X-Cairn-Project` is present, `project` scope is stored at
+`${CAIRN_AGENTFS_BASE_DIR}/projects/<project-id>.db`. Sessions with different
+project identities therefore do not share project memory. Without the header,
+HTTP mode retains the legacy behavior and resolves `project` from the server
+working directory.
+
+These headers are session routing metadata, not authorization. The bearer
+token still grants access to the entire server, including the ability to choose
+another valid project identity. Use separate server instances for separate
+trust domains.
+
 HTTP mode is one trusted storage domain:
 
 - One bearer token grants access to every exposed memory tool.
 - There is no per-user ACL, tenant isolation, or client-specific filesystem.
-- `project` scope resolves from the server process's working directory, so all
-  HTTP clients of that process share the same `project.db`.
+- Sessions without `X-Cairn-Project` share the project database resolved from
+  the server process's working directory.
 - Use one server instance per isolation boundary. Do not offer one instance to
   mutually untrusted users.
 - Keep the Cairnkeep listener on loopback behind a TLS reverse proxy, or use an
@@ -107,8 +129,18 @@ claude mcp remove cairn-memory -s user 2>/dev/null || true
 claude mcp add --transport http -s user \
   cairn-memory "$CAIRN_MEMORY_REMOTE_URL" \
   --header "Authorization: Bearer $CAIRN_MEMORY_HTTP_TOKEN"
+
+codex mcp remove cairn-memory 2>/dev/null || true
+codex mcp add cairn-memory \
+  --url "$CAIRN_MEMORY_REMOTE_URL" \
+  --bearer-token-env-var CAIRN_MEMORY_HTTP_TOKEN
 ```
 
+Codex reads the bearer token from the named environment variable when it
+starts. Do not run `codex mcp login cairn-memory`: that command starts an OAuth
+flow, while Cairnkeep intentionally uses a static bearer token and advertises
+no OAuth authorization endpoint.
+
 OpenCode is configured separately in its per-user `opencode.json`. It supports
 environment references in remote MCP headers, so the token does not need to be
 written literally into the JSON:
@@ -132,3 +164,24 @@ Ensure the secret-manager bootstrap exports `CAIRN_MEMORY_HTTP_TOKEN` before
 OpenCode starts. Preserve any other keys already present in `opencode.json`
 rather than replacing the whole file. The URL, token, private host names, and
 device-specific configuration must never be committed to this public project.
+
+For distinct project memory, install a project-local MCP entry with the same
+URL and authorization header plus the three routing headers. Claude Code
+expands `${VAR}` references in project `.mcp.json` URL and header values;
+OpenCode uses `{env:VAR}` references. A private overlay should generate and
+merge these files so secrets remain in the process environment rather than the
+repository.
+
+For Codex, put the routing configuration in the trusted project's private
+`.codex/config.toml` and exclude it from version control:
+
+```toml
+[mcp_servers.cairn-memory]
+url = "https://memory.example.com/mcp"
+bearer_token_env_var = "CAIRN_MEMORY_HTTP_TOKEN"
+
+[mcp_servers.cairn-memory.http_headers]
+"X-Cairn-Project" = "example-project"
+"X-Cairn-Scopes" = "identity,personal,project"
+"X-Cairn-AnythingLLM-Workspaces" = "engineering-patterns"
+```

package/examples/anythingllm/README.md

@@ -0,0 +1,66 @@
+# AnythingLLM sync — reference example
+
+The bundled reference implementation of the document-sync script that
+Cairnkeep's `domain_knowledge_sync` tool shells out to. It is a usable,
+deployment-neutral starting point; copy and adapt it when endpoint,
+authentication, or include/exclude rules are deployment-specific.
+
+See [`../../docs/domain-knowledge.md`](../../docs/domain-knowledge.md) for the
+full RAG picture.
+
+## What it does
+
+Incrementally syncs each configured project's docs into its own AnythingLLM
+workspace: creates the workspace, uploads changed files (tracked by sha256),
+embeds them, and removes docs that disappeared. Supports `--dry-run`, `--full`,
+`--replace`, `--rebuild-state`, `--list`, and `--project <slug>`.
+
+## Setup
+
+1. Requires Python 3 and `requests` (`pip install requests`).
+2. Copy the config to the default user config location and fill in your
+   projects:
+   ```bash
+   mkdir -p "${XDG_CONFIG_HOME:-$HOME/.config}/cairnkeep"
+   cp anythingllm-projects.example.json \
+     "${XDG_CONFIG_HOME:-$HOME/.config}/cairnkeep/anythingllm-projects.json"
+   # edit: set each project's absolute path, slug, and include/exclude globs
+   ```
+3. Point at your AnythingLLM instance:
+   ```bash
+   export ANYTHINGLLM_BASE_URL=http://localhost:3001   # default
+   export ANYTHINGLLM_API_KEY=<your AnythingLLM API key>
+   ```
+4. First upload, then keep it in sync:
+   ```bash
+   python3 sync_to_anythingllm.py --full --project my-project
+   python3 sync_to_anythingllm.py                       # incremental, all projects
+   ```
+
+## Wiring into cairnkeep
+
+The installed server uses this script by default. To use an adapted copy, set:
+
+```bash
+CAIRN_ANYTHINGLLM_SYNC_SCRIPT=/abs/path/to/sync_to_anythingllm.py
+```
+
+Override the user-owned configuration or state locations when needed:
+
+```bash
+CAIRN_ANYTHINGLLM_PROJECTS_FILE=/abs/path/to/anythingllm-projects.json
+CAIRN_ANYTHINGLLM_STATE_FILE=/abs/path/to/anythingllm-sync.json
+```
+
+For backward compatibility, an existing `anythingllm-projects.json` beside a
+customized script and its `.anythingllm-sync.json` state are still used when the
+override variables are unset.
+
+## Files
+
+| File | Committed? | Notes |
+|---|---|---|
+| `sync_to_anythingllm.py` | yes | the script |
+| `anythingllm-projects.example.json` | yes | schema template |
+| `anythingllm-projects.json` | **no** | User-owned config; defaults under the XDG config directory |
+| `anythingllm-sync.json` | **no** | Machine-local SHA-256 state; defaults under the XDG state directory |

package/examples/anythingllm/anythingllm-projects.example.json

@@ -0,0 +1,30 @@
+{
+  "projects": [
+    {
+      "slug": "my-project",
+      "display_name": "My Project Documentation",
+      "path": "/abs/path/to/my-project",
+      "patterns": [
+        "README.md",
+        "docs/**/*.md"
+      ],
+      "exclude_patterns": [
+        "CHANGELOG.md",
+        "LICENSE.md"
+      ]
+    },
+    {
+      "slug": "another-project",
+      "display_name": "Another Project Docs",
+      "path": "/abs/path/to/another-project",
+      "patterns": [
+        "AGENTS.md",
+        "docs/**/*.md",
+        ".planning/wiki/**/*.md"
+      ],
+      "exclude_patterns": [
+        ".planning/wiki/tmp/**"
+      ]
+    }
+  ]
+}