kcp-harness 0.1.0

package/dist/downstream.js

@@ -0,0 +1,167 @@
+// Downstream MCP server management — spawn, initialize, and proxy to
+// downstream MCP servers over stdio.
+//
+// The harness acts as an MCP client to each downstream server. It:
+// 1. Spawns the server as a child process with stdio pipes
+// 2. Performs the MCP initialization handshake
+// 3. Collects the server's tool list
+// 4. Routes tool calls to the appropriate downstream
+// 5. Cleans up on shutdown
+//
+// Each downstream connection handles JSON-RPC 2.0 over newline-delimited
+// stdio — the standard MCP framing. Request/response correlation uses
+// monotonic integer IDs.
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+const HARNESS_VERSION = "0.1.0";
+const INIT_TIMEOUT_MS = 15_000;
+const CALL_TIMEOUT_MS = 60_000;
+/** Manages the lifecycle of downstream MCP servers. */
+export class DownstreamManager {
+    connections = [];
+    /** Map from tool name → downstream connection that owns it. */
+    toolOwners = new Map();
+    /** Spawn and initialize a downstream MCP server. */
+    async add(config) {
+        const conn = this.spawn(config);
+        await this.initialize(conn);
+        this.connections.push(conn);
+        // Register tool ownership
+        for (const tool of conn.tools) {
+            if (this.toolOwners.has(tool.name)) {
+                // Name collision — prefix with downstream name
+                const prefixed = `${config.name}__${tool.name}`;
+                this.toolOwners.set(prefixed, conn);
+            }
+            else {
+                this.toolOwners.set(tool.name, conn);
+            }
+        }
+        return conn;
+    }
+    /** Get all tools from all downstream servers. */
+    allTools() {
+        const tools = [];
+        for (const conn of this.connections) {
+            tools.push(...conn.tools);
+        }
+        return tools;
+    }
+    /** Find which downstream owns a tool. */
+    ownerOf(toolName) {
+        return this.toolOwners.get(toolName);
+    }
+    /** Call a tool on the downstream that owns it. */
+    async callTool(toolName, args) {
+        const conn = this.toolOwners.get(toolName);
+        if (!conn)
+            throw new Error(`no downstream owns tool: ${toolName}`);
+        if (!conn.alive)
+            throw new Error(`downstream ${conn.name} is not alive`);
+        const result = await this.rpc(conn, "tools/call", {
+            name: toolName,
+            arguments: args,
+        });
+        return result;
+    }
+    /** Shut down all downstream connections. */
+    async shutdown() {
+        for (const conn of this.connections) {
+            conn.alive = false;
+            conn.readline.close();
+            conn.process.kill("SIGTERM");
+            // Clear pending requests
+            for (const [, p] of conn.pending) {
+                clearTimeout(p.timer);
+                p.reject(new Error("downstream shutting down"));
+            }
+            conn.pending.clear();
+        }
+        this.connections = [];
+        this.toolOwners.clear();
+    }
+    // -- Internal lifecycle ---------------------------------------------------
+    spawn(config) {
+        const proc = spawn(config.command, config.args ?? [], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, ...config.env },
+        });
+        if (!proc.stdout || !proc.stdin) {
+            throw new Error(`failed to spawn downstream ${config.name}: no stdio`);
+        }
+        const rl = createInterface({ input: proc.stdout, terminal: false });
+        const conn = {
+            name: config.name,
+            config,
+            process: proc,
+            readline: rl,
+            tools: [],
+            nextId: 1,
+            pending: new Map(),
+            alive: true,
+        };
+        // Wire up response handling
+        rl.on("line", (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            try {
+                const msg = JSON.parse(trimmed);
+                if (msg.id !== undefined && msg.id !== null) {
+                    const p = conn.pending.get(Number(msg.id));
+                    if (p) {
+                        conn.pending.delete(Number(msg.id));
+                        clearTimeout(p.timer);
+                        if (msg.error)
+                            p.reject(new Error(msg.error.message));
+                        else
+                            p.resolve(msg.result);
+                    }
+                }
+            }
+            catch {
+                // Ignore unparseable lines (stderr leaking into stdout, etc.)
+            }
+        });
+        proc.on("exit", () => {
+            conn.alive = false;
+            // Reject all pending requests
+            for (const [, p] of conn.pending) {
+                clearTimeout(p.timer);
+                p.reject(new Error(`downstream ${config.name} exited`));
+            }
+            conn.pending.clear();
+        });
+        return conn;
+    }
+    async initialize(conn) {
+        // MCP initialization handshake
+        const initResult = (await this.rpc(conn, "initialize", {
+            protocolVersion: "2025-06-18",
+            capabilities: {},
+            clientInfo: { name: "kcp-harness", version: HARNESS_VERSION },
+        }, INIT_TIMEOUT_MS));
+        // Send initialized notification
+        this.notify(conn, "notifications/initialized");
+        // List tools
+        const toolsResult = (await this.rpc(conn, "tools/list", {}, INIT_TIMEOUT_MS));
+        conn.tools = toolsResult.tools ?? [];
+    }
+    // -- JSON-RPC transport ---------------------------------------------------
+    rpc(conn, method, params, timeoutMs = CALL_TIMEOUT_MS) {
+        const id = conn.nextId++;
+        const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+        conn.process.stdin.write(msg + "\n");
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                conn.pending.delete(id);
+                reject(new Error(`timeout waiting for ${method} from ${conn.name}`));
+            }, timeoutMs);
+            conn.pending.set(id, { resolve, reject, timer });
+        });
+    }
+    notify(conn, method, params) {
+        const msg = JSON.stringify({ jsonrpc: "2.0", method, params });
+        conn.process.stdin.write(msg + "\n");
+    }
+}

