agent-trellis 0.7.0 → 0.8.2

package/README.md

@@ -1,178 +1,73 @@
 # Trellis
 
-**A single source of capability for every coding agent you run.**
+<p align="center">
+  <img src="docs/assets/brand-v3/trellis-mark-v3-a.svg" width="88" alt="Trellis logo" />
+</p>
 
-Skills, MCP servers, subagent definitions, shared memory, and secret policy —
-defined once, adapted natively into Claude Code, Codex, Kiro, and the [pi coding
-agent](https://github.com/earendil-works/pi), without drift and without a second
-copy of anything.
+<p align="center"><strong>Unified Code Agent Runtime</strong></p>
 
-Trellis does not replace any of these agents' native config. It generates and
-verifies each one's native adapter from one canonical source, and refuses to let
-a plaintext secret or a duplicated skill file slip through.
+One canonical source for Skills, MCP, Memory, and shared instructions —
+projected safely into Claude Code, Codex, Kiro, pi, Kimi Code, and ZCode.
 
-## Why
+> 中文：一个 canonical source 统一管理多个 Code Agent 的 Skill、MCP、Memory
+> 与共享指令，支持预览、备份与回滚。
 
-By late 2026 the "sync my AI agent rules across tools" space is crowded — at
-least seven open source projects do it (`block/ai-rules`, `ai-rules-sync`,
-`skillshare`, `skills-hub`, `skills-link`, `agent_sync`, and others). None of
-them cover **Kiro** or **pi**, and none of them go past rules/skills into MCP
-servers, shared memory, and secret hygiene as one coherent system. That's the
-gap Trellis fills — see [`docs/research.md`](docs/research.md) for the full
-landscape survey and [`docs/architecture.md`](docs/architecture.md) for what we
-build versus what we deliberately reuse.
+![Agent Trellis — One Runtime. Every Code Agent.](docs/assets/poster-series-v3/agent-trellis-poster-v3-horizontal-en.png)
 
-Trellis aligns with the emerging [`.agents Protocol`](https://dotagentsprotocol.com)
-draft rather than inventing a sixth competing standard, and is likely its first
-working implementation.
-
-## Install
+## Quick start
 
-```
+```bash
 npm install -g agent-trellis
+
+trellis onboard --dry-run   # preview: migration source, managed agents, MCP, memory
+trellis onboard             # apply — every write is backed up automatically
+trellis doctor              # verify state, any time
 ```
 
-## Quick start
+Something went wrong? `trellis rollback` inverts the last run.
 
-See [`docs/getting-started.md`](docs/getting-started.md) for the detailed
-walkthrough — example output for each command, what each `migrate`/`sync`
-conflict action means, and troubleshooting.
+## How it compares
 
-**One command:**
+| | Skills / Rules | MCP | Memory | Secret hygiene | Agents covered |
+|---|---|---|---|---|---|
+| [ai-rules](https://github.com/block/ai-rules), [skills-link](https://github.com/shanliuling/skills-link), [agent_sync](https://github.com/yelmuratoff/agent_sync) | ✅ | ❌ | ❌ | ❌ | Many — but not Kiro or pi |
+| [skillshare](https://github.com/runkids/skillshare), [skills-hub](https://github.com/qufei1993/skills-hub) | ✅ skills only | ❌ | ❌ | ❌ | Codex, Claude, … |
+| [mcp-router](https://github.com/mcp-router/mcp-router) | ❌ | ✅ desktop router | ❌ | config in its own dashboard | — |
+| [MetaMCP](https://github.com/metatool-ai/metamcp), [mcp-hub](https://github.com/ravitemer/mcp-hub) | ❌ | ✅ aggregator | ❌ | ❌ | — |
+| [cli-agent-orchestrator](https://github.com/awslabs/cli-agent-orchestrator) | ❌ | ❌ | ❌ | ❌ | Runs agent fleets, doesn't unify config |
+| **Trellis** | ✅ | ✅ native config, Runtime, or hub mode | ✅ shared memory + handoffs | ✅ references only, `secrets audit` | Claude Code, Codex, Kiro, pi, Kimi Code, ZCode |
 
-```
-trellis onboard
-```
+Sync tools stop at rules and skills. MCP routers manage servers but hold their
+own config — a second source of truth (we hit real token drift with exactly
+that setup). Trellis is the only one treating Skills + MCP + Memory +
+instructions as **one** canonical system, and the only one covering Kiro and
+pi. Full landscape survey: [`docs/research.md`](docs/research.md).
 
-Creates canonical source, detects which of Claude Code/Codex/Kiro/pi are on
-this machine, then resolves two independent choices: a **migration source**
-(read from — auto-selected if only one present agent has real content,
-prompted with a numbered choice if more than one, skippable if starting
-fresh; pass `--agent <id>` to skip the prompt) and a **managed set** (written
-to — zero or more agents, chosen explicitly; pass `--manage <ids>` or
-`--manage none` to skip the prompt). The source is **not** managed by
-default — importing from Claude Code doesn't mean Trellis starts writing to
-Claude Code too, unless you explicitly include it. Selecting an agent that
-isn't installed yet (e.g. pi) is itself the authorization to install it —
-one confirmation, then a real `npm install -g <package>`; Kiro has no CLI
-package and is refused with its download URL instead. Once resolved, it
-runs `migrate`, `sync`, `mcp sync`, and `secrets audit` against the managed
-set — the whole onboarding path in one command, no follow-up commands to
-type by hand. If no agent is detected, it prints each supported agent's
-real install command/URL and stops — it never installs anything on its own
-initiative. Add `--dry-run` to preview the whole thing with zero writes.
+## Design principles
 
-```
-trellis onboard --agent claude-code --manage pi
-```
+1. **One canonical source, many adapters** — agent-native configs are
+   generated artifacts, never hand-edited.
+2. **No plaintext secrets, ever** — outputs hold variable references;
+   `trellis secrets audit` rejects raw values.
+3. **Verify, don't assume** — every adapter claim is backed by an executed
+   probe in isolated Docker sandboxes, never a developer's own dotfiles.
 
-**Or step by step** (what `onboard` is actually doing under the hood, if you
-want to run any one stage on its own):
-
-**Already using Claude Code, Codex, Kiro, or pi and want to migrate what you
-already have?**
-
-1. `trellis init` — creates `~/.trellis/` with a minimal skeleton (only what's
-   missing; never overwrites a file you already have) and tells you which of
-   the four agents it found on this machine.
-2. `trellis migrate --from <agent>` — once per agent you already use. Copies
-   that agent's real skills and instructions into canonical source. Never
-   overwrites: an already-identical skill is reported and skipped, a genuine
-   conflict is reported and left for you to resolve by hand. Add `--dry-run`
-   to preview first.
-3. `trellis sync` — distributes canonical skills/instructions to every
-   **managed** agent (`~/.trellis/managed.yaml` — empty by default; edit it
-   by hand or let `trellis onboard` write it). An agent that's merely present
-   but not managed is never touched. Add `--dry-run` to preview first.
-4. `trellis mcp sync` — distributes `~/.trellis/mcp/servers.yaml` (see
-   [`schema/servers.example.yaml`](schema/servers.example.yaml)) to every
-   managed agent's native MCP config (create/repair only — see Known
-   limitations).
-5. `trellis secrets audit` — fails non-zero if any managed agent's real
-   config holds a literal credential or an unexpected env var name.
-6. `trellis doctor` — read-only scan of every present agent's current state
-   (managed or not); run any time to check for drift.
-
-**Starting from nothing?** Skip step 2 — `trellis init`'s placeholder
-`agents.md` and empty `skills/` are a fine starting point; edit them by hand.
-
-**Every real write `sync`/`mcp sync`/`onboard` perform is backed up
-first, automatically — no flag to opt in.** Before creating, repairing,
-or removing anything, each is recorded to a structured, timestamped run
-under `~/.trellis/backups/`, with enough information to invert it exactly.
-`trellis rollback` undoes one recorded run — omit a run id for the most
-recent one:
+Trellis aligns with the emerging [`.agents Protocol`](https://dotagentsprotocol.com)
+draft rather than inventing another standard.
 
-```
-$ trellis rollback
-rollback 2026-09-13T04-52-18-727Z-mcp-sync
-✅ 3 restored, 0 conflict(s), 0 already reverted
-   - [restore] restore /Users/you/.claude.json to its content before this run (...)
-```
+## Docs
 
-If something else touched a path since the backed-up run, that one path
-is a `conflict` — reported, left untouched, never force-restored over —
-while every other path in the same rollback still restores. `--list`
-shows available runs without touching anything; `--dry-run` previews a
-restore with zero writes.
+- [Overview](docs/overview.md) ([中文](docs/overview.zh-CN.md)) — what it is and why
+- [Getting started](docs/getting-started.md) — every command, with example output
+- [Architecture](docs/architecture.md) — what we build vs. deliberately reuse
+- [Research](docs/research.md) — the full competitive landscape
 
 ## Status
 
-**Early, pre-1.0.** All eight CLI commands above (`onboard`, `init`,
-`migrate`, `doctor`, `sync`, `mcp sync`, `secrets audit`, `rollback`) are implemented,
-unit-tested, and verified end-to-end against real Docker containers (never a
-developer's own dotfiles during development — see
-[`docs/architecture.md`](docs/architecture.md)'s testing philosophy). See
-[`docs/roadmap.md`](docs/roadmap.md) for what's shipped (P0–P6) vs. planned
-(P7, a GUI). `onboard` picks one agent as the migration base when more than
-one is present — merging differing content across multiple agents into one
-result is named future work, not built yet.
-
-**Known limitations, honestly stated rather than discovered the hard way:**
-- MCP servers are never spawned/handshake-tested by `trellis mcp sync` or
-  `trellis sync` — only that the *config* is written correctly.
-  `trellis doctor --probe-mcp` is the one command that actually connects,
-  and it's opt-in.
-- The pi bridge extension (`trellis-pi-mcp-bridge`) has been verified to
-  load and register tools without erroring, never against a real LLM tool
-  call in production.
-- Verification has run against real Docker containers and a real,
-  isolated pi CLI install — not yet against a developer's actual, existing
-  `~/.claude`/`~/.codex`/`~/.kiro`/`~/.pi` in daily use. If you hit
-  something a clean-room sandbox wouldn't have caught, please open an
-  issue.
-- Automatic removal of an MCP server is deliberately unsupported (create/
-  repair only) until an ownership-tracking mechanism exists — see
-  `docs/roadmap.md`'s P2 note.
-- `~/.trellis/backups/` has no automatic pruning yet — every `sync`/
-  `mcp sync`/`onboard` run that performs a real write adds one more run
-  directory, with no cap. Delete old ones by hand for now.
-
-A canonical MCP server can also declare `enabled: false` (kept defined,
-never written to any agent) and `static_env` (a value that was never a
-secret — an email, an environment tag — written verbatim instead of
-resolved by name; still scanned against `reject_patterns` like every
-other literal field). Before ever writing a name-only `env` entry,
-`mcp sync` now checks it actually resolves through the same source
-`secrets audit` and the pi bridge use — an unresolvable name is refused
-as a conflict, not silently written and left to break that server's
-connection once the agent starts it. Both found via real-machine
-dogfooding, not a synthetic fixture — see
-[`schema/servers.example.yaml`](schema/servers.example.yaml).
-
-## Design principles
-
-1. **One canonical source, many adapters.** Each agent's native config file is
-   a generated or symlinked artifact, never hand-edited.
-2. **Reuse before building.** MCP aggregation, memory, and secret-reference
-   patterns already have mature open source answers — Trellis wires to them
-   instead of reimplementing them. See [`docs/architecture.md`](docs/architecture.md).
-3. **No plaintext secrets, ever.** Every adapter output holds variable
-   references only; `trellis secrets audit` scans for and rejects raw values.
-4. **Verify, don't assume.** Every claim this project makes about an agent's
-   behavior (file format, discovery path, MCP support) is backed by an
-   executed probe, not documentation-reading. Adapters that can't be verified
-   this way don't ship.
+**Early, pre-1.0.** All CLI commands are implemented, unit-tested, and verified
+against real agents in isolated containers. Known limitations are listed in
+[Getting started](docs/getting-started.md); please open an issue for anything
+a clean-room sandbox wouldn't catch.
 
 ## License
 

package/dist/adapters/claude-code.js

@@ -13,6 +13,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { isInScope } from "../core/adapter.js";
+import { usesNativeCapabilityDelivery } from "../core/types.js";
 import * as claudeCodeProbe from "../probes/claude-code.js";
 import { applySymlinkPlan, planSymlinks } from "./symlinkPlan.js";
 import { applyJsonMcp, planJsonMcp, renderJsonServerEntry } from "./jsonMcp.js";
@@ -32,7 +33,7 @@ export class ClaudeCodeAdapter {
         const canonicalRoot = dirname(canonical.instructionsFile);
         const skillsRoot = join(this.homeDir, ".claude", "skills");
         const desiredSkills = canonical.skills
-            .filter((skill) => isInScope(this.id, skill.scope, canonical.managedAgents))
+            .filter((skill) => usesNativeCapabilityDelivery(this.id, canonical.mcp) && isInScope(this.id, skill.scope, canonical.managedAgents))
             .map((skill) => ({ name: skill.name, target: skill.dir }));
         const skillItems = planSymlinks({
             rootDir: skillsRoot,
@@ -82,7 +83,7 @@ export class ClaudeCodeAdapter {
             return { ok: false, mismatches: ["claude-code is not present on this machine"] };
         }
         const mismatches = [];
-        const desiredNames = new Set(canonical.skills.filter((s) => isInScope(this.id, s.scope, canonical.managedAgents)).map((s) => s.name));
+        const desiredNames = new Set(canonical.skills.filter((s) => usesNativeCapabilityDelivery(this.id, canonical.mcp) && isInScope(this.id, s.scope, canonical.managedAgents)).map((s) => s.name));
         const actualSkills = new Set(snapshot.skillRoots.flatMap((root) => root.skills).map((s) => s.name));
         for (const name of desiredNames) {
             if (!actualSkills.has(name)) {

package/dist/adapters/codex.js

@@ -19,6 +19,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { isInScope } from "../core/adapter.js";
+import { usesNativeCapabilityDelivery } from "../core/types.js";
 import * as codexProbe from "../probes/codex.js";
 import { readInstructionsPath } from "../probes/codex.js";
 import { applySymlinkPlan, planSymlinks } from "./symlinkPlan.js";
@@ -40,7 +41,7 @@ export class CodexAdapter {
         const canonicalRoot = dirname(canonical.instructionsFile);
         const skillsRoot = join(this.homeDir, ".agents", "skills");
         const desiredSkills = canonical.skills
-            .filter((skill) => isInScope(this.id, skill.scope, canonical.managedAgents))
+            .filter((skill) => usesNativeCapabilityDelivery(this.id, canonical.mcp) && isInScope(this.id, skill.scope, canonical.managedAgents))
             .map((skill) => ({ name: skill.name, target: skill.dir }));
         const skillItems = planSymlinks({
             rootDir: skillsRoot,
@@ -136,7 +137,7 @@ export class CodexAdapter {
             return { ok: false, mismatches: ["codex is not present on this machine"] };
         }
         const mismatches = [];
-        const desiredNames = new Set(canonical.skills.filter((s) => isInScope(this.id, s.scope, canonical.managedAgents)).map((s) => s.name));
+        const desiredNames = new Set(canonical.skills.filter((s) => usesNativeCapabilityDelivery(this.id, canonical.mcp) && isInScope(this.id, s.scope, canonical.managedAgents)).map((s) => s.name));
         const actualSkills = new Set(snapshot.skillRoots.flatMap((root) => root.skills).map((s) => s.name));
         for (const name of desiredNames) {
             if (!actualSkills.has(name)) {

package/dist/adapters/jsonMcp.d.ts

@@ -15,6 +15,7 @@ import type { AdapterPlanItem } from "../core/adapter.js";
  * Codex's TOML does — see tomlSection.ts's two-table rendering)
  * (trellis-mcp-static-env-and-disabled-servers design.md D4). */
 export declare function renderJsonServerEntry(def: McpServerDef): Record<string, unknown>;
+export type JsonMcpEntryRenderer = (def: McpServerDef, name: string) => Record<string, unknown>;
 export declare function planJsonMcp(opts: {
     configPath: string;
     parsed: Record<string, unknown> | undefined;
@@ -27,9 +28,10 @@ export declare function planJsonMcp(opts: {
      * pass `{}`) to get today's create/repair/conflict-only behavior with
      * zero removal candidates. */
     ownership?: Record<string, unknown>;
+    render?: JsonMcpEntryRenderer;
 }): AdapterPlanItem[];
 /** Merges every `"create"` MCP item into `parsed` (or a fresh `{}` if the
  * file didn't exist) and deletes every `"remove"` item's key, returning
  * the object to stringify — every sibling top-level key on `parsed` is
  * spread through untouched. */
-export declare function applyJsonMcp(parsed: Record<string, unknown> | undefined, items: AdapterPlanItem[]): Record<string, unknown>;
+export declare function applyJsonMcp(parsed: Record<string, unknown> | undefined, items: AdapterPlanItem[], render?: JsonMcpEntryRenderer): Record<string, unknown>;

package/dist/adapters/jsonMcp.js

@@ -8,7 +8,7 @@
  */
 import { deepEqual } from "../lib/deepEqual.js";
 import { resolvedEnvTextMap } from "../lib/mcpMigrateRead.js";
-import { resolveMcpPlan } from "./mcpPlan.js";
+import { LEGACY_GATEWAY_ENTRY_NAME, LEGACY_RUNTIME_ENTRY_NAME, resolveMcpPlan } from "./mcpPlan.js";
 /** Renders the native JSON shape Claude Code/Kiro's `mcpServers` map
  * expects — `env` names render as `${VAR}` references, `staticEnv`
  * entries render as their literal values, both in the same map (JSON's
@@ -32,11 +32,12 @@ export function renderJsonServerEntry(def) {
 }
 export function planJsonMcp(opts) {
     const { configPath, parsed, mcp, agentId, managedAgents, policy, ownership } = opts;
+    const render = opts.render ?? ((def, _name) => renderJsonServerEntry(def));
     const { desired, conflicts } = resolveMcpPlan(agentId, mcp, managedAgents, policy);
     const existingServers = parsed?.mcpServers ?? {};
     const items = [];
     for (const { name, def } of desired) {
-        const rendered = renderJsonServerEntry(def);
+        const rendered = render(def, name);
         const current = existingServers[name];
         if (deepEqual(current, rendered)) {
             continue; // already correct — no-op
@@ -59,6 +60,19 @@ export function planJsonMcp(opts) {
     for (const [name, expected] of Object.entries(ownership ?? {})) {
         if (desiredNames.has(name))
             continue; // still wanted — not a removal candidate at all
+        if ((name === LEGACY_GATEWAY_ENTRY_NAME || name === LEGACY_RUNTIME_ENTRY_NAME) && desiredNames.has("trellis")) {
+            const current = existingServers[name];
+            if (current !== undefined && deepEqual(current, expected)) {
+                items.push({
+                    action: "remove",
+                    kind: "mcp",
+                    target: configPath,
+                    mcpRemove: { name },
+                    description: `legacy MCP server "${name}" removed from ${configPath} after Trellis Runtime key migration`,
+                });
+            }
+            continue;
+        }
         const current = existingServers[name];
         if (current === undefined)
             continue; // already gone — nothing to remove, ledger is pruned separately
@@ -78,7 +92,7 @@ export function planJsonMcp(opts) {
  * file didn't exist) and deletes every `"remove"` item's key, returning
  * the object to stringify — every sibling top-level key on `parsed` is
  * spread through untouched. */
-export function applyJsonMcp(parsed, items) {
+export function applyJsonMcp(parsed, items, render = (def, _name) => renderJsonServerEntry(def)) {
     const base = parsed ?? {};
     const existingServers = base.mcpServers ?? {};
     const mergedServers = { ...existingServers };
@@ -86,7 +100,7 @@ export function applyJsonMcp(parsed, items) {
         if (item.kind !== "mcp")
             continue;
         if (item.action === "create" && item.mcpWrite) {
-            mergedServers[item.mcpWrite.name] = renderJsonServerEntry(item.mcpWrite.def);
+            mergedServers[item.mcpWrite.name] = render(item.mcpWrite.def, item.mcpWrite.name);
         }
         else if (item.action === "remove" && item.mcpRemove) {
             delete mergedServers[item.mcpRemove.name];

package/dist/adapters/kimi-code.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Kimi Code Runtime-first adapter.
+ *
+ * Runtime delivery owns only ~/.kimi-code/mcp.json. Native Kimi Skills and
+ * AGENTS.md remain opt-in for `native`/`both`; Runtime-only delivery uses
+ * `trellis kimi`, which launches Kimi with an empty --skills-dir root so the
+ * shared ~/.agents/skills tree is not discovered a second time.
+ */
+import type { AdapterPlanItem, AdapterProbeResult, AdapterVerifyResult, TrellisAdapter } from "../core/adapter.js";
+import type { CanonicalSource } from "../core/types.js";
+import type { BackupSession } from "../lib/backup.js";
+export declare class KimiCodeAdapter implements TrellisAdapter {
+    private readonly homeDir;
+    readonly name = "Kimi Code";
+    readonly id: "kimi-code";
+    constructor(homeDir?: string);
+    probe(): Promise<AdapterProbeResult>;
+    plan(canonical: CanonicalSource): Promise<AdapterPlanItem[]>;
+    apply(plan: AdapterPlanItem[], backup: BackupSession): Promise<void>;
+    verify(canonical: CanonicalSource): Promise<AdapterVerifyResult>;
+}

package/dist/adapters/kimi-code.js

@@ -0,0 +1,107 @@
+/**
+ * Kimi Code Runtime-first adapter.
+ *
+ * Runtime delivery owns only ~/.kimi-code/mcp.json. Native Kimi Skills and
+ * AGENTS.md remain opt-in for `native`/`both`; Runtime-only delivery uses
+ * `trellis kimi`, which launches Kimi with an empty --skills-dir root so the
+ * shared ~/.agents/skills tree is not discovered a second time.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { isInScope } from "../core/adapter.js";
+import { usesNativeCapabilityDelivery } from "../core/types.js";
+import * as kimiProbe from "../probes/kimi-code.js";
+import { applyJsonMcp, planJsonMcp, renderJsonServerEntry } from "./jsonMcp.js";
+import { RUNTIME_COMMAND, RUNTIME_ENTRY_NAME } from "./mcpPlan.js";
+import { applySymlinkPlan, planSymlinks } from "./symlinkPlan.js";
+import { loadMcpOwnership, ownedByAgent, recordOwned, forgetOwned, saveMcpOwnership } from "../lib/mcpOwnership.js";
+const KIMI_RUNTIME_STARTUP_TIMEOUT_MS = 30_000;
+function renderKimiServerEntry(def, name) {
+    const entry = renderJsonServerEntry(def);
+    if (def.transport === "stdio")
+        delete entry.type;
+    if (name === RUNTIME_ENTRY_NAME && def.command === RUNTIME_COMMAND) {
+        entry.deferred = true;
+        entry.startupTimeoutMs = KIMI_RUNTIME_STARTUP_TIMEOUT_MS;
+    }
+    return entry;
+}
+export class KimiCodeAdapter {
+    homeDir;
+    name = "Kimi Code";
+    id = "kimi-code";
+    constructor(homeDir = homedir()) {
+        this.homeDir = homeDir;
+    }
+    async probe() {
+        const snapshot = await kimiProbe.probe(this.homeDir);
+        return { present: snapshot.present, version: snapshot.version };
+    }
+    async plan(canonical) {
+        const native = usesNativeCapabilityDelivery(this.id, canonical.mcp);
+        const items = [];
+        const root = join(this.homeDir, ".kimi-code");
+        const canonicalRoot = dirname(canonical.instructionsFile);
+        items.push(...planSymlinks({
+            rootDir: join(root, "skills"),
+            desired: native
+                ? canonical.skills
+                    .filter((skill) => isInScope(this.id, skill.scope, canonical.managedAgents))
+                    .map((skill) => ({ name: skill.name, target: skill.dir }))
+                : [],
+            canonicalRoot: join(canonicalRoot, "skills"),
+            kind: "skill",
+        }));
+        items.push(...planSymlinks({
+            rootDir: root,
+            desired: native ? [{ name: "AGENTS.md", target: canonical.instructionsFile }] : [],
+            canonicalRoot,
+            kind: "instructions",
+        }));
+        const configPath = join(this.homeDir, ".kimi-code", "mcp.json");
+        const parsed = existsSync(configPath) ? JSON.parse(readFileSync(configPath, "utf-8")) : undefined;
+        const ownership = ownedByAgent(loadMcpOwnership(this.homeDir), this.id);
+        items.push(...planJsonMcp({
+            configPath,
+            parsed,
+            mcp: canonical.mcp,
+            agentId: this.id,
+            managedAgents: canonical.managedAgents,
+            policy: canonical.secretsPolicy,
+            ownership,
+            render: renderKimiServerEntry,
+        }));
+        return items;
+    }
+    async apply(plan, backup) {
+        await applySymlinkPlan(plan.filter((item) => item.kind === "skill" || item.kind === "instructions"), backup);
+        const mcpWrites = plan.filter((item) => item.kind === "mcp" && (item.action === "create" || item.action === "remove"));
+        if (mcpWrites.length === 0)
+            return;
+        const configPath = mcpWrites[0].target;
+        const parsed = existsSync(configPath) ? JSON.parse(readFileSync(configPath, "utf-8")) : undefined;
+        const merged = applyJsonMcp(parsed, mcpWrites, renderKimiServerEntry);
+        backup.writeFile(configPath, `${JSON.stringify(merged, null, 2)}\n`);
+        let ownership = loadMcpOwnership(this.homeDir);
+        for (const item of mcpWrites) {
+            if (item.action === "create" && item.mcpWrite)
+                ownership = recordOwned(ownership, this.id, item.mcpWrite.name, renderKimiServerEntry(item.mcpWrite.def, item.mcpWrite.name));
+            if (item.action === "remove" && item.mcpRemove)
+                ownership = forgetOwned(ownership, this.id, item.mcpRemove.name);
+        }
+        saveMcpOwnership(this.homeDir, ownership);
+    }
+    async verify(canonical) {
+        const snapshot = await kimiProbe.probe(this.homeDir);
+        if (!snapshot.present)
+            return { ok: false, mismatches: ["kimi-code is not present on this machine"] };
+        const desired = new Set(canonical.skills.filter((skill) => usesNativeCapabilityDelivery(this.id, canonical.mcp) && isInScope(this.id, skill.scope, canonical.managedAgents)).map((skill) => skill.name));
+        const actual = new Set(snapshot.skillRoots.flatMap((root) => root.skills).filter((skill) => skill.dir.includes("/.kimi-code/skills/")).map((skill) => skill.name));
+        const mismatches = [
+            ...[...desired].filter((name) => !actual.has(name)).map((name) => `skill "${name}" is missing on Kimi Code`),
+            ...[...actual].filter((name) => !desired.has(name)).map((name) => `skill "${name}" is not in Kimi Code's canonical scope`),
+        ];
+        return mismatches.length === 0 ? { ok: true } : { ok: false, mismatches };
+    }
+}

