kibi-mcp 0.17.5 → 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-config.js

@@ -0,0 +1,67 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { readFile } from "node:fs/promises";
+import * as path from "node:path";
+import { DEFAULT_CHECKS_CONFIG, RULE_NAMES, } from "kibi-cli/public/check-types";
+// implements REQ-002
+export async function loadChecksConfig(workspaceRoot) {
+    const configPath = path.join(workspaceRoot, ".kb", "config.json");
+    try {
+        const content = await readFile(configPath, "utf8");
+        const parsed = JSON.parse(content);
+        const parsedRules = parsed.checks?.rules;
+        const normalizedRules = {
+            ...DEFAULT_CHECKS_CONFIG.rules,
+        };
+        if (parsedRules && typeof parsedRules === "object") {
+            for (const [key, value] of Object.entries(parsedRules)) {
+                if (typeof value === "boolean") {
+                    normalizedRules[key] = value;
+                }
+            }
+        }
+        const parsedSt = parsed.checks?.symbolTraceability;
+        const normalizedSt = { ...DEFAULT_CHECKS_CONFIG.symbolTraceability };
+        if (parsedSt &&
+            typeof parsedSt === "object" &&
+            typeof parsedSt.requireAdr === "boolean") {
+            normalizedSt.requireAdr = parsedSt.requireAdr;
+        }
+        return {
+            rules: normalizedRules,
+            symbolTraceability: normalizedSt,
+        };
+    }
+    catch {
+        return DEFAULT_CHECKS_CONFIG;
+    }
+}
+// implements REQ-002
+export function getEffectiveRules(configRules, requestedRules) {
+    if (requestedRules && requestedRules.length > 0) {
+        return new Set(requestedRules.filter((rule) => RULE_NAMES.has(rule)));
+    }
+    const effective = new Set();
+    for (const rule of RULE_NAMES) {
+        const enabled = configRules[rule] ?? true;
+        if (enabled) {
+            effective.add(rule);
+        }
+    }
+    return effective;
+}

package/dist/tools/check-format.js

@@ -0,0 +1,92 @@
+function formatDiagnosticsForMcp(diagnostics) {
+    return diagnostics.map((d) => ({
+        category: d.category,
+        severity: d.severity,
+        message: d.message,
+        ...(d.file !== undefined ? { file: d.file } : {}),
+        ...(d.suggestion !== undefined ? { suggestion: d.suggestion } : {}),
+    }));
+}
+export function formatImpactText(impactResult) {
+    if (impactResult.impactDiagnostics.length === 0) {
+        return "No impact diagnostics found";
+    }
+    const details = impactResult.impactDiagnostics.map((diagnostic) => {
+        const files = diagnostic.files.length > 0
+            ? diagnostic.files.join(", ")
+            : "unknown-source";
+        return `- ${diagnostic.id} | ${diagnostic.severity} | ${files} | ${diagnostic.message} Suggestion: ${diagnostic.suggestion}`;
+    });
+    return `${impactResult.impactDiagnostics.length} impact diagnostics found\n${details.join("\n")}`;
+}
+function formatOptionalList(label, values) {
+    if (values === undefined || values.length === 0) {
+        return [];
+    }
+    return [`${label}: ${values.join(", ")}`];
+}
+export function formatQualityDiagnosticsText(diagnostics) {
+    if (diagnostics.length === 0) {
+        return "No quality diagnostics found";
+    }
+    const details = diagnostics.map((diagnostic) => {
+        const parts = [
+            diagnostic.id,
+            diagnostic.severity,
+            diagnostic.category,
+            diagnostic.message,
+        ];
+        const metadata = [
+            `Blocking: ${diagnostic.blocking ? "yes" : "no"}`,
+            ...formatOptionalList("Files", diagnostic.files),
+            ...formatOptionalList("Docs", diagnostic.docs),
+            ...(diagnostic.entityId !== undefined
+                ? [`Entity: ${diagnostic.entityId}`]
+                : []),
+            ...(diagnostic.source !== undefined
+                ? [`Source: ${diagnostic.source}`]
+                : []),
+            `Suggestion: ${diagnostic.suggestion}`,
+        ];
+        return `- ${parts.join(" | ")}\n  ${metadata.join("\n  ")}`;
+    });
+    return `${diagnostics.length} quality diagnostic${diagnostics.length === 1 ? "" : "s"} found\n${details.join("\n")}`;
+}
+export function buildStructuredContent(input) {
+    const qualityDiagnostics = input.qualityDiagnostics ?? [];
+    return {
+        violations: [...input.violations],
+        count: input.violations.length,
+        diagnostics: formatDiagnosticsForMcp(input.diagnostics),
+        ...(qualityDiagnostics.length > 0
+            ? { qualityDiagnostics: [...qualityDiagnostics] }
+            : {}),
+        ...(input.impactResult
+            ? {
+                impactDiagnostics: input.impactResult.impactDiagnostics,
+                sourceFiles: input.impactResult.sourceFiles,
+                extractedSymbols: input.impactResult.extractedSymbols,
+                linkedEntities: input.impactResult.linkedEntities,
+                nextActions: input.impactResult.nextActions,
+            }
+            : {}),
+    };
+}
+export function formatViolationText(violations) {
+    if (violations.length === 0) {
+        return "No violations found";
+    }
+    const details = violations.map((violation) => {
+        const parts = [
+            violation.rule,
+            violation.entityId,
+            violation.source ?? "unknown-source",
+            violation.description,
+        ];
+        if (violation.suggestion) {
+            parts.push(`Suggestion: ${violation.suggestion}`);
+        }
+        return `- ${parts.join(" | ")}`;
+    });
+    return `${violations.length} violations found\n${details.join("\n")}`;
+}

