kibi-mcp 1.0.0 → 2.1.0

package/dist/server/tool-registration.js

@@ -1,5 +1,6 @@
 import { getSpec, statusSpec } from "kibi-runtime";
-import { executeApplyPlan, executeCompileIntent, executeDelete, executeIngestVerification, executeUpsert, validateUpsertSpec, } from "kibi-runtime";
+import { executeApplyPlan, executeCompileIntent, executeDelete, executeIngestProof, executeUpsert, validateUpsertSpec, } from "kibi-runtime";
+import { startJob } from "./jobs.js";
 // implements REQ-002, REQ-013
 export function registerConfiguredTools(server, runtime, registerTool) {
     const toolDef = (name) => {
@@ -26,6 +27,9 @@ export function registerConfiguredTools(server, runtime, registerTool) {
             name,
             effects: publicSpec.effects,
             requiresProlog: publicSpec.requiresProlog,
+            ...(publicSpec.agentVisibleStructuredData === true
+                ? { agentVisibleStructuredData: true }
+                : {}),
             execute: (args, context) => execute(context, args),
         };
         registerTool(server, name, definition.description, definition.inputSchema, async () => undefined, runtime, spec, definition.annotations, definition.outputSchema);
@@ -80,7 +84,7 @@ export function registerConfiguredTools(server, runtime, registerTool) {
     });
     register({
         name: "kb_semantic_advisor",
-        execute: async (_context, args) => runtime.handleKbSemanticAdvisor(args),
+        execute: async (context, args) => runtime.handleKbSemanticAdvisor(args, context),
     });
     register({
         name: "kb_upsert",
@@ -96,15 +100,24 @@ export function registerConfiguredTools(server, runtime, registerTool) {
     });
     register({
         name: "kb_check",
-        execute: async (context, args) => runtime.handleKbCheck(prologFor(context), args),
+        execute: async (context, args) => {
+            const { async: asyncMode, ...checkArgs } = args;
+            if (asyncMode !== true) {
+                return runtime.handleKbCheck(prologFor(context), args);
+            }
+            // Long-KB full checks can exceed the tool timeout. Detach into a job
+            // and return the kibi.job.v1 receipt immediately; the agent polls
+            // kb_job_status for the terminal state and full result.
+            return startJob("kb_check", () => runtime.handleKbCheck(prologFor(context), checkArgs));
+        },
     });
     register({
         name: "kb_model_requirement",
-        execute: async (context, args) => runtime.handleKbModelRequirement(prologFor(context), args),
+        execute: async (context, args) => runtime.handleKbModelRequirement(prologFor(context), args, withSessionProlog(context)),
     });
     register({
         name: "kb_suggest_predicates",
-        execute: async (context, args) => runtime.handleKbSuggestPredicates(prologFor(context), args),
+        execute: async (context, args) => runtime.handleKbSuggestPredicates(prologFor(context), args, withSessionProlog(context)),
     });
     register({
         name: "kb_plan_bootstrap",
@@ -123,9 +136,9 @@ export function registerConfiguredTools(server, runtime, registerTool) {
             : executeApplyPlan(args, context),
     });
     register({
-        name: "kb_ingest_verification",
-        execute: async (context, args) => runtime.handleKbIngestVerification
-            ? runtime.handleKbIngestVerification(args, context)
-            : executeIngestVerification(args, context),
+        name: "kb_ingest_proof",
+        execute: async (context, args) => runtime.handleKbIngestProof
+            ? runtime.handleKbIngestProof(args, context)
+            : executeIngestProof(args, context),
     });
 }

package/dist/server/tools-runtime.js

@@ -49,10 +49,15 @@ function adaptProlog(prolog) {
     if (existing) {
         return existing;
     }
+    const engine = prolog;
+    const queryEntities = engine.queryEntities;
+    const searchEntities = engine.searchEntities;
+    const storageStatus = engine.storageStatus;
+    const queryStatusJson = engine.queryStatusJson;
     let lastResult = null;
     const port = {
-        query: async (goal) => {
-            lastResult = await prolog.query(goal);
+        query: async (goal, signal) => {
+            lastResult = await engine.query(goal, signal);
             return lastResult;
         },
         nextSolution: async () => {
@@ -60,39 +65,41 @@ function adaptProlog(prolog) {
             lastResult = null;
             return result;
         },
-        save: () => prolog.query("kb_save"),
-        ...(typeof prolog.queryEntities ===
-            "function"
+        save: (signal) => engine.query("kb_save", signal),
+        ...(typeof queryEntities === "function"
             ? {
-                queryEntities: (input) => prolog.queryEntities(input),
+                // The captured method uses .call(engine, ...) below to preserve the
+                // EngineClient receiver (unbound queryStatusJson breaks this.command).
+                queryEntities: (input, signal) => queryEntities.call(engine, input, signal),
             }
             : {}),
-        ...(typeof prolog.searchEntities ===
-            "function"
+        ...(typeof searchEntities === "function"
             ? {
-                searchEntities: (input) => prolog.searchEntities(input),
+                searchEntities: (input, signal) => searchEntities.call(engine, input, signal),
             }
             : {}),
-        ...(typeof prolog.storageStatus ===
-            "function"
+        ...(typeof storageStatus === "function"
             ? {
-                storageStatus: () => prolog.storageStatus(),
+                storageStatus: () => storageStatus.call(engine),
             }
             : {}),
-        ...(typeof prolog.queryStatusJson ===
-            "function"
+        ...(typeof queryStatusJson === "function"
             ? {
-                queryStatusJson: () => prolog.queryStatusJson(),
+                queryStatusJson: (signal) => queryStatusJson.call(engine, signal),
             }
             : {}),
     };
     prologPorts.set(prolog, port);
     return port;
 }
+/** Test seam: adapt a session engine so AbortSignal reaches EngineClient/PrologPort methods. */
+export function _adaptPrologForTests(prolog) {
+    return adaptProlog(prolog);
+}
 const operationRuntime = createMcpRuntime({
     workspaceRoot: resolveWorkspaceRoot(),
-    activeBranchName: async () => (await getSessionModule()).activeBranchName,
-    attachedBranchKbPath: async () => (await getSessionModule()).attachedBranchKbPath,
+    activeBranchName: async () => (await getSessionModule()).getActiveBranchName(),
+    attachedBranchKbPath: async () => (await getSessionModule()).getAttachedBranchKbPath(),
     ensureProlog: async () => (await getSessionModule()).ensureProlog(),
     adaptProlog,
     fs: nodeFilesystem,
@@ -100,7 +107,7 @@ const operationRuntime = createMcpRuntime({
     net: { fetch: (input, init) => globalThis.fetch(input, init) },
     refreshAttachedBranchStamp: async () => {
         const session = await getSessionModule();
-        const kbPath = session.attachedBranchKbPath;
+        const kbPath = session.getAttachedBranchKbPath();
         if (kbPath) {
             try {
                 session.updateAttachedBranchStamp(await readBranchKbStamp(kbPath));
@@ -124,12 +131,12 @@ export const DEFAULT_TOOLS_RUNTIME = {
     // 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,
+    activeBranchName: async () => (await getSessionModule()).getActiveBranchName(),
     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,
+    isShuttingDown: async () => (await getSessionModule()).getIsShuttingDown(),
+    prologProcess: async () => (await getSessionModule()).getPrologProcess(),
     operationRuntime,
     handleKbCheck,
     handleKbCoverage,

package/dist/server/tools.js

@@ -20,6 +20,7 @@ import { executeOperation } from "kibi-runtime";
 import { operationData, toKibiResult } from "kibi-runtime";
 import { isMcpDebugEnabled } from "../env.js";
 import { appendDiagnosticErrorUsage, appendDiagnosticSuccessUsage, } from "./diagnostic-usage.js";
+import { getJob, jobSnapshot } from "./jobs.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";
@@ -27,10 +28,32 @@ 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";
-// Give cancellation and the Prolog reset a short bounded grace period, but do
-// not hold the MCP request open for the full five-second shutdown budget when
-// a handler never observes AbortSignal.
+// Give cancellation a short bounded grace period, but do not hold the MCP
+// request open for the full five-second shutdown budget when a handler never
+// observes AbortSignal.
 const TOOL_TIMEOUT_GRACE_MS = 100;
+// Mutations that ignore AbortSignal may leave the journal indeterminate. Only
+// then tear down the shared session engine — never on ordinary read timeouts,
+// which would reject sibling tools with "Kibi engine connection closed".
+const TOOL_TIMEOUT_WEDGE_MS = 1_000;
+function isMutationEffect(effects) {
+    return (effects?.some((effect) => effect === "kb-write" || effect === "workspace-write") ?? false);
+}
+/** Embed envelope data in content text for opted-in tools (hosts that hide structuredContent).
+ * Preserves non-text content parts; only augments/replaces text parts. */
+function withAgentVisibleText(content, data) {
+    const textParts = content.filter((part) => part.type === "text" && typeof part.text === "string");
+    const nonTextParts = content.filter((part) => part.type !== "text");
+    const summary = textParts
+        .map((part) => part.text)
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim();
+    const payload = JSON.stringify(data);
+    // Prefer JSON-first so first-line-only host summaries still include machine data.
+    const text = summary.length > 0 ? `${payload}\n${summary}` : payload;
+    return [{ type: "text", text }, ...nonTextParts];
+}
 // implements REQ-008
 function debugLog(...args) {
     if (isMcpDebugEnabled()) {
@@ -63,27 +86,28 @@ async function withToolTimeout(toolName, operation, onTimeout) {
     const timeoutMs = getToolTimeoutMs();
     let timeout;
     try {
-        return await Promise.race([
-            operation,
-            new Promise((_, reject) => {
-                timeout = setTimeout(() => {
-                    const error = createToolTimeoutError(toolName, timeoutMs);
-                    // Do not report the timeout until cancellation/reset has completed
-                    // and the original request has reached a terminal state. This is
-                    // especially important for source-first mutations: a caller must
-                    // never retry while the authoritative journal is still deciding its
-                    // outcome.
-                    void onTimeout(error, timeoutMs)
-                        .then(async () => {
-                        await Promise.race([
-                            operation.then(() => undefined, () => undefined),
-                            new Promise((resolve) => setTimeout(resolve, TOOL_TIMEOUT_GRACE_MS)),
-                        ]);
-                    })
-                        .finally(() => reject(error));
-                }, timeoutMs);
-            }),
-        ]);
+        const timeoutPromise = new Promise((_, reject) => {
+            timeout = setTimeout(() => {
+                const error = createToolTimeoutError(toolName, timeoutMs);
+                // Do not report the timeout until cancellation/reset has completed
+                // and the original request has reached a terminal state. This is
+                // especially important for source-first mutations: a caller must
+                // never retry while the authoritative journal is still deciding its
+                // outcome.
+                void onTimeout(error, timeoutMs)
+                    .then(async () => {
+                    await Promise.race([
+                        operation.then(() => undefined, () => undefined),
+                        new Promise((resolve) => setTimeout(resolve, TOOL_TIMEOUT_GRACE_MS)),
+                    ]);
+                })
+                    .finally(() => reject(error));
+            }, timeoutMs);
+        });
+        // When abort settles `operation` before this timeout promise rejects,
+        // the late reject must not become an unhandled rejection.
+        timeoutPromise.catch(() => undefined);
+        return await Promise.race([operation, timeoutPromise]);
     }
     finally {
         if (timeout) {
@@ -138,15 +162,30 @@ runtime = DEFAULT_TOOLS_RUNTIME, spec, annotations, outputSchema) {
             try {
                 // Execute handler
                 const result = await withToolTimeout(name, handlerPromise, async (error) => {
-                    resetAttempted = true;
                     controller.abort(error);
+                    // Read/discovery timeouts must cancel in-flight RPCs without
+                    // terminating the shared session engine. A global resetProlog here
+                    // rejects sibling tools with "Kibi engine connection closed".
+                    if (!isMutationEffect(operationSpec.effects)) {
+                        return;
+                    }
+                    const settled = await Promise.race([
+                        handlerPromise.then(() => true, () => true),
+                        new Promise((resolve) => setTimeout(() => resolve(false), TOOL_TIMEOUT_WEDGE_MS)),
+                    ]);
+                    if (settled) {
+                        return;
+                    }
+                    resetAttempted = true;
                     try {
                         await runtime.resetProlog(`tool timeout: ${name}`);
                         resetSucceeded = true;
                     }
-                    catch (error) {
+                    catch (resetFailure) {
                         resetError =
-                            error instanceof Error ? error.message : String(error);
+                            resetFailure instanceof Error
+                                ? resetFailure.message
+                                : String(resetFailure);
                     }
                 });
                 const data = operationData(result);
@@ -168,8 +207,13 @@ runtime = DEFAULT_TOOLS_RUNTIME, spec, annotations, outputSchema) {
                     typeof result === "object" &&
                     !Array.isArray(result) &&
                     "content" in result) {
+                    const withContent = result;
+                    const content = operationSpec.agentVisibleStructuredData === true
+                        ? withAgentVisibleText(withContent.content, data)
+                        : withContent.content;
                     return {
                         ...result,
+                        content,
                         structuredContent: envelope,
                     };
                 }
@@ -194,7 +238,7 @@ runtime = DEFAULT_TOOLS_RUNTIME, spec, annotations, outputSchema) {
                     });
                 }
                 if (isToolTimeoutError(error) &&
-                    operationSpec.effects.some((effect) => effect === "kb-write" || effect === "workspace-write")) {
+                    isMutationEffect(operationSpec.effects)) {
                     const recoveryActions = [
                         {
                             operation: "kb_status",
@@ -263,4 +307,60 @@ export function registerAllTools(server,
 // INTENTIONAL: same generic bridge cast as addTool — see comment there.
 runtime = DEFAULT_TOOLS_RUNTIME) {
     registerConfiguredTools(server, runtime, addTool);
+    registerJobStatusTool(server);
+}
+/**
+ * kb_job_status polls background jobs started by long-running operations
+ * (currently `kb_check` with `async: true`). This is an MCP-server-native
+ * companion to the job receipts, not part of the canonical CLI operation
+ * catalog: jobs live in the server process and have no CLI counterpart.
+ */
+function registerJobStatusTool(server) {
+    addTool(server, "kb_job_status", "Poll a background job started with async:true (e.g. kb_check async jobs). Returns the kibi.job.v1 state: running, succeeded (with the full result), or failed (with the error).", {
+        type: "object",
+        properties: {
+            jobId: {
+                type: "string",
+                description: "The jobId from the kibi.job.v1 receipt.",
+            },
+        },
+        required: ["jobId"],
+    }, async (args) => {
+        const jobId = typeof args.jobId === "string" ? args.jobId : "";
+        const job = jobId === "" ? undefined : getJob(jobId);
+        if (job === undefined) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            kibiProtocol: 1,
+                            jobVersion: "kibi.job.v1",
+                            jobId,
+                            status: "unknown",
+                            error: "No such job. Jobs are process-local and dropped on server restart; check the jobId or re-run the operation with async:true.",
+                        }),
+                    },
+                ],
+                structuredContent: {
+                    kibiProtocol: 1,
+                    jobVersion: "kibi.job.v1",
+                    jobId,
+                    status: "unknown",
+                    error: "No such job. Jobs are process-local and dropped on server restart; check the jobId or re-run the operation with async:true.",
+                },
+            };
+        }
+        const snapshot = jobSnapshot(job);
+        return {
+            content: [{ type: "text", text: JSON.stringify(snapshot) }],
+            structuredContent: snapshot,
+        };
+    }, undefined, undefined, {
+        title: "Poll a Kibi background job",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    });
 }

package/dist/startup-resolution.js

@@ -15,7 +15,7 @@
  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/>.
  */
-import { existsSync, readFileSync, realpathSync } from "node:fs";
+import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -28,35 +28,33 @@ function toEntrypointPath(entrypointUrl) {
     return path.resolve(entrypointUrl);
 }
 function readJson(filePath) {
-    return JSON.parse(readFileSync(filePath, "utf8"));
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+export function nextAncestorDirectory(current) {
+    const parent = path.dirname(current);
+    return parent === current ? undefined : parent;
 }
 function nearestPackageJson(startPath) {
     let current = path.dirname(startPath);
-    while (true) {
+    while (current !== undefined) {
         const candidate = path.join(current, "package.json");
-        if (existsSync(candidate)) {
+        if (fs.existsSync(candidate)) {
             return candidate;
         }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            throw new Error(`Unable to find package.json for ${startPath}`);
-        }
-        current = parent;
+        current = nextAncestorDirectory(current);
     }
+    throw new Error(`Unable to find package.json for ${startPath}`);
 }
 function nearestPackageJsonFromDirectory(startPath) {
     let current = path.resolve(startPath);
-    while (true) {
+    while (current !== undefined) {
         const candidate = path.join(current, "package.json");
-        if (existsSync(candidate)) {
+        if (fs.existsSync(candidate)) {
             return candidate;
         }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            return null;
-        }
-        current = parent;
+        current = nextAncestorDirectory(current);
     }
+    return null;
 }
 function packageInfoFromEntrypoint(entrypoint) {
     const normalizedEntrypoint = path.resolve(entrypoint);
@@ -82,7 +80,7 @@ export function resolveProjectLocalMcp(cwd) {
         }
         const projectRequire = createRequire(projectPackageJson);
         const resolved = projectRequire.resolve(PACKAGE_NAME);
-        const entrypoint = realpathSync.native?.(resolved) ?? realpathSync(resolved);
+        const entrypoint = fs.realpathSync.native?.(resolved) ?? fs.realpathSync(resolved);
         return packageInfoFromEntrypoint(entrypoint);
     }
     catch (error) {

package/dist/tools/check-impact.js

@@ -22,7 +22,7 @@ export function hasImpactOptions(args) {
         args.includeWorkingTreeDiff ||
         (args.sourceFiles && args.sourceFiles.length > 0));
 }
-export function analyzeKbCheckImpact(workspaceRoot, args) {
+export async function analyzeKbCheckImpact(workspaceRoot, args) {
     if (!hasImpactOptions(args)) {
         return undefined;
     }

package/dist/tools/core-module.js

@@ -2,6 +2,13 @@ import path from "node:path";
 import { PrologProcess, resolveKbPlPath } from "kibi-runtime";
 import { escapeAtomContent } from "kibi-runtime";
 import { getCoreModulePathOverride, getKbPlPathOverride } from "../env.js";
+export function parseMaybeDoubleEncodedJson(rawJson) {
+    let parsed = JSON.parse(rawJson);
+    if (typeof parsed === "string") {
+        parsed = JSON.parse(parsed);
+    }
+    return parsed;
+}
 function isPrologProcess(value) {
     return (value instanceof PrologProcess ||
         (value !== null &&
@@ -60,11 +67,7 @@ export async function runJsonModuleQuery(prolog, fileName, goal, errorLabel) {
     if (!rawJson) {
         throw new Error(`${errorLabel} query returned no JsonString binding`);
     }
-    let parsed = JSON.parse(rawJson);
-    if (typeof parsed === "string") {
-        parsed = JSON.parse(parsed);
-    }
-    return parsed;
+    return parseMaybeDoubleEncodedJson(rawJson);
 }
 async function runInteractiveModuleQuery(prolog, modulePath, goal, errorLabel) {
     const loadResult = await prolog.query(`use_module('${modulePath}')`);

package/dist/tools/discovery-adapter.js

@@ -1,12 +1,21 @@
 import { resolveWorkspaceRoot } from "../workspace.js";
 export function createDiscoveryContext(prolog, baseContext) {
     // implements REQ-kibi-operation-interface-parity
+    // Keep this adapter aligned with tools-runtime adaptProlog: indexed discovery
+    // and typed status must reach EngineClient command frames (not query-only
+    // fallbacks), and AbortSignal must forward for MCP tool cancellation.
+    const engine = prolog;
+    const queryEntities = engine.queryEntities;
+    const searchEntities = engine.searchEntities;
+    const storageStatus = engine.storageStatus;
+    const queryStatusJson = engine.queryStatusJson;
     let lastResult = null;
     const mode = prolog
         .useOneShotMode;
+    const signal = baseContext?.signal ?? new AbortController().signal;
     const port = {
-        query: async (goal) => {
-            lastResult = await prolog.query(goal);
+        query: async (goal, querySignal) => {
+            lastResult = await engine.query(goal, querySignal ?? signal);
             return lastResult;
         },
         oneShotMode: mode === undefined
@@ -17,18 +26,32 @@ export function createDiscoveryContext(prolog, baseContext) {
             lastResult = null;
             return result;
         },
-        save: () => prolog.query("kb_save"),
-        ...(typeof prolog.queryStatusJson ===
-            "function"
+        save: (saveSignal) => engine.query("kb_save", saveSignal ?? signal),
+        ...(typeof queryEntities === "function"
             ? {
-                queryStatusJson: () => prolog.queryStatusJson(),
+                queryEntities: (input, querySignal) => queryEntities.call(engine, input, querySignal ?? signal),
+            }
+            : {}),
+        ...(typeof searchEntities === "function"
+            ? {
+                searchEntities: (input, querySignal) => searchEntities.call(engine, input, querySignal ?? signal),
+            }
+            : {}),
+        ...(typeof storageStatus === "function"
+            ? {
+                storageStatus: () => storageStatus.call(engine),
+            }
+            : {}),
+        ...(typeof queryStatusJson === "function"
+            ? {
+                queryStatusJson: (statusSignal) => queryStatusJson.call(engine, statusSignal ?? signal),
             }
             : {}),
     };
     return {
         ...(baseContext ?? {}),
         workspaceRoot: baseContext?.workspaceRoot ?? resolveWorkspaceRoot(),
-        signal: baseContext?.signal ?? new AbortController().signal,
+        signal,
         clock: baseContext?.clock ?? (() => new Date()),
         prolog: port,
     };

package/dist/tools/model-requirement.js

@@ -2,11 +2,11 @@ import { modelRequirementSpec } from "kibi-runtime";
 import { estimateNormativeSignalConfidence, extractRequirementClaim, getWorkspaceMigrationWarning, strictWriteSetToApplyPlan, writeSetPrimaryEntityId, } from "kibi-runtime";
 import { resolveWorkspaceRoot } from "../workspace.js";
 export { estimateNormativeSignalConfidence, extractRequirementClaim, getWorkspaceMigrationWarning, strictWriteSetToApplyPlan, writeSetPrimaryEntityId, };
-export async function handleKbModelRequirement(_prolog, args) {
-    const context = {
+export async function handleKbModelRequirement(_prolog, args, context) {
+    const resolved = context ?? {
         workspaceRoot: resolveWorkspaceRoot(),
         signal: new AbortController().signal,
         clock: () => new Date(),
     };
-    return modelRequirementSpec.execute(args, context);
+    return modelRequirementSpec.execute(args, resolved);
 }

package/dist/tools/semantic-advisor.js

@@ -1,4 +1,4 @@
 import { executeSemanticAdvisor } from "kibi-runtime";
-export async function handleKbSemanticAdvisor(args) {
-    return executeSemanticAdvisor(args);
+export async function handleKbSemanticAdvisor(args, context) {
+    return executeSemanticAdvisor(args, context);
 }

package/dist/tools/suggest-predicates.js

@@ -1,13 +1,14 @@
 import { suggestPredicatesSpec } from "kibi-runtime";
 import { resolveWorkspaceRoot } from "../workspace.js";
 import { createDiscoveryContext } from "./discovery-adapter.js";
-export async function handleKbSuggestPredicates(prolog, args) {
-    const context = prolog === null
-        ? {
-            workspaceRoot: resolveWorkspaceRoot(),
-            signal: new AbortController().signal,
-            clock: () => new Date(),
-        }
-        : createDiscoveryContext(prolog);
-    return suggestPredicatesSpec.execute(args, context);
+export async function handleKbSuggestPredicates(prolog, args, context) {
+    const resolved = context ??
+        (prolog === null
+            ? {
+                workspaceRoot: resolveWorkspaceRoot(),
+                signal: new AbortController().signal,
+                clock: () => new Date(),
+            }
+            : createDiscoveryContext(prolog));
+    return suggestPredicatesSpec.execute(args, resolved);
 }

package/dist/tools-config.js

@@ -38,7 +38,7 @@ const MCP_TOOL_ORDER = [
     "kb_plan_bootstrap",
     "kb_compile_intent",
     "kb_apply_plan",
-    "kb_ingest_verification",
+    "kb_ingest_proof",
 ];
 // implements REQ-002
 const TOOL_ANNOTATIONS = {
@@ -134,8 +134,8 @@ const TOOL_ANNOTATIONS = {
         idempotentHint: false,
         openWorldHint: false,
     },
-    kb_ingest_verification: {
-        title: "Ingest contracted verification evidence",
+    kb_ingest_proof: {
+        title: "Ingest proof-run evidence",
         readOnlyHint: false,
         destructiveHint: false,
         idempotentHint: false,