@cairnkeep/cli 2.5.0 → 2.7.0

package/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable user-facing changes are documented here. This project follows
 
 ## [Unreleased]
 
+## [2.7.0] - 2026-08-02
+
+### Added
+
+- Add a Cairnkeep-owned `cairn graph build|query|status|diff|explain|path`
+  workflow, matching Claude Code and OpenCode `/graphify` modes, shell
+  completion, local-only code indexing, atomic publication, and snapshot diffs
+  without installing Graphify-owned harness assets or re-indexing generated
+  graph artifacts; add thin Pi prompt and Kimi Skill adapters that expose
+  `/graphify` while delegating exclusively to `cairn graph`, with explicit sync,
+  uninstall, package, and shell-completion coverage.
+
+## [2.6.0] - 2026-07-29
+
+### Added
+
+- Add Qwen Code as a supported memory client with a generated project launcher,
+  local stdio guidance, and tested authenticated remote HTTP configuration.
+- Expand the harness comparison to cover current native plugin and MCP clients,
+  while keeping memory-only support separate from the full operating layer.
+
 ## [2.5.0] - 2026-07-29
 
 ### Added
@@ -211,7 +232,9 @@ stored memories.
 - Preserve executable permissions and Bash 3.2 portability on macOS.
 - Add backup-first uninstall and SQLite-safe memory export/import guidance.
 
-[Unreleased]: https://github.com/cairnkeep/cairnkeep/compare/v2.5.0...HEAD
+[Unreleased]: https://github.com/cairnkeep/cairnkeep/compare/v2.7.0...HEAD
+[2.7.0]: https://github.com/cairnkeep/cairnkeep/compare/v2.6.0...v2.7.0
+[2.6.0]: https://github.com/cairnkeep/cairnkeep/compare/v2.5.0...v2.6.0
 [2.5.0]: https://github.com/cairnkeep/cairnkeep/compare/v2.4.0...v2.5.0
 [2.4.0]: https://github.com/cairnkeep/cairnkeep/compare/v2.3.1...v2.4.0
 [2.3.1]: https://github.com/cairnkeep/cairnkeep/compare/v2.3.0...v2.3.1

package/README.md

@@ -10,16 +10,16 @@ A *cairn* is a stack of stones left as a trail marker for whoever follows; a
 *keep* is where you store what matters. **Cairnkeep** is where coding agents
 stack durable memory — decisions, pitfalls, patterns — and follow the trail
 across sessions, projects, and harnesses (Claude Code, OpenCode, Kimi Code,
-Pi, and other MCP clients).
+Qwen Code, Pi, and other MCP clients).
 
 ## Status
 
-Shipped: the memory server, the `cairn` CLI (`bootstrap`, `memory-server`, `sync`, `sync-pi`,
+Shipped: the memory server, the `cairn` CLI (`bootstrap`, `memory-server`, `sync`, `sync-pi`, `sync-kimi`,
 `doctor`, `trajectory`, `artifact`, `notes`, `memory`, `eval`, `audit-timer`, `completion`, `uninstall`) installable via
 `npm i -g @cairnkeep/cli`, and the
 operating layer (commands,
 agents, hooks) installed on Claude Code and OpenCode, plus a native Pi
-trajectory extension. The generic launchers
+trajectory extension and thin Pi/Kimi graph adapters. The generic launchers
 expose wrapper seams (`.ai/pre-launch.sh`, `CAIRN_EXTRA_SETTINGS`,
 `.ai/post-exit.sh`) so an enterprise wrapper can add provider/credential setup
 without forking them. Also shipped: context exploration (`/context-explore`) and
@@ -37,17 +37,23 @@ and 20 are end-of-life upstream.
 |---|---|
 | 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 |
-| Kimi Code on Linux/macOS | Memory MCP server plus project launcher; no Cairnkeep operating-layer assets yet |
-| Pi on Linux/macOS | Native opt-in trajectory extension and launcher; no bundled MCP bridge |
+| Kimi Code on Linux/macOS | Memory MCP server, project launcher, and opt-in `/graphify` Skill |
+| Qwen Code on Linux/macOS | Memory MCP server plus project launcher; no Cairnkeep operating-layer assets yet |
+| Pi on Linux/macOS | Native opt-in trajectory extension, launcher, and `/graphify` prompt; no bundled MCP bridge |
 | 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) |
 
