kibi-cursor 2.0.1 → 2.1.1

package/agent-plugin/skills/kibi-usage/resources/source-authoring.md

@@ -29,3 +29,39 @@ Cancellation follows the same rule: wait for the terminal journal state. A
 pre-commit rollback is retryable, a committed source with a failed derivative
 is repairable, and an indeterminate outcome is non-retryable until its recovery
 action resolves the journal.
+
+## Naming entities
+
+Name every entity by what it governs, the way you would name a source file.
+Never choose "the next number": parallel branches pick the same next number and
+collide even when they touch unrelated behavior.
+
+- Use `<TYPE>-<area>-<behavior>` in kebab-case, with the type prefix kept
+  uppercase: `REQ-cli-gc`, `SCEN-mcp-search-discovery`,
+  `TEST-mcp-search-discovery`, `ADR-capability-plugins-v1`,
+  `EVT-exact-branch-store-ensure`, and a flag named after its gate such as
+  `FLAG-scip-symbol-extraction`.
+- The filename stem equals the frontmatter `id`
+  (`.kb/requirements/REQ-cli-gc.md` has `id: REQ-cli-gc`). Always set `id`
+  explicitly; a missing `id` falls back to a path-and-title hash that changes
+  when the file is renamed.
+- Before creating an entity, `kb_search` the area. If an existing entity already
+  covers the behavior, update it, or create a replacement and link it with
+  `supersedes`. A `-v2` suffix is acceptable only for that direct superseding
+  replacement.
+- A name collision with another branch usually means the same work was done
+  twice. Reconcile the two entities; do not rename one of them to dodge the
+  collision.
+- The area prefix is for humans. Whether two requirements are about the same
+  thing is decided by their facts: a shared `subject_key` and identical
+  predicate or property signatures, which `domain-redundancy` and
+  `domain-contradictions` compare deterministically. Reuse existing subject keys
+  (dotted `component.aspect[.sub]`, lowercase snake segments such as
+  `kibi.cli.check.staged`) instead of deriving a subject from the requirement
+  ID.
+
+`entity-id-style` reports new purely numeric IDs (`REQ-123`) and IDs whose
+filename stem differs from `id` as non-blocking quality diagnostics. Legacy
+numbered entities created before the naming standard are grandfathered and are
+not renamed, because code comments such as `// implements REQ-003` still
+reference them.

package/agent-plugin/skills/kibi-usage/resources/workflows.md

@@ -33,11 +33,62 @@ surfaces are a release defect: require a new package version and label any
 project override temporary. This skill never selects a package manager or
 edits dependency configuration.
 
+## Choosing a discovery mode
+
+`kb_search` is not one behavior. It selects deterministic intent ranking when
+you pass `rankingMode: "intent-v1"`, `semanticFacets`, or `sourceLocations`,
+and legacy lexical ranking otherwise. Naming the tool is not enough; the inputs
+decide the path.
+
+- **Exact identity** — you already know the ID. Use `kb_query`, not search.
+- **Literal token** — a symbol, file, or error string that appears verbatim.
+  Use lexical `kb_search` and keep the query close to the literal text.
+- **Conceptual or behavioral** — "how does checkout handle a declined card".
+  Use intent mode and ground it in what you actually know:
+
+```json
+{
+  "query": "declined card during checkout",
+  "rankingMode": "intent-v1",
+  "semanticFacets": {
+    "actors": ["shopper"],
+    "actions": ["pay"],
+    "objects": ["card"],
+    "constraints": ["declined"]
+  }
+}
+```
+
+- **Before changing code** — pass the file you are about to edit as a source
+  location, so results are matched against source-linked symbols and return
+  source evidence:
+
+```json
+{
+  "query": "checkout total rounding",
+  "rankingMode": "intent-v1",
+  "sourceLocations": [{ "path": "src/checkout.ts", "symbol": "computeTotal" }]
+}
+```
+
+Supply facets only from the request, the code, or prior results. Inventing
+facets fabricates evidence and biases ranking. Intent mode abstains below
+`minScore` instead of returning weak matches; an abstention is an explicit
+no-answer, so widen the query or drop to lexical search rather than treating it
+as "nothing exists". There is no target percentage of intent-mode calls — a
+literal identifier lookup is still best served lexically.
+
+Results are summaries by default: identifying metadata, score, reasons, and a
+snippet. Read them to pick candidates, then `kb_query` those IDs for full
+bodies, or pass `fields: "full"` when you genuinely need every body. Extract
+the relevant existing constraints and decisions from the response before
+planning a behavior change; a search receipt is not comprehension.
+
 ## Discovery to Validation Sequence
 
 The canonical workflow for any KB operation follows this pattern:
 
