kibi-mcp 0.17.3 → 0.17.5

package/dist/diagnostics-helpers.js

@@ -0,0 +1,137 @@
+import { createHash } from "node:crypto";
+const SECRET_LIKE_KEY_RE = /(token|secret|password|authorization|api[_-]?key|bearer)/i;
+const DIAGNOSTIC_PHASE_BY_STAGE = {
+    persistence: "persistence",
+    prolog_runtime: "runtime",
+    prolog_lifecycle: "runtime",
+    tool_timeout: "runtime",
+    validation: "validation",
+    handler: "handler",
+};
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function redactSecretLikeValue(value) {
+    if (Array.isArray(value))
+        return value.map(redactSecretLikeValue);
+    if (!isPlainObject(value))
+        return value;
+    const redacted = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+        redacted[key] = SECRET_LIKE_KEY_RE.test(key)
+            ? "[REDACTED]"
+            : redactSecretLikeValue(nestedValue);
+    }
+    return redacted;
+}
+function canonicalizeJsonValue(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalizeJsonValue);
+    if (!isPlainObject(value))
+        return value;
+    return Object.fromEntries(Object.keys(value)
+        .sort()
+        .map((key) => [key, canonicalizeJsonValue(value[key])]));
+}
+function stableJsonStringify(value) {
+    return JSON.stringify(canonicalizeJsonValue(value));
+}
+export function redactDiagnosticArgs(args) {
+    return redactSecretLikeValue(args);
+}
+export function deriveDiagnosticRetryKey(toolName, args) {
+    const hash = createHash("sha256")
+        .update(toolName)
+        .update("\0")
+        .update(stableJsonStringify(redactDiagnosticArgs(args)))
+        .digest("hex");
+    return `retry_${hash.slice(0, 16)}`;
+}
+export function classifyDiagnosticError(error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const lower = err.message.toLowerCase();
+    if (lower.includes("stale_snapshot"))
+        return buildErrorFields(err, "stale_snapshot", "persistence", "KB snapshot is stale; refresh/retry after the latest KB state is attached.");
+    if (lower.includes("unknown option") && lower.includes("h for help"))
+        return buildErrorFields(err, "prolog_unknown_option", "prolog_runtime", "Prolog rejected startup/module/query options; inspect MCP package wiring and Prolog invocation.");
+    if (lower.includes("prolog process not started"))
+        return buildErrorFields(err, "prolog_process_not_started", "prolog_lifecycle", "Prolog process is unavailable; restart the MCP server before retrying.");
+    if (lower.includes("resetting prolog worker") ||
+        lower.includes("prolog worker reset"))
+        return buildErrorFields(err, "prolog_worker_reset", "prolog_lifecycle", "Prolog worker was reset so the next MCP call can start from a fresh worker.");
+    if (/timed out after \d+ms/i.test(err.message) ||
+        lower.includes("tool timeout"))
+        return buildErrorFields(err, "tool_timeout", "tool_timeout", "MCP tool execution exceeded its bounded timeout.");
+    if (lower.includes("coarsely while granular symbols are available"))
+        return buildErrorFields(err, "coarse_symbol_linkage", "validation", "Symbol traceability targeted a coarse file/module while narrower exported symbols exist.");
+    if (err.message.startsWith("Entity validation failed:"))
+        return buildErrorFields(err, "entity_validation_failed", "validation", "Entity payload failed schema validation.");
+    if (err.message.startsWith("Relationship validation failed"))
+        return buildErrorFields(err, "relationship_validation_failed", "validation", "Relationship payload failed schema validation.");
+    if (err.message.startsWith("Relationship source must match the upserted entity"))
+        return buildErrorFields(err, "relationship_source_mismatch", "validation", "Relationship source did not match the entity being upserted.");
+    if (lower.includes("module load failed"))
+        return buildErrorFields(err, "prolog_module_load_failed", "prolog_runtime", "Prolog failed to load an execution module.");
+    if (lower.includes("query failed"))
+        return buildErrorFields(err, "prolog_query_failed", "prolog_runtime", "Prolog query execution failed.");
+    return buildErrorFields(err, "handler_error", "handler", "Unhandled MCP handler error.");
+}
+export function deriveDiagnosticHints(input) {
+    const error = input.error instanceof Error ? input.error : new Error(String(input.error));
+    const message = error.message.toLowerCase();
+    if (message.includes("invalid value 'implemented'"))
+        return "invalid_status: use one of the schema-accepted statuses (for example open, active, accepted, passing).";
+    if (message.includes("additional properties"))
+        return "additional_properties: remove unsupported fields from the payload and retry with schema-only arguments.";
+    const { error_category, error_stage, error_summary } = classifyDiagnosticError(error);
+    const mappedStage = DIAGNOSTIC_PHASE_BY_STAGE[error_stage] ?? error_stage;
+    if (error_category === "tool_timeout")
+        return `tool_timeout ${mappedStage}: retry the same request after reducing payload size or scope.`;
+    if (error_category === "relationship_source_mismatch")
+        return `relationship_source_mismatch ${mappedStage}: align the relationship source with the upserted entity id.`;
+    if (error_category === "prolog_process_not_started")
+        return `prolog_process_not_started ${mappedStage}: restart the MCP server before retrying the tool call.`;
+    if (error_category === "prolog_query_failed")
+        return `prolog_query_failed ${mappedStage}: inspect the Prolog query or workspace state and retry.`;
+    return `${error_category} ${mappedStage}: ${error_summary}`;
+}
+export function buildDiagnosticToolCall(input) {
+    const diagnosticError = input.error
+        ? classifyDiagnosticError(input.error)
+        : null;
+    const payload = isPlainObject(input.args)
+        ? extractToolCallPayload(input.args)
+        : { businessArgs: null, telemetry: null };
+    return {
+        schema_version: 1,
+        canonical_tool: input.tool,
+        request_id: input.requestId,
+        diagnostic_phase: input.diagnosticPhase,
+        business_args: payload.businessArgs,
+        raw_args_redacted: redactDiagnosticArgs(input.args),
+        retry_key: deriveDiagnosticRetryKey(input.tool, input.args),
+        hint: deriveDiagnosticHints({
+            tool: input.tool,
+            error: input.error ?? new Error("diagnostic tool call"),
+            businessArgs: payload.businessArgs,
+        }),
+        diagnostic_error: diagnosticError,
+        diagnostic_telemetry: input.telemetry ?? payload.telemetry,
+    };
+}
+export function extractToolCallPayload(args) {
+    const { _diagnostic_telemetry, ...businessArgs } = args;
+    const telemetry = _diagnostic_telemetry && typeof _diagnostic_telemetry === "object"
+        ? _diagnostic_telemetry
+        : null;
+    return { businessArgs, telemetry };
+}
+function buildErrorFields(error, category, stage, summary) {
+    return {
+        error_name: error.name,
+        error_message: error.message,
+        error_category: category,
+        error_stage: stage,
+        error_summary: summary,
+    };
+}