+The `cairn graph` CLI is harness-independent and can be run from a project
+shell used by Kimi Code, Pi, Qwen Code, Codex, or another client. Claude Code,
+OpenCode, Pi, and Kimi can receive thin `/graphify` adapters; those adapters do
+not imply equivalent hooks, agents, or MCP support.
+
 Linux, macOS, Bash 3.2 portability, and clean Node 22/24/26 runtime checks
 are exercised in CI.
 
 See [Harness compatibility](docs/harness-compatibility.md) for exact support
-levels, Kimi configuration, and candidates that are not yet runtime-tested.
+levels, Kimi and Qwen configuration, and candidates that are not yet runtime-tested.
 
 ## Try with Podman
 
@@ -78,13 +84,17 @@ storage paths, secrets, and private derived images, see
   `cairn artifact list|show|delete|prune` manages opt-in local artifacts;
   `cairn eval validate|run|ablate|report|prune|delete` coordinates explicit
   local two-pass and one-capability-at-a-time measurements;
+  `cairn graph build|query|status|diff|explain|path` owns the local Graphify
+  workflow from any project shell without installing Graphify-owned harness
+  assets; Claude Code, OpenCode, Pi, and Kimi add thin `/graphify` wrappers;
   `cairn notes distill|search-error|promote|doctor` compiles and searches
   default-off local hindsight notes outside the online agent path;
   `cairn memory export|import` relocates the durable store between machines
   (`export` requires the optional `sqlite3` CLI);
   `cairn audit-timer` installs the scheduled memory+wiki audit;
   `cairn completion bash|zsh|fish` generates shell completion definitions; and
-  `cairn sync-pi` installs the native Pi trajectory extension;
+  `cairn sync-pi` installs the native Pi trajectory extension and graph prompt;
+  `cairn sync-kimi` installs the Kimi graph Skill;
   `cairn uninstall` reverses the install (backup-first, revertible).
 - **`templates/`** — project scaffolding (generic launchers, env) plus the
   derived-knowledge layer (wiki, alignment, graph, security, planning).