package/dist/governor.d.ts

@@ -0,0 +1,34 @@
+import { type AgentPlan, type DecisionTrace } from "kcp-agent";
+import type { GovernancePolicy } from "./config.js";
+import type { Classification } from "./classifier.js";
+import type { SessionState, ApprovedPlan } from "./session.js";
+import type { SpendResult } from "./budget-ledger.js";
+/** The governor's decision for a tool call. */
+export interface GovernanceDecision {
+    /** Whether the tool call is approved. */
+    approved: boolean;
+    /** How the decision was made. */
+    mode: "plan-first" | "auto-plan" | "kcp-passthrough" | "blocked";
+    /** The plan that governs this decision (if any). */
+    plan?: AgentPlan;
+    /** The decision trace (if tracing is enabled). */
+    trace?: DecisionTrace;
+    /** Human-readable reason for the decision. */
+    reason: string;
+    /** The approved plan that matched (for plan-first mode). */
+    approvedPlan?: ApprovedPlan;
+    /** Budget spend result (for auto-plan mode with costs). */
+    budgetSpend?: SpendResult;
+}
+/**
+ * Govern a classified tool call — decide whether to approve or block.
+ *
+ * For KCP tools (kcp_plan, kcp_load, etc.), the call is always passed through
+ * to the kcp-agent planner directly — the harness doesn't gate KCP's own tools.
+ *
+ * For file/URL tools targeting governed domains, the governor checks:
+ * 1. Is there an existing approved plan that covers this path? → approve
+ * 2. If not, auto-plan against the domain's manifest → approve if selected
+ * 3. Otherwise → block (fail-closed)
+ */
+export declare function govern(classification: Classification, toolName: string, args: Record<string, unknown>, session: SessionState, policy: GovernancePolicy): Promise<GovernanceDecision>;

package/dist/governor.js