package/dist/diagnostics.js

@@ -1,39 +1,19 @@
 /*
- 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/>.
+ * 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.
  */
 import fs from "node:fs";
 import path from "node:path";
 import { resolveWorkspaceRoot } from "./workspace.js";
+export { buildDiagnosticToolCall, classifyDiagnosticError, deriveDiagnosticHints, deriveDiagnosticRetryKey, extractToolCallPayload, redactDiagnosticArgs, } from "./diagnostics-helpers.js";
 const DIAGNOSTIC_MODE_FLAG = "--diagnostic-mode";
-/**
- * Whether diagnostic mode is enabled via CLI flag.
- * Set during server startup and never changes at runtime.
- */
 export const DIAGNOSTIC_MODE_ENABLED = process.argv.includes(DIAGNOSTIC_MODE_FLAG);
-/**
- * Path to the diagnostic usage log file.
- * Only valid when DIAGNOSTIC_MODE_ENABLED is true.
- */
 let diagnosticUsageLogPath = null;
-/**
- * Initialize diagnostic mode: set up usage.log path.
- * Called once during server startup.
- */
-// implements REQ-008
 export function initializeDiagnosticMode(enabled = DIAGNOSTIC_MODE_ENABLED) {
     diagnosticUsageLogPath = null;
     if (!enabled) {
@@ -44,24 +24,14 @@ export function initializeDiagnosticMode(enabled = DIAGNOSTIC_MODE_ENABLED) {
     diagnosticUsageLogPath = path.join(workspaceRoot, ".kb", "usage.log");
     process.env.KIBI_MCP_DIAGNOSTIC_MODE = "1";
 }
-/**
- * Append a JSON line to the usage.log file.
- * No-op if diagnostic mode is not enabled.
- */
-// implements REQ-008
 export function appendUsageLogLine(entry) {
-    if (!diagnosticUsageLogPath) {
+    if (!diagnosticUsageLogPath)
         return;
-    }
-    const logDir = path.dirname(diagnosticUsageLogPath);
-    fs.mkdirSync(logDir, { recursive: true });
+    fs.mkdirSync(path.dirname(diagnosticUsageLogPath), { recursive: true });
     fs.appendFileSync(diagnosticUsageLogPath, `${JSON.stringify(entry)}\n`, {
         encoding: "utf8",
     });
 }
-/**
- * Schema for _diagnostic_telemetry field added to tool inputs in diagnostic mode.
- */
 export const DIAGNOSTIC_TELEMETRY_SCHEMA = {
     type: "object",
     description: "REQUIRED when diagnostic mode is on. Provide self-reflection metadata about this tool call.",
@@ -88,58 +58,6 @@ export const DIAGNOSTIC_TELEMETRY_SCHEMA = {
         },
     },
 };
-// implements REQ-002
-export function classifyDiagnosticError(error) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    const message = err.message;
-    const lower = message.toLowerCase();
-    if (lower.includes("stale_snapshot")) {
-        return buildErrorFields(err, "stale_snapshot", "persistence", "KB snapshot is stale; refresh/retry after the latest KB state is attached.");
-    }
-    if (lower.includes("unknown option") && lower.includes("h for help")) {
-        return buildErrorFields(err, "prolog_unknown_option", "prolog_runtime", "Prolog rejected startup/module/query options; inspect MCP package wiring and Prolog invocation.");
-    }
-    if (lower.includes("prolog process not started")) {
-        return buildErrorFields(err, "prolog_process_not_started", "prolog_lifecycle", "Prolog process is unavailable; restart the MCP server before retrying.");
-    }
-    if (lower.includes("resetting prolog worker") ||
-        lower.includes("prolog worker reset")) {
-        return buildErrorFields(err, "prolog_worker_reset", "prolog_lifecycle", "Prolog worker was reset so the next MCP call can start from a fresh worker.");
-    }
-    if (/timed out after \d+ms/i.test(message) ||
-        lower.includes("tool timeout")) {
-        return buildErrorFields(err, "tool_timeout", "tool_timeout", "MCP tool execution exceeded its bounded timeout.");
-    }
-    if (lower.includes("coarsely while granular symbols are available")) {
-        return buildErrorFields(err, "coarse_symbol_linkage", "validation", "Symbol traceability targeted a coarse file/module while narrower exported symbols exist.");
-    }
-    if (message.startsWith("Entity validation failed:")) {
-        return buildErrorFields(err, "entity_validation_failed", "validation", "Entity payload failed schema validation.");
-    }
-    if (message.startsWith("Relationship validation failed")) {
-        return buildErrorFields(err, "relationship_validation_failed", "validation", "Relationship payload failed schema validation.");
-    }
-    if (message.startsWith("Relationship source must match the upserted entity")) {
-        return buildErrorFields(err, "relationship_source_mismatch", "validation", "Relationship source did not match the entity being upserted.");
-    }
-    if (lower.includes("module load failed")) {
-        return buildErrorFields(err, "prolog_module_load_failed", "prolog_runtime", "Prolog failed to load an execution module.");
-    }
-    if (lower.includes("query failed")) {
-        return buildErrorFields(err, "prolog_query_failed", "prolog_runtime", "Prolog query execution failed.");
-    }
-    return buildErrorFields(err, "handler_error", "handler", "Unhandled MCP handler error.");
-}
-function buildErrorFields(error, category, stage, summary) {
-    return {
-        error_name: error.name,
-        error_message: error.message,
-        error_category: category,
-        error_stage: stage,
-        error_summary: summary,
-    };
-}
-// implements REQ-002
 export function deriveDiagnosticFields(toolName, args, telemetry, result) {
     const fields = {
         telemetry_status: telemetry ? "provided" : "missing",
@@ -172,13 +90,3 @@ export function deriveDiagnosticFields(toolName, args, telemetry, result) {
     }
     return fields;
 }
-/**
- * Extract business args and telemetry from tool call arguments.
- */
-export function extractToolCallPayload(args) {
-    const { _diagnostic_telemetry, ...businessArgs } = args;
-    const telemetry = _diagnostic_telemetry && typeof _diagnostic_telemetry === "object"
-        ? _diagnostic_telemetry
-        : null;
-    return { businessArgs, telemetry };
-}

package/dist/server/diagnostic-usage.js

@@ -0,0 +1,74 @@
+import { buildDiagnosticToolCall, deriveDiagnosticHints, } from "../diagnostics.js";
+// implements REQ-002
+export async function appendDiagnosticSuccessUsage(input) {
+    const finishedAt = new Date();
+    const diagnosticFields = input.runtime.deriveDiagnosticFields(input.toolName, input.businessArgs, input.telemetry, input.result);
+    const toolCall = buildDiagnosticToolCall({
+        tool: input.toolName,
+        requestId: input.requestId,
+        args: input.args,
+        diagnosticPhase: "success",
+        telemetry: input.telemetry,
+    });
+    const processHandle = await input.runtime.prologProcess();
+    const branchName = await input.runtime.activeBranchName();
+    input.runtime.appendUsageLogLine({
+        timestamp: finishedAt.toISOString(),
+        request_id: input.requestId,
+        tool: input.toolName,
+        telemetry: input.telemetry,
+        business_args: input.businessArgs,
+        tool_call: toolCall,
+        retry_key: toolCall.retry_key,
+        diagnostic_phase: toolCall.diagnostic_phase,
+        status: "success",
+        started_at: input.startedAt.toISOString(),
+        finished_at: finishedAt.toISOString(),
+        duration_ms: finishedAt.getTime() - input.startedAt.getTime(),
+        prolog_pid: processHandle?.getPid() ?? null,
+        active_branch: branchName,
+        ...diagnosticFields,
+    });
+}
+// implements REQ-002
+export async function appendDiagnosticErrorUsage(input) {
+    const finishedAt = new Date();
+    const err = input.error instanceof Error ? input.error : new Error(String(input.error));
+    const diagnosticErrorFields = input.runtime.classifyDiagnosticError(err);
+    const diagnosticHints = deriveDiagnosticHints({
+        tool: input.toolName,
+        error: err,
+        businessArgs: input.businessArgs,
+    });
+    const toolCall = buildDiagnosticToolCall({
+        tool: input.toolName,
+        requestId: input.requestId,
+        args: input.args,
+        diagnosticPhase: "error",
+        error: err,
+        telemetry: input.telemetry,
+    });
+    const processHandle = await input.runtime.prologProcess();
+    const branchName = await input.runtime.activeBranchName();
+    input.runtime.appendUsageLogLine({
+        timestamp: finishedAt.toISOString(),
+        request_id: input.requestId,
+        tool: input.toolName,
+        telemetry: input.telemetry,
+        business_args: input.businessArgs,
+        tool_call: toolCall,
+        retry_key: toolCall.retry_key,
+        diagnostic_phase: toolCall.diagnostic_phase,
+        status: "error",
+        started_at: input.startedAt.toISOString(),
+        finished_at: finishedAt.toISOString(),
+        duration_ms: finishedAt.getTime() - input.startedAt.getTime(),
+        prolog_pid: processHandle?.getPid() ?? null,
+        active_branch: branchName,
+        reset_attempted: input.resetState.resetAttempted,
+        reset_succeeded: input.resetState.resetSucceeded,
+        reset_error: input.resetState.resetError,
+        diagnostic_hints: [diagnosticHints],
+        ...diagnosticErrorFields,
+    });
+}

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

@@ -0,0 +1,104 @@
+import { z } from "zod";
+// implements REQ-002
+export function jsonSchemaToZod(schema) {
+    if (!schema || typeof schema !== "object") {
+        return z.any();
+    }
+    const obj = schema;
+    if (Array.isArray(obj.enum) && obj.enum.length > 0) {
+        const description = typeof obj.description === "string" ? obj.description : undefined;
+        const literals = obj.enum.filter((value) => typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean" ||
+            value === null);
+        if (literals.length === 0) {
+            return description ? z.any().describe(description) : z.any();
+        }
+        const literalSchemas = literals.map((value) => z.literal(value));
+        if (literalSchemas.length === 1) {
+            const single = literalSchemas[0];
+            if (!single) {
+                return description ? z.any().describe(description) : z.any();
+            }
+            return description ? single.describe(description) : single;
+        }
+        const union = z.union(literalSchemas);
+        return description ? union.describe(description) : union;
+    }
+    const schemaType = typeof obj.type === "string" ? obj.type : undefined;
+    switch (schemaType) {
+        case "object": {
+            const properties = obj.properties && typeof obj.properties === "object"
+                ? obj.properties
+                : {};
+            const required = new Set(Array.isArray(obj.required)
+                ? obj.required.filter((k) => typeof k === "string" && k.length > 0)
+                : []);
+            const shape = {};
+            for (const [key, value] of Object.entries(properties)) {
+                const propSchema = jsonSchemaToZod(value);
+                shape[key] = required.has(key) ? propSchema : propSchema.optional();
+            }
+            const objectSchema = obj.additionalProperties === false
+                ? z.object(shape)
+                : z.looseObject(shape);
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            return description ? objectSchema.describe(description) : objectSchema;
+        }
+        case "array": {
+            const itemSchema = jsonSchemaToZod(obj.items);
+            let arraySchema = z.array(itemSchema);
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            if (typeof obj.minItems === "number") {
+                arraySchema = arraySchema.min(obj.minItems);
+            }
+            if (typeof obj.maxItems === "number") {
+                arraySchema = arraySchema.max(obj.maxItems);
+            }
+            return description ? arraySchema.describe(description) : arraySchema;
+        }
+        case "string": {
+            let s = z.string();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            if (typeof obj.minLength === "number") {
+                s = s.min(obj.minLength);
+            }
+            if (typeof obj.maxLength === "number") {
+                s = s.max(obj.maxLength);
+            }
+            return description ? s.describe(description) : s;
+        }
+        case "number": {
+            let n = z.number();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            if (typeof obj.minimum === "number") {
+                n = n.min(obj.minimum);
+            }
+            if (typeof obj.maximum === "number") {
+                n = n.max(obj.maximum);
+            }
+            return description ? n.describe(description) : n;
+        }
+        case "integer": {
+            let n = z.number().int();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            if (typeof obj.minimum === "number") {
+                n = n.min(obj.minimum);
+            }
+            if (typeof obj.maximum === "number") {
+                n = n.max(obj.maximum);
+            }
+            return description ? n.describe(description) : n;
+        }
+        case "boolean": {
+            const b = z.boolean();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            return description ? b.describe(description) : b;
+        }
+        default: {
+            const anySchema = z.any();
+            const description = typeof obj.description === "string" ? obj.description : undefined;
+            return description ? anySchema.describe(description) : anySchema;
+        }
+    }
+}

package/dist/server/session.js

@@ -192,7 +192,7 @@ async function refreshAttachedBranchKbWithRetry(prolog, kbPath, currentStamp, as
     return postAttachStamp;
 }
 function usesBranchKbPath(kbPath) {
-    return kbPath.includes("/.kb/branches/") || kbPath.includes("\\.kb\\branches\\");
+    return (kbPath.includes("/.kb/branches/") || kbPath.includes("\\.kb\\branches\\"));
 }
 // implements REQ-008
 async function ensurePrologUnsafe() {

package/dist/server/tool-registration.js

@@ -0,0 +1,128 @@
+// implements REQ-002, REQ-013
+export function registerConfiguredTools(server, runtime, registerTool) {
+    const toolDef = (name) => {
+        const t = runtime.tools.find((tool) => tool.name === name);
+        if (!t)
+            throw new Error(`Unknown tool: ${name}`);
+        return t;
+    };
+    const register = ({ name, handler }) => {
+        const definition = toolDef(name);
+        registerTool(server, name, definition.description, definition.inputSchema, handler, runtime);
+    };
+    // INTENTIONAL ARGUMENT CASTS: The `args as (unknown as)? XyzArgs` casts below
+    // bridge the generic ToolHandler (which receives Record<string, unknown>) to the
+    // specific handler argument types. Argument shapes are validated by Zod schemas
+    // (via jsonSchemaToZod) before the handler is invoked, so the casts are safe at runtime.
+    register({
+        name: "kb_query",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbQuery(prolog, args);
+        },
+    });
+    register({
+        name: "kb_search",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbSearch(prolog, args);
+        },
+    });
+    register({
+        name: "kb_status",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbStatus(prolog, args);
+        },
+    });
+    register({
+        name: "kb_skills_list",
+        handler: async (args) => runtime.handleKbSkillsList(args),
+    });
+    register({
+        name: "kb_skills_load",
+        handler: async (args) => runtime.handleKbSkillsLoad(args),
+    });
+    register({
+        name: "kb_skills_read",
+        handler: async (args) => runtime.handleKbSkillsRead(args),
+    });
+    register({
+        name: "kb_find_gaps",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbFindGaps(prolog, args);
+        },
+    });
+    register({
+        name: "kb_coverage",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbCoverage(prolog, args);
+        },
+    });
+    register({
+        name: "kb_graph",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbGraph(prolog, args);
+        },
+    });
+    register({
+        name: "kb_sparql_remote",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleSparql(prolog, args);
+        },
+    });
+    register({
+        name: "kb_semantic_advisor",
+        handler: async (args) => runtime.handleKbSemanticAdvisor(args),
+    });
+    register({
+        name: "kb_upsert",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbUpsert(prolog, args);
+        },
+    });
+    register({
+        name: "kb_validate_upsert",
+        handler: async (args) => runtime.handleKbValidateUpsert(args),
+    });
+    register({
+        name: "kb_delete",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbDelete(prolog, args);
+        },
+    });
+    register({
+        name: "kb_check",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbCheck(prolog, args);
+        },
+    });
+    register({
+        name: "kb_model_requirement",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbModelRequirement(prolog, args);
+        },
+    });
+    register({
+        name: "kb_suggest_predicates",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbSuggestPredicates(prolog, args);
+        },
+    });
+    register({
+        name: "kb_autopilot_generate",
+        handler: async (args) => {
+            const prolog = await runtime.ensureProlog();
+            return runtime.handleKbAutopilotGenerate(prolog, args);
+        },
+    });
+}