@@ -159,6 +169,16 @@ configuration requires a literal URL and supports a token reference through
 `bearerTokenEnvVar`; it does not expand `${VAR}` in the URL. See
 [Harness compatibility](docs/harness-compatibility.md#kimi-code).
 
+Install Kimi's thin graph Skill separately with `cairn sync-kimi --apply`.
+It registers `/graphify` (also `/skill:graphify`) and delegates every supported
+operation exclusively to `cairn graph`.
+
+For Qwen Code, use project `.qwen/settings.json`: local stdio launches
+`cairn memory-server`, while remote HTTP uses `httpUrl` and environment-expanded
+headers. Review and approve project MCP configuration with
+`qwen mcp approve cairn-memory`, then launch with `./.ai/start-qwen.sh`. See
+[Harness compatibility](docs/harness-compatibility.md#qwen-code).
+
 For Pi, install the local trajectory adapter and use the scaffolded launcher:
 
 ```bash
@@ -167,9 +187,10 @@ cairn bootstrap /path/to/project
 cd /path/to/project && ./.ai/start-pi.sh
 ```
 
-This installs trajectory capture only. Cairnkeep does not bundle or select a Pi
-MCP bridge; configure a user-chosen bridge separately if you also want the MCP
-memory tools inside Pi.
+This installs trajectory capture plus the thin `/graphify` prompt. The prompt
+delegates exclusively to `cairn graph`. Cairnkeep does not bundle or select a
+Pi MCP bridge; configure a user-chosen bridge separately if you also want the
+MCP memory tools inside Pi.
 
 Closed trajectories can be compiled into local hindsight notes without a model
 or embedding service. Capture and distillation are separate opt-ins:
@@ -208,8 +229,8 @@ unless a wrapper opts in:
   export env (e.g. a provider base URL) or abort the launch by returning
   non-zero. This is where credential refresh / connectivity setup lives.
 - **`CAIRN_EXTRA_SETTINGS`** — path to a settings file layered onto the harness
-  (`--settings` for Claude Code, `OPENCODE_CONFIG` for OpenCode). Pi has no equivalent
-  generic settings-file flag, so its launcher leaves this variable unused.
+  (`--settings` for Claude Code, `OPENCODE_CONFIG` for OpenCode). Kimi, Qwen,
+  and Pi do not interpret this variable in their generic launchers.
   Process env still wins, so an inline value beats the profile.
 - **`.ai/post-exit.sh`** — sourced after the harness exits, with
   `CAIRN_EXIT_STATUS` set to its exit code.

package/bin/cairn

@@ -33,8 +33,11 @@ Usage:
                            agents, hooks) into ~/.claude, or into DIR for a single
                            project (--live-root <project>/.claude).
   cairn sync-pi [--apply] [--live-root DIR]
-                           Install/update the Pi trajectory extension into
-                           ~/.pi/agent, or into DIR for an isolated Pi root.
+                           Install/update the Pi trajectory extension and thin
+                           /graphify prompt into ~/.pi/agent or isolated DIR.
+  cairn sync-kimi [--apply] [--live-root DIR]
+                           Install/update the thin Kimi /graphify Skill into
+                           $KIMI_CODE_HOME, ~/.kimi-code, or isolated DIR.
   cairn doctor             Health-check the memory server and configured LLM /
                            embedding endpoints, git provider, and stores.
                            Use --repair for derived trajectory/typed metadata,
@@ -56,6 +59,9 @@ Usage:
   cairn eval <validate|run|ablate|report|prune|delete>
                            Validate or run default-off local evaluations, inspect
                            reports, and manage retained experiment results.
+  cairn graph <build|query|status|diff|explain|path>
+                           Build the local code graph, inspect freshness and
+                           changes, or query exact symbols and paths.
   cairn memory <path|export|import>
                            Relocate global-scope memory. `path` prints its location;
                            `export <file.tgz>` takes a WAL-safe snapshot (requires
@@ -64,7 +70,7 @@ Usage:
                            Install (opt-in) a systemd user timer that runs the
                            memory+wiki audit on a schedule; prints a cron alternative.
   cairn uninstall [--dry-run] [--yes] [--purge-memory] [--live-root DIR]
-                  [--pi-live-root DIR] [PROJECT ...]
+                  [--pi-live-root DIR] [--kimi-live-root DIR] [PROJECT ...]
                            Reverse what cairnkeep installed/modified (operating
                            layer, hook registrations, MCP registration, audit
                            timer, and any given projects' bootstrap scaffold).
@@ -110,12 +116,18 @@ case "$cmd" in
   eval)
     exec node "$CAIRN_ROOT/mcp-memory-server/dist/eval-cli.js" "$@"
     ;;
+  graph)
+    exec node "$CAIRN_ROOT/mcp-memory-server/dist/graph-cli.js" "$@"
+    ;;
   sync)
     exec "$CAIRN_ROOT/scripts/sync-claude-assets.sh" "$@"
     ;;
   sync-pi)
     exec "$CAIRN_ROOT/scripts/sync-pi-assets.sh" "$@"
     ;;
+  sync-kimi)
+    exec "$CAIRN_ROOT/scripts/sync-kimi-assets.sh" "$@"
+    ;;
   audit-timer)
     exec "$CAIRN_ROOT/scripts/install-audit-timer.sh" "$@"
     ;;

package/claude/commands/graphify.md

@@ -1,12 +1,14 @@
 ---
 description: "Build, rebuild, query, and inspect the project knowledge graph in .planning/graphs/"
-argument-hint: "[build [--force]|query <term>|status|diff]"
+argument-hint: "[build [--force]|query <term>|explain <symbol>|path <from> <to>|status|diff]"
 allowed-tools: Read, Bash
 ---
 
 **STOP -- DO NOT READ THIS FILE. You are already reading it. This prompt was injected into your context by Claude Code's command system. Using the Read tool on this file wastes tokens. Begin executing Step 0 immediately.**
 