-1. **Discover**: `kb_search` with focused probes
+1. **Discover**: `kb_search` with focused probes; pick the mode above
 2. **Confirm**: `kb_query` for exact IDs and state
 3. **Inspect**: `kb_status` when freshness matters
 4. **Decompose**: `kb_semantic_advisor` on the complete normative prose; verify or supply every atomic clause

package/bin/launch-kibi-mcp.mjs

@@ -362,7 +362,14 @@ export function launchKibiMcp(
     [projectLocal.binPath, ...childArgs],
     {
       cwd: workspaceRoot,
-      env: { ...env, KIBI_WORKSPACE: workspaceRoot },
+      env: {
+        ...env,
+        KIBI_WORKSPACE: workspaceRoot,
+        // Identify the host on usage rows. This never enables telemetry;
+        // KIBI_DIAGNOSTIC_MODE stays the operator's explicit opt-in and is
+        // passed through untouched.
+        KIBI_MCP_HOST: "cursor",
+      },
       stdio: ["inherit", "inherit", "inherit"],
     },
   );

package/dist/.cursor-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
   "name": "kibi-cursor",
   "displayName": "Kibi",
-  "version": "2.0.1",
-  "description": "Optional Cursor adapter for Kibi. Requires SWI-Prolog 9+ and project-local kibi-cli, kibi-mcp, and kibi-core before the bundled MCP server can start.",
+  "version": "2.1.1",
+  "description": "Optional Cursor adapter for Kibi. Requires project-local kibi-cli, kibi-mcp, and kibi-core (SWI-Prolog is bundled on Linux and macOS) before the bundled MCP server can start.",
   "license": "AGPL-3.0-or-later",
   "author": {
     "name": "Kibi"

package/dist/bin/launch-kibi-mcp.mjs

@@ -362,7 +362,14 @@ export function launchKibiMcp(
     [projectLocal.binPath, ...childArgs],
     {
       cwd: workspaceRoot,
-      env: { ...env, KIBI_WORKSPACE: workspaceRoot },
+      env: {
+        ...env,
+        KIBI_WORKSPACE: workspaceRoot,
+        // Identify the host on usage rows. This never enables telemetry;
+        // KIBI_DIAGNOSTIC_MODE stays the operator's explicit opt-in and is
+        // passed through untouched.
+        KIBI_MCP_HOST: "cursor",
+      },
       stdio: ["inherit", "inherit", "inherit"],
     },
   );

package/dist/guidance.d.ts

@@ -5,6 +5,17 @@ export type GuidanceContext = {
     readonly hasKibi: boolean;
     readonly mcpState: McpState;
     readonly workspaceTrusted: boolean;
+    /** Requirements the edited file already owns, when the manifest knows them. */
+    readonly linkedRequirementIds?: readonly string[];
 };
 export declare function readGuidance(filePath: string, context: GuidanceContext): string | undefined;
+/**
+ * Guidance emitted before an edit is written.
+ *
+ * The post-edit and stop messages can only ask for repair once the code is
+ * already changed. This is the one point where retrieval can still inform the
+ * change, so it names the requirements the file already implements and asks
+ * for them to be read before the edit rather than reconciled after it.
+ */
+export declare function preEditGuidance(filePath: string, context: GuidanceContext): string | undefined;
 export declare function writeGuidance(filePath: string, context: GuidanceContext): string | undefined;

package/dist/guidance.js

@@ -18,6 +18,40 @@ export function readGuidance(filePath, context) {
     const advisory = interfaceAdvisory(context.mcpState, context.workspaceTrusted);
     return advisory ? [advisory, ...guidance].join("\n") : guidance.join("\n");
 }
+/**
+ * Guidance emitted before an edit is written.
+ *
+ * The post-edit and stop messages can only ask for repair once the code is
+ * already changed. This is the one point where retrieval can still inform the
+ * change, so it names the requirements the file already implements and asks
+ * for them to be read before the edit rather than reconciled after it.
+ */
+export function preEditGuidance(filePath, context) {
+    if (!context.hasKibi) {
+        return undefined;
+    }
+    const relativePath = toRepoRelativePath(filePath, context.cwd);
+    if (!isMeaningfulTrackedPath(relativePath)) {
+        return undefined;
+    }
+    if (isDocumentationTrackedPath(relativePath)) {
+        return undefined;
+    }
+    const linkedRequirements = context.linkedRequirementIds ?? [];
+    const guidance = linkedRequirements.length > 0
+        ? [
+            `Kibi pre-edit guidance: ${relativePath} already implements ${linkedRequirements.join(", ")}.`,
+            `Read those requirements with kb_query before changing behavior here, and widen with kb_query({sourceFile:"${relativePath}"}) for scenarios and tests.`,
+            "If the change contradicts an existing requirement, resolve that in Kibi before writing the edit.",
+        ]
+        : [
+            `Kibi pre-edit guidance: ${relativePath} has no linked requirement in the symbol manifest.`,
+            `Discover existing constraints with kb_search, then kb_query({sourceFile:"${relativePath}"}), before changing behavior here.`,
+            "Record the requirement this change serves rather than leaving the symbol unowned.",
+        ];
+    const advisory = interfaceAdvisory(context.mcpState, context.workspaceTrusted);
+    return advisory ? [advisory, ...guidance].join("\n") : guidance.join("\n");
+}
 export function writeGuidance(filePath, context) {
     if (!context.hasKibi) {
         return undefined;
@@ -35,12 +69,12 @@ export function writeGuidance(filePath, context) {
         const advisory = interfaceAdvisory(context.mcpState, context.workspaceTrusted);
         return advisory ? [advisory, ...guidance].join("\n") : guidance.join("\n");
     }
+    // Retrieval is asked for before the edit; this message stays scoped to the
+    // impact review that only becomes possible once the change exists.
     const guidance = [
-        "Kibi write guidance: use the selected MCP or CLI JSON route to link production symbols to requirements.",
-        `After editing, run kb_check({sourceFiles:["${relativePath}"], includeImpactDiagnostics:true, includeWorkingTreeDiff:true}) for symbol granularity and semantic review of linked requirements/tests.`,
-        `After editing, resolve freshness with kb_search/kb_query for sourceFile="${relativePath}".`,
-        "Prefer symbol manifest + executable_for or // implements REQ-xxx for traceability.",
-        "Do not read or edit `.kb/` files directly. Query before mutate; run kb_upsert sequentially and kb_check before completion.",
+        `Kibi impact review: run kb_check({sourceFiles:["${relativePath}"], includeImpactDiagnostics:true, includeWorkingTreeDiff:true}) while this edit is fresh.`,
+        "Check symbol granularity and whether linked requirements, scenarios, and tests still cover the changed behavior.",
+        "Prefer symbol manifest + executable_for or // implements REQ-<area>-<behavior> for traceability.",
     ];
     const advisory = interfaceAdvisory(context.mcpState, context.workspaceTrusted);
     return advisory ? [advisory, ...guidance].join("\n") : guidance.join("\n");

package/dist/hook-runner.js

@@ -3,12 +3,13 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { readGuidance, writeGuidance } from "./guidance.js";
+import { preEditGuidance, readGuidance, writeGuidance } from "./guidance.js";
 import { parseHookInput, parseStdinJson, readStdin } from "./hook-input.js";
 import { addDirtyPaths, clearSessionHookState, hasGuidedPath, loadHookState, recordKbMcpTool, recordPlanDelivered, rememberGuidedPath, resolveStateDir, } from "./hook-state.js";
 import { extractKbMcpToolCall } from "./kb-mcp-tools.js";
 import { BOOTSTRAP_REMINDER, DIRECT_KB_EDIT_WARNING, interfaceAdvisory, stopFollowupMessage, } from "./messages.js";
 import { extractExplicitPathFields, isDirectKbPath, isKbFreshnessRelevantPath, isMeaningfulTrackedPath, toRepoRelativePath, } from "./path-policy.js";
+import { getSourceLinkedRequirementIds } from "./source-linked-requirements.js";
 const editableTools = new Set([
     "Edit",
     "MultiEdit",
@@ -86,7 +87,27 @@ export async function runHook(rawInput, environment = {}) {
                     agent_message: DIRECT_KB_EDIT_WARNING,
                 };
             }
-            return emptyResult();
+            const primaryPath = resolvePrimaryPath(input);
+            if (!primaryPath || !kibiReady || !isKnownEditableTool(input.toolName)) {
+                return emptyResult();
+            }
+            const relativePath = toRepoRelativePath(primaryPath, cwd);
+            const state = loadHookState(stateDir);
+            if (hasGuidedPath(state, "pre-edit", relativePath)) {
+                return emptyResult();
+            }
+            const guidance = preEditGuidance(primaryPath, {
+                cwd,
+                hasKibi: kibiReady,
+                mcpState: state.mcpState,
+                workspaceTrusted,
+                linkedRequirementIds: getSourceLinkedRequirementIds(cwd, primaryPath, stateDir),
+            });
+            if (!guidance) {
+                return emptyResult();
+            }
+            rememberGuidedPath(stateDir, "pre-edit", relativePath);
+            return { permission: "allow", agent_message: guidance };
         }
         case "beforeReadFile": {
             const primaryPath = resolvePrimaryPath(input);

package/dist/hook-state-storage.js

@@ -51,6 +51,7 @@ export function emptyHookState() {
         mcpState: "unknown",
         dirtyPaths: [],
         guidedReadPaths: [],
+        guidedPreEditPaths: [],
         guidedWritePaths: [],
         kbMutationTools: [],
         kbCheckRun: false,
@@ -164,6 +165,7 @@ function coerceHookState(value) {
         : [];
     const dirtyPaths = strings(value.dirtyPaths, normalizePath);
     const guidedReadPaths = strings(value.guidedReadPaths, normalizePath);
+    const guidedPreEditPaths = strings(value.guidedPreEditPaths, normalizePath);
     const guidedWritePaths = strings(value.guidedWritePaths, normalizePath);
     const kbMutationTools = strings(value.kbMutationTools, (entry) => entry.trim());
     const impactCheckedPaths = strings(value.impactCheckedPaths, normalizePath);
@@ -171,6 +173,7 @@ function coerceHookState(value) {
         mcpState: value.mcpState === "observed" ? "observed" : "unknown",
         dirtyPaths: [...new Set(dirtyPaths)].slice(-maxDirtyPaths),
         guidedReadPaths: [...new Set(guidedReadPaths)].slice(-maxGuidedPaths),
+        guidedPreEditPaths: [...new Set(guidedPreEditPaths)].slice(-maxGuidedPaths),
         guidedWritePaths: [...new Set(guidedWritePaths)].slice(-maxGuidedPaths),
         kbMutationTools: [...new Set(kbMutationTools)].slice(-maxKbMutationTools),
         kbCheckRun: value.kbCheckRun === true,

package/dist/hook-state.d.ts

@@ -1,9 +1,11 @@
 import type { McpState } from "./kb-mcp-tools.js";
 export { loadHookState, resolveStateDir, saveHookState, updateHookState, } from "./hook-state-storage.js";
+export type GuidedPathKind = "read" | "pre-edit" | "write";
 export type HookState = {
     mcpState: McpState;
     dirtyPaths: string[];
     guidedReadPaths: string[];
+    guidedPreEditPaths: string[];
     guidedWritePaths: string[];
     kbMutationTools: string[];
     kbCheckRun: boolean;
@@ -12,8 +14,8 @@ export type HookState = {
     planDelivered: boolean;
 };
 export declare function addDirtyPaths(stateDir: string | undefined, dirtyPaths: readonly string[]): HookState;
-export declare function rememberGuidedPath(stateDir: string | undefined, kind: "read" | "write", guidedPath: string): HookState;
-export declare function hasGuidedPath(state: HookState, kind: "read" | "write", guidedPath: string): boolean;
+export declare function rememberGuidedPath(stateDir: string | undefined, kind: GuidedPathKind, guidedPath: string): HookState;
+export declare function hasGuidedPath(state: HookState, kind: GuidedPathKind, guidedPath: string): boolean;
 export declare function recordPlanDelivered(stateDir: string | undefined): HookState;
 export declare function recordKbMcpTool(stateDir: string | undefined, toolName: string, options?: {
     impactCheckRun?: boolean;

package/dist/hook-state.js

@@ -15,6 +15,14 @@ export function rememberGuidedPath(stateDir, kind, guidedPath) {
                 guidedReadPaths: mergeStringPaths(state.guidedReadPaths, [normalized]),
             };
         }
+        if (kind === "pre-edit") {
+            return {
+                ...state,
+                guidedPreEditPaths: mergeStringPaths(state.guidedPreEditPaths, [
+                    normalized,
+                ]),
+            };
+        }
         return {
             ...state,
             guidedWritePaths: mergeStringPaths(state.guidedWritePaths, [normalized]),
@@ -22,9 +30,14 @@ export function rememberGuidedPath(stateDir, kind, guidedPath) {
     });
 }
 export function hasGuidedPath(state, kind, guidedPath) {
-    const normalized = normalizePath(guidedPath);
-    const bucket = kind === "read" ? state.guidedReadPaths : state.guidedWritePaths;
-    return bucket.includes(normalized);
+    return guidedBucket(state, kind).includes(normalizePath(guidedPath));
+}
+function guidedBucket(state, kind) {
+    if (kind === "read")
+        return state.guidedReadPaths;
+    if (kind === "pre-edit")
+        return state.guidedPreEditPaths;
+    return state.guidedWritePaths;
 }
 export function recordPlanDelivered(stateDir) {
     return updateHookState(stateDir, (state) => state.planDelivered ? state : { ...state, planDelivered: true });

package/dist/kb-mcp-tools.d.ts

@@ -1,10 +1,8 @@
-export type KbMcpToolCall = {
-    toolName: string;
-    impactCheckRun: boolean;
-    sourceFiles: string[];
-};
-export type McpState = "observed" | "unknown";
-export type KibiInterface = "mcp" | "cli" | "setup";
+import type { KbMcpToolCall as SharedKbMcpToolCall, KibiInterface as SharedKibiInterface, McpState as SharedMcpState } from "kibi-agent-core/kb-mcp-tools";
+export type KbMcpToolCall = SharedKbMcpToolCall;
+export type McpState = SharedMcpState;
+export type KibiInterface = SharedKibiInterface;
+export declare function canonicalKbToolName(toolName: string | undefined): string | undefined;
 export declare function resolveKibiInterface(mcpState: McpState, workspaceTrusted: boolean): KibiInterface;
 export declare function extractKbMcpToolCall(toolName: string | undefined, toolInput: unknown): KbMcpToolCall | undefined;
 export declare function extractKbMcpToolName(toolName: string | undefined, toolInput: unknown): string | undefined;

package/dist/kb-mcp-tools.js

@@ -1,154 +1,14 @@
 // implements REQ-cursor-kibi-plugin-v1
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readString(record, keys) {
-    for (const key of keys) {
-        const value = record[key];
-        if (typeof value === "string") {
-            return value;
-        }
-    }
-    return undefined;
-}
-function readBoolean(record, keys) {
-    for (const key of keys) {
-        const value = record[key];
-        if (typeof value === "boolean") {
-            return value;
-        }
-    }
-    return undefined;
-}
-function readStringArray(record, keys) {
-    for (const key of keys) {
-        const value = record[key];
-        if (!Array.isArray(value)) {
-            continue;
-        }
-        return value.filter((item) => typeof item === "string" && item.length > 0);
-    }
-    return [];
-}
-function readRecord(record, keys) {
-    for (const key of keys) {
-        const value = record[key];
-        if (isRecord(value)) {
-            return value;
-        }
-    }
-    return undefined;
+import { canonicalKbToolName as canonicalSharedKbToolName, extractKbMcpToolCall as extractSharedKbMcpToolCall, extractKbMcpToolName as extractSharedKbMcpToolName, resolveKibiInterface as resolveSharedKibiInterface, } from "kibi-agent-core/kb-mcp-tools";
+export function canonicalKbToolName(toolName) {
+    return canonicalSharedKbToolName(toolName);
 }
 export function resolveKibiInterface(mcpState, workspaceTrusted) {
-    if (mcpState === "observed") {
-        return "mcp";
-    }
-    return workspaceTrusted ? "cli" : "setup";
+    return resolveSharedKibiInterface(mcpState, workspaceTrusted);
 }
 export function extractKbMcpToolCall(toolName, toolInput) {
-    const directToolName = toolName?.trim();
-    let normalizedToolName = directToolName?.startsWith("kb_")
-        ? directToolName
-        : undefined;
-    if (isRecord(toolInput)) {
-        normalizedToolName ??= readString(toolInput, [
-            "toolName",
-            "tool_name",
-            "name",
-        ]);
-        const args = readRecord(toolInput, ["arguments", "args"]);
-        const payload = args ?? toolInput;
-        const includeImpactDiagnostics = readBoolean(payload, [
-            "includeImpactDiagnostics",
-            "include_impact_diagnostics",
-        ]);
-        const includeWorkingTreeDiff = readBoolean(payload, [
-            "includeWorkingTreeDiff",
-            "include_working_tree_diff",
-        ]);
-        const sourceFiles = readStringArray(payload, [
-            "sourceFiles",
-            "source_files",
-        ]);
-        if (normalizedToolName?.startsWith("kb_")) {
-            return {
-                toolName: normalizedToolName,
-                impactCheckRun: normalizedToolName === "kb_check" &&
-                    includeImpactDiagnostics === true &&
-                    includeWorkingTreeDiff === true &&
-                    sourceFiles.length > 0,
-                sourceFiles,
-            };
-        }
-        const nestedArgs = toolInput.arguments ?? toolInput.args;
-        if (isRecord(nestedArgs)) {
-            const nestedTool = readString(nestedArgs, [
-                "toolName",
-                "tool_name",
-                "name",
-            ]);
-            if (nestedTool?.startsWith("kb_")) {
-                return { toolName: nestedTool, impactCheckRun: false, sourceFiles: [] };
-            }
-        }
-    }
-    if (normalizedToolName?.startsWith("kb_")) {
-        return {
-            toolName: normalizedToolName,
-            impactCheckRun: false,
-            sourceFiles: [],
-        };
-    }
-    return undefined;
+    return extractSharedKbMcpToolCall(toolName, toolInput);
 }
 export function extractKbMcpToolName(toolName, toolInput) {
-    const toolCall = extractKbMcpToolCall(toolName, toolInput);
-    // rationale: the fallbacks below re-derive the same name from the same
-    // inputs, so dropping the toolCall shortcut is observationally equivalent.
-    // Stryker disable next-line ConditionalExpression, BlockStatement
-    if (toolCall) {
-        return toolCall.toolName;
-    }
-    // rationale: any tool name that trims to a kb_ prefix already produced a
-    // tool call above, so this branch only sees equivalent names.
-    // Stryker disable next-line MethodExpression
-    if (toolName) {
-        // rationale: any name that trims to a kb_ prefix already produced a tool
-        // call above, so this trim cannot change the returned name.
-        // Stryker disable MethodExpression
-        const normalized = toolName.trim();
-        if (normalized.startsWith("kb_")) {
-            return normalized;
-        }
-        // Stryker restore
-    }
-    if (!isRecord(toolInput)) {
-        return undefined;
-    }
-    // rationale: this alias list duplicates the one inside
-    // extractKbMcpToolCall, which already returned for every kb_ match.
-    // Stryker disable next-line StringLiteral
-    const directTool = readString(toolInput, ["toolName", "tool_name", "name"]);
-    if (directTool?.startsWith("kb_")) {
-        return directTool;
-    }
-    const nestedArgs = toolInput.arguments ?? toolInput.args;
-    if (isRecord(nestedArgs)) {
-        // rationale: this alias list duplicates the one inside
-        // extractKbMcpToolCall, which already returned for every kb_ match.
-        // Stryker disable next-line StringLiteral
-        // rationale: duplicate alias list; extractKbMcpToolCall already
-        // returned for every kb_ match.
-        // Stryker disable StringLiteral
-        const nestedTool = readString(nestedArgs, [
-            "toolName",
-            "tool_name",
-            "name",
-        ]);
-        // Stryker restore
-        if (nestedTool?.startsWith("kb_")) {
-            return nestedTool;
-        }
-    }
-    return undefined;
+    return extractSharedKbMcpToolName(toolName, toolInput);
 }