package/dist/server/tool-types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/tools-runtime.js

@@ -0,0 +1,76 @@
+import { DIAGNOSTIC_MODE_ENABLED, appendUsageLogLine, classifyDiagnosticError, deriveDiagnosticFields, extractToolCallPayload, } from "../diagnostics.js";
+import { TOOLS } from "../tools-config.js";
+import { handleKbAutopilotGenerate } from "../tools/autopilot-generate.js";
+import { handleKbCheck } from "../tools/check.js";
+import { handleKbCoverage } from "../tools/coverage.js";
+import { handleKbDelete } from "../tools/delete.js";
+import { handleKbFindGaps } from "../tools/find-gaps.js";
+import { handleKbGraph } from "../tools/graph.js";
+import { handleKbModelRequirement } from "../tools/model-requirement.js";
+import { handleKbQuery } from "../tools/query.js";
+import { handleKbSearch } from "../tools/search.js";
+import { handleKbSemanticAdvisor } from "../tools/semantic-advisor.js";
+import { handleKbSkillsList, handleKbSkillsLoad, handleKbSkillsRead, } from "../tools/skills.js";
+import { handleSparql } from "../tools/sparql.js";
+import { handleKbStatus } from "../tools/status.js";
+import { handleKbSuggestPredicates } from "../tools/suggest-predicates.js";
+import { handleKbUpsert } from "../tools/upsert.js";
+import { handleKbValidateUpsert } from "../tools/validate-upsert.js";
+const defaultToolsServerDeps = {
+    getSessionModule: () => import("./session.js"),
+};
+let sessionModulePromise = null;
+// implements REQ-008
+export function _setToolsServerDepsForTests(deps, resetPromise = false) {
+    defaultToolsServerDeps.getSessionModule =
+        deps.getSessionModule ?? defaultToolsServerDeps.getSessionModule;
+    if (resetPromise) {
+        sessionModulePromise = null;
+    }
+}
+// implements REQ-012
+export function _resetSessionModulePromise() {
+    sessionModulePromise = null;
+}
+/* v8 ignore next (3 lines) — lazy async module loader; body only executes once per process
+ * when DEFAULT_TOOLS_RUNTIME.activeBranchName/ensureProlog/etc. are first called.
+ * Cannot be re-triggered without process restart (sessionModulePromise is module-level). */
+async function getSessionModule() {
+    sessionModulePromise ??= defaultToolsServerDeps.getSessionModule();
+    return sessionModulePromise;
+}
+export const DEFAULT_TOOLS_RUNTIME = {
+    diagnosticModeEnabled: () => DIAGNOSTIC_MODE_ENABLED,
+    appendUsageLogLine,
+    classifyDiagnosticError,
+    deriveDiagnosticFields,
+    extractToolCallPayload,
+    // INTENTIONAL: TOOLS is imported as a Zod-inferred schema type; ToolConfig is the
+    // runtime interface with looser Record<string, unknown> inputSchema. The cast is safe
+    // because the tool definitions are statically authored and validated at startup.
+    tools: TOOLS,
+    activeBranchName: async () => (await getSessionModule()).activeBranchName,
+    ensureProlog: async () => (await getSessionModule()).ensureProlog(),
+    resetProlog: async (reason) => (await getSessionModule()).resetProlog(reason),
+    inFlightRequests: async () => (await getSessionModule()).inFlightRequests,
+    isShuttingDown: async () => (await getSessionModule()).isShuttingDown,
+    prologProcess: async () => (await getSessionModule()).prologProcess,
+    handleKbCheck,
+    handleKbCoverage,
+    handleKbDelete,
+    handleKbFindGaps,
+    handleKbGraph,
+    handleSparql,
+    handleKbQuery,
+    handleKbSearch,
+    handleKbStatus,
+    handleKbSemanticAdvisor,
+    handleKbSkillsList,
+    handleKbSkillsLoad,
+    handleKbSkillsRead,
+    handleKbUpsert,
+    handleKbValidateUpsert,
+    handleKbModelRequirement,
+    handleKbSuggestPredicates,
+    handleKbAutopilotGenerate,
+};