package/dist/tools/check-impact.js

@@ -0,0 +1,45 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { analyzeChangedFileImpact, } from "kibi-cli/public/impact-diagnostics";
+export function hasImpactOptions(args) {
+    return Boolean(args.includeImpactDiagnostics ||
+        args.staged ||
+        args.includeWorkingTreeDiff ||
+        (args.sourceFiles && args.sourceFiles.length > 0));
+}
+export function analyzeKbCheckImpact(workspaceRoot, args) {
+    if (!hasImpactOptions(args)) {
+        return undefined;
+    }
+    return analyzeChangedFileImpact({
+        workspaceRoot,
+        ...(args.sourceFiles !== undefined
+            ? { sourceFiles: args.sourceFiles }
+            : {}),
+        ...(args.staged !== undefined ? { staged: args.staged } : {}),
+        ...(args.includeWorkingTreeDiff !== undefined
+            ? { includeWorkingTreeDiff: args.includeWorkingTreeDiff }
+            : {}),
+        ...(args.includeImpactDiagnostics !== undefined
+            ? { includeImpactDiagnostics: args.includeImpactDiagnostics }
+            : {}),
+        ...(args.maxDiagnostics !== undefined
+            ? { maxDiagnostics: args.maxDiagnostics }
+            : {}),
+    });
+}

package/dist/tools/check-prolog.js

