agent-trellis 0.6.3 → 0.8.0

package/dist/core/capabilitySelection.d.ts

@@ -0,0 +1,45 @@
+import type { AgentId, CapabilityDelivery, CanonicalSource, McpRouteMode } from "./types.js";
+export type NameSelection = "all" | "none" | string[];
+export interface CapabilitySelection {
+    skills: NameSelection;
+    mcpServers: NameSelection;
+    memories: NameSelection;
+    memoryMigration: "all" | "none";
+    mcpRoutes: Partial<Record<AgentId, {
+        mode: McpRouteMode;
+        servers?: string[];
+    }>>;
+    runtimeDelivery: Partial<Record<AgentId, CapabilityDelivery>>;
+}
+export interface CapabilityItem {
+    name: string;
+    displayName: string;
+    fingerprint?: string;
+    status: "new" | "unchanged" | "changed" | "unsupported";
+    detail?: string;
+}
+export interface UnsupportedCapabilitySource {
+    name: string;
+    detail: string;
+}
+export interface CapabilityInventory {
+    skills: CapabilityItem[];
+    mcpServers: CapabilityItem[];
+    canonicalMemories: CapabilityItem[];
+    nativeMemory: UnsupportedCapabilitySource[];
+}
+export type SelectionFileResult = {
+    ok: true;
+    selection: CapabilitySelection;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseCapabilitySelectionFile(path: string): SelectionFileResult;
+export declare function defaultCapabilitySelection(): CapabilitySelection;
+export declare function resolveSelectedNames(selection: NameSelection, available: readonly string[]): string[];
+export declare function selectionContains(selection: NameSelection, name: string): boolean;
+export declare function buildCapabilityInventory(source: {
+    skillNames: readonly string[];
+    mcpServerNames: readonly string[];
+}, canonical: Pick<CanonicalSource, "skills" | "mcp" | "memories">, nativeMemory?: UnsupportedCapabilitySource[]): CapabilityInventory;

package/dist/core/capabilitySelection.js

@@ -0,0 +1,124 @@
+import { existsSync, readFileSync } from "node:fs";
+import { parse as parseYaml } from "yaml";
+import { ALL_AGENTS } from "./types.js";
+const ALL_SELECTION = {
+    skills: "all",
+    mcpServers: "all",
+    memories: "all",
+    memoryMigration: "all",
+    mcpRoutes: {},
+    runtimeDelivery: {},
+};
+function parseNameSelection(value, field) {
+    if (value === undefined)
+        return "all";
+    if (value === "all" || value === "none")
+        return value;
+    if (Array.isArray(value) && value.every((item) => typeof item === "string" && item.length > 0)) {
+        return [...new Set(value)];
+    }
+    throw new Error(`${field} must be "all", "none", or a list of names`);
+}
+function parseRoutes(value) {
+    if (value === undefined)
+        return {};
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("mcp_routes must be a map of agent ids to route definitions");
+    }
+    const routes = {};
+    for (const [rawAgent, rawRoute] of Object.entries(value)) {
+        if (!ALL_AGENTS.includes(rawAgent)) {
+            throw new Error(`mcp_routes contains unknown agent "${rawAgent}"`);
+        }
+        if (typeof rawRoute !== "object" || rawRoute === null || Array.isArray(rawRoute)) {
+            throw new Error(`mcp_routes.${rawAgent} must be a route object`);
+        }
+        const route = rawRoute;
+        if (route.mode !== "direct" && route.mode !== "gateway" && route.mode !== "hub") {
+            throw new Error(`mcp_routes.${rawAgent}.mode must be direct, gateway, or hub`);
+        }
+        if (route.servers !== undefined && (!Array.isArray(route.servers) || !route.servers.every((item) => typeof item === "string" && item.length > 0))) {
+            throw new Error(`mcp_routes.${rawAgent}.servers must be a list of names`);
+        }
+        routes[rawAgent] = {
+            mode: route.mode,
+            ...(route.servers ? { servers: [...new Set(route.servers)] } : {}),
+        };
+    }
+    return routes;
+}
+function parseRuntimeDelivery(value) {
+    if (value === undefined)
+        return {};
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("runtime_delivery must be a map of agent ids to native, mcp, or both");
+    }
+    const delivery = {};
+    for (const [rawAgent, rawMode] of Object.entries(value)) {
+        if (!ALL_AGENTS.includes(rawAgent)) {
+            throw new Error(`runtime_delivery contains unknown agent "${rawAgent}"`);
+        }
+        if (rawMode !== "native" && rawMode !== "mcp" && rawMode !== "both") {
+            throw new Error(`runtime_delivery.${rawAgent} must be native, mcp, or both`);
+        }
+        delivery[rawAgent] = rawMode;
+    }
+    return delivery;
+}
+export function parseCapabilitySelectionFile(path) {
+    if (!existsSync(path))
+        return { ok: false, error: `selection file does not exist: ${path}` };
+    try {
+        const parsed = (parseYaml(readFileSync(path, "utf8")) ?? {});
+        return {
+            ok: true,
+            selection: {
+                skills: parseNameSelection(parsed.skills, "skills"),
+                mcpServers: parseNameSelection(parsed.mcp_servers, "mcp_servers"),
+                memories: parseNameSelection(parsed.memories, "memories"),
+                memoryMigration: parsed.memory_migration === undefined || parsed.memory_migration === "all" ? "all" : parsed.memory_migration === "none" ? "none" : (() => { throw new Error('memory_migration must be "all" or "none"'); })(),
+                mcpRoutes: parseRoutes(parsed.mcp_routes),
+                runtimeDelivery: parseRuntimeDelivery(parsed.runtime_delivery),
+            },
+        };
+    }
+    catch (err) {
+        return { ok: false, error: `could not parse selection file ${path}: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+export function defaultCapabilitySelection() {
+    return { ...ALL_SELECTION, mcpRoutes: {}, runtimeDelivery: {} };
+}
+export function resolveSelectedNames(selection, available) {
+    if (selection === "all")
+        return [...available];
+    if (selection === "none")
+        return [];
+    const availableSet = new Set(available);
+    return [...new Set(selection.filter((name) => availableSet.has(name)))];
+}
+export function selectionContains(selection, name) {
+    return selection === "all" || (selection !== "none" && selection.includes(name));
+}
+export function buildCapabilityInventory(source, canonical, nativeMemory = []) {
+    const canonicalSkills = new Set(canonical.skills.map((skill) => skill.name));
+    const canonicalMcp = new Set(Object.keys(canonical.mcp.servers));
+    return {
+        skills: source.skillNames.map((name) => ({
+            name,
+            displayName: name,
+            status: canonicalSkills.has(name) ? "unchanged" : "new",
+        })),
+        mcpServers: source.mcpServerNames.map((name) => ({
+            name,
+            displayName: name,
+            status: canonicalMcp.has(name) ? "unchanged" : "new",
+        })),
+        canonicalMemories: canonical.memories.map((memory) => ({
+            name: memory.name,
+            displayName: memory.name,
+            status: "unchanged",
+        })),
+        nativeMemory,
+    };
+}

package/dist/core/types.d.ts

@@ -5,11 +5,12 @@
  * files on disk are its serialization, not the other way around.
  */
 export type Transport = "stdio" | "http" | "sse";
-export type AgentId = "claude-code" | "codex" | "kiro" | "pi";
+export type McpAuthMode = "oauth";
+export type AgentId = "claude-code" | "codex" | "kiro" | "pi" | "kimi-code";
 export declare const ALL_AGENTS: readonly AgentId[];
 /**
  * Every scopable item (skill, subagent, memory entry, MCP server) defaults
- * to "all four agents" when `scope` is omitted — sharing everywhere is the
+ * to all managed agents when `scope` is omitted — sharing everywhere is the
  * common case Trellis exists for; restricting to specific agents is the
  * exception and must be declared explicitly. See docs/architecture.md
  * "Private / agent-specific capabilities".
@@ -26,6 +27,9 @@ export type Scope = AgentId[] | undefined;
 export declare function resolveScope(scope: Scope, managedAgents: readonly AgentId[]): readonly AgentId[];
 export interface McpServerDef {
     transport: Transport;
+    /** Explicit authorization classification. Absence means ordinary MCP;
+     * Trellis never infers OAuth from a URL or a transient 401. */
+    auth?: McpAuthMode;
     /** stdio only */
     command?: string;
     args?: string[];
@@ -109,6 +113,18 @@ export interface GatewayConfig {
      */
     agents?: AgentId[];
 }
+export type McpRouteMode = "direct" | "gateway" | "hub";
+export interface McpRoute {
+    mode: McpRouteMode;
+    /** Omit to expose every eligible canonical server for this agent. */
+    servers?: string[];
+}
+export type CapabilityDelivery = "native" | "mcp" | "both";
+export interface McpRuntimeConfig {
+    /** Per-agent delivery for Trellis-owned capabilities and upstream MCP.
+     * Omitted means native, preserving the existing adapter behavior. */
+    delivery?: Partial<Record<AgentId, CapabilityDelivery>>;
+}
 export interface McpConfig {
     servers: Record<string, McpServerDef>;
     /**
@@ -127,7 +143,14 @@ export interface McpConfig {
      * two mean different things and may both be set, in which case gateway
      * wins per agent (trellis-mcp-gateway-hosting design.md D5/D6). */
     gateway?: GatewayConfig;
+    /** Optional per-agent route overrides. Explicit routes take precedence
+     * over the legacy hub/gateway shorthand for the named agent. */
+    routes?: Partial<Record<AgentId, McpRoute>>;
+    /** Optional runtime delivery preferences. */
+    runtime?: McpRuntimeConfig;
 }
+export declare function capabilityDeliveryForAgent(agentId: AgentId, mcp: McpConfig): CapabilityDelivery;
+export declare function usesNativeCapabilityDelivery(agentId: AgentId, mcp: McpConfig): boolean;
 export interface SkillRef {
     name: string;
     /** Absolute path to the skill's directory. Must contain `SKILL.md` — the

package/dist/core/types.js

@@ -9,6 +9,7 @@ export const ALL_AGENTS = [
     "codex",
     "kiro",
     "pi",
+    "kimi-code",
 ];
 /**
  * `managedAgents` is the hard outer boundary (trellis-managed-agents
@@ -22,3 +23,9 @@ export function resolveScope(scope, managedAgents) {
     const candidates = scope ?? managedAgents;
     return candidates.filter((id) => managedAgents.includes(id));
 }
+export function capabilityDeliveryForAgent(agentId, mcp) {
+    return mcp.runtime?.delivery?.[agentId] ?? "native";
+}
+export function usesNativeCapabilityDelivery(agentId, mcp) {
+    return capabilityDeliveryForAgent(agentId, mcp) !== "mcp";
+}

package/dist/lib/backup.d.ts

@@ -39,10 +39,12 @@ export interface BackupManifest {
     operations: BackupOperation[];
 }
 export interface BackupSession {
+    readonly runId: string;
     writeFile(path: string, content: string): void;
     createSymlink(path: string, linkTarget: string): Promise<void>;
     repairSymlink(path: string, oldLinkTarget: string, newLinkTarget: string): Promise<void>;
     removeSymlink(path: string, oldLinkTarget: string): Promise<void>;
+    hasOperations(): boolean;
     /** Writes manifest.json. No-op (creates nothing) if zero operations
      * were ever recorded. */
     finalize(): void;

package/dist/lib/backup.js

@@ -67,6 +67,7 @@ export function openBackupSession(homeDir, command) {
         dirCreated = true;
     }
     return {
+        runId,
         writeFile(path, content) {
             ensureDir();
             const afterHash = sha256(content);
@@ -105,6 +106,9 @@ export function openBackupSession(homeDir, command) {
             await rm(path, { force: true });
             operations.push({ kind: "symlink-remove", path, beforeLinkTarget: oldLinkTarget });
         },
+        hasOperations() {
+            return operations.length > 0;
+        },
         finalize() {
             if (!dirCreated)
                 return;

package/dist/lib/builtinSkills.d.ts

@@ -0,0 +1,2 @@
+export declare const TRELLIS_RUNTIME_SKILL_NAME = "trellis-runtime";
+export declare function isBuiltinSkillName(name: string): boolean;

package/dist/lib/builtinSkills.js

@@ -0,0 +1,4 @@
+export const TRELLIS_RUNTIME_SKILL_NAME = "trellis-runtime";
+export function isBuiltinSkillName(name) {
+    return name === TRELLIS_RUNTIME_SKILL_NAME;
+}

package/dist/lib/cliMetadata.d.ts

@@ -0,0 +1 @@
+export declare const TRELLIS_VERSION: string;

package/dist/lib/cliMetadata.js

@@ -0,0 +1,14 @@
+import { readFileSync } from "node:fs";
+/**
+ * Read the package version relative to the compiled/source CLI entrypoint.
+ * `src/lib` and `dist/lib` are both exactly two levels below package.json,
+ * so the same URL works under tsx and from an installed package.
+ */
+function loadPackageVersion() {
+    const manifest = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+    if (typeof manifest.version !== "string" || manifest.version.length === 0) {
+        throw new Error("agent-trellis package.json does not declare a version");
+    }
+    return manifest.version;
+}
+export const TRELLIS_VERSION = loadPackageVersion();

package/dist/lib/gatewayBackend.d.ts

@@ -23,6 +23,8 @@ export interface GatewayBackend {
     listTools(): Promise<AggregatedTool[]>;
     /** Invoke one aggregated tool; implementations route it to its owner. */
     callTool(name: string, args?: Record<string, unknown>): Promise<unknown>;
+    /** Sanitized connection state for user/Agent remediation. */
+    listStatus?(): readonly UpstreamStatus[];
     /** Release everything this backend holds. Must be safe to call twice. */
     close(): Promise<void>;
 }
@@ -32,6 +34,17 @@ export interface UpstreamSpec {
     name: string;
     def: McpServerDef;
 }
+export type UpstreamStatusKind = "ready" | "auth-required" | "unavailable" | "timeout" | "degraded";
+export interface UpstreamStatus {
+    name: string;
+    transport: "stdio" | "http" | "sse";
+    status: UpstreamStatusKind;
+    detail?: string;
+    remediation?: string;
+    remediationKind?: "oauth" | "environment" | "install" | "endpoint" | "router";
+    requiresHuman?: boolean;
+    requiresSessionRestart?: boolean;
+}
 export interface LocalBackendOptions {
     secretsPolicy: SecretsPolicy;
     clientInfo: McpClientInfo;
@@ -64,12 +77,27 @@ export declare class LocalBackend implements GatewayBackend {
     private readonly warn;
     private readonly registry;
     private readonly connected;
+    private readonly statuses;
     private closed;
     private constructor();
     static connect(upstreams: readonly UpstreamSpec[], options: LocalBackendOptions): Promise<LocalBackend>;
     private addUpstream;
     listTools(): Promise<AggregatedTool[]>;
     callTool(name: string, args?: Record<string, unknown>): Promise<unknown>;
+    listStatus(): readonly UpstreamStatus[];
     close(): Promise<void>;
     private closeUpstream;
 }
+/**
+ * Attaches a stored OAuth token, refreshing it first if it has expired.
+ *
+ * Returns the definition unchanged when nothing is stored for this
+ * server: the overwhelmingly common case is a remote server that uses no
+ * OAuth at all, or one whose credential lives in `headers` already, and
+ * neither should be disturbed.
+ *
+ * An explicit `Authorization` header in canonical wins. Someone who wrote
+ * one meant it, and silently overriding it with a stored token would be
+ * the kind of invisible precedence that is impossible to debug.
+ */
+export declare function withOAuthHeader(name: string, def: McpServerDef, homeDir: string): Promise<McpServerDef>;

package/dist/lib/gatewayBackend.js

@@ -32,6 +32,7 @@ export class LocalBackend {
     warn;
     registry = new McpToolRegistry();
     connected = new Set();
+    statuses = new Map();
     closed = false;
     constructor(warn) {
         this.warn = warn;
@@ -43,6 +44,8 @@ export class LocalBackend {
         return backend;
     }
     async addUpstream({ name, def }, options) {
+        const transport = def.transport === "http" || def.transport === "sse" ? def.transport : "stdio";
+        this.statuses.set(name, { name, transport, status: "unavailable", detail: "connecting" });
         let effectiveDef = def;
         if (options.homeDir && def.url) {
             try {
@@ -53,6 +56,7 @@ export class LocalBackend {
                 // dropped — the same isolation a failed connection gets, never a
                 // browser and never a blocked startup.
                 this.warn(`trellis-mcp-gateway: skipping MCP server "${name}": ${errorText(err)}`);
+                this.statuses.set(name, failureStatus(name, def, err));
                 return;
             }
         }
@@ -62,6 +66,7 @@ export class LocalBackend {
         }
         catch (err) {
             this.warn(`trellis-mcp-gateway: failed to connect to MCP server "${name}": ${errorText(err)}`);
+            this.statuses.set(name, failureStatus(name, def, err));
             return;
         }
         this.connected.add(client);
@@ -73,12 +78,28 @@ export class LocalBackend {
         catch (err) {
             this.warn(`trellis-mcp-gateway: failed to list tools for MCP server "${name}": ${errorText(err)}`);
             await this.closeUpstream(client);
+            this.statuses.set(name, failureStatus(name, def, err));
             return;
         }
         const { skipped } = this.registry.add(name, client, tools);
         for (const collided of skipped) {
             this.warn(`trellis-mcp-gateway: tool "${collided}" from server "${name}" collides with an already-registered tool and was skipped`);
         }
+        if (tools.length === 0 && name === "mcp-router") {
+            this.statuses.set(name, {
+                name,
+                transport,
+                status: "degraded",
+                detail: "router connected but exposed no downstream tools",
+                remediationKind: "router",
+                requiresHuman: true,
+                remediation: "check the MCP router's provider login/configuration and reconnect it, then restart the Agent session",
+                requiresSessionRestart: true,
+            });
+        }
+        else {
+            this.statuses.set(name, { name, transport, status: "ready", detail: `connected; ${tools.length} tool(s) available` });
+        }
     }
     async listTools() {
         return this.registry.listTools();
@@ -86,6 +107,9 @@ export class LocalBackend {
     async callTool(name, args) {
         return this.registry.callTool(name, args);
     }
+    listStatus() {
+        return [...this.statuses.values()];
+    }
     async close() {
         if (this.closed)
             return;
@@ -105,6 +129,53 @@ export class LocalBackend {
         }
     }
 }
+function failureStatus(name, def, error) {
+    const detail = errorText(error).slice(0, 300);
+    const auth = def.url !== undefined && /401|403|unauthorized|forbidden|authentication|required|login/i.test(detail);
+    const timeout = /timed out|timeout/i.test(detail);
+    if (auth) {
+        return {
+            name,
+            transport: def.transport === "sse" ? "sse" : "http",
+            status: "auth-required",
+            detail,
+            remediationKind: "oauth",
+            requiresHuman: true,
+            requiresSessionRestart: true,
+            remediation: `run \`trellis mcp auth ${name}\` in a human terminal, then restart the Agent session`,
+        };
+    }
+    if (timeout) {
+        return {
+            name,
+            transport: def.transport === "sse" ? "sse" : def.url ? "http" : "stdio",
+            status: "timeout",
+            detail,
+            remediationKind: def.url ? "endpoint" : "environment",
+            requiresHuman: true,
+            requiresSessionRestart: true,
+            remediation: def.url
+                ? `check the endpoint/network; if it requires OAuth, run \`trellis mcp auth ${name}\``
+                : `check that \`${def.command ?? "the MCP command"}\` is installed and responsive`,
+        };
+    }
+    const envNames = [...(def.env ?? []), ...Object.keys(def.envAliases ?? {})];
+    const missingExecutable = /ENOENT|not found|no such file/i.test(detail);
+    return {
+        name,
+        transport: def.transport === "sse" ? "sse" : def.url ? "http" : "stdio",
+        status: "unavailable",
+        detail,
+        remediationKind: def.url ? "endpoint" : (missingExecutable ? "install" : "environment"),
+        requiresHuman: true,
+        requiresSessionRestart: true,
+        remediation: def.url
+            ? `check the MCP endpoint and credentials; run \`trellis mcp auth ${name}\` if it uses OAuth`
+            : envNames.length > 0
+                ? `check the configured environment variables (${envNames.join(", ")}) and rerun \`trellis mcp sync\``
+                : `check that \`${def.command ?? "the MCP command"}\` is installed and responsive`,
+    };
+}
 /**
  * Attaches a stored OAuth token, refreshing it first if it has expired.
  *
@@ -117,7 +188,7 @@ export class LocalBackend {
  * one meant it, and silently overriding it with a stored token would be
  * the kind of invisible precedence that is impossible to debug.
  */