package/dist/adapters/kiro.js

@@ -19,6 +19,7 @@ import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { isInScope } from "../core/adapter.js";
+import { usesNativeCapabilityDelivery } from "../core/types.js";
 import * as kiroProbe from "../probes/kiro.js";
 import { applySymlinkPlan, planSymlinks } from "./symlinkPlan.js";
 import { applyJsonMcp, planJsonMcp, renderJsonServerEntry } from "./jsonMcp.js";
@@ -48,7 +49,7 @@ export class KiroAdapter {
         const canonicalRoot = dirname(canonical.instructionsFile);
         const skillsRoot = join(this.homeDir, ".kiro", "skills");
         const desiredSkills = canonical.skills
-            .filter((skill) => isInScope(this.id, skill.scope, canonical.managedAgents))
+            .filter((skill) => usesNativeCapabilityDelivery(this.id, canonical.mcp) && isInScope(this.id, skill.scope, canonical.managedAgents))
             .map((skill) => ({ name: skill.name, target: skill.dir }));
         const skillItems = planSymlinks({
             rootDir: skillsRoot,
@@ -161,7 +162,7 @@ export class KiroAdapter {
             return { ok: false, mismatches: ["kiro is not present on this machine"] };
         }
         const mismatches = [];
-        const desiredNames = new Set(canonical.skills.filter((s) => isInScope(this.id, s.scope, canonical.managedAgents)).map((s) => s.name));
+        const desiredNames = new Set(canonical.skills.filter((s) => usesNativeCapabilityDelivery(this.id, canonical.mcp) && isInScope(this.id, s.scope, canonical.managedAgents)).map((s) => s.name));
         const actualSkills = new Set(snapshot.skillRoots.flatMap((root) => root.skills).map((s) => s.name));
         for (const name of desiredNames) {
             if (!actualSkills.has(name)) {

package/dist/adapters/mcpPlan.d.ts

@@ -18,12 +18,17 @@
  */
 import type { AgentId, McpConfig, McpServerDef, SecretsPolicy } from "../core/types.js";
 export declare const HUB_ENTRY_NAME = "trellis-hub";
-export declare const GATEWAY_ENTRY_NAME = "trellis-gateway";
+export declare const GATEWAY_ENTRY_NAME = "trellis";
+export declare const LEGACY_GATEWAY_ENTRY_NAME = "trellis-gateway";
+export declare const RUNTIME_ENTRY_NAME = "trellis";
+export declare const LEGACY_RUNTIME_ENTRY_NAME = "trellis-runtime";
 /** The command an agent spawns in gateway mode. Bare `trellis` rather than
  * an absolute path: the entry has to keep working across reinstalls and
  * version bumps, and every agent resolves it through the same PATH the
  * user installed the CLI onto. */
 export declare const GATEWAY_COMMAND = "trellis";
+export declare const RUNTIME_COMMAND = "trellis";
+export declare function isOAuthMcpServer(def: McpServerDef): boolean;
 /**
  * Gateway mode applies to every managed agent when `agents` is omitted —
  * the expected normal case (design.md D14). An explicit list narrows it,