kibi-mcp 0.19.0 → 0.19.2

package/dist/tools/autopilot-test-compat.js

@@ -0,0 +1,88 @@
+import { presentAutopilot, selectAutopilotCandidates, } from "kibi-cli/operations";
+import { resolveWorkspaceRoot } from "../workspace.js";
+import { activation, candidate, record, signal, } from "./autopilot-test-parsers.js";
+let testDependencies;
+export function setTestDependencies(dependencies) {
+    testDependencies = dependencies;
+}
+export function resetTestDependencies() {
+    testDependencies = undefined;
+}
+async function invoke(dependencies, name, values) {
+    const callable = dependencies[name];
+    return typeof callable === "function"
+        ? Reflect.apply(callable, undefined, [...values])
+        : undefined;
+}
+export async function executeTestDependencies(prolog, input) {
+    const dependencies = testDependencies;
+    if (!dependencies)
+        return null;
+    const root = resolveWorkspaceRoot();
+    const policy = activation(await invoke(dependencies, "resolveActivationPolicy", [root, prolog]));
+    if (!policy)
+        return null;
+    const discovered = record(await invoke(dependencies, "discoverProviderEvidence", [root, policy]));
+    const rawSummary = record(discovered?.summary);
+    const summary = {
+        activationState: policy.activationState,
+        activationMode: policy.activationMode,
+        applyBlocked: policy.applyBlocked,
+        reason: policy.reason,
+        providersRun: [],
+        providerCounts: {},
+        detectedLanguages: [],
+        detectedTestFrameworks: [],
+        excludedRoots: [],
+        truncated: false,
+        scanWarnings: [],
+        ...(rawSummary ? Object.fromEntries(Object.entries(rawSummary)) : {}),
+    };
+    const rawEntities = await invoke(dependencies, "loadEntities", [prolog, {}]);
+    const existingIds = new Set(Array.isArray(rawEntities)
+        ? rawEntities
+            .map((entry) => record(entry)?.id)
+            .filter((id) => typeof id === "string")
+        : []);
+    const discoveryInput = {
+        evidence: Array.isArray(discovered?.evidence) ? discovered.evidence : [],
+    };
+    const context = { ids: existingIds, workspaceRoot: root };
+    const minConfidence = Math.max(0.6, Math.min(0.95, input.minConfidence ?? 0.8));
+    const all = [];
+    for (const name of [
+        "buildTypedMarkdownCandidates",
+        "buildSymbolManifestCandidates",
+        "buildGenericMarkdownCandidates",
+        "buildNormativeRequirementCandidates",
+        "buildProviderEvidenceCandidates",
+    ]) {
+        const result = await invoke(dependencies, name, [
+            discoveryInput,
+            context,
+            minConfidence,
+        ]);
+        if (Array.isArray(result))
+            all.push(...result.flatMap((entry) => candidate(entry) ?? []));
+    }
+    const rawSignals = await invoke(dependencies, "collectSourceOnlyAuthoringSignals", [discoveryInput, context, minConfidence]);
+    const signals = Array.isArray(rawSignals)
+        ? rawSignals.flatMap((entry) => signal(entry) ?? [])
+        : [];
+    const selected = selectAutopilotCandidates(all.filter((entry) => entry.confidence >= minConfidence), existingIds, input.entityTypes, Math.max(1, Math.min(200, Math.trunc(input.maxCandidates ?? 50))));
+    const warning = await invoke(dependencies, "getWorkspaceMigrationWarning", [
+        root,
+    ]);
+    return presentAutopilot({
+        root,
+        activation: policy,
+        discoverySummary: summary,
+        migrationWarning: typeof warning === "string" ? warning : null,
+        ...(input.bootstrapContext
+            ? { bootstrapContext: input.bootstrapContext }
+            : {}),
+        candidates: selected.candidates,
+        sourceOnlySignals: signals,
+        suppressedCandidates: selected.suppressed,
+    });
+}

package/dist/tools/autopilot-test-parsers.js