@@ -0,0 +1,51 @@
+import { resolveCorePlPath } from "./core-module.js";
+import { collectQueryPlanSafetyViolations } from "./query-plan-safety.js";
+// implements REQ-002
+export async function runAggregatedChecks(prolog, rulesAllowlist, requireAdr) {
+    const violations = [];
+    const checksPlPath = resolveCorePlPath("checks.pl");
+    if (rulesAllowlist.has("query-plan-safety")) {
+        violations.push(...collectQueryPlanSafetyViolations(checksPlPath));
+    }
+    const normalizedChecksPlPath = checksPlPath.replace(/\\/g, "/");
+    const checksPlPathEscaped = normalizedChecksPlPath.replace(/'/g, "''");
+    const requireAdrStr = requireAdr ? "true" : "false";
+    const query = `(load_files('${checksPlPathEscaped}', [if(changed)]),
+    (   predicate_property(checks:check_all_json_with_options(_, _), _)
+    ->  call(checks:check_all_json_with_options(JsonString, ${requireAdrStr}))
+    ;   call(checks:check_all_json(JsonString))
+    ))`;
+    const result = await prolog.query(query);
+    if (!result.success) {
+        throw new Error(`Aggregated checks query failed: ${result.error || "Unknown error"}`);
+    }
+    const violationsDict = parseViolations(result.bindings.JsonString);
+    for (const ruleViolations of Object.values(violationsDict)) {
+        for (const v of ruleViolations) {
+            const isAllowed = rulesAllowlist.has(v.rule);
+            if (isAllowed) {
+                violations.push({
+                    rule: v.rule,
+                    entityId: v.entityId,
+                    description: v.description,
+                    ...(v.suggestion ? { suggestion: v.suggestion } : {}),
+                    ...(v.source ? { source: v.source } : {}),
+                });
+            }
+        }
+    }
+    return violations;
+}
+function parseViolations(jsonString) {
+    try {
+        if (!jsonString || typeof jsonString !== "string") {
+            throw new Error("No JSON string in binding");
+        }
+        const parsed = JSON.parse(jsonString);
+        const violations = typeof parsed === "string" ? JSON.parse(parsed) : parsed;
+        return violations;
+    }
+    catch (parseError) {
+        throw new Error(`Failed to parse violations JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+    }
+}

package/dist/tools/check.js

@@ -1,198 +1,21 @@
-/*
- Kibi — repo-local, per-branch, queryable long-term memory for software projects
- Copyright (C) 2026 Piotr Franczyk
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU Affero General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU Affero General Public License for more details.
-
- You should have received a copy of the GNU Affero General Public License
- along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-import { readFile } from "node:fs/promises";
-import * as path from "node:path";
-import { DEFAULT_CHECKS_CONFIG, RULE_NAMES, } from "kibi-cli/public/check-types";
+import { checkSpec } from "kibi-cli/operations";
 import { resolveWorkspaceRoot } from "../workspace.js";
-import { resolveCorePlPath } from "./core-module.js";
-function formatDiagnosticsForMcp(diagnostics) {
-    return diagnostics.map((d) => ({
-        category: d.category,
-        severity: d.severity,
-        message: d.message,
-        ...(d.file !== undefined ? { file: d.file } : {}),
-        ...(d.suggestion !== undefined ? { suggestion: d.suggestion } : {}),
-    }));
-}
-function formatViolationText(violations) {
-    if (violations.length === 0) {
-        return "No violations found";
-    }
-    const details = violations.map((violation) => {
-        const parts = [
-            violation.rule,
-            violation.entityId,
-            violation.source ?? "unknown-source",
-            violation.description,
-        ];
-        if (violation.suggestion) {
-            parts.push(`Suggestion: ${violation.suggestion}`);
-        }
-        return `- ${parts.join(" | ")}`;
-    });
-    return `${violations.length} violations found\n${details.join("\n")}`;
-}
-// implements REQ-002
-async function loadChecksConfig(workspaceRoot) {
-    const configPath = path.join(workspaceRoot, ".kb", "config.json");
-    try {
-        const content = await readFile(configPath, "utf8");
-        const parsed = JSON.parse(content);
-        const parsedRules = parsed.checks?.rules;
-        const normalizedRules = {
-            ...DEFAULT_CHECKS_CONFIG.rules,
-        };
-        if (parsedRules && typeof parsedRules === "object") {
-            for (const [key, value] of Object.entries(parsedRules)) {
-                if (typeof value === "boolean") {
-                    normalizedRules[key] = value;
-                }
-                // Ignore non-boolean values (they are not added to normalizedRules, preserving defaults)
-            }
-        }
-        const parsedSt = parsed.checks?.symbolTraceability;
-        const normalizedSt = { ...DEFAULT_CHECKS_CONFIG.symbolTraceability };
-        if (parsedSt && typeof parsedSt === "object") {
-            if (typeof parsedSt.requireAdr === "boolean") {
-                normalizedSt.requireAdr = parsedSt.requireAdr;
-            }
-        }
-        return {
-            rules: normalizedRules,
-            symbolTraceability: normalizedSt,
-        };
-    }
-    catch {
-        return DEFAULT_CHECKS_CONFIG;
-    }
-}
-// implements REQ-002
-function getEffectiveRules(configRules, requestedRules) {
-    if (requestedRules && requestedRules.length > 0) {
-        return new Set(requestedRules.filter((rule) => RULE_NAMES.has(rule)));
-    }
-    const effective = new Set();
-    for (const rule of RULE_NAMES) {
-        const enabled = configRules[rule] ?? true;
-        if (enabled) {
-            effective.add(rule);
-        }
-    }
-    return effective;
-}
 /**
  * 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;
-    try {
-        const workspaceRoot = workspaceOverride ?? resolveWorkspaceRoot();
-        const checksConfig = await loadChecksConfig(workspaceRoot);
-        const rulesAllowlist = getEffectiveRules(checksConfig.rules, rules);
-        if (rulesAllowlist.size === 0) {
-            return {
-                content: [{ type: "text", text: "No violations found" }],
-                structuredContent: {
-                    violations: [],
-                    count: 0,
-                    diagnostics: [],
-                },
-            };
-        }
-        // 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 summary = formatViolationText(aggregatedViolations);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: summary,
-                },
-            ],
-            structuredContent: {
-                violations: aggregatedViolations,
-                count: aggregatedViolations.length,
-                diagnostics: formatDiagnosticsForMcp(diagnostics),
-            },
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Check execution failed: ${message}`);
-    }
-}
-// implements REQ-002
-async function runAggregatedChecks(prolog, rulesAllowlist, requireAdr) {
-    const violations = [];
-    const checksPlPath = resolveCorePlPath("checks.pl");
-    const normalizedChecksPlPath = checksPlPath.replace(/\\/g, "/");
-    const checksPlPathEscaped = normalizedChecksPlPath.replace(/'/g, "''");
-    // Use check_all_json_with_options if available, otherwise fall back to check_all_json
-    const requireAdrStr = requireAdr ? "true" : "false";
-    const query = `(use_module('${checksPlPathEscaped}'),
-    (   predicate_property(checks:check_all_json_with_options(_, _), _)
-    ->  call(checks:check_all_json_with_options(JsonString, ${requireAdrStr}))
-    ;   call(checks:check_all_json(JsonString))
-    ))`;
-    const result = await prolog.query(query);
-    if (!result.success) {
-        throw new Error(`Aggregated checks query failed: ${result.error || "Unknown error"}`);
-    }
-    let violationsDict;
-    try {
-        const jsonString = result.bindings.JsonString;
-        if (!jsonString) {
-            throw new Error("No JSON string in binding");
-        }
-        let parsed = JSON.parse(jsonString);
-        if (typeof parsed === "string") {
-            parsed = JSON.parse(parsed);
-        }
-        violationsDict = parsed;
-    }
-    catch (parseError) {
-        throw new Error(`Failed to parse violations JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
-    }
-    for (const ruleViolations of Object.values(violationsDict)) {
-        for (const v of ruleViolations) {
-            const isAllowed = rulesAllowlist.has(v.rule);
-            if (isAllowed) {
-                violations.push({
-                    rule: v.rule,
-                    entityId: v.entityId,
-                    description: v.description,
-                    ...(v.suggestion ? { suggestion: v.suggestion } : {}),
-                    ...(v.source ? { source: v.source } : {}),
-                });
-            }
-        }
-    }
-    return violations;
+    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"),
+        },
+    });
 }