@@ -0,0 +1,201 @@
+// Governor — enforce governance via kcp-agent's deterministic planner.
+//
+// The governor is the enforcement layer. When the classifier identifies a
+// tool call as knowledge-navigation, the governor decides whether to allow
+// it by running the kcp-agent planner and checking the result.
+//
+// Two modes:
+//
+// 1. **Plan-first** (preferred): the agent has called kcp_plan/kcp_load and
+//    established an approved plan. Subsequent tool calls are checked against
+//    the plan's selected units. Fast — no planner call needed.
+//
+// 2. **Auto-plan** (fallback): the agent tries to access a governed path
+//    without a prior plan. The governor auto-creates a plan with the file
+//    path as the task, then checks eligibility. If the path's unit is
+//    selected → approve; if not → block.
+//
+// In both modes, the governor is fail-closed: if the planner can't reach
+// the manifest, if the unit isn't selected, or if the budget is exhausted,
+// the call is blocked — never silently passed through.
+import { planTree, plans, } from "kcp-agent";
+import { isPathApproved, addPlan, recordSpend } from "./session.js";
+/**
+ * Govern a classified tool call — decide whether to approve or block.
+ *
+ * For KCP tools (kcp_plan, kcp_load, etc.), the call is always passed through
+ * to the kcp-agent planner directly — the harness doesn't gate KCP's own tools.
+ *
+ * For file/URL tools targeting governed domains, the governor checks:
+ * 1. Is there an existing approved plan that covers this path? → approve
+ * 2. If not, auto-plan against the domain's manifest → approve if selected
+ * 3. Otherwise → block (fail-closed)
+ */
+export async function govern(classification, toolName, args, session, policy) {
+    // KCP tools pass through — they ARE the governance layer
+    if (toolName.startsWith("kcp_")) {
+        return { approved: true, mode: "kcp-passthrough", reason: "KCP tool — governance layer itself" };
+    }
+    if (!classification.governed || !classification.domain) {
+        return { approved: true, mode: "kcp-passthrough", reason: "ungoverned tool call" };
+    }
+    const domain = classification.domain;
+    const target = classification.target;
+    // Mode 1: check existing approved plans
+    if (target) {
+        const approved = isPathApproved(session, target);
+        if (approved) {
+            return {
+                approved: true,
+                mode: "plan-first",
+                plan: approved.plan,
+                approvedPlan: approved,
+                reason: `path ${target} is in approved plan for "${approved.task}"`,
+            };
+        }
+    }
+    // Mode 2: auto-plan — create a governance plan on the fly
+    if (target && domain.manifest) {
+        try {
+            const autoPlan = await autoGovern(target, domain, session, policy);
+            return autoPlan;
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            // Fail-closed: planner error → block
+            if (policy.fail_closed) {
+                return {
+                    approved: false,
+                    mode: "blocked",
+                    reason: `auto-plan failed (fail-closed): ${msg}`,
+                };
+            }
+            return {
+                approved: false,
+                mode: "blocked",
+                reason: `auto-plan failed: ${msg}`,
+            };
+        }
+    }
+    // No target extractable + governed domain → block
+    return {
+        approved: false,
+        mode: "blocked",
+        reason: `governed tool call with no extractable target — blocked by policy`,
+    };
+}
+/**
+ * Auto-govern: run the kcp-agent planner to decide if accessing a target
+ * path is approved. Creates a plan and checks if the target is in the
+ * selected set.
+ */
+async function autoGovern(target, domain, session, policy) {
+    const followOptions = buildFollowOptions(policy, session);
+    // Use the target path as the task — the planner will score units
+    // against this and select the most relevant ones.
+    const task = `access ${target}`;
+    const tree = await planTree(domain.manifest, task, followOptions);
+    if (tree.error) {
+        return {
+            approved: false,
+            mode: "blocked",
+            reason: `manifest error: ${tree.error}`,
+        };
+    }
+    // Extract the flat plan list
+    const allPlans = Array.from(plans(tree));
+    const rootPlan = allPlans[0];
+    if (!rootPlan) {
+        return {
+            approved: false,
+            mode: "blocked",
+            reason: "planner returned no plan",
+        };
+    }
+    // Check: is the target path in the selected set?
+    const targetNorm = normalizePath(target);
+    const matchingUnit = rootPlan.selected.find((u) => u.loadEligible && pathOverlaps(targetNorm, u.path));
+    if (matchingUnit) {
+        // Register the plan in the session for future fast-path lookups
+        addPlan(session, domain.manifest, task, rootPlan);
+        // Track budget spend via ledger
+        let budgetSpend;
+        if (rootPlan.budget?.projectedSpend) {
+            const currency = rootPlan.budget.currency ?? "USDC";
+            budgetSpend = session.ledger.recordPlanSpend(domain.manifest, task, rootPlan.budget.projectedSpend, currency);
+            // Also update the legacy counter
+            recordSpend(session, rootPlan.budget.projectedSpend);
+            if (!budgetSpend.accepted) {
+                return {
+                    approved: false,
+                    mode: "auto-plan",
+                    plan: rootPlan,
+                    budgetSpend,
+                    reason: `auto-plan blocked: budget ceiling exceeded — ${budgetSpend.reason}`,
+                };
+            }
+        }
+        // Register with temporal watcher
+        session.temporalWatch.register(domain.manifest, task, rootPlan, followOptions);
+        return {
+            approved: true,
+            mode: "auto-plan",
+            plan: rootPlan,
+            budgetSpend,
+            reason: `auto-plan approved: unit "${matchingUnit.id}" (score ${matchingUnit.score}) covers ${target}`,
+        };
+    }
+    // Check: was the unit selected but not load-eligible? (paywall, attestation, etc.)
+    const ineligibleUnit = rootPlan.selected.find((u) => !u.loadEligible && pathOverlaps(targetNorm, u.path));
+    if (ineligibleUnit) {
+        return {
+            approved: false,
+            mode: "auto-plan",
+            plan: rootPlan,
+            reason: `auto-plan blocked: unit "${ineligibleUnit.id}" covers ${target} but is not load-eligible (${ineligibleUnit.reasons.filter(r => r.startsWith("unaffordable") || r.startsWith("needs")).join("; ") || "gate restriction"})`,
+        };
+    }
+    // Target not in selected set → check if it was skipped and why
+    const skippedUnit = rootPlan.skipped.find((u) => pathOverlaps(targetNorm, u.id));
+    const skipReason = skippedUnit
+        ? `unit "${skippedUnit.id}" was skipped: ${skippedUnit.reason}`
+        : `no unit covers path ${target}`;
+    return {
+        approved: false,
+        mode: "auto-plan",
+        plan: rootPlan,
+        reason: `auto-plan blocked: ${skipReason}`,
+    };
+}
+/** Build FollowOptions from governance policy and session state. */
+function buildFollowOptions(policy, session) {
+    const planOptions = {
+        maxUnits: policy.max_units,
+        strict: policy.strict,
+        env: policy.env,
+    };
+    if (policy.budget) {
+        planOptions.budget = {
+            amount: policy.budget.amount,
+            currency: policy.budget.currency,
+            spent: session.budgetSpent,
+        };
+    }
+    if (policy.context_budget !== undefined) {
+        planOptions.contextBudget = policy.context_budget;
+    }
+    return {
+        planOptions,
+        maxDepth: 0, // auto-plan doesn't follow federation by default
+        fetchGuard: {}, // default guards (no private hosts, https only)
+    };
+}
+function normalizePath(p) {
+    return p.replace(/\/+/g, "/").replace(/^\.\//, "");
+}
+/** Check if a target path overlaps with a unit path (loose match). */
+function pathOverlaps(target, unitPath) {
+    const a = normalizePath(target);
+    const b = normalizePath(unitPath);
+    return a === b || a.endsWith("/" + b) || a.endsWith(b) || b.endsWith("/" + a);
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { classify, extractTargets, normalizePath, matchesPrefix, type Classification, } from "./classifier.js";
+export { govern, type GovernanceDecision, } from "./governor.js";
+export { AuditLog, InMemoryAuditLog, buildEvent, buildLifecycleEvent, buildBudgetEvent, buildDriftEvent, type AuditWriter, type AuditEvent, type AuditEventType, } from "./audit.js";
+export { createSession, addPlan, isPathApproved, recordLoaded, getKnown, recordSpend, nextSequence, type SessionState, type ApprovedPlan, } from "./session.js";
+export { DownstreamManager, type McpTool, type DownstreamConnection, } from "./downstream.js";
+export { HarnessProxy, serveProxy, type ProxyOptions, } from "./proxy.js";
+export { loadConfig, parseConfig, DEFAULT_POLICY, DEFAULT_AUDIT, type HarnessConfig, type GovernedDomain, type GovernancePolicy, type DownstreamConfig, type AuditConfig, } from "./config.js";
+export { callKcpTool } from "./kcp-bridge.js";
+export { BudgetLedger, type BudgetCeiling, type LedgerEntry, type LedgerSource, type LedgerCost, type LedgerSnapshot, type SpendResult, } from "./budget-ledger.js";
+export { TemporalWatch, type WatchedPlan, type DriftResult, type WatchResult, } from "./temporal-watch.js";
+export { generate, generateAll, listAgents, harnessServerEntry, governedPathsBlock, manifestRef, } from "./integrations/generate.js";
+export { AGENTS, type AgentTarget, type IntegrationOutput, type IntegrationFile, type IntegrationOptions, type AgentInfo, } from "./integrations/types.js";

package/dist/index.js

@@ -0,0 +1,21 @@
+// kcp-harness — public API.
+//
+// The KCP Compliance Harness: an MCP proxy that enforces deterministic
+// knowledge governance for any agent. The harness intercepts tool calls,
+// classifies them as knowledge-navigation or pass-through, and routes
+// governed calls through the kcp-agent planner before execution.
+//
+// Every decision is logged to an append-only audit log. The agent can't
+// bypass governance because it only has access to the proxy's stdio.
+export { classify, extractTargets, normalizePath, matchesPrefix, } from "./classifier.js";
+export { govern, } from "./governor.js";
+export { AuditLog, InMemoryAuditLog, buildEvent, buildLifecycleEvent, buildBudgetEvent, buildDriftEvent, } from "./audit.js";
+export { createSession, addPlan, isPathApproved, recordLoaded, getKnown, recordSpend, nextSequence, } from "./session.js";
+export { DownstreamManager, } from "./downstream.js";
+export { HarnessProxy, serveProxy, } from "./proxy.js";
+export { loadConfig, parseConfig, DEFAULT_POLICY, DEFAULT_AUDIT, } from "./config.js";
+export { callKcpTool } from "./kcp-bridge.js";
+export { BudgetLedger, } from "./budget-ledger.js";
+export { TemporalWatch, } from "./temporal-watch.js";
+export { generate, generateAll, listAgents, harnessServerEntry, governedPathsBlock, manifestRef, } from "./integrations/generate.js";
+export { AGENTS, } from "./integrations/types.js";

package/dist/integrations/claude-code.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationOutput, IntegrationOptions } from "./types.js";
+export declare function generateClaudeCode(options: IntegrationOptions): IntegrationOutput;

package/dist/integrations/claude-code.js

@@ -0,0 +1,95 @@
+// Claude Code integration — MCP config + PreToolUse hooks + CLAUDE.md instructions.
+import { harnessServerEntry, governedPathsBlock, manifestRef } from "./generate.js";
+export function generateClaudeCode(options) {
+    const server = harnessServerEntry(options);
+    const manifest = manifestRef(options);
+    const paths = options.paths ?? ["docs/", "src/"];
+    const mcpJson = {
+        path: ".mcp.json",
+        content: JSON.stringify({
+            mcpServers: {
+                "kcp-harness": server,
+            },
+        }, null, 2) + "\n",
+        commitToGit: true,
+        description: "MCP server config — adds kcp-harness as a governance proxy",
+    };
+    const hooksJson = {
+        path: ".claude/settings.json",
+        content: JSON.stringify({
+            hooks: {
+                PreToolUse: [
+                    {
+                        matcher: "Read|Edit|Write|Glob|Grep",
+                        hooks: [
+                            {
+                                type: "command",
+                                command: "node",
+                                args: ["-e", `
+const args = JSON.parse(process.env.TOOL_INPUT || '{}');
+const path = args.file_path || args.path || '';
+const governed = ${JSON.stringify(paths)}.some(p => path.startsWith(p) || path.includes('/' + p));
+if (governed) {
+  console.log(JSON.stringify({ decision: "block", reason: "Use kcp_load to access governed knowledge at " + path }));
+  process.exit(2);
+}
+                  `.trim()],
+                            },
+                        ],
+                    },
+                ],
+            },
+        }, null, 2) + "\n",
+        commitToGit: true,
+        description: "PreToolUse hooks — block direct reads of governed paths, require kcp_load",
+    };
+    const claudeMd = {
+        path: "CLAUDE.md",
+        content: `# Knowledge Governance
+
+This project uses the KCP Compliance Harness for deterministic knowledge governance.
+
+## Governed Paths
+
+The following paths are governed by \`${manifest}\`:
+${governedPathsBlock(options)}
+
+## Rules
+
+1. **Always use \`kcp_load\`** before reading governed files — never read them directly
+2. Call \`kcp_plan\` first to see what units are available for your task
+3. The harness enforces budget ceilings and temporal validity automatically
+4. Use \`harness_status\` to check the current governance state
+5. Use \`harness_budget\` to check remaining budget
+6. Use \`harness_temporal_check\` to verify plans are still valid
+
+## Example Workflow
+
+\`\`\`
+1. kcp_plan  task="understand the API" manifest="${manifest}"
+2. kcp_load  task="understand the API" manifest="${manifest}"
+3. Read governed files through the harness (auto-governed)
+\`\`\`
+`,
+        commitToGit: true,
+        description: "CLAUDE.md — instructions for using governed knowledge",
+    };
+    return {
+        agent: "claude-code",
+        name: "Claude Code",
+        files: [mcpJson, hooksJson, claudeMd],
+        instructions: `## Claude Code Integration
+
+1. The \`.mcp.json\` registers kcp-harness as an MCP server
+2. The \`.claude/settings.json\` adds PreToolUse hooks that block direct reads of governed paths
+3. The \`CLAUDE.md\` instructs the agent to use kcp_load for knowledge access
+
+**Setup:**
+\`\`\`bash
+# Or add manually:
+claude mcp add --scope project kcp-harness -- npx kcp-harness serve
+\`\`\`
+
+The hooks enforce governance at the tool level — even if the model tries to \`Read\` a governed path directly, the hook blocks it and redirects to kcp_load.`,
+    };
+}

package/dist/integrations/cline.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationOutput, IntegrationOptions } from "./types.js";
+export declare function generateCline(options: IntegrationOptions): IntegrationOutput;