@@ -0,0 +1,120 @@
+export function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? Object.fromEntries(Object.entries(value))
+        : null;
+}
+export function candidate(value) {
+    const item = record(value);
+    if (!item ||
+        typeof item.candidateId !== "string" ||
+        typeof item.entityType !== "string" ||
+        typeof item.title !== "string" ||
+        typeof item.sourceKind !== "string" ||
+        typeof item.sourcePath !== "string" ||
+        typeof item.confidence !== "number" ||
+        !Array.isArray(item.applyPlan))
+        return null;
+    const relationships = Array.isArray(item.relationships)
+        ? item.relationships.flatMap((entry) => {
+            const relation = record(entry);
+            return relation &&
+                typeof relation.type === "string" &&
+                typeof relation.from === "string" &&
+                typeof relation.to === "string"
+                ? [{ type: relation.type, from: relation.from, to: relation.to }]
+                : [];
+        })
+        : [];
+    const applyPlan = item.applyPlan
+        .map(record)
+        .filter((entry) => entry !== null);
+    return {
+        candidateId: item.candidateId,
+        entityType: item.entityType,
+        title: item.title,
+        sourceKind: item.sourceKind,
+        sourcePath: item.sourcePath,
+        confidence: item.confidence,
+        confidenceBand: typeof item.confidenceBand === "string" ? item.confidenceBand : "medium",
+        evidence: Array.isArray(item.evidence)
+            ? item.evidence.filter((entry) => typeof entry === "string")
+            : [],
+        relationships,
+        applyPlan,
+    };
+}
+export function signal(value) {
+    const item = record(value);
+    if (!item ||
+        !["req", "scenario", "test"].includes(String(item.kind)) ||
+        typeof item.title !== "string" ||
+        typeof item.sourcePath !== "string" ||
+        typeof item.confidence !== "number")
+        return null;
+    const kind = item.kind === "req"
+        ? "req"
+        : item.kind === "scenario"
+            ? "scenario"
+            : "test";
+    return {
+        kind,
+        title: item.title,
+        sourcePath: item.sourcePath,
+        confidence: item.confidence,
+        evidence: Array.isArray(item.evidence)
+            ? item.evidence.filter((entry) => typeof entry === "string")
+            : [],
+    };
+}
+export function activation(value) {
+    const item = record(value);
+    if (!item ||
+        typeof item.activationState !== "string" ||
+        typeof item.activationMode !== "string" ||
+        typeof item.applyBlocked !== "boolean" ||
+        typeof item.allowCandidateGeneration !== "boolean" ||
+        typeof item.reason !== "string")
+        return null;
+    const states = new Set([
+        "root_uninitialized",
+        "root_partial",
+        "vendored_only",
+        "root_active_thin",
+        "root_active_seeded",
+    ]);
+    const modes = new Set([
+        "cold_start_bootstrap",
+        "repair_bootstrap",
+        "attached_thin_handoff",
+        "attached_seeded_handoff",
+        "vendored_blocked",
+    ]);
+    if (!states.has(item.activationState) || !modes.has(item.activationMode))
+        return null;
+    return {
+        activationState: item.activationState === "root_partial"
+            ? "root_partial"
+            : item.activationState === "vendored_only"
+                ? "vendored_only"
+                : item.activationState === "root_active_thin"
+                    ? "root_active_thin"
+                    : item.activationState === "root_active_seeded"
+                        ? "root_active_seeded"
+                        : "root_uninitialized",
+        activationMode: item.activationMode === "repair_bootstrap"
+            ? "repair_bootstrap"
+            : item.activationMode === "attached_thin_handoff"
+                ? "attached_thin_handoff"
+                : item.activationMode === "attached_seeded_handoff"
+                    ? "attached_seeded_handoff"
+                    : item.activationMode === "vendored_blocked"
+                        ? "vendored_blocked"
+                        : "cold_start_bootstrap",
+        applyBlocked: item.applyBlocked,
+        allowCandidateGeneration: item.allowCandidateGeneration,
+        reason: item.reason,
+        ...(typeof item.handoffMessage === "string"
+            ? { handoffMessage: item.handoffMessage }
+            : {}),
+    };
+}

package/dist/tools/check.js

@@ -1,114 +1,21 @@
-import { collectFullKbQualityDiagnostics, } from "kibi-cli/public/impact-diagnostics";
+import { checkSpec } from "kibi-cli/operations";
 import { resolveWorkspaceRoot } from "../workspace.js";