-**graphify CLI:** the `graphify` subcommand is exposed by `gsd-tools` (on PATH). Invoke as `gsd-tools graphify …` as documented in this command and in `docs/CLI-TOOLS.md`. Other GSD queries use `gsd-tools <subcmd>` where a handler exists.
+**graph workflow:** Cairnkeep owns this surface through `cairn graph`. The
+operator installs only the isolated `graphify` executable; do not invoke
+Graphify's harness installer.
 
 ## Step 0 -- Banner
 
@@ -18,29 +20,13 @@ GRAPHIFY
 
 Then proceed to Step 1.
 
-## Step 1 -- Config Gate
+## Step 1 -- Capability ownership
 
-Check if graphify is enabled by reading `.planning/config.json` directly using the Read tool.
-
-**DO NOT use the gsd-tools config get-value command** -- it hard-exits on missing keys.
-
-1. Read `.planning/config.json` using the Read tool
-2. If the file does not exist: display the disabled message below and **STOP**
-3. Parse the JSON content. Check if `config.graphify && config.graphify.enabled === true`
-4. If `graphify.enabled` is NOT explicitly `true`: display the disabled message below and **STOP**
-5. If `graphify.enabled` is `true`: proceed to Step 2
-
-**Disabled message:**
-
-```
-GRAPHIFY
-
-Knowledge graph is disabled. To activate:
-
-  gsd-tools config-set graphify.enabled true
-
-Then run /graphify build to create the initial graph.
-```
+Do not implement a separate configuration gate in the prompt. Every
+`cairn graph` operation enforces the typed `graph` capability and its legacy
+`graphify.enabled` compatibility default before Graphify or graph-file I/O.
+Proceed directly to Step 2; if the owner reports a disabled capability, display
+its fixed remediation message and **STOP**.
 
 ---
 
@@ -52,6 +38,8 @@ Parse `$ARGUMENTS` to determine the operation mode:
 |----------|--------|
 | `build` or `build --force` | Run inline build (Step 3) |
 | `query <term>` | Run inline query (Step 2a) |
+| `explain <symbol>` | Explain one exact symbol (Step 2d) |
+| `path <from> <to>` | Find the shortest path between two exact symbols (Step 2e) |
 | `status` | Run inline status check (Step 2b) |
 | `diff` | Run inline diff check (Step 2c) |
 | No argument or unknown | Show usage message |
@@ -66,6 +54,8 @@ Usage: /graphify <mode>
 Modes:
   build [--force] Build or rebuild the knowledge graph
   query <term>    Search the graph for a term
+  explain <symbol> Explain one exact symbol and its relationships
+  path <from> <to> Find the shortest path between two exact symbols
   status          Show graph freshness and statistics
   diff            Show changes since last build
 ```
@@ -75,28 +65,39 @@ Modes:
 Run:
 
 ```bash
-gsd-tools graphify query <term>
+cairn graph query <term>
 ```
 
-Parse the JSON output and display results:
-- If the output contains `"disabled": true`, display the disabled message from Step 1 and **STOP**
-- If the output contains `"error"` field, display the error message and **STOP**
-- If no nodes found, display: `No graph matches for '<term>'. Try /graphify build to create or rebuild the graph.`
-- Otherwise, display matched nodes grouped by type, with edge relationships and confidence tiers (EXTRACTED/INFERRED/AMBIGUOUS)
+Pass the parsed term as exactly one argument and display the result verbatim.
+On failure, display the error without retrying or changing configuration.
 
 **STOP** after displaying results. Do not spawn an agent.
 
+### Step 2d -- Explain
+
+Run `cairn graph explain <symbol>`, passing the parsed symbol as exactly one
+argument. Display Graphify's explanation verbatim. On failure, display the
+error and suggest `/graphify build` only when the published graph is missing.
+
+**STOP** after displaying the result. Do not spawn an agent.
+
+### Step 2e -- Path
+
+Run `cairn graph path <from> <to>`, passing each parsed symbol as exactly one
+argument. Display Graphify's path result verbatim. On failure, display the
+error and suggest `/graphify build` only when the published graph is missing.
+
+**STOP** after displaying the result. Do not spawn an agent.
+
 ### Step 2b -- Status
 
 Run:
 
 ```bash