-async function withOAuthHeader(name, def, homeDir) {
+export async function withOAuthHeader(name, def, homeDir) {
     const hasExplicitAuth = Object.keys(def.headers ?? {}).some((key) => key.toLowerCase() === "authorization");
     if (hasExplicitAuth)
         return def;

package/dist/lib/installAgent.d.ts

@@ -2,14 +2,15 @@
  * Install-then-manage (trellis-managed-agents design.md D5): selecting a
  * not-yet-present agent into the managed set is itself the authorization
  * to install it, but never silently — one confirmation, then a real
- * `npm install -g <package>` child process. Kiro has no npm package (a
- * desktop download) and is refused before this module is ever reached.
+ * `npm install -g <package>` child process. Kiro and Kimi Code use official
+ * install scripts rather than an npm package and are refused before this
+ * module is ever reached.
  */
 import type { AgentId } from "../core/types.js";
 /** Only agents with a real `npm install -g <pkg>` command — Kiro's own
  * `INSTALL_HINTS` entry is a download URL, not a package, and is never
  * looked up here. */
-export declare const NPM_INSTALLABLE: Record<Exclude<AgentId, "kiro">, string>;
+export declare const NPM_INSTALLABLE: Record<Exclude<AgentId, "kiro" | "kimi-code">, string>;
 export interface ConfirmAndInstallOptions {
     /** Test/real seam, same pattern as onboard's `promptForAgent` — a real
      * terminal confirmation by default. */
@@ -19,8 +20,9 @@ export interface ConfirmAndInstallOptions {
 }
 export interface ConfirmAndInstallResult {
     installed: boolean;
-    /** False only when the agent has no npm package at all (Kiro) — the
-     * caller refuses this agent with its download URL instead of prompting. */
+    /** False when the agent has no supported npm installation path — the
+     * caller refuses it with its official installation hint instead of
+     * prompting. */
     installable: boolean;
 }
 export declare function confirmAndInstall(agent: AgentId, opts?: ConfirmAndInstallOptions): Promise<ConfirmAndInstallResult>;

package/dist/lib/installAgent.js

@@ -2,8 +2,9 @@
  * Install-then-manage (trellis-managed-agents design.md D5): selecting a
  * not-yet-present agent into the managed set is itself the authorization
  * to install it, but never silently — one confirmation, then a real
- * `npm install -g <package>` child process. Kiro has no npm package (a
- * desktop download) and is refused before this module is ever reached.
+ * `npm install -g <package>` child process. Kiro and Kimi Code use official
+ * install scripts rather than an npm package and are refused before this
+ * module is ever reached.
  */
 import { execFileSync } from "node:child_process";
 import { createInterface } from "node:readline/promises";
@@ -31,7 +32,7 @@ function runInstallReal(pkg) {
     execFileSync("npm", ["install", "-g", pkg], { stdio: "inherit" });
 }
 export async function confirmAndInstall(agent, opts = {}) {
-    if (agent === "kiro") {
+    if (agent === "kiro" || agent === "kimi-code") {
         return { installed: false, installable: false };
     }
     const pkg = NPM_INSTALLABLE[agent];

package/dist/lib/mcpConnect.js

@@ -19,6 +19,7 @@ import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { resolveSecretEnv } from "./secretEnv.js";
 import { extractTemplateVarNames } from "./envVarNames.js";
 export const DEFAULT_CONNECT_TIMEOUT_MS = 10_000;
+const FAILED_TRANSPORT_CLEANUP_TIMEOUT_MS = 1_000;
 /**
  * A hanging server (process alive, protocol response never sent) leaves
  * `promise` permanently unsettled — indistinguishable from "still
@@ -55,7 +56,10 @@ export async function connectWithCleanup(client, transport, timeoutMs, message)
     }
     catch (err) {
         try {
-            await transport.close();
+            // A failed HTTP transport can itself hang while closing. Cleanup is
+            // best-effort and must not turn one bad upstream into a Gateway-wide
+            // startup timeout; preserve the original connect error below.
+            await withTimeout(Promise.resolve().then(() => transport.close()), FAILED_TRANSPORT_CLEANUP_TIMEOUT_MS, "transport cleanup timed out");
         }
         catch {
             // best-effort; the original connect failure is what matters

package/dist/lib/mcpMigrateRead.d.ts

@@ -37,6 +37,7 @@ export interface McpMigrateReadResult {
 export declare function resolvedEnvTextMap(def: Pick<McpServerDef, "env" | "envAliases" | "staticEnv">): Record<string, string>;
 export declare function readClaudeCodeMcpDefs(homeDir: string): McpMigrateReadResult;
 export declare function readKiroMcpDefs(homeDir: string): McpMigrateReadResult;
+export declare function readKimiCodeMcpDefs(homeDir: string): McpMigrateReadResult;
 export interface CodexMcpEntryRich {
     name: string;
     enabled: boolean;

package/dist/lib/mcpMigrateRead.js

@@ -108,6 +108,9 @@ export function readClaudeCodeMcpDefs(homeDir) {
 export function readKiroMcpDefs(homeDir) {
     return readRichJsonMcpDefs(join(homeDir, ".kiro", "settings", "mcp.json"));
 }
+export function readKimiCodeMcpDefs(homeDir) {
+    return readRichJsonMcpDefs(join(homeDir, ".kimi-code", "mcp.json"));
+}
 /**
  * Pure conversion half — separated from the subprocess/file-read effects
  * below so the stdio/non-stdio/malformed decision logic is unit-testable

package/dist/lib/mcpRuntime.d.ts

@@ -0,0 +1,46 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { CallToolResult, GetPromptResult, Implementation, Prompt, ReadResourceResult, Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { AgentId } from "../core/types.js";
+import type { GatewayBackend } from "./gatewayBackend.js";
+export interface RuntimeContext {
+    agentId: AgentId;
+    homeDir: string;
+}
+export interface TrellisProvider {
+    readonly id: string;
+    listTools?(context: RuntimeContext): Promise<Tool[]> | Tool[];
+    callTool(name: string, args: unknown, context: RuntimeContext): Promise<CallToolResult>;
+    listResources?(context: RuntimeContext): Promise<Resource[]> | Resource[];
+    readResource?(uri: URL, context: RuntimeContext): Promise<ReadResourceResult> | ReadResourceResult;
+    listPrompts?(context: RuntimeContext): Promise<Prompt[]> | Prompt[];
+    getPrompt?(name: string, args: Record<string, string> | undefined, context: RuntimeContext): Promise<GetPromptResult> | GetPromptResult;
+    close?(): Promise<void>;
+}
+export declare class BuiltinRegistry {
+    private readonly providers;
+    private readonly warn;
+    private readonly toolOwners;
+    private readonly originalToolOwners;
+    private readonly exposedToOriginal;
+    private readonly resourceOwners;
+    private readonly promptOwners;
+    constructor(providers: readonly TrellisProvider[], warn?: (message: string) => void);
+    listTools(context: RuntimeContext): Promise<Tool[]>;
+    callTool(name: string, args: unknown, context: RuntimeContext): Promise<CallToolResult>;
+    listResources(context: RuntimeContext): Promise<Resource[]>;
+    readResource(uri: URL, context: RuntimeContext): Promise<ReadResourceResult>;
+    listPrompts(context: RuntimeContext): Promise<Prompt[]>;
+    getPrompt(name: string, args: Record<string, string> | undefined, context: RuntimeContext): Promise<GetPromptResult>;
+    close(): Promise<void>;
+}
+/** Adapts the existing gateway tool backend without duplicating its routing
+ * or upstream connection logic. */
+export declare class UpstreamProvider implements TrellisProvider {
+    private readonly backend;
+    readonly id = "upstream";
+    constructor(backend: GatewayBackend);
+    listTools(): Promise<Tool[]>;
+    callTool(name: string, args: unknown): Promise<CallToolResult>;
+    close(): Promise<void>;
+}
+export declare function createRuntimeServer(serverInfo: Implementation, context: RuntimeContext, registry: BuiltinRegistry): Server;