kibi-mcp 0.22.0 → 1.0.0

package/bin/kibi-mcp

@@ -19,11 +19,11 @@
 const args = globalThis.Bun?.argv?.slice(2) ?? process.argv.slice(2);
 
 async function importStartupResolution() {
-  try {
-    return await import("../dist/startup-resolution.js");
-  } catch {
-    return await import("../src/startup-resolution.ts");
-  }
+  // Published packages contain the compiled runtime only. Do not replace a
+  // real dependency/import failure with a source-tree fallback: doing so
+  // hides package contract errors and makes startup depend on an unpackaged
+  // TypeScript tree.
+  return await import("../dist/startup-resolution.js");
 }
 
 async function serverEntrypointUrl() {
@@ -32,7 +32,10 @@ async function serverEntrypointUrl() {
   if (existsSync(distUrl)) {
     return distUrl.href;
   }
-  return new URL("../src/server.ts", import.meta.url).href;
+  throw new Error(
+    `[KIBI-MCP] Missing compiled server entrypoint: ${distUrl.pathname}. ` +
+      "Run the package build before launching kibi-mcp.",
+  );
 }
 
 async function buildResolution() {
@@ -64,11 +67,9 @@ async function importServer(entrypoint) {
     const { pathToFileURL } = await import("node:url");
     return await import(pathToFileURL(entrypoint).href);
   }
-  try {
-    return await import("../dist/server.js");
-  } catch {
-    return await import("../src/server.ts");
-  }
+  // Preserve the original import error. In particular, an incompatible
+  // kibi-cli export must not be replaced with a misleading source fallback.
+  return await import("../dist/server.js");
 }
 
 function printHelp() {

package/dist/diagnostics.js

@@ -144,8 +144,46 @@ const RECEIPT_GAP_CODES = new Set([
     "stale_verification_receipt",
     "failed_verification_receipt",
     "invalid_verification_receipt",
+    "verification_contract_mismatch",
     "verification_snapshot_unavailable",
 ]);
+const MAX_COVERAGE_RECEIPT_GAPS = 50;
+function coverageReceiptGapDetails(rows) {
+    const details = rows
+        .flatMap((row) => {
+        const codes = [...new Set(stringArray(row.proofGaps))]
+            .filter((code) => RECEIPT_GAP_CODES.has(code))
+            .sort();
+        if (codes.length === 0)
+            return [];
+        const stages = isRecord(row.proofStages) ? row.proofStages : undefined;
+        const passingE2e = isRecord(stages?.passingE2e)
+            ? stages.passingE2e
+            : undefined;
+        const testIds = [
+            "missingReceiptTests",
+            "staleReceiptTests",
+            "failedReceiptTests",
+            "invalidReceiptTests",
+            "contractMismatchReceiptTests",
+            "snapshotUnavailableTests",
+        ].flatMap((key) => stringArray(passingE2e?.[key]));
+        const requirementId = typeof row.id === "string" ? row.id : "unknown";
+        return [
+            {
+                requirementId,
+                testIds: [...new Set(testIds)].sort(),
+                codes,
+            },
+        ];
+    })
+        .sort((left, right) => left.requirementId.localeCompare(right.requirementId));
+    return {
+        details: details.slice(0, MAX_COVERAGE_RECEIPT_GAPS),
+        total: details.length,
+        truncated: details.length > MAX_COVERAGE_RECEIPT_GAPS,
+    };
+}
 function appendCoverageFields(fields, args, structuredContent) {
     const rows = Array.isArray(structuredContent.rows)
         ? structuredContent.rows.filter(isRecord)
@@ -166,6 +204,10 @@ function appendCoverageFields(fields, args, structuredContent) {
     fields.coverage_proof_gap_count = gapCodes.length;
     fields.coverage_gap_codes = uniqueGapCodes;
     fields.coverage_receipt_gap_count = gapCodes.filter((gap) => RECEIPT_GAP_CODES.has(gap)).length;
+    const receiptGaps = coverageReceiptGapDetails(rows);
+    fields.coverage_receipt_gaps = receiptGaps.details;
+    fields.coverage_receipt_gap_total = receiptGaps.total;
+    fields.coverage_receipt_gaps_truncated = receiptGaps.truncated;
     if (typeof scope?.complete === "boolean") {
         fields.coverage_scope_complete = scope.complete;
     }
@@ -234,7 +276,25 @@ export function deriveDiagnosticFields(toolName, args, telemetry, result) {
             fields.actor_id = telemetry.actor_id;
         }
     }
-    const structuredContent = structuredContentFrom(result);
+    const envelope = structuredContentFrom(result);
+    const structuredContent = envelope?.kibiProtocol === 1 && isRecord(envelope.data)
+        ? envelope.data
+        : envelope;
+    if (envelope?.kibiProtocol === 1) {
+        fields.protocol_version = envelope.kibiProtocol;
+        fields.result_version = envelope.resultVersion ?? null;
+        fields.result_status = envelope.status ?? null;
+        fields.effect_failures = Array.isArray(envelope.effects)
+            ? envelope.effects.filter((effect) => effect !== null &&
+                typeof effect === "object" &&
+                !Array.isArray(effect) &&
+                effect.status === "failed")
+            : [];
+        fields.followed_next_actions = Array.isArray(telemetry?.followed_next_actions)
+            ? telemetry.followed_next_actions
+            : [];
+        fields.unsafe_original_retry = telemetry?.unsafe_original_retry === true;
+    }
     if (toolName === "kb_query" || toolName === "kb_search") {
         const resultCount = Number(structuredContent?.count ?? 0);
         fields.result_count = resultCount;

package/dist/env.js

@@ -36,7 +36,11 @@ export function isMcpDebugEnabled() {
 }
 export function getBranchOverride() {
     // implements REQ-002
-    return getTrimmedEnvValue("KIBI_BRANCH");
+    // Branch names are identities, not display labels. Preserve the value
+    // exactly so the Git-ref validator can reject whitespace or other invalid
+    // input instead of silently attaching a different branch.
+    const value = getEnvValue("KIBI_BRANCH");
+    return value === undefined || value.length === 0 ? undefined : value;
 }
 export function getKbPlPathOverride() {
     // implements REQ-002

package/dist/runtime/mcp-runtime.js

@@ -1,3 +1,4 @@
+import { resolveBranchAttachment } from "kibi-runtime";
 // implements REQ-kibi-operation-interface-parity
 export function createMcpRuntime(session) {
     const sessionPrologs = new WeakMap();
@@ -11,18 +12,50 @@ export function createMcpRuntime(session) {
                 signal: options.signal ?? session.signal ?? new AbortController().signal,
                 clock: options.clock ?? session.clock ?? (() => new Date()),
                 ...(fs ? { fs } : {}),
+                ...(fs ? { sourceFirst: true } : {}),
                 ...(git ? { git } : {}),
                 ...(net ? { net } : {}),
             };
+            const attachment = resolveBranchAttachment(context.workspaceRoot);
+            if (!("error" in attachment) && attachment.migrationRequired) {
+                console.warn(`[KIBI-MCP] Legacy branch attachment: Git '${attachment.gitBranch}' is reading KB '${attachment.kbBranch}'. Run 'kibi branch migrate --from ${attachment.kbBranch} --to ${attachment.gitBranch} --apply'; writes are blocked until then.`);
+            }
+            const withAttachment = "error" in attachment
+                ? context
+                : { ...context, branchAttachment: attachment };
             if (!spec.requiresProlog) {
-                return context;
+                // Preserve explicit host/test injection without asking the shared MCP
+                // session to initialise a store merely to report its condition.
+                const providedProlog = options.prolog;
+                let lazyProlog;
+                const lazyContext = {};
+                const ensureProlog = async () => {
+                    if (providedProlog !== undefined)
+                        return providedProlog;
+                    if (lazyProlog !== undefined)
+                        return session.adaptProlog(lazyProlog);
+                    lazyProlog = await session.ensureProlog();
+                    if (lazyContext.current !== undefined)
+                        sessionPrologs.set(lazyContext.current, lazyProlog);
+                    return session.adaptProlog(lazyProlog);
+                };
+                const operationContext = {
+                    ...withAttachment,
+                    ...(options.prolog ? { prolog: options.prolog } : {}),
+                    ensureProlog,
+                };
+                lazyContext.current = operationContext;
+                return operationContext;
+            }
+            if (!("error" in attachment) && attachment.migrationRequired) {
+                throw new Error(`Legacy branch attachment requires explicit migration before '${spec.name}'; run kibi branch migrate --from ${attachment.kbBranch} --to ${attachment.gitBranch} --apply`);
             }
             if (options.prolog) {
-                return { ...context, prolog: options.prolog };
+                return { ...withAttachment, prolog: options.prolog };
             }
             const sessionProlog = await session.ensureProlog();
             const operationContext = {
-                ...context,
+                ...withAttachment,
                 prolog: session.adaptProlog(sessionProlog),
             };
             sessionPrologs.set(operationContext, sessionProlog);

package/dist/server/docs.js

@@ -16,6 +16,7 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import { TOOLS } from "../tools-config.js";
+import { KIBI_ICONS } from "./icons.js";
 const ACTIVE_TOOLS = TOOLS;
 function renderToolsDoc() {
     const lines = [
@@ -41,58 +42,32 @@ function renderToolsDoc() {
 export const PROMPTS = [
     // implements REQ-002, REQ-013, REQ-mcp-search-discovery
     {
-        name: "init-kibi",
-        description: "Activation workflow to populate a new or empty Kibi KB from an existing repository.",
+        name: "kibi-bootstrap",
+        title: "Bootstrap Kibi knowledge",
+        description: "Bootstrap Kibi knowledge for an existing repository through the canonical planner and apply operation.",
         text: [
-            "# Kibi Interactive Activation Workflow",
+            "# Kibi Bootstrap",
             "",
-            "Use this post-hoc workflow to onboard a new or empty repository into Kibi through interactive discovery.",
+            "Route an explicit bootstrap request to the canonical `kibi-bootstrap` skill and planner.",
             "",
-            "## Step 1: Gather Declared Context",
+            "## Route",
             "",
-            "The agent must ask at most 4 bounded questions to gather declared intent from the user:",
-            "1. **Project Summary**: What is the core purpose of this project?",
-            "2. **Source of Truth**: Where is the primary documentation (canonical requirements, ADRs)?",
-            "3. **Priority Root**: In a monorepo, which package should be prioritized?",
-            "4. **Verification Anchors**: Where are the primary tests or verification configs located?",
+            "Inspect `kb_status.bootstrap` and follow its typed `nextAction`. If infrastructure is missing, run `kibi init` before planning.",
             "",
-            "## Step 2: Synthesize Candidates (read-only)",
+            "## Preview and Approval",
             "",
-            "Call `kb_autopilot_generate` with the gathered context to synthesize candidate entities.",
+            "Call `kb_plan_bootstrap` read-only. Ask only the bounded questions returned when its status is `needs_context`; do not invent a questionnaire.",
             "",
-            "This tool is **read-only**. It returns additive `structuredContent` with:",
-            "- `promptBlock`: review text that must be surfaced before writes",
-            "- `recommendedActions`: agent-facing next steps, including any REQ/SCEN/TEST authoring routed for manual handling",
-            "- `declaredContext`: the user-provided bootstrap context",
-            "- `confidence`: confidence summary for the generated output",
-            "- `bootstrapMode`: current KB state (e.g., `root_uninitialized`)",
-            "- `candidates`: synthesized entities grounded in declared context and source evidence",
-            "- `applyPlan`: exact sequential `kb_upsert` payloads for approved candidates",
-            "- `discoverySummary`: source-backed discovery notes",
+            "Show the exact returned `structuredContent.plan`, its actions, and canonical hash. Get explicit user approval, then pass that plan object unchanged to `kb_apply_plan`.",
             "",
-            "## Step 3: Preview and Approval",
+            "## Verify and repair",
             "",
-            "Surface the `promptBlock`, a summary of `candidates`, and the exact `structuredContent.applyPlan` payloads. Wait for explicit user approval before proceeding to writes.",
-            "",
-            "## Step 4: Apply Candidates",
-            "",
-            "Apply candidates sequentially using `kb_upsert`.",
-            "1. Execute `structuredContent.applyPlan` sequentially in listed order.",
-            "2. Confirm success of each `kb_upsert` before moving to the next.",
-            "3. Run `kb_check` after the batch to verify KB integrity.",
-            "",
-            "## Rules",
-            "- Never apply bootstrap writes without user-facing preview and explicit approval.",
-            "- `kb_autopilot_generate` is strictly read-only; synthesis is the backend, not the actor.",
-            "- MCP tools and the trusted project-local CLI are peer surfaces; choose by what is visible and approved here.",
-            "- If Kibi MCP tools are visible and approved, use MCP.",
-            "- Otherwise, in a trusted workspace, use the project-local CLI's dedicated JSON routes with `--input <file|->`.",
-            "- If neither interface is available, Kibi operation is blocked; tell the operator to enable MCP or the trusted project-local CLI. Do not infer MCP availability from config file existence.",
-            "- Do not read or edit `.kb/` files directly. Query before mutate. Run `kb_upsert` sequentially. Run `kb_check` before completion.",
+            "Inspect the typed `kb_apply_plan` result, follow any `nextActions` for recovery, and finish with `kb_check` and `kb_status`. Never read or edit `.kb` directly or reconstruct a plan.",
         ].join("\n"),
     },
     {
         name: "kibi_overview",
+        title: "Kibi usage overview",
         description: "High-level model for using kibi-mcp safely and effectively.",
         text: [
             "# kibi-mcp Overview",
@@ -113,7 +88,7 @@ export const PROMPTS = [
             "Core modeling principles:",
             "- Kibi has eight entity types: common authoring (req, scenario, test, fact) and supporting/system (adr, flag, event, symbol).",
             "- Encode requirements as linked facts: `req --constrains--> fact` plus `req --requires_property--> fact`.",
-            "- High-confidence `kb_model_requirement` output is deterministic; `/init-kibi` bootstrap writes still require preview and explicit approval.",
+            "- High-confidence `kb_model_requirement` output is deterministic; `/kibi-bootstrap` bootstrap writes still require preview and explicit approval.",
             "- Low-confidence claims (< 0.7) are downgraded to `observation` facts to prevent false-positive contradictions.",
             "- Only strict domain facts participate in contradiction inference; observation and meta facts are non-blocking notes.",
             "- v1 contradictions are limited to exact-value, boolean/enum, numeric range, and polarity conflicts.",
@@ -127,6 +102,7 @@ export const PROMPTS = [
     },
     {
         name: "kibi_workflow",
+        title: "Kibi workflow steps",
         description: "Step-by-step call order for discovery, mutation, and verification.",
         text: [
             "# kibi-mcp Workflow",
@@ -149,6 +125,7 @@ export const PROMPTS = [
     },
     {
         name: "kibi_constraints",
+        title: "Kibi constraints",
         description: "Operational limits, validation rules, and mutation gotchas.",
         text: [
             "# kibi-mcp Constraints",
@@ -236,6 +213,7 @@ function registerDocResources() {
         {
             uri: "kibi://docs/overview",
             name: "kibi docs overview",
+            title: "Kibi server overview",
             description: "Full server description, purpose, and scope.",
             mimeType: "text/markdown",
             text: overview,
@@ -243,6 +221,7 @@ function registerDocResources() {
         {
             uri: "kibi://docs/tools",
             name: "kibi docs tools",
+            title: "Kibi tools reference",
             description: "Available tools with summaries and required parameters.",
             mimeType: "text/markdown",
             text: renderToolsDoc(),
@@ -250,6 +229,7 @@ function registerDocResources() {
         {
             uri: "kibi://docs/errors",
             name: "kibi docs errors",
+            title: "Kibi error guide",
             description: "Common error modes and suggested recovery actions.",
             mimeType: "text/markdown",
             text: errors,
@@ -257,6 +237,7 @@ function registerDocResources() {
         {
             uri: "kibi://docs/examples",
             name: "kibi docs examples",
+            title: "Kibi usage examples",
             description: "Concrete tool call sequences for common tasks.",
             mimeType: "text/markdown",
             text: examples,
@@ -266,7 +247,10 @@ function registerDocResources() {
 export const DOC_RESOURCES = registerDocResources();
 export function setupDocsAndPrompts(server) {
     for (const prompt of PROMPTS) {
-        server.prompt(prompt.name, prompt.description, async () => ({
+        server.registerPrompt(prompt.name, {
+            title: prompt.title,
+            description: prompt.description,
+        }, async () => ({
             messages: [
                 {
                     role: "user",
@@ -276,7 +260,12 @@ export function setupDocsAndPrompts(server) {
         }));
     }
     for (const resource of DOC_RESOURCES) {
-        server.resource(resource.name, resource.uri, { description: resource.description, mimeType: resource.mimeType }, async () => ({
+        server.registerResource(resource.name, resource.uri, {
+            title: resource.title,
+            description: resource.description,
+            mimeType: resource.mimeType,
+            icons: KIBI_ICONS,
+        }, async () => ({
             contents: [
                 {
                     uri: resource.uri,

package/dist/server/icons.js

@@ -0,0 +1,27 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+const KIBI_LOGO_MARK_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 308 309"><rect width="308" height="309" rx="64" fill="#1D1E23"/><ellipse cx="113.3" cy="150.9" rx="51.3" ry="51.5" fill="#A2D3F4"/><path d="M228.1 197.8L227.6 165.5H156.5L95.4 165.3V135.1H156.5L227.5 135.1V101.2H252.2V197.8Z" fill="#A2D3F4"/></svg>`;
+const KIBI_ICON_SRC = `data:image/svg+xml;base64,${Buffer.from(KIBI_LOGO_MARK_SVG, "utf8").toString("base64")}`;
+export const KIBI_ICONS = [
+    {
+        src: KIBI_ICON_SRC,
+        mimeType: "image/svg+xml",
+        sizes: ["any"],
+        theme: "dark",
+    },
+];

package/dist/server/json-schema-to-zod.js

@@ -73,7 +73,19 @@ export function jsonSchemaToZod(schema) {
         const union = z.union(literalSchemas);
         return description ? union.describe(description) : union;
     }
-    const schemaType = typeof obj.type === "string" ? obj.type : undefined;
+    const schemaTypes = Array.isArray(obj.type)
+        ? obj.type.filter((value) => typeof value === "string")
+        : typeof obj.type === "string"
+            ? [obj.type]
+            : [];
+    // JSON Schema nullable fields are represented as a type union in the
+    // catalog. Build a real Zod union so MCP publishes and validates the same
+    // nullability instead of silently degrading the field to z.any().
+    if (schemaTypes.length > 1) {
+        const variants = schemaTypes.map((type) => jsonSchemaToZod({ ...obj, type }));
+        return z.union(variants);
+    }
+    const schemaType = schemaTypes[0];
     switch (schemaType) {
         case "object": {
             const properties = obj.properties && typeof obj.properties === "object"
@@ -178,6 +190,11 @@ export function jsonSchemaToZod(schema) {
             const description = typeof obj.description === "string" ? obj.description : undefined;
             return description ? b.describe(description) : b;
         }
+        case "null": {
+            const n = z.null();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            return description ? n.describe(description) : n;
+        }
         default: {
             const anySchema = z.any();
             const description = typeof obj.description === "string" ? obj.description : undefined;

package/dist/server/session.js

@@ -18,9 +18,9 @@
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import process from "node:process";
-import { EngineClient } from "kibi-cli/engine";
-import { PrologProcess } from "kibi-cli/prolog";
-import { copyCleanSnapshot, getBranchDiagnostic, isValidBranchName, resolveActiveBranch, } from "kibi-cli/public/branch-resolver";
+import { EngineClient } from "kibi-runtime";
+import { PrologProcess } from "kibi-runtime";
+import { copyCleanSnapshot, ensureBranchStoreManifest, getBranchDiagnostic, isValidBranchName, resolveActiveBranch, resolveBranchAttachment, } from "kibi-runtime";
 import { getBranchOverride, isMcpDebugEnabled } from "../env.js";
 import { resolveKbPath, resolveWorkspaceRoot } from "../workspace.js";
 import { KbRefreshError, describeBranchKbStamp, readBranchKbStamp, sameBranchKbStamp, } from "./kb-freshness.js";
@@ -32,6 +32,7 @@ const defaultSessionDeps = {
     getBranchDiagnostic,
     isValidBranchName,
     resolveActiveBranch,
+    resolveBranchAttachment,
     resolveKbPath,
     resolveWorkspaceRoot,
 };
@@ -90,19 +91,19 @@ export function ensureBranchKbExists(workspaceRoot, branch) {
     if (sessionDeps.fs.existsSync(branchPath)) {
         return false;
     }
-    // Try to copy from the previously active branch if available
-    const previousBranch = activeBranchName;
-    const previousBranchPath = sessionDeps.resolveKbPath(workspaceRoot, previousBranch);
-    if (previousBranch !== branch &&
-        previousBranch !== "develop" &&
-        sessionDeps.fs.existsSync(previousBranchPath)) {
-        // Copy from previous branch for continuity
-        sessionDeps.copyCleanSnapshot(previousBranchPath, branchPath);
-        debugLog(`[KIBI-MCP] Created branch KB for '${branch}' from '${previousBranch}'`);
-        return false;
+    // Branch initialization is intentionally empty. The compiled store is
+    // materialized from the current checkout's authored sources by sync; it is
+    // never copied from another branch.
+    // Unit/integration hosts can provide a virtual filesystem through the
+    // existing session dependency seam.  Only the real Node filesystem needs
+    // the identity manifest writer; virtual hosts already model the resolved
+    // branch path and should not be forced to create that path on the host.
+    if (sessionDeps.fs === fs) {
+        ensureBranchStoreManifest(workspaceRoot, branch);
+    }
+    else {
+        sessionDeps.fs.mkdirSync(branchPath, { recursive: true });
     }
-    // No previous branch available - create empty KB
-    sessionDeps.fs.mkdirSync(branchPath, { recursive: true });
     debugLog(`[KIBI-MCP] Created empty branch KB for '${branch}'`);
     return true;
 }
@@ -228,14 +229,15 @@ async function ensurePrologUnsafe() {
         targetBranch = envBranch;
     }
     else {
-        // No override - resolve active branch from git (may change between requests)
-        const branchResult = sessionDeps.resolveActiveBranch(workspaceRoot);
+        // No override - resolve the exact Git branch, with read-compatible legacy
+        // literal-path storage detection for bridge-release repositories.
+        const branchResult = sessionDeps.resolveBranchAttachment(workspaceRoot);
         if ("error" in branchResult) {
             const diagnostic = sessionDeps.getBranchDiagnostic(undefined, branchResult.error);
             console.error(`[KIBI-MCP] ${diagnostic}`);
             throw new Error(`Failed to resolve active branch: ${branchResult.error}`);
         }
-        targetBranch = branchResult.branch;
+        targetBranch = branchResult.kbBranch;
     }
     // Check if we need to switch branches
     if (isInitialized && useEngine && prologProcess?.isRunning()) {
@@ -322,39 +324,11 @@ async function ensurePrologUnsafe() {
         : new sessionDeps.PrologProcess({ timeout: 120000 });
     await prologProcess.start();
     await assertGeneration();
-    // Startup debug: resolve which kibi-cli is being used and its version (best-effort).
-    // Gate all output under KIBI_MCP_DEBUG and write only to stderr via debugLog.
-    if (isMcpDebugEnabled()) {
-        try {
-            const req = sessionDeps.createRequire(import.meta.url);
-            try {
-                const resolved = req.resolve("kibi-cli/prolog");
-                debugLog(`[KIBI-MCP] require.resolve('kibi-cli/prolog') -> ${resolved}`);
-            }
-            catch (resolveErr) {
-                debugLog("[KIBI-MCP] require.resolve('kibi-cli/prolog') failed:", resolveErr.message);
-            }
-            // Try to read package.json for kibi-cli to get version. This may fail if
-            // the package uses exports blocking package.json access — log explicit failure.
-            try {
-                // prefer direct package.json require; createRequire makes this ESM-friendly
-                // eslint-disable-next-line @typescript-eslint/no-var-requires
-                const pkg = req("kibi-cli/package.json");
-                if (pkg && typeof pkg.version === "string") {
-                    debugLog(`[KIBI-MCP] kibi-cli version: ${pkg.version}`);
-                }
-                else {
-                    debugLog("[KIBI-MCP] kibi-cli package.json read but no version field");
-                }
-            }
-            catch (pkgErr) {
-                debugLog("[KIBI-MCP] Failed to read kibi-cli package.json (exports may restrict access):", pkgErr.message);
-            }
-        }
-        catch (err) {
-            debugLog("[KIBI-MCP] Failed to create require() for debug lookup:", err.message);
-        }
-    }
+    // Adapters report the package that owns runtime execution. Do not resolve
+    // CLI implementation paths from the MCP process; the runtime package is
+    // the sole first-party execution boundary.
+    if (isMcpDebugEnabled())
+        debugLog("[KIBI-MCP] Runtime boundary: kibi-runtime");
     debugLog("[KIBI-MCP] Branch selection:");
     debugLog(`[KIBI-MCP]   KIBI_BRANCH env: ${envBranch || "not set"}`);
     debugLog(`[KIBI-MCP]   Resolved branch: ${targetBranch}`);

package/dist/server/tool-registration.js

@@ -1,4 +1,5 @@
-import { getSpec } from "kibi-cli/operations";
+import { getSpec, statusSpec } from "kibi-runtime";
+import { executeApplyPlan, executeCompileIntent, executeDelete, executeIngestVerification, executeUpsert, validateUpsertSpec, } from "kibi-runtime";
 // implements REQ-002, REQ-013
 export function registerConfiguredTools(server, runtime, registerTool) {
     const toolDef = (name) => {
@@ -14,6 +15,10 @@ export function registerConfiguredTools(server, runtime, registerTool) {
         }
         return prolog;
     };
+    const withSessionProlog = (context) => ({
+        ...context,
+        prolog: prologFor(context),
+    });
     const register = ({ name, execute }) => {
         const definition = toolDef(name);
         const publicSpec = getSpec(name);
@@ -23,7 +28,7 @@ export function registerConfiguredTools(server, runtime, registerTool) {
             requiresProlog: publicSpec.requiresProlog,
             execute: (args, context) => execute(context, args),
         };
-        registerTool(server, name, definition.description, definition.inputSchema, async () => undefined, runtime, spec, definition.annotations);
+        registerTool(server, name, definition.description, definition.inputSchema, async () => undefined, runtime, spec, definition.annotations, definition.outputSchema);
     };
     // INTENTIONAL ARGUMENT CASTS: The `args as (unknown as)? XyzArgs` casts below
     // bridge the generic ToolHandler (which receives Record<string, unknown>) to the
@@ -39,7 +44,11 @@ export function registerConfiguredTools(server, runtime, registerTool) {
     });
     register({
         name: "kb_status",
-        execute: async (context, args) => runtime.handleKbStatus(prologFor(context), args, context),
+        execute: async (context, args) => 
+        // Status owns its non-mutating fallback. Do not require the session engine
+        // here: an absent or unreadable branch store is exactly the condition it
+        // must be able to describe.
+        statusSpec.execute(args, context),
     });
     register({
         name: "kb_skills_list",
@@ -75,15 +84,15 @@ export function registerConfiguredTools(server, runtime, registerTool) {
     });
     register({
         name: "kb_upsert",
-        execute: async (context, args) => runtime.handleKbUpsert(prologFor(context), args),
+        execute: async (context, args) => executeUpsert(args, withSessionProlog(context)),
     });
     register({
         name: "kb_validate_upsert",
-        execute: async (context, args) => runtime.handleKbValidateUpsert(prologFor(context), args),
+        execute: async (context, args) => validateUpsertSpec.execute(args, withSessionProlog(context)),
     });
     register({
         name: "kb_delete",
-        execute: async (context, args) => runtime.handleKbDelete(prologFor(context), args),
+        execute: async (context, args) => executeDelete(args, withSessionProlog(context)),
     });
     register({
         name: "kb_check",
@@ -98,7 +107,25 @@ export function registerConfiguredTools(server, runtime, registerTool) {
         execute: async (context, args) => runtime.handleKbSuggestPredicates(prologFor(context), args),
     });
     register({
-        name: "kb_autopilot_generate",
-        execute: async (context, args) => runtime.handleKbAutopilotGenerate(args, context),
+        name: "kb_plan_bootstrap",
+        execute: async (context, args) => runtime.handleKbPlanBootstrap(args, context),
+    });
+    register({
+        name: "kb_compile_intent",
+        execute: async (context, args) => runtime.handleKbCompileIntent
+            ? runtime.handleKbCompileIntent(args, context)
+            : executeCompileIntent(args, context),
+    });
+    register({
+        name: "kb_apply_plan",
+        execute: async (context, args) => runtime.handleKbApplyPlan
+            ? runtime.handleKbApplyPlan(args, context)
+            : executeApplyPlan(args, context),
+    });
+    register({
+        name: "kb_ingest_verification",
+        execute: async (context, args) => runtime.handleKbIngestVerification
+            ? runtime.handleKbIngestVerification(args, context)
+            : executeIngestVerification(args, context),
     });
 }