kibi-mcp 0.19.0 → 0.19.2

package/bin/kibi-mcp

@@ -98,7 +98,7 @@ if (args.includes("-h") || args.includes("--help")) {
 
   if (args.includes("--diagnostic-mode")) {
     globalThis.__KIBI_MCP_DIAGNOSTIC_MODE = true;
-    process.env.KIBI_WORKSPACE = process.cwd();
+    process.env.KIBI_WORKSPACE ??= process.cwd();
     process.env.KIBI_MCP_DIAGNOSTIC_MODE = "1";
   }
 

package/dist/runtime/mcp-runtime.js

@@ -0,0 +1,43 @@
+// implements REQ-kibi-operation-interface-parity
+export function createMcpRuntime(session) {
+    const sessionPrologs = new WeakMap();
+    return {
+        open: async (spec, options = {}) => {
+            const fs = options.fs ?? session.fs;
+            const git = options.git ?? session.git;
+            const net = options.net ?? session.net;
+            const context = {
+                workspaceRoot: options.workspaceRoot ?? session.workspaceRoot,
+                signal: options.signal ?? session.signal ?? new AbortController().signal,
+                clock: options.clock ?? session.clock ?? (() => new Date()),
+                ...(fs ? { fs } : {}),
+                ...(git ? { git } : {}),
+                ...(net ? { net } : {}),
+            };
+            if (!spec.requiresProlog) {
+                return context;
+            }
+            if (options.prolog) {
+                return { ...context, prolog: options.prolog };
+            }
+            const sessionProlog = await session.ensureProlog();
+            const operationContext = {
+                ...context,
+                prolog: session.adaptProlog(sessionProlog),
+            };
+            sessionPrologs.set(operationContext, sessionProlog);
+            return operationContext;
+        },
+        afterSuccess: async (spec) => {
+            if (spec.effects.includes("kb-write") &&
+                (await session.attachedBranchKbPath()) !== null) {
+                await session.refreshAttachedBranchStamp();
+            }
+        },
+        close: async (context, outcome) => {
+            await session.requestCleanup?.(context, outcome);
+            sessionPrologs.delete(context);
+        },
+        sessionProlog: (context) => sessionPrologs.get(context),
+    };
+}

package/dist/server/docs.js

@@ -16,9 +16,6 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import { TOOLS } from "../tools-config.js";
-// 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.
 const ACTIVE_TOOLS = TOOLS;
 function renderToolsDoc() {
     const lines = [
@@ -87,7 +84,10 @@ export const PROMPTS = [
             "## 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.",
-            "- Guidance must stay MCP-only; do not suggest `kibi` CLI commands.",
+            "- Prefer MCP tools; CLI routes are available when MCP is unavailable.",
+            "- If Kibi MCP tools are visible, use MCP. If MCP availability is unknown and a trusted local Kibi CLI is available, use its 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.",
         ].join("\n"),
     },
     {

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

@@ -1,4 +1,40 @@
 import { z } from "zod";
+function hasRequiredProperties(value, schema) {
+    if (schema === null || typeof schema !== "object")
+        return false;
+    const condition = schema;
+    const required = Array.isArray(condition.required)
+        ? condition.required.filter((key) => typeof key === "string" && key.length > 0)
+        : [];
+    if (required.length > 0 &&
+        !required.every((key) => Object.hasOwn(value, key))) {
+        return false;
+    }
+    if (Array.isArray(condition.anyOf) &&
+        !condition.anyOf.some((entry) => hasRequiredProperties(value, entry))) {
+        return false;
+    }
+    if (Array.isArray(condition.allOf) &&
+        !condition.allOf.every((entry) => hasRequiredProperties(value, entry))) {
+        return false;
+    }
+    return true;
+}
+function conditionalRequiredKeys(value, condition) {
+    if (condition === null || typeof condition !== "object")
+        return [];
+    const rule = condition;
+    if (!("if" in rule) || !("then" in rule))
+        return [];
+    if (!hasRequiredProperties(value, rule.if))
+        return [];
+    if (rule.then === null || typeof rule.then !== "object")
+        return [];
+    const required = rule.then.required;
+    return Array.isArray(required)
+        ? required.filter((key) => typeof key === "string" && key.length > 0)
+        : [];
+}
 // implements REQ-002
 export function jsonSchemaToZod(schema) {
     if (!schema || typeof schema !== "object") {
@@ -43,7 +79,29 @@ export function jsonSchemaToZod(schema) {
                 ? z.object(shape)
                 : z.looseObject(shape);
             const description = typeof obj.description === "string" ? obj.description : undefined;
-            return description ? objectSchema.describe(description) : objectSchema;
+            let result = description
+                ? objectSchema.describe(description)
+                : objectSchema;
+            if (Array.isArray(obj.allOf)) {
+                result = result
+                    .superRefine((value, context) => {
+                    if (value === null || typeof value !== "object")
+                        return;
+                    for (const condition of obj.allOf) {
+                        for (const key of conditionalRequiredKeys(value, condition)) {
+                            if (!Object.hasOwn(value, key)) {
+                                context.addIssue({
+                                    code: "custom",
+                                    path: [key],
+                                    message: `Required by conditional JSON Schema rule: ${key}`,
+                                });
+                            }
+                        }
+                    }
+                })
+                    .meta({ allOf: obj.allOf });
+            }
+            return result;
         }
         case "array": {
             const itemSchema = jsonSchemaToZod(obj.items);
@@ -55,7 +113,17 @@ export function jsonSchemaToZod(schema) {
             if (typeof obj.maxItems === "number") {
                 arraySchema = arraySchema.max(obj.maxItems);
             }
-            return description ? arraySchema.describe(description) : arraySchema;
+            let result = description
+                ? arraySchema.describe(description)
+                : arraySchema;
+            if (obj.uniqueItems === true) {
+                result = result
+                    .refine((values) => Array.isArray(values) &&
+                    new Set(values.map((value) => JSON.stringify(value))).size ===
+                        values.length, { message: "Array items must be unique" })
+                    .meta({ uniqueItems: true });
+            }
+            return result;
         }
         case "string": {
             let s = z.string();
@@ -66,6 +134,9 @@ export function jsonSchemaToZod(schema) {
             if (typeof obj.maxLength === "number") {
                 s = s.max(obj.maxLength);
             }
+            if (typeof obj.pattern === "string") {
+                s = s.regex(new RegExp(obj.pattern));
+            }
             return description ? s.describe(description) : s;
         }
         case "number": {

package/dist/server/session.js

@@ -42,6 +42,8 @@ let ensurePrologTail = Promise.resolve();
 let prologResetGeneration = 0;
 export let attachedBranchKbPath = null;
 let attachedBranchStamp = null;
+// implements REQ-mcp-kb-freshness
+// covered_by TEST-mcp-kb-freshness
 export function updateAttachedBranchStamp(stamp) {
     attachedBranchStamp = stamp;
 }
@@ -85,7 +87,7 @@ export function ensureBranchKbExists(workspaceRoot, branch) {
     }
     const branchPath = sessionDeps.resolveKbPath(workspaceRoot, branch);
     if (sessionDeps.fs.existsSync(branchPath)) {
-        return;
+        return false;
     }
     // Try to copy from the previously active branch if available
     const previousBranch = activeBranchName;
@@ -96,11 +98,12 @@ export function ensureBranchKbExists(workspaceRoot, branch) {
         // Copy from previous branch for continuity
         sessionDeps.copyCleanSnapshot(previousBranchPath, branchPath);
         debugLog(`[KIBI-MCP] Created branch KB for '${branch}' from '${previousBranch}'`);
-        return;
+        return false;
     }
     // No previous branch available - create empty KB
     sessionDeps.fs.mkdirSync(branchPath, { recursive: true });
     debugLog(`[KIBI-MCP] Created empty branch KB for '${branch}'`);
+    return true;
 }
 export async function initiateGracefulShutdown(exitCode = 0) {
     if (isShuttingDown) {
@@ -108,6 +111,18 @@ export async function initiateGracefulShutdown(exitCode = 0) {
     }
     isShuttingDown = true;
     debugLog(`[KIBI-MCP] Initiating graceful shutdown (exit code: ${exitCode})`);
+    const currentProlog = prologProcess;
+    prologProcess = null;
+    if (currentProlog?.isRunning()) {
+        debugLog("[KIBI-MCP] Cancelling active Prolog work...");
+        try {
+            await currentProlog.terminate();
+            debugLog("[KIBI-MCP] Prolog process terminated");
+        }
+        catch (error) {
+            console.error("[KIBI-MCP] Error terminating Prolog:", error);
+        }
+    }
     // Wait for in-flight requests
     if (inFlightRequests.size > 0) {
         debugLog(`[KIBI-MCP] Waiting for ${inFlightRequests.size} in-flight requests to complete...`);
@@ -133,17 +148,6 @@ export async function initiateGracefulShutdown(exitCode = 0) {
             }
         }
     }
-    // Cleanup Prolog process
-    if (prologProcess?.isRunning()) {
-        debugLog("[KIBI-MCP] Terminating Prolog process...");
-        try {
-            await prologProcess.terminate();
-            debugLog("[KIBI-MCP] Prolog process terminated");
-        }
-        catch (error) {
-            console.error("[KIBI-MCP] Error terminating Prolog:", error);
-        }
-    }
     // Exit
     process.exit(exitCode);
 }
@@ -271,13 +275,20 @@ async function ensurePrologUnsafe() {
             // Continue anyway - we'll try to attach to the new KB
         }
         // Ensure new branch KB exists
-        ensureBranchKbExists(workspaceRoot, targetBranch);
+        const createdEmptyBranch = ensureBranchKbExists(workspaceRoot, targetBranch);
         // Attach to new branch KB
         const attachResult = await prologProcess.query(`kb_attach('${kbPath}')`);
         await assertGeneration();
         if (!attachResult.success) {
             throw new Error(`Failed to attach to new branch KB: ${attachResult.error || "Unknown error"}`);
         }
+        if (createdEmptyBranch) {
+            const initialSaveResult = await prologProcess.query("kb_save");
+            await assertGeneration();
+            if (!initialSaveResult.success) {
+                throw new Error(`Failed to initialize empty branch KB: ${initialSaveResult.error || "Unknown error"}`);
+            }
+        }
         activeBranchName = targetBranch;
         attachedBranchKbPath = kbPath;
         attachedBranchStamp = await readBranchKbStamp(kbPath);
@@ -327,13 +338,20 @@ async function ensurePrologUnsafe() {
     debugLog(`[KIBI-MCP]   KIBI_BRANCH env: ${envBranch || "not set"}`);
     debugLog(`[KIBI-MCP]   Resolved branch: ${targetBranch}`);
     activeBranchName = targetBranch;
-    ensureBranchKbExists(workspaceRoot, targetBranch);
+    const createdEmptyBranch = ensureBranchKbExists(workspaceRoot, targetBranch);
     const kbPath = sessionDeps.resolveKbPath(workspaceRoot, targetBranch);
     const attachResult = await prologProcess.query(`kb_attach('${kbPath}')`);
     await assertGeneration();
     if (!attachResult.success) {
         throw new Error(`Failed to attach KB: ${attachResult.error || "Unknown error"}`);
     }
+    if (createdEmptyBranch) {
+        const initialSaveResult = await prologProcess.query("kb_save");
+        await assertGeneration();
+        if (!initialSaveResult.success) {
+            throw new Error(`Failed to initialize empty branch KB: ${initialSaveResult.error || "Unknown error"}`);
+        }
+    }
     attachedBranchKbPath = kbPath;
     attachedBranchStamp = await readBranchKbStamp(kbPath);
     isInitialized = true;

package/dist/server/tool-registration.js

@@ -1,3 +1,4 @@
+import { getSpec } from "kibi-cli/operations";
 // implements REQ-002, REQ-013
 export function registerConfiguredTools(server, runtime, registerTool) {
     const toolDef = (name) => {
@@ -6,9 +7,23 @@ export function registerConfiguredTools(server, runtime, registerTool) {
             throw new Error(`Unknown tool: ${name}`);
         return t;
     };
-    const register = ({ name, handler }) => {
+    const prologFor = (context) => {
+        const prolog = runtime.operationRuntime.sessionProlog(context);
+        if (!prolog) {
+            throw new Error("Operation requires a session Prolog process");
+        }
+        return prolog;
+    };
+    const register = ({ name, execute }) => {
         const definition = toolDef(name);
-        registerTool(server, name, definition.description, definition.inputSchema, handler, runtime);
+        const publicSpec = getSpec(name);
+        const spec = {
+            name,
+            effects: publicSpec.effects,
+            requiresProlog: publicSpec.requiresProlog,
+            execute: (args, context) => execute(context, args),
+        };
+        registerTool(server, name, definition.description, definition.inputSchema, async () => undefined, runtime, spec, definition.annotations);
     };
     // INTENTIONAL ARGUMENT CASTS: The `args as (unknown as)? XyzArgs` casts below
     // bridge the generic ToolHandler (which receives Record<string, unknown>) to the
@@ -16,116 +31,74 @@ export function registerConfiguredTools(server, runtime, registerTool) {
     // (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);
-        },
+        execute: async (context, args) => runtime.handleKbQuery(prologFor(context), args),
     });
     register({
         name: "kb_search",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbSearch(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbSearch(prologFor(context), args),
     });
     register({
         name: "kb_status",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbStatus(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbStatus(prologFor(context), args),
     });
     register({
         name: "kb_skills_list",
-        handler: async (args) => runtime.handleKbSkillsList(args),
+        execute: async (_context, args) => runtime.handleKbSkillsList(args),
     });
     register({
         name: "kb_skills_load",
-        handler: async (args) => runtime.handleKbSkillsLoad(args),
+        execute: async (_context, args) => runtime.handleKbSkillsLoad(args),
     });
     register({
         name: "kb_skills_read",
-        handler: async (args) => runtime.handleKbSkillsRead(args),
+        execute: async (_context, args) => runtime.handleKbSkillsRead(args),
     });
     register({
         name: "kb_find_gaps",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbFindGaps(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbFindGaps(prologFor(context), args),
     });
     register({
         name: "kb_coverage",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbCoverage(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbCoverage(prologFor(context), args),
     });
     register({
         name: "kb_graph",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbGraph(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbGraph(prologFor(context), args),
     });
     register({
         name: "kb_sparql_remote",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleSparql(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleSparql(args, context),
     });
     register({
         name: "kb_semantic_advisor",
-        handler: async (args) => runtime.handleKbSemanticAdvisor(args),
+        execute: async (_context, args) => runtime.handleKbSemanticAdvisor(args),
     });
     register({
         name: "kb_upsert",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbUpsert(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbUpsert(prologFor(context), args),
     });
     register({
         name: "kb_validate_upsert",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbValidateUpsert(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbValidateUpsert(prologFor(context), args),
     });
     register({
         name: "kb_delete",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbDelete(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbDelete(prologFor(context), args),
     });
     register({
         name: "kb_check",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbCheck(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbCheck(prologFor(context), args),
     });
     register({
         name: "kb_model_requirement",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbModelRequirement(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbModelRequirement(prologFor(context), args),
     });
     register({
         name: "kb_suggest_predicates",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbSuggestPredicates(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbSuggestPredicates(prologFor(context), args),
     });
     register({
         name: "kb_autopilot_generate",
-        handler: async (args) => {
-            const prolog = await runtime.ensureProlog();
-            return runtime.handleKbAutopilotGenerate(prolog, args);
-        },
+        execute: async (context, args) => runtime.handleKbAutopilotGenerate(args, context),
     });
 }

package/dist/server/tools-runtime.js

@@ -1,4 +1,7 @@
+import { getSpec } from "kibi-cli/operations";
 import { DIAGNOSTIC_MODE_ENABLED, appendUsageLogLine, classifyDiagnosticError, deriveDiagnosticFields, extractToolCallPayload, } from "../diagnostics.js";
+import { isMcpDebugEnabled } from "../env.js";
+import { createMcpRuntime } from "../runtime/mcp-runtime.js";
 import { TOOLS } from "../tools-config.js";
 import { handleKbAutopilotGenerate } from "../tools/autopilot-generate.js";
 import { handleKbCheck } from "../tools/check.js";
@@ -11,15 +14,17 @@ 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 { resolveWorkspaceRoot } from "../workspace.js";
+import { readBranchKbStamp } from "./kb-freshness.js";
 const defaultToolsServerDeps = {
     getSessionModule: () => import("./session.js"),
 };
 let sessionModulePromise = null;
+const prologPorts = new WeakMap();
 // implements REQ-008
 export function _setToolsServerDepsForTests(deps, resetPromise = false) {
     defaultToolsServerDeps.getSessionModule =
@@ -39,6 +44,50 @@ async function getSessionModule() {
     sessionModulePromise ??= defaultToolsServerDeps.getSessionModule();
     return sessionModulePromise;
 }
+function adaptProlog(prolog) {
+    const existing = prologPorts.get(prolog);
+    if (existing) {
+        return existing;
+    }
+    let lastResult = null;
+    const port = {
+        query: async (goal) => {
+            lastResult = await prolog.query(goal);
+            return lastResult;
+        },
+        nextSolution: async () => {
+            const result = lastResult;
+            lastResult = null;
+            return result;
+        },
+        save: () => prolog.query("kb_save"),
+    };
+    prologPorts.set(prolog, port);
+    return port;
+}
+const operationRuntime = createMcpRuntime({
+    workspaceRoot: resolveWorkspaceRoot(),
+    activeBranchName: async () => (await getSessionModule()).activeBranchName,
+    attachedBranchKbPath: async () => (await getSessionModule()).attachedBranchKbPath,
+    ensureProlog: async () => (await getSessionModule()).ensureProlog(),
+    adaptProlog,
+    net: { fetch: (input, init) => globalThis.fetch(input, init) },
+    refreshAttachedBranchStamp: async () => {
+        const session = await getSessionModule();
+        const kbPath = session.attachedBranchKbPath;
+        if (kbPath) {
+            try {
+                session.updateAttachedBranchStamp(await readBranchKbStamp(kbPath));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (isMcpDebugEnabled()) {
+                    console.warn("[KIBI-MCP] Attached branch stamp refresh failed:", message);
+                }
+            }
+        }
+    },
+});
 export const DEFAULT_TOOLS_RUNTIME = {
     diagnosticModeEnabled: () => DIAGNOSTIC_MODE_ENABLED,
     appendUsageLogLine,
@@ -55,12 +104,13 @@ export const DEFAULT_TOOLS_RUNTIME = {
     inFlightRequests: async () => (await getSessionModule()).inFlightRequests,
     isShuttingDown: async () => (await getSessionModule()).isShuttingDown,
     prologProcess: async () => (await getSessionModule()).prologProcess,
+    operationRuntime,
     handleKbCheck,
     handleKbCoverage,
     handleKbDelete,
     handleKbFindGaps,
     handleKbGraph,
-    handleSparql,
+    handleSparql: (args, context) => getSpec("kb_sparql_remote").execute(args, context),
     handleKbQuery,
     handleKbSearch,
     handleKbStatus,

package/dist/server/tools.js

@@ -16,6 +16,7 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import process from "node:process";
+import { executeOperation, } from "kibi-cli/operations/runtime-types";
 import { isMcpDebugEnabled } from "../env.js";
 import { appendDiagnosticErrorUsage, appendDiagnosticSuccessUsage, } from "./diagnostic-usage.js";
 import { jsonSchemaToZod } from "./json-schema-to-zod.js";
@@ -73,7 +74,7 @@ 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
 // because the runtime object satisfies the full ToolsRuntime contract at runtime.
-runtime = DEFAULT_TOOLS_RUNTIME) {
+runtime = DEFAULT_TOOLS_RUNTIME, spec, annotations) {
     const wrappedHandler = async (args) => {
         const startedAt = new Date();
         const diagnosticModeEnabled = runtime.diagnosticModeEnabled();
@@ -100,21 +101,30 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
             }
             // Track the handler promise in inFlightRequests Map
             const trackedRequests = await runtime.inFlightRequests();
-            const handlerPromise = handler(businessArgs);
+            const controller = new AbortController();
+            const operationSpec = spec ?? {
+                name,
+                effects: ["local-read"],
+                requiresProlog: false,
+                execute: async (input, _context) => handler(input),
+            };
+            const handlerPromise = executeOperation(runtime.operationRuntime, operationSpec, businessArgs, { signal: controller.signal });
             trackedRequests.set(requestId, handlerPromise);
             let resetAttempted = false;
             let resetSucceeded = false;
             let resetError = null;
             try {
                 // Execute handler
-                const result = await withToolTimeout(name, handlerPromise, async () => {
+                const result = await withToolTimeout(name, handlerPromise, async (error) => {
                     resetAttempted = true;
+                    controller.abort(error);
                     try {
                         await runtime.resetProlog(`tool timeout: ${name}`);
                         resetSucceeded = true;
                     }
                     catch (error) {
-                        resetError = error instanceof Error ? error.message : String(error);
+                        resetError =
+                            error instanceof Error ? error.message : String(error);
                     }
                 });
                 // Log usage in diagnostic mode
@@ -163,7 +173,11 @@ runtime = DEFAULT_TOOLS_RUNTIME) {
             throw new Error(`Tool ${name} failed: ${err.message}`, { cause: err });
         }
     };
-    server.registerTool(name, { description, inputSchema: jsonSchemaToZod(inputSchema) }, wrappedHandler);
+    server.registerTool(name, {
+        description,
+        inputSchema: jsonSchemaToZod(inputSchema),
+        ...(annotations ? { annotations } : {}),
+    }, wrappedHandler);
 }
 // implements REQ-002, REQ-013
 export function registerAllTools(server, 

package/dist/server/transport.js

@@ -23,7 +23,7 @@ function debugLog(...args) {
         console.error(...args);
     }
 }
-export function setupTransportHandlers(server, transport) {
+export function setupTransportHandlers(_server, transport) {
     transport.onerror = (error) => {
         // Stdio transport surfaces JSON parse / schema validation failures via onerror.
         // Those errors should not crash the server: emit a JSON-RPC error (id omitted)
@@ -62,11 +62,15 @@ export function setupTransportHandlers(server, transport) {
         debugLog("[KIBI-MCP] Transport closed");
         initiateGracefulShutdown(0);
     };
-    process.on("SIGTERM", () => {
-        debugLog("[KIBI-MCP] Received SIGTERM, initiating graceful shutdown");
-        void initiateGracefulShutdown(0);
-    });
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+        process.on(signal, () => {
+            debugLog(`[KIBI-MCP] Received ${signal}, initiating graceful shutdown`);
+            void initiateGracefulShutdown(0);
+        });
+    }
 }
+// implements REQ-002
+// covered_by TEST-mcp-kb-freshness
 export async function connectTransport(server, transport) {
     await server.connect(transport);
 }