package/dist/server/tools.js

@@ -16,86 +16,15 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import process from "node:process";
-import { z } from "zod";
-import { DIAGNOSTIC_MODE_ENABLED, appendUsageLogLine, classifyDiagnosticError, deriveDiagnosticFields, extractToolCallPayload, } from "../diagnostics.js";
 import { isMcpDebugEnabled } from "../env.js";
-import { TOOLS } from "../tools-config.js";
-import { handleKbAutopilotGenerate, } from "../tools/autopilot-generate.js";
-import { handleKbCheck } from "../tools/check.js";
-import { handleKbCoverage } from "../tools/coverage.js";
-import { handleKbDelete } from "../tools/delete.js";
-import { handleKbFindGaps } from "../tools/find-gaps.js";
-import { handleKbGraph } from "../tools/graph.js";
-import { handleKbModelRequirement, } from "../tools/model-requirement.js";
-import { handleKbQuery } from "../tools/query.js";
-import { handleKbSearch } from "../tools/search.js";
-import { handleKbSemanticAdvisor, } from "../tools/semantic-advisor.js";
-import { handleKbSkillsList, handleKbSkillsLoad, handleKbSkillsRead, } from "../tools/skills.js";
-import { handleSparql } from "../tools/sparql.js";
-import { handleKbStatus } from "../tools/status.js";
-import { handleKbSuggestPredicates, } from "../tools/suggest-predicates.js";
-import { handleKbUpsert } from "../tools/upsert.js";
-import { handleKbValidateUpsert } from "../tools/validate-upsert.js";
+import { appendDiagnosticErrorUsage, appendDiagnosticSuccessUsage, } from "./diagnostic-usage.js";
+import { jsonSchemaToZod } from "./json-schema-to-zod.js";
+import { registerConfiguredTools } from "./tool-registration.js";
+import { DEFAULT_TOOLS_RUNTIME, _resetSessionModulePromise, _setToolsServerDepsForTests, } from "./tools-runtime.js";
+export { jsonSchemaToZod } from "./json-schema-to-zod.js";
+export { _resetSessionModulePromise, _setToolsServerDepsForTests };
 const DEFAULT_TOOL_TIMEOUT_MS = 90_000;
 const TOOL_TIMEOUT_ENV = "KIBI_MCP_TOOL_TIMEOUT_MS";