-gsd-tools graphify status
+cairn graph status
 ```
 
-Parse the JSON output and display:
-- If `exists: false`, display the message field
-- Otherwise show last build time, node/edge/hyperedge counts, and STALE or FRESH indicator
+Display the local node/edge counts and freshness result verbatim.
 
 **STOP** after displaying status. Do not spawn an agent.
 
@@ -105,14 +106,11 @@ Parse the JSON output and display:
 Run:
 
 ```bash
-gsd-tools graphify diff
+cairn graph diff
 ```
 
-Parse the JSON output and display:
-- If `no_baseline: true`, display the message field
-- Otherwise show node and edge change counts (added/removed/changed)
-
-If no snapshot exists, suggest running `build` twice (first to create, second to generate a diff baseline).
+Display the node and edge change counts verbatim. If no snapshot exists,
+suggest rebuilding after the next code change.
 
 **STOP** after displaying diff. Do not spawn an agent.
 
@@ -123,20 +121,14 @@ If no snapshot exists, suggest running `build` twice (first to create, second to
 Run:
 
 ```bash
-gsd-tools graphify build [--force]
+cairn graph build [--force]
 ```
 
-Parse the JSON output and display:
-- If the output contains `"disabled": true`, display the disabled message from Step 1 and **STOP**
-- If the output contains an `"error"` field, display the error and the `stage` field when present, then **STOP**
-- Otherwise display the build summary using `status.last_build`, `status.node_count`, `status.edge_count`, `status.hyperedge_count`, whether the snapshot was saved, and whether a forced clean rebuild was used
-
-This command now performs the full pipeline directly:
-- runs `graphify update .` with legacy fallback to `graphify . --update`
-- when `--force` is present, clears `graphify-out/`, published graph artifacts, and `.planning/graphs/.last-build-snapshot.json` first
-- validates `graphify-out/graph.json`
-- copies `graph.json`, `graph.html`, and `GRAPH_REPORT.md` into `.planning/graphs/`
-- writes `.planning/graphs/.last-build-snapshot.json`
+Display the build summary verbatim. This managed path runs Graphify's local
+code-only `update`, strips provider credentials from its subprocess
+environment, validates the resulting graph, atomically publishes available
+artifacts into `.planning/graphs/`, and snapshots the previous graph for diff.
+`--force` permits a rebuilt graph with fewer nodes after code deletion.
 
 **STOP** after displaying the build result. Do not spawn an agent.
 
@@ -144,7 +136,6 @@ This command now performs the full pipeline directly:
 
 ## Anti-Patterns
 
-1. DO NOT spawn an agent for graphify operations -- build/query/status/diff are handled directly
+1. DO NOT spawn an agent for graphify operations -- build/query/explain/path/status/diff are handled directly
 2. DO NOT modify graph files directly outside the graphify CLI path
-3. DO NOT skip the config gate check
-4. DO NOT use gsd-tools config get-value for the config gate -- it exits on missing keys
+3. DO NOT duplicate capability parsing in the prompt -- `cairn graph` owns it

package/docs/building-an-overlay.md

@@ -28,13 +28,13 @@ manifest, profile-lock, private-registry, and rollback contract.
 ## The launcher seams
 
 The generic launchers (`.ai/start-claude.sh`, `.ai/start-opencode.sh`,
-`.ai/start-kimi.sh`, and `.ai/start-pi.sh`, scaffolded by `cairn bootstrap`) run
+`.ai/start-kimi.sh`, `.ai/start-qwen.sh`, and `.ai/start-pi.sh`, scaffolded by `cairn bootstrap`) run
 optional hooks, each a no-op when absent:
 
 | Seam | When | Use it for |
 |---|---|---|
 | `.ai/pre-launch.sh` | sourced after `.env`, before launch | export a provider base URL / credentials, refresh a token, run a connectivity check, or **abort** the launch by returning non-zero |
-| `CAIRN_EXTRA_SETTINGS` | read just before launch | path to a settings file layered onto Claude Code (`--settings`) or OpenCode (`OPENCODE_CONFIG`); Kimi and Pi leave it available to hooks but do not interpret it |
+| `CAIRN_EXTRA_SETTINGS` | read just before launch | path to a settings file layered onto Claude Code (`--settings`) or OpenCode (`OPENCODE_CONFIG`); Kimi, Qwen, and Pi leave it available to hooks but do not interpret it |
 | `.ai/post-exit.sh` | sourced after the harness exits | teardown; `CAIRN_EXIT_STATUS` holds the exit code |
 
 **Typical overlay launcher** — a corporate wrapper needs a non-default provider

package/docs/harness-compatibility.md

@@ -10,15 +10,24 @@ commands, hooks, plugins, or trajectory adapters.
 |---|---|---|
 | Claude Code | Memory MCP, commands, agents, hooks, launcher | Exercised by Cairnkeep tests |
 | OpenCode | Memory MCP, commands, workflows, plugins, launcher | Exercised by Cairnkeep tests |
-| Kimi Code | Memory MCP, `AGENTS.md`, launcher | Launcher tested; remote MCP tested with Kimi Code 0.30.0 |
-| Pi | Native opt-in trajectory extension and launcher | Exercised by Cairnkeep tests; no bundled MCP bridge |
+| Kimi Code | Memory MCP, `AGENTS.md`, launcher, opt-in graph Skill | Launcher tested; remote MCP tested with Kimi Code 0.30.0; graph Skill contract-tested |
+| Qwen Code | Memory MCP, launcher | Launcher tested; stdio and remote MCP tested with Qwen Code 0.21.1 |
+| Pi | Native opt-in trajectory extension, launcher, and graph prompt | Exercised by Cairnkeep tests; no bundled MCP bridge |
 | Codex CLI | Memory MCP | Configuration supported; no Cairnkeep operating-layer assets or launcher |
 | Other MCP clients | Memory and optional domain-knowledge tools | Protocol-compatible; not automatically runtime-tested |
 
 Only Claude Code and OpenCode currently receive the complete operating layer.
-Kimi skills and hooks require harness-specific adaptation and validation before
-they can be presented as equivalent. In Kimi, call MCP tools directly or use
-ordinary prompts until that work is complete.
+Kimi receives one narrow graph Skill, while Pi receives one narrow graph prompt;
+neither is equivalent to the full commands, agents, hooks, and plugins surface.
+Qwen skills and hooks still require harness-specific adaptation and validation.
+
+`cairn graph` is a separate, harness-independent project-shell CLI. Kimi Code,
+Pi, Qwen Code, Codex, and other shell-capable clients can invoke
+`cairn graph build|query|status|diff|explain|path` when `cairn` and the isolated
+`graphify` executable are on `PATH`. `cairn sync-kimi --apply` registers a Kimi
+Skill as `/graphify` (or `/skill:graphify`), and `cairn sync-pi --apply`
+registers a Pi prompt template as `/graphify`; both delegate exclusively to
+that CLI. Neither adds an MCP bridge to Pi or expands the other support levels.
 
 ## Kimi Code
 
@@ -91,6 +100,72 @@ token value in either file.
 Kimi MCP configuration is documented at
 [Kimi Code MCP](https://www.kimi.com/code/docs/en/kimi-code-cli/customization/mcp.html).
 
+## Qwen Code
+
+Qwen Code can read MCP definitions from user settings, project
+`.qwen/settings.json`, and compatible repository `.mcp.json` files. Use the
+Qwen-specific project settings file for remote HTTP so its `httpUrl` transport
+and environment expansion are explicit.
+
+### Local stdio
+
+Create `.qwen/settings.json` in a trusted project:
+
+```json
+{
+  "mcpServers": {
+    "cairn-memory": {
+      "command": "cairn",
+      "args": ["memory-server"]
+    }
+  }
+}
+```
+
+Project MCP definitions are approval-gated. Review the file, then run:
+
+```bash
+qwen mcp approve cairn-memory
+./.ai/start-qwen.sh
+```
+
+The server is a local child process. Its storage stays on this computer unless
+the operator deliberately replaces this stdio definition with a remote one.
+
+### Remote HTTP
+
+Qwen Code 0.21.1 was exercised with environment expansion in project settings:
+
+```json
+{
+  "mcpServers": {
+    "cairn-memory": {
+      "httpUrl": "${CAIRN_MEMORY_REMOTE_URL}",
+      "headers": {
+        "Authorization": "Bearer ${CAIRN_MEMORY_HTTP_TOKEN}",
+        "X-Cairn-Project": "example-project",
+        "X-Cairn-Scopes": "identity,personal,project",
+        "X-Cairn-AnythingLLM-Workspaces": "example-workspace"
+      }
+    }
+  }
+}
+```
+
+Keep the endpoint and token in `.ai/.env` or a machine secret store. The
+generated launcher exports `.ai/.env` before Qwen reads the settings. Re-run
+`qwen mcp approve cairn-memory` after changing the project definition because
+the approval is bound to the configuration digest.
+
+The authenticated recipe above is validated for `.qwen/settings.json`.
+Cairnkeep does not assume that a one-shot `--mcp-config` input performs the same
+environment expansion. A private overlay should write the project settings
+backup-first, preserve unrelated keys, exclude private routing metadata from
+Git, and leave secret values as environment references.
+
+Qwen MCP configuration is documented at
+[Qwen Code MCP](https://qwenlm.github.io/qwen-code-docs/en/users/features/mcp/).
+
 ## Candidate memory clients
 
 The following clients have documented MCP support and are reasonable adapter
@@ -99,17 +174,28 @@ writers, operating assets, or runtime CI:
 
 | Client | Documented MCP surface | Cairnkeep status |
 |---|---|---|
-| Gemini CLI | `mcpServers` in `settings.json` | Candidate for stdio and HTTP memory tests |
+| Antigravity CLI | Workspace `.agents/mcp_config.json` and plugins | Current successor candidate for memory plus native operating assets |
+| Cursor | Project `.cursor/mcp.json`, plugins, and Agent CLI | Candidate for memory plus native operating assets |
 | GitHub Copilot CLI | `copilot mcp` and `.mcp.json` | Candidate for memory plus shared skills |
-| Qwen Code | `qwen mcp` and MCP configuration | Candidate for stdio and HTTP memory tests |
+| Factory Droid | Native plugin marketplace | Candidate for reusing a compatible operating-layer package |
 | goose | MCP extensions and CLI session extension loading | Candidate for memory and recipe integration |
+| Gemini CLI | `mcpServers` in `settings.json` | Legacy candidate for enterprise or API-key users only |
 
 Primary references:
 
-- [Gemini CLI MCP](https://github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md)
+- [Antigravity MCP](https://antigravity.google/docs/mcp)
+- [Cursor MCP](https://docs.cursor.com/context/model-context-protocol)
 - [GitHub Copilot CLI MCP](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers)
-- [Qwen Code MCP](https://qwenlm.github.io/qwen-code-docs/en/users/features/mcp/)
 - [goose](https://github.com/aaif-goose/goose)
+- [Gemini CLI transition announcement](https://github.com/google-gemini/gemini-cli/discussions/28017)
+- [Superpowers harness integrations](https://github.com/obra/superpowers)
+
+Superpowers is a useful comparison because it keeps shared behavior in one
+source tree and ships thin native adapters through each harness's supported
+plugin, extension, hook, or context mechanism. Cairnkeep follows the same
+principle for future operating-layer ports: reuse common content, map real tool
+names and lifecycle events per harness, and document degraded capabilities
+instead of copying one harness's files into another.
 
 Support should be added one client at a time with a clean install, a local
 stdio handshake, an authenticated HTTP handshake, a real write/recall canary,

package/docs/learning/CURRICULUM-MAP.md

@@ -1,6 +1,6 @@
 # Curriculum Coverage Map
 
-**Baseline:** Cairnkeep 2.5.0
+**Baseline:** Cairnkeep 2.7.0
 **Last reviewed:** 2026-07-29
 
 This map prevents the course from drifting behind the product. It assigns each
@@ -70,12 +70,14 @@ against `cairn help` so a new command cannot bypass a curriculum decision.
 | `cairn memory-server` | L02 |
 | `cairn sync` | L02 |
 | `cairn sync-pi` | L13 |
+| `cairn sync-kimi` | L02 |
 | `cairn doctor` | L03; advanced repair in L13-L14 |
 | `cairn trajectory` | L13 |
 | `cairn artifact` | L13 |
 | `cairn capabilities` | L15 |
 | `cairn notes` | L13 |
 | `cairn eval` | L16 |
+| `cairn graph` | L05-L06 |
 | `cairn memory` | L07-L08 |
 | `cairn audit-timer` | L05 and L13 |
 | `cairn uninstall` | L02 and L11-L12 |

package/docs/learning/FEATURE-GUIDE.md

@@ -1,6 +1,6 @@
 # Cairnkeep feature guide
 
-**Baseline:** Cairnkeep 2.5.0
+**Baseline:** Cairnkeep 2.7.0
 
 This is the step-back map for choosing and operating Cairnkeep features. The
 [course labs](https://github.com/cairnkeep/cairnkeep-course-labs) provide one
@@ -76,7 +76,8 @@ prerequisites for ordinary memory.
 
 - Use a generated launcher so project environment and hooks are repeatable.
 - Run `cairn sync --check` after every core upgrade; apply only reported drift.
-- Run `cairn sync-pi --check` when the optional Pi capture adapter is installed.
+- Run `cairn sync-pi --check` when the optional Pi capture/graph adapter is installed.
+- Run `cairn sync-kimi --check` when the optional Kimi graph Skill is installed.
 - Use `cairn doctor --repair` only after preserving the affected store and only
   for repairable derived indexes/metadata.
 - Use `cairn uninstall --dry-run` before uninstall; durable memory is retained

package/docs/learning/README.md

@@ -1,8 +1,8 @@
 # Learn Cairnkeep
 
-This learning path teaches Cairnkeep through small, verifiable outcomes. The
-canonical lesson is written once and can be reused as a guide, blog post,
-workshop handout, or video script.
+This public learning path teaches Cairnkeep through small, verifiable outcomes.
+It is the technical source for guides, workshops, and independently reviewed
+publication material.
 
 ## Start here
 
@@ -22,9 +22,9 @@ The public [course labs](https://github.com/cairnkeep/cairnkeep-course-labs)
 provide one synthetic project with tagged checkpoints shared by lessons,
 articles, workshops, and videos.
 
-Lessons marked **Ready** include a complete exercise and presenter script.
-Lessons marked **Brief** define outcomes and acceptance criteria and will be
-expanded according to the [production plan](PRODUCTION-PLAN.md).
+Lessons marked **Ready** include a complete, release-verified exercise. Lessons
+marked **Brief** define public outcomes and acceptance criteria and will be
+expanded only after their labs are executable.
 
 ## Curriculum
 
@@ -62,7 +62,7 @@ Every complete lesson contains:
 3. A hands-on exercise using non-sensitive sample data.
 4. Verification and recovery steps.
 5. A privacy or security boundary.
-6. A presenter-ready video script.
+6. Release compatibility metadata for completed exercises.
 
 The learner should never need optional infrastructure to complete L00-L06.
 Remote memory, RAG, routing, containers, structured capture, typed nodes,
@@ -70,8 +70,8 @@ capability governance, and evaluation are separate opt-in modules.
 
 ## For contributors
 
-Use [the lesson template](templates/lesson-template.md) and
-[the video template](templates/video-script-template.md). The
-[instructor guide](instructor-guide.md) defines rehearsal, recording, and
-publication checks. Commands in finished lessons must be tested against the
-current release before publication.
+Use [the lesson template](templates/lesson-template.md). Commands in finished
+lessons must be tested against the current release before publication.
+Unpublished editorial plans and recording scripts are intentionally maintained
+outside the public product repository; stable video links or transcripts can
+be added here after publication.

package/docs/learning/lessons/L00-why-cairnkeep.md

@@ -3,7 +3,7 @@
 **Status:** Ready
 **Track:** Quickstart
 **Time:** 10 minutes
-**Tested with:** Cairnkeep 2.5.0
+**Tested with:** Cairnkeep 2.7.0
 
 ## Outcome
 
@@ -93,7 +93,3 @@ configuration and are taught later.
 - Optional services are not prerequisites.
 
 Next: [L01 - Try it safely](L01-safe-trial.md).
-
-## Video
-
-Use [the L00 presenter script](../video-scripts/L00-why-cairnkeep.md).