package/dist/integrations/cline.js

@@ -0,0 +1,70 @@
+// Cline integration — MCP settings snippet + .clinerules
+import { harnessServerEntry, governedPathsBlock, manifestRef } from "./generate.js";
+export function generateCline(options) {
+    const server = harnessServerEntry(options);
+    const manifest = manifestRef(options);
+    const mcpSnippet = {
+        path: "cline-mcp-snippet.json",
+        content: JSON.stringify({
+            "kcp-harness": {
+                ...server,
+                disabled: false,
+                autoApprove: [
+                    "kcp_plan",
+                    "kcp_trace",
+                    "harness_status",
+                    "harness_session",
+                    "harness_budget",
+                    "harness_temporal_check",
+                ],
+            },
+        }, null, 2) + "\n",
+        commitToGit: false,
+        description: "MCP snippet to add via Cline's MCP Servers settings UI",
+    };
+    const rulesFile = {
+        path: ".clinerules",
+        content: `# KCP Knowledge Governance
+
+This project uses the KCP Compliance Harness for deterministic knowledge governance.
+
+## Governed Paths
+
+${governedPathsBlock(options)}
+
+Governed by: \`${manifest}\`
+
+## Mandatory Rules
+
+1. **Always call \`kcp_load\`** before reading files in governed paths
+2. Call \`kcp_plan\` first to inspect the load plan
+3. The harness blocks ungoverned access to governed paths (fail-closed)
+4. Budget and temporal governance are enforced automatically
+
+## Available MCP Tools (kcp-harness server)
+
+- \`kcp_plan\` — deterministic load plan
+- \`kcp_load\` — plan + load content
+- \`kcp_trace\` — 13-gate decision trace
+- \`kcp_validate\` — lint knowledge.yaml
+- \`harness_status\` — governance state
+- \`harness_budget\` — spend tracking
+- \`harness_temporal_check\` — drift detection
+`,
+        commitToGit: true,
+        description: "Cline rules — governance instructions",
+    };
+    return {
+        agent: "cline",
+        name: "Cline",
+        files: [mcpSnippet, rulesFile],
+        instructions: `## Cline Integration
+
+**Setup:**
+1. Open Cline sidebar > MCP Servers tab > gear icon
+2. Add the kcp-harness entry from \`cline-mcp-snippet.json\`
+3. Place \`.clinerules\` in your project root
+
+The \`autoApprove\` list lets Cline call read-only governance tools without confirmation prompts. Write operations (kcp_load) still require approval.`,
+    };
+}