-const defaultToolsServerDeps = {
-    getSessionModule: () => import("./session.js"),
-};
-// implements REQ-008
-export function _setToolsServerDepsForTests(deps, resetPromise = false) {
-    defaultToolsServerDeps.getSessionModule =
-        deps.getSessionModule ?? defaultToolsServerDeps.getSessionModule;
-    if (resetPromise) {
-        sessionModulePromise = null;
-    }
-}
-// implements REQ-012
-export function _resetSessionModulePromise() {
-    sessionModulePromise = null;
-}
-let sessionModulePromise = null;
-/* v8 ignore next (3 lines) — lazy async module loader; body only executes once per process
- * when DEFAULT_TOOLS_RUNTIME.activeBranchName/ensureProlog/etc. are first called.
- * Cannot be re-triggered without process restart (sessionModulePromise is module-level). */
-async function getSessionModule() {
-    sessionModulePromise ??= defaultToolsServerDeps.getSessionModule();
-    return sessionModulePromise;
-}
-const DEFAULT_TOOLS_RUNTIME = {
-    diagnosticModeEnabled: () => DIAGNOSTIC_MODE_ENABLED,
-    appendUsageLogLine,
-    classifyDiagnosticError,
-    deriveDiagnosticFields,
-    extractToolCallPayload,
-    // INTENTIONAL: TOOLS is imported as a Zod-inferred schema type; ToolConfig is the
-    // runtime interface with looser Record<string, unknown> inputSchema. The cast is safe
-    // because the tool definitions are statically authored and validated at startup.
-    tools: TOOLS,
-    activeBranchName: async () => (await getSessionModule()).activeBranchName,
-    ensureProlog: async () => (await getSessionModule()).ensureProlog(),
-    resetProlog: async (reason) => (await getSessionModule()).resetProlog(reason),
-    inFlightRequests: async () => (await getSessionModule()).inFlightRequests,
-    isShuttingDown: async () => (await getSessionModule()).isShuttingDown,
-    prologProcess: async () => (await getSessionModule()).prologProcess,
-    handleKbCheck,
-    handleKbCoverage,
-    handleKbDelete,
-    handleKbFindGaps,
-    handleKbGraph,
-    handleSparql,
-    handleKbQuery,
-    handleKbSearch,
-    handleKbStatus,
-    handleKbSemanticAdvisor,
-    handleKbSkillsList,
-    handleKbSkillsLoad,
-    handleKbSkillsRead,
-    handleKbUpsert,
-    handleKbValidateUpsert,
-    handleKbModelRequirement,
-    handleKbSuggestPredicates,
-    handleKbAutopilotGenerate,
-};
 // implements REQ-008
 function debugLog(...args) {
     if (isMcpDebugEnabled()) {
@@ -140,109 +69,6 @@ async function withToolTimeout(toolName, operation, onTimeout) {
     }
 }
 // implements REQ-002
-export function jsonSchemaToZod(schema) {
-    if (!schema || typeof schema !== "object") {
-        return z.any();
-    }
-    const obj = schema;
-    if (Array.isArray(obj.enum) && obj.enum.length > 0) {
-        const description = typeof obj.description === "string" ? obj.description : undefined;
-        const literals = obj.enum.filter((value) => typeof value === "string" ||
-            typeof value === "number" ||
-            typeof value === "boolean" ||
-            value === null);
-        if (literals.length === 0) {
-            return description ? z.any().describe(description) : z.any();
-        }
-        const literalSchemas = literals.map((value) => z.literal(value));
-        if (literalSchemas.length === 1) {
-            const single = literalSchemas[0];
-            if (!single) {
-                return description ? z.any().describe(description) : z.any();
-            }
-            return description ? single.describe(description) : single;
-        }
-        const union = z.union(literalSchemas);
-        return description ? union.describe(description) : union;
-    }
-    const schemaType = typeof obj.type === "string" ? obj.type : undefined;
-    switch (schemaType) {
-        case "object": {
-            const properties = obj.properties && typeof obj.properties === "object"
-                ? obj.properties
-                : {};
-            const required = new Set(Array.isArray(obj.required)
-                ? obj.required.filter((k) => typeof k === "string" && k.length > 0)
-                : []);
-            const shape = {};
-            for (const [key, value] of Object.entries(properties)) {
-                const propSchema = jsonSchemaToZod(value);
-                shape[key] = required.has(key) ? propSchema : propSchema.optional();
-            }
-            const objectSchema = obj.additionalProperties === false
-                ? z.object(shape)
-                : z.looseObject(shape);
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            return description ? objectSchema.describe(description) : objectSchema;
-        }
-        case "array": {
-            const itemSchema = jsonSchemaToZod(obj.items);
-            let arraySchema = z.array(itemSchema);
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            if (typeof obj.minItems === "number") {
-                arraySchema = arraySchema.min(obj.minItems);
-            }
-            if (typeof obj.maxItems === "number") {
-                arraySchema = arraySchema.max(obj.maxItems);
-            }
-            return description ? arraySchema.describe(description) : arraySchema;
-        }
-        case "string": {
-            let s = z.string();
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            if (typeof obj.minLength === "number") {
-                s = s.min(obj.minLength);
-            }
-            if (typeof obj.maxLength === "number") {
-                s = s.max(obj.maxLength);
-            }
-            return description ? s.describe(description) : s;
-        }
-        case "number": {
-            let n = z.number();
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            if (typeof obj.minimum === "number") {
-                n = n.min(obj.minimum);
-            }
-            if (typeof obj.maximum === "number") {
-                n = n.max(obj.maximum);
-            }
-            return description ? n.describe(description) : n;
-        }
-        case "integer": {
-            let n = z.number().int();
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            if (typeof obj.minimum === "number") {
-                n = n.min(obj.minimum);
-            }
-            if (typeof obj.maximum === "number") {
-                n = n.max(obj.maximum);
-            }
-            return description ? n.describe(description) : n;
-        }
-        case "boolean": {
-            const b = z.boolean();
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            return description ? b.describe(description) : b;
-        }
-        default: {
-            const anySchema = z.any();
-            const description = typeof obj.description === "string" ? obj.description : undefined;
-            return description ? anySchema.describe(description) : anySchema;
-        }
-    }
-}
-// implements REQ-002
 export function addTool(server, name, description, inputSchema, handler, 
 // INTENTIONAL: DEFAULT_TOOLS_RUNTIME is typed as ToolsRuntime<PrologProcess>; the
 // generic TProlog parameter exists so tests can inject a mock type. The cast is safe
@@ -293,23 +119,15 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
                 });
                 // Log usage in diagnostic mode
                 if (diagnosticModeEnabled) {
-                    const finishedAt = new Date();
-                    const diagnosticFields = runtime.deriveDiagnosticFields(name, businessArgs, telemetry, result);
-                    const processHandle = await runtime.prologProcess();
-                    const branchName = await runtime.activeBranchName();
-                    runtime.appendUsageLogLine({
-                        timestamp: finishedAt.toISOString(),
-                        request_id: requestId,
-                        tool: name,
+                    await appendDiagnosticSuccessUsage({
+                        runtime,
+                        toolName: name,
+                        requestId,
+                        args,
+                        businessArgs,
                         telemetry,
-                        business_args: businessArgs,
-                        status: "success",
-                        started_at: startedAt.toISOString(),
-                        finished_at: finishedAt.toISOString(),
-                        duration_ms: finishedAt.getTime() - startedAt.getTime(),
-                        prolog_pid: processHandle?.getPid() ?? null,
-                        active_branch: branchName,
-                        ...diagnosticFields,
+                        startedAt,
+                        result,
                     });
                 }
                 return result;
@@ -317,27 +135,16 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
             catch (error) {
                 // Log error in diagnostic mode
                 if (diagnosticModeEnabled) {
-                    const finishedAt = new Date();
-                    const err = error instanceof Error ? error : new Error(String(error));
-                    const diagnosticErrorFields = runtime.classifyDiagnosticError(err);
-                    const processHandle = await runtime.prologProcess();
-                    const branchName = await runtime.activeBranchName();
-                    runtime.appendUsageLogLine({
-                        timestamp: finishedAt.toISOString(),
-                        request_id: requestId,
-                        tool: name,
+                    await appendDiagnosticErrorUsage({
+                        runtime,
+                        toolName: name,
+                        requestId,
+                        args,
+                        businessArgs,
                         telemetry,
-                        business_args: businessArgs,
-                        status: "error",
-                        started_at: startedAt.toISOString(),
-                        finished_at: finishedAt.toISOString(),
-                        duration_ms: finishedAt.getTime() - startedAt.getTime(),
-                        prolog_pid: processHandle?.getPid() ?? null,
-                        active_branch: branchName,
-                        reset_attempted: resetAttempted,
-                        reset_succeeded: resetSucceeded,
-                        reset_error: resetError,
-                        ...diagnosticErrorFields,
+                        startedAt,
+                        error,
+                        resetState: { resetAttempted, resetSucceeded, resetError },
                     });
                 }
                 throw error;
@@ -362,75 +169,5 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
 export function registerAllTools(server, 
 // INTENTIONAL: same generic bridge cast as addTool — see comment there.
 runtime = DEFAULT_TOOLS_RUNTIME) {
-    const toolDef = (name) => {
-        const t = runtime.tools.find((tool) => tool.name === name);
-        if (!t)
-            throw new Error(`Unknown tool: ${name}`);
-        return t;
-    };
-    // INTENTIONAL ARGUMENT CASTS: The `args as (unknown as)? XyzArgs` casts below
-    // bridge the generic ToolHandler (which receives Record<string, unknown>) to the
-    // specific handler argument types. Argument shapes are validated by Zod schemas
-    // (via jsonSchemaToZod) before the handler is invoked, so the casts are safe at runtime.
-    addTool(server, "kb_query", toolDef("kb_query").description, toolDef("kb_query").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbQuery(prolog, args);
-    }, runtime);
-    addTool(server, "kb_search", toolDef("kb_search").description, toolDef("kb_search").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbSearch(prolog, args);
-    }, runtime);
-    addTool(server, "kb_status", toolDef("kb_status").description, toolDef("kb_status").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbStatus(prolog, args);
-    }, runtime);
-    addTool(server, "kb_skills_list", toolDef("kb_skills_list").description, toolDef("kb_skills_list").inputSchema, async (args) => runtime.handleKbSkillsList(args), runtime);
-    addTool(server, "kb_skills_load", toolDef("kb_skills_load").description, toolDef("kb_skills_load").inputSchema, async (args) => runtime.handleKbSkillsLoad(args), runtime);
-    addTool(server, "kb_skills_read", toolDef("kb_skills_read").description, toolDef("kb_skills_read").inputSchema, async (args) => runtime.handleKbSkillsRead(args), runtime);
-    addTool(server, "kb_find_gaps", toolDef("kb_find_gaps").description, toolDef("kb_find_gaps").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbFindGaps(prolog, args);
-    }, runtime);
-    addTool(server, "kb_coverage", toolDef("kb_coverage").description, toolDef("kb_coverage").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbCoverage(prolog, args);
-    }, runtime);
-    addTool(server, "kb_graph", toolDef("kb_graph").description, toolDef("kb_graph").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbGraph(prolog, args);
-    }, runtime);
-    addTool(server, "kb_sparql_remote", toolDef("kb_sparql_remote").description, toolDef("kb_sparql_remote").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleSparql(prolog, args);
-    }, runtime);
-    addTool(server, "kb_semantic_advisor", toolDef("kb_semantic_advisor").description, toolDef("kb_semantic_advisor").inputSchema, async (args) => {
-        return runtime.handleKbSemanticAdvisor(args);
-    }, runtime);
-    addTool(server, "kb_upsert", toolDef("kb_upsert").description, toolDef("kb_upsert").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbUpsert(prolog, args);
-    }, runtime);
-    addTool(server, "kb_validate_upsert", toolDef("kb_validate_upsert").description, toolDef("kb_validate_upsert").inputSchema, async (args) => {
-        return runtime.handleKbValidateUpsert(args);
-    }, runtime);
-    addTool(server, "kb_delete", toolDef("kb_delete").description, toolDef("kb_delete").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbDelete(prolog, args);
-    }, runtime);
-    addTool(server, "kb_check", toolDef("kb_check").description, toolDef("kb_check").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbCheck(prolog, args);
-    }, runtime);
-    addTool(server, "kb_model_requirement", toolDef("kb_model_requirement").description, toolDef("kb_model_requirement").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbModelRequirement(prolog, args);
-    }, runtime);
-    addTool(server, "kb_suggest_predicates", toolDef("kb_suggest_predicates").description, toolDef("kb_suggest_predicates").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbSuggestPredicates(prolog, args);
-    }, runtime);
-    addTool(server, "kb_autopilot_generate", toolDef("kb_autopilot_generate").description, toolDef("kb_autopilot_generate").inputSchema, async (args) => {
-        const prolog = await runtime.ensureProlog();
-        return runtime.handleKbAutopilotGenerate(prolog, args);
-    }, runtime);
+    registerConfiguredTools(server, runtime, addTool);
 }

