agent-trellis 0.7.0 → 0.8.0

package/README.md

@@ -1,15 +1,42 @@
 # Trellis
 
-**A single source of capability for every coding agent you run.**
+<p align="center">
+  <img src="docs/assets/trellis-mark.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.
+Trellis gives Claude Code, Codex, Kiro, pi, and Kimi Code one Runtime for
+Skills, MCP, Memory, and shared instructions.
+
+> 中文：Trellis 是统一的 Code Agent Runtime，为多个 Code Agent 提供一致的
+> Skill、MCP、Memory 与共享指令能力。
+
+Trellis does not replace an Agent's native runtime. It manages one canonical
+source and generates verified native or Runtime projections from it.
+
+[Read the product overview →](docs/overview.md)
+
+![Agent Trellis architecture](docs/assets/agent-trellis-architecture-horizontal.svg)
+
+## Install
+
+```bash
+npm install -g agent-trellis
+```
+
+## Quick start
+
+```bash
+trellis onboard --dry-run
+trellis onboard
+trellis doctor
+```
+
+Use the dry-run to review migration source, managed Agents, MCP mode, and
+Memory before applying. See [`docs/overview.md`](docs/overview.md) for the
+short product explanation and [`docs/getting-started.md`](docs/getting-started.md)
+for the complete workflow.
 
 ## Why
 
@@ -26,14 +53,6 @@ Trellis aligns with the emerging [`.agents Protocol`](https://dotagentsprotocol.
 draft rather than inventing a sixth competing standard, and is likely its first
 working implementation.
 
-## Install
-
-```
-npm install -g agent-trellis
-```
-
-## Quick start
-
 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.
@@ -44,7 +63,7 @@ conflict action means, and troubleshooting.
 trellis onboard
 ```
 
-Creates canonical source, detects which of Claude Code/Codex/Kiro/pi are on
+Creates canonical source, detects which of Claude Code/Codex/Kiro/pi/Kimi Code 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
@@ -62,19 +81,63 @@ 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.
 
+Onboarding only adds to the existing managed set. To deliberately narrow or
+replace Trellis's future write boundary without touching an agent's current
+native state, use `trellis manage list|set|add|remove`; these mutations are
+dry-runnable and backed by `trellis rollback`.
+
 ```
 trellis onboard --agent claude-code --manage pi
 ```
 
+## Trellis itself as a Skill
+
+Trellis ships one package-owned Skill, `trellis-runtime`, with two layers:
+
+| Layer | Who uses it | What it covers |
+| --- | --- | --- |
+| Takeover and migration | the operator, with Agent assistance | inspect, dry-run, choose a migration source, choose the managed boundary, select Skills/MCP/Memory, authorize OAuth, sync, audit, verify, and rollback |
+| Runtime consumption | every managed Agent | discover and read canonical Skills, inspect shared Memory and global instructions, diagnose MCP, see managed Agents, and inspect or explicitly confirm task handoffs |
+
+`trellis init` bootstraps this Skill into
+`~/.trellis/skills/trellis-runtime/SKILL.md`. After an Agent is managed,
+`trellis sync` delivers it in the Agent's native Skill location for native or
+`both` delivery. For Runtime-only delivery, `SkillProvider` exposes the same
+canonical Skill through the `trellis` MCP Runtime; Kimi Code uses
+`trellis kimi` to prevent a second native Skill discovery path. This is one
+canonical Skill, not a copied per-Agent variant.
+
+Before takeover, the Skill cannot be consumed from an Agent that has not been
+connected to Trellis yet; use the CLI and
+[`docs/getting-started.md`](docs/getting-started.md#trellis-runtime-skill)
+for the first-run path. After takeover, the Skill is the Agent's operating
+guide for Trellis-managed capabilities. The MCP client may display names such
+as `mcp__trellis__skills_search`; `mcp__` is client-generated, while Trellis's
+portable names are `skills_search`, `memory_search`, `runtime_status`, and so
+on.
+
 **Or step by step** (what `onboard` is actually doing under the hood, if you
 want to run any one stage on its own):
 
+For standard MCP Router/client exports, use `trellis mcp import <json-file>`.
+It reads `mcpServers` without changing the source, de-duplicates existing
+servers, extracts credential-like environment values into the ignored local
+secret file, converts supported `mcp-remote` Basic Auth entries to native HTTP,
+and reports unsupported inline credentials or unavailable paths.
+Always run it with `--dry-run` first; see the detailed importer rules in
+[`docs/getting-started.md`](docs/getting-started.md).
+
+After upgrading Trellis, refresh the package-owned Runtime Skill with
+`trellis skill update-builtin --dry-run` followed by
+`trellis skill update-builtin`; the operation is backed up and does not require
+editing Agent-native files.
+
 **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.
+   the five supported 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
@@ -86,8 +149,7 @@ already have?**
    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).
+   managed agent's native MCP config, including ownership-safe removal.
 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
@@ -118,15 +180,16 @@ restore with zero writes.
 
 ## 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.
+**Early, pre-1.0.** The CLI commands above are implemented, unit-tested, and
+verified against isolated Linux Docker scenarios (never a developer's own
+dotfiles during development — see
+[`docs/architecture.md`](docs/architecture.md)'s testing philosophy). The
+sandbox matrix covers migration, steady-state management, runtime routing,
+failure isolation, and expected conflicts. A separate agent image installs
+real Codex, Claude Code, Kiro CLI, and pi binaries to verify their isolated
+configuration behavior. `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
@@ -136,16 +199,12 @@ result is named future work, not built yet.
 - 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.
+- Verification has run against real Docker containers and real isolated
+  Codex, Claude Code, Kiro CLI, and pi installs — not against a developer's
+  actual daily-use agent directories. If you hit something a clean-room
+  sandbox wouldn't have caught, please open an issue.
 - `~/.trellis/backups/` has no automatic pruning yet — every `sync`/
-  `mcp sync`/`onboard` run that performs a real write adds one more run
+  `mcp sync`/`onboard`/`mcp import` 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,

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,