-import { getEffectiveRules, loadChecksConfig } from "./check-config.js";
-import { buildStructuredContent, formatImpactText, formatQualityDiagnosticsText, formatViolationText, } from "./check-format.js";
-import { analyzeKbCheckImpact } from "./check-impact.js";
-import { runAggregatedChecks } from "./check-prolog.js";
-function qualityDiagnosticsFromImpact(impactResult) {
-    if (impactResult === undefined) {
-        return [];
-    }
-    return impactResult.impactDiagnostics.filter((diagnostic) => !diagnostic.blocking && diagnostic.severity !== "error");
-}
-function buildSummary(input) {
-    const sections = [formatViolationText(input.violations)];
-    if (input.impactResult !== undefined) {
-        sections.push(formatImpactText(input.impactResult));
-    }
-    if (input.qualityDiagnostics.length > 0) {
-        sections.push(formatQualityDiagnosticsText(input.qualityDiagnostics));
-    }
-    return sections.join("\n");
-}
 /**
  * Handle kb_check tool calls - run validation rules on the KB
  * Reuses validation logic from CLI check command
  */
 // implements REQ-002
 export async function handleKbCheck(prolog, args) {
-    const { rules, workspaceRoot: workspaceOverride } = args;
-    const hasExplicitRules = rules !== undefined;
-    try {
-        const workspaceRoot = workspaceOverride ?? resolveWorkspaceRoot();
-        const checksConfig = await loadChecksConfig(workspaceRoot);
-        const rulesAllowlist = getEffectiveRules(checksConfig.rules, rules);
-        const impactResult = analyzeKbCheckImpact(workspaceRoot, args);
-        const impactQualityDiagnostics = qualityDiagnosticsFromImpact(impactResult);
-        if (rulesAllowlist.size === 0) {
-            const qualityDiagnostics = hasExplicitRules
-                ? []
-                : impactResult
-                    ? impactQualityDiagnostics
-                    : await collectFullKbQualityDiagnostics({
-                        prolog,
-                        ...(args.maxDiagnostics !== undefined
-                            ? { maxDiagnostics: args.maxDiagnostics }
-                            : {}),
-                    });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: buildSummary({
-                            violations: [],
-                            impactResult,
-                            qualityDiagnostics,
-                        }),
-                    },
-                ],
-                structuredContent: buildStructuredContent({
-                    violations: [],
-                    diagnostics: [],
-                    qualityDiagnostics,
-                    impactResult,
-                }),
-            };
-        }
-        // Ensure we read the latest KB state, not a cached snapshot.
-        prolog.invalidateCache();
-        // Run aggregated checks using same approach as CLI
-        // This now runs ALL rules including symbol-traceability
-        const aggregatedViolations = await runAggregatedChecks(prolog, rulesAllowlist, checksConfig.symbolTraceability.requireAdr);
-        const diagnostics = aggregatedViolations.map((v) => ({
-            category: "SYNC_ERROR",
-            severity: "error",
-            message: v.description,
-            ...(v.source !== undefined ? { file: v.source } : {}),
-            ...(v.suggestion !== undefined ? { suggestion: v.suggestion } : {}),
-        }));
-        const qualityDiagnostics = hasExplicitRules
-            ? impactQualityDiagnostics
-            : impactResult
-                ? impactQualityDiagnostics
-                : await collectFullKbQualityDiagnostics({
-                    prolog,
-                    hardViolationEntityIds: new Set(aggregatedViolations.map((violation) => violation.entityId)),
-                    ...(args.maxDiagnostics !== undefined
-                        ? { maxDiagnostics: args.maxDiagnostics }
-                        : {}),
-                });
-        const summary = buildSummary({
-            violations: aggregatedViolations,
-            impactResult,
-            qualityDiagnostics,
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: summary,
-                },
-            ],
-            structuredContent: buildStructuredContent({
-                violations: aggregatedViolations,
-                diagnostics,
-                qualityDiagnostics,
-                impactResult,
-            }),
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Check execution failed: ${message}`);
-    }
+    const workspaceRoot = args.workspaceRoot ?? resolveWorkspaceRoot();
+    return checkSpec.execute({ ...args }, {
+        workspaceRoot,
+        signal: new AbortController().signal,
+        clock: () => new Date(),
+        prolog: {
+            query: (goal) => prolog.query(goal),
+            nextSolution: async () => null,
+            invalidateCache: () => prolog.invalidateCache(),
+            save: () => prolog.query("kb_save"),
+        },
+    });
 }

package/dist/tools/coverage.js

@@ -1,28 +1,14 @@
-import { runJsonModuleQuery, toPrologList } from "./core-module.js";
+import { executeCoverage } from "kibi-cli/operations";
 // implements REQ-002, REQ-013
 export async function handleKbCoverage(prolog, args) {
-    const by = args.by ?? "req";
-    const limit = args.limit ?? 100;
-    const offset = args.offset ?? 0;
-    const includePassing = args.includePassing ?? false;
-    const includeTransitive = args.includeTransitive ?? true;
-    try {
-        const payload = await runJsonModuleQuery(prolog, "discovery.pl", `discovery:coverage_report_json('${by}', ${toPrologList(args.tags)}, ${includePassing}, ${includeTransitive}, ${limit}, ${offset}, JsonString)`, "Coverage execution");
-        const summary = payload?.summary ?? {};
-        const fullyCovered = Number(summary.fullyCovered ?? 0);
-        const total = Number(summary.total ?? 0);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Coverage summary: ${fullyCovered} fully covered out of ${total}.`,
-                },
-            ],
-            ...(payload !== undefined ? { structuredContent: payload } : {}),
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Coverage execution failed: ${message}`);
-    }
+    return executeCoverage({ ...args }, {
+        workspaceRoot: process.cwd(),
+        signal: new AbortController().signal,
+        clock: () => new Date(),
+        prolog: {
+            query: (goal) => prolog.query(goal),
+            nextSolution: async () => null,
+            save: () => prolog.query("kb_save"),
+        },
+    });
 }

package/dist/tools/delete.js

@@ -1,113 +1,6 @@
-import { escapeAtom, parseEntityFromList, parseListOfLists, } from "kibi-cli/prolog/codec";
-/**
- * Handle kb.delete tool calls
- * Prevents deletion of entities with dependents (referential integrity)
- */
-export async function handleKbDelete(
-// implements REQ-002, REQ-011
-prolog, args) {
-    const { ids } = args;
-    if (!ids || ids.length === 0) {
-        throw new Error("At least one ID required for delete");
-    }
-    let deleted = 0;
-    let skipped = 0;
-    const errors = [];
-    try {
-        for (const id of ids) {
-            const safeId = escapeAtom(id);
-            // Check if entity exists
-            const checkGoal = `once(kb_entity('${safeId}', _, _))`;
-            const checkResult = await prolog.query(checkGoal);
-            if (!checkResult.success) {
-                errors.push(`Entity ${id} does not exist`);
-                skipped++;
-                continue;
-            }
-            // Check for dependents (entities that reference this one)
-            const dependentsGoal = `findall([RelType,From], (member(RelType, [depends_on, verified_by, validates, specified_by, relates_to, guards, publishes, consumes]), kb_relationship(RelType, From, '${safeId}')), Dependents)`;
-            const dependentsResult = await prolog.query(dependentsGoal);
-            if (!dependentsResult.success) {
-                errors.push(`Failed to inspect dependents for entity ${id}: ${dependentsResult.error ?? "Query failed"}`);
-                skipped++;
-                continue;
-            }
-            const hasDependents = dependentsResult.bindings.Dependents !== undefined &&
-                dependentsResult.bindings.Dependents !== "[]";
-            if (hasDependents) {
-                errors.push(`Cannot delete entity ${id}: has dependents (other entities reference it)`);
-                skipped++;
-            }
-            if (hasDependents) {
-                continue;
-            }
-            // No dependents, safe to delete
-            const entityMetadata = await loadEntityMetadataForDelete(prolog, id, safeId);
-            const deleteGoal = buildDeleteGoal(safeId, entityMetadata);
-            const deleteResult = await prolog.query(deleteGoal);
-            if (!deleteResult.success) {
-                errors.push(`Failed to delete entity ${id}: ${deleteResult.error || "Unknown error"}`);
-                skipped++;
-            }
-            else {
-                deleted++;
-            }
-        }
-        // Save KB to disk
-        const saveResult = await prolog.query("kb_save");
-        if (!saveResult.success) {
-            throw new Error(`Failed to save KB after delete: ${saveResult.error || "Unknown error"}`);
-        }
-        prolog.invalidateCache();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Deleted ${deleted} entities. Skipped ${skipped}. ${errors.length > 0 ? `Errors: ${errors.join("; ")}` : ""}`,
-                },
-            ],
-            structuredContent: {
-                deleted,
-                skipped,
-                errors,
-            },
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Delete execution failed: ${message}`);
-    }
-}
-async function loadEntityMetadataForDelete(prolog, id, safeId) {
-    const result = await prolog.query(`findall(['${safeId}',Type,Props], kb_entity('${safeId}', Type, Props), Results)`);
-    if (!result.success) {
-        throw new Error(`Failed to load metadata for entity ${id}: ${result.error || "Unknown error"}`);
-    }
-    const rows = result.bindings.Results
-        ? parseListOfLists(result.bindings.Results)
-        : [];
-    if (rows.length === 0) {
-        throw new Error(`Failed to load metadata for entity ${id}: Entity not found`);
-    }
-    const entity = parseEntityFromList(rows[0] ?? []);
-    const type = String(entity.type ?? "unknown");
-    const { id: _entityId, type: _entityType, ...props } = entity;
-    return { type, props };
-}
-function buildDeleteGoal(safeId, metadata) {
-    const auditProps = [
-        `id='${safeId}'`,
-        ...serializeDeleteProps(metadata.props),
-    ];
-    return `kb_retract_entity('${safeId}', ${metadata.type}, [${auditProps.join(", ")}])`;
-}
-function serializeDeleteProps(props) {
-    const orderedKeys = ["title", "source", "text_ref"];
-    return orderedKeys.flatMap((key) => {
-        const value = props[key];
-        if (typeof value !== "string") {
-            return [];
-        }
-        return `${key}=${JSON.stringify(value)}`;
-    });
+import { deleteSpec } from "kibi-cli/operations";
+import { createMutationContext } from "./mutation-context.js";
+// implements REQ-kibi-operation-interface-parity
+export async function handleKbDelete(prolog, args) {
+    return deleteSpec.execute(args, createMutationContext(prolog));
 }

package/dist/tools/discovery-adapter.js

@@ -0,0 +1,23 @@
+import { resolveWorkspaceRoot } from "../workspace.js";
+export function createDiscoveryContext(prolog) {
+    // implements REQ-kibi-operation-interface-parity
+    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"),
+    };
+    return {
+        workspaceRoot: resolveWorkspaceRoot(),
+        signal: new AbortController().signal,
+        clock: () => new Date(),
+        prolog: port,
+    };
+}

package/dist/tools/entity-query.js

@@ -1,111 +1 @@
-import { escapeAtomContent, parseEntityFromBinding, parseEntityFromList, parseListOfLists, } from "kibi-cli/prolog/codec";
-export const VALID_ENTITY_TYPES = [
-    // implements REQ-002
-    "req",
-    "scenario",
-    "test",
-    "adr",
-    "flag",
-    "event",
-    "symbol",
-    "fact",
-];
-// implements REQ-002, REQ-013
-export function validateEntityType(type) {
-    if (type && !VALID_ENTITY_TYPES.includes(type)) {
-        throw new Error(`Invalid type '${type}'. Valid types: ${VALID_ENTITY_TYPES.join(", ")}. Use a single type value, or omit this parameter to query all entities.`);
-    }
-}
-// implements REQ-002, REQ-013
-export function buildEntityGoal(args) {
-    const { type, id, tags, sourceFile } = args;
-    if (sourceFile) {
-        const safeSource = escapeAtomContent(sourceFile);
-        if (type) {
-            const safeType = escapeAtomContent(type);
-            return `findall([Id,'${safeType}',Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, '${safeType}', Props)), Results)`;
-        }
-        return `findall([Id,Type,Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, Type, Props)), Results)`;
-    }
-    if (id && type) {
-        const safeId = escapeAtomContent(id);
-        const safeType = escapeAtomContent(type);
-        return `findall(['${safeId}','${safeType}',Props], kb_entity('${safeId}', '${safeType}', Props), Results)`;
-    }
-    if (id) {
-        const safeId = escapeAtomContent(id);
-        return `findall(['${safeId}',Type,Props], kb_entity('${safeId}', Type, Props), Results)`;
-    }
-    if (tags && tags.length > 0) {
-        if (type) {
-            const safeType = escapeAtomContent(type);
-            return `findall([Id,'${safeType}',Props], kb_entity(Id, '${safeType}', Props), Results)`;
-        }
-        return "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)";
-    }
-    if (type) {
-        const safeType = escapeAtomContent(type);
-        return `findall([Id,'${safeType}',Props], kb_entity(Id, '${safeType}', Props), Results)`;
-    }
-    return "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)";
-}
-// implements REQ-002, REQ-013
-export async function loadEntities(prolog, args) {
-    validateEntityType(args.type);
-    const goal = buildEntityGoal(args);
-    const queryResult = await prolog.query(goal);
-    let results = [];
-    if (!queryResult.success) {
-        throw new Error(queryResult.error || "Query failed with unknown error");
-    }
-    if (queryResult.bindings.Results) {
-        const entitiesData = parseListOfLists(queryResult.bindings.Results);
-        for (const data of entitiesData) {
-            results.push(parseEntityFromList(data));
-        }
-    }
-    else if (queryResult.bindings.Result) {
-        results = [parseEntityFromBinding(queryResult.bindings.Result)];
-    }
-    if (args.tags && args.tags.length > 0) {
-        const requestedTags = args.tags;
-        results = dedupeEntities(results.filter((entity) => hasAnyTag(entity, requestedTags)));
-    }
-    return dedupeEntities(results);
-}
-// implements REQ-002
-export function paginateResults(results, limit = 100, offset = 0) {
-    return results.slice(offset, offset + limit);
-}
-function hasAnyTag(entity, requestedTags) {
-    const expected = new Set(requestedTags.map(normalizeTagValue));
-    const rawTags = entity.tags;
-    if (!Array.isArray(rawTags) || rawTags.length === 0) {
-        return false;
-    }
-    for (const tag of rawTags) {
-        if (expected.has(normalizeTagValue(tag))) {
-            return true;
-        }
-    }
-    return false;
-}
-function normalizeTagValue(tag) {
-    return String(tag).trim();
-}
-// implements REQ-002
-export function dedupeEntities(entities) {
-    const seen = new Set();
-    const deduped = [];
-    for (const entity of entities) {
-        const id = String(entity.id ?? "");
-        const type = String(entity.type ?? "");
-        const key = `${type}::${id}`;
-        if (seen.has(key)) {
-            continue;
-        }
-        seen.add(key);
-        deduped.push(entity);
-    }
-    return deduped;
-}
+export { VALID_ENTITY_TYPES, buildEntityGoal, dedupeEntities, loadEntities, paginateResults, validateEntityType, } from "kibi-cli/operations";

package/dist/tools/find-gaps.js

@@ -1,29 +1,14 @@
-import { runJsonModuleQuery, toPrologAtom, toPrologList, } from "./core-module.js";
-import { validateEntityType } from "./entity-query.js";
+import { executeFindGaps } from "kibi-cli/operations";
 // implements REQ-002, REQ-013
 export async function handleKbFindGaps(prolog, args) {
-    validateEntityType(args.type);
-    const limit = args.limit ?? 100;
-    const offset = args.offset ?? 0;
-    try {
-        const payload = await runJsonModuleQuery(prolog, "discovery.pl", `discovery:find_gaps_json(${toPrologAtom(args.type)}, ${toPrologList(args.missingRelationships)}, ${toPrologList(args.presentRelationships)}, ${toPrologList(args.tags)}, ${toPrologAtom(args.sourceFile)}, ${limit}, ${offset}, JsonString)`, "Find-gaps execution");
-        const rows = payload?.rows ?? [];
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: rows.length === 0
-                        ? "No matching gaps found."
-                        : `Found ${payload?.count ?? rows.length} gap rows. Showing ${rows.length}: ${rows
-                            .map((row) => row.id)
-                            .join(", ")}`,
-                },
-            ],
-            ...(payload !== undefined ? { structuredContent: payload } : {}),
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Find-gaps execution failed: ${message}`);
-    }
+    return executeFindGaps({ ...args }, {
+        workspaceRoot: process.cwd(),
+        signal: new AbortController().signal,
+        clock: () => new Date(),
+        prolog: {
+            query: (goal) => prolog.query(goal),
+            nextSolution: async () => null,
+            save: () => prolog.query("kb_save"),
+        },
+    });
 }