package/dist/integrations/continue.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationOutput, IntegrationOptions } from "./types.js";
+export declare function generateContinue(options: IntegrationOptions): IntegrationOutput;

package/dist/integrations/continue.js

@@ -0,0 +1,39 @@
+// Continue integration — .continue/mcpServers/kcp-harness.yaml
+import { manifestRef } from "./generate.js";
+export function generateContinue(options) {
+    const manifest = manifestRef(options);
+    const harnessCmd = options.harnessCommand ?? "npx";
+    const harnessArgs = options.harnessArgs ?? [
+        "kcp-harness", "serve",
+        ...(options.harnessConfig ? ["--config", options.harnessConfig] : []),
+    ];
+    const mcpYaml = {
+        path: ".continue/mcpServers/kcp-harness.yaml",
+        content: `name: KCP Compliance Harness
+version: 0.1.0
+schema: v1
+mcpServers:
+  - name: kcp-harness
+    command: ${harnessCmd}
+    args:
+${harnessArgs.map((a) => `      - "${a}"`).join("\n")}
+`,
+        commitToGit: true,
+        description: "Continue MCP server config for kcp-harness",
+    };
+    return {
+        agent: "continue",
+        name: "Continue",
+        files: [mcpYaml],
+        instructions: `## Continue Integration
+
+**Setup:**
+1. Place \`.continue/mcpServers/kcp-harness.yaml\` in your project root
+2. Restart Continue
+
+Continue loads MCP servers from the \`.continue/mcpServers/\` directory automatically.
+Use agent mode to access kcp-harness tools (\`kcp_plan\`, \`kcp_load\`, etc.).
+
+Note: Continue uses YAML format (not JSON) for MCP server configs in the directory-based approach.`,
+    };
+}

package/dist/integrations/copilot.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationOutput, IntegrationOptions } from "./types.js";
+export declare function generateCopilot(options: IntegrationOptions): IntegrationOutput;