package/dist/tools/upsert.js

@@ -25,9 +25,9 @@ import relationshipSchema from "kibi-cli/schemas/relationship";
 import { Project, ScriptKind } from "ts-morph";
 import { isMcpDebugEnabled } from "../env.js";
 import { analyzeSemanticAdvisorInput } from "../semantic-advisor/analyze-prose.js";
-import { refreshCoordinatesForSymbolId } from "./symbols.js";
-import { attachedBranchKbPath, updateAttachedBranchStamp, } from "../server/session.js";
 import { readBranchKbStamp } from "../server/kb-freshness.js";
+import { attachedBranchKbPath, updateAttachedBranchStamp, } from "../server/session.js";
+import { refreshCoordinatesForSymbolId } from "./symbols.js";
 let refreshCoordinatesForSymbolIdImpl = refreshCoordinatesForSymbolId;
 const ajv = new Ajv({ strict: false });
 const entitySchemaRecord = entitySchema;
@@ -191,7 +191,8 @@ export async function handleKbUpsert(prolog, args) {
     let relationshipsCreated = 0;
     try {
         if ((args.relationships === undefined ||
-            (Array.isArray(args.relationships) && args.relationships.length === 0)) &&
+            (Array.isArray(args.relationships) &&
+                args.relationships.length === 0)) &&
             args.id) {
             // Preserve relationships on updates when the request omits relationships
             // OR provides an empty array. This avoids accidental edge deletion by
@@ -476,7 +477,9 @@ function validateSymbolGranularity(entity, relationships) {
     const shownNonBehavioral = nonBehavioralNames.slice(0, maxNamesInMessage);
     const hiddenNonBehavioralCount = nonBehavioralNames.length - shownNonBehavioral.length;
     const nonBehavioralList = shownNonBehavioral.join(", ") +
-        (hiddenNonBehavioralCount > 0 ? `, and ${hiddenNonBehavioralCount} more` : "");
+        (hiddenNonBehavioralCount > 0
+            ? `, and ${hiddenNonBehavioralCount} more`
+            : "");
     const ignoredSymbolsMessage = nonBehavioralNames.length > 0
         ? ` Non-behavioral symbols in the file were ignored for this decision: ${nonBehavioralList}.`
         : "";
@@ -653,10 +656,22 @@ async function checkScenarioCoverageGuidance(prolog, relationships, entityType,
  */
 async function fetchExistingRelationships(prolog, entityId) {
     const relTypes = [
-        "depends_on", "specified_by", "verified_by", "validates",
-        "implements", "covered_by", "executable_for", "constrained_by",
-        "constrains", "requires_property", "requires_predicate",
-        "guards", "publishes", "consumes", "supersedes", "relates_to",
+        "depends_on",
+        "specified_by",
+        "verified_by",
+        "validates",
+        "implements",
+        "covered_by",
+        "executable_for",
+        "constrained_by",
+        "constrains",
+        "requires_property",
+        "requires_predicate",
+        "guards",
+        "publishes",
+        "consumes",
+        "supersedes",
+        "relates_to",
     ];
     const existing = [];
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-mcp",
-  "version": "0.17.3",
+  "version": "0.17.5",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "ajv": "^8.18.0",
@@ -9,8 +9,8 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-cli": "^0.12.7",
-    "kibi-core": "^0.6.3",
+    "kibi-cli": "^0.12.8",
+    "kibi-core": "^0.6.4",
     "mcpcat": "^0.1.12",
     "ts-morph": "^23.0.0",
     "zod": "^4.3.6"
@@ -27,10 +27,7 @@
     "build": "tsc -p tsconfig.json",
     "prepack": "npm run build"
   },
-  "files": [
-    "dist",
-    "bin"
-  ],
+  "files": ["dist", "bin"],
   "engines": {
     "node": ">=18",
     "bun": ">=1.0"