kibi-cli 0.12.8 → 0.16.1

package/dist/commands/check.js

@@ -15,14 +15,15 @@
  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 } from "node:fs";
+import { existsSync } from "node:fs";
 import * as path from "node:path";
 import { getBranchOverride, isCliTraceOrDebugEnabled } from "../env.js";
 import { extractFromManifest, extractFromManifestString, } from "../extractors/manifest.js";
 import { extractFromMarkdownString, } from "../extractors/markdown.js";
 import { PrologProcess } from "../prolog.js";
 import { escapeAtom, parseTriples, parseViolationRows, } from "../prolog/codec.js";
-import { getBehavioralSymbolNames, getNonBehavioralSymbolNames, isAllowedGranularityReason, isTraceabilityRelationshipType, } from "../public/symbol-granularity.js";
+import { createSemanticReviewDiagnostics, createSymbolGranularityDiagnostics, createSymbolQualityDiagnostics, hasBlockingImpactDiagnostics, } from "../public/impact-diagnostics.js";
+import { executeCheck } from "../public/operations/check-executor.js";
 import { KIBI_NO_IMPACT_DECLARATION, KIBI_SYMBOLS_MANIFEST_PATH, } from "../traceability/evidence-model.js";
 import { getStagedFiles } from "../traceability/git-staged.js";
 import { validateStagedMarkdown } from "../traceability/markdown-validate.js";
@@ -34,8 +35,6 @@ import { cleanupTempKb, consultOverlay, createOverlayFacts, createTempKb, projec
 import { formatViolations as formatStagedViolations, validateStagedSymbols, } from "../traceability/validate.js";
 import { loadConfig } from "../utils/config.js";
 import { safeCleanupProlog } from "../utils/prolog-cleanup.js";
-import { RULES, getEffectiveRules, } from "../utils/rule-registry.js";
-import { runAggregatedChecks } from "./aggregated-checks.js";
 import { getCurrentBranch } from "./init-helpers.js";
 function getMatchGroup(match, index = 1) {
     const value = match?.[index];
@@ -46,6 +45,27 @@ function buildManifestLookup(stagedFiles) {
     const manifestResults = [];
     const authoredSymbolResults = [];
     const stagedAuthoredSymbolResults = [];
+    const makeLookupKey = (entry) => {
+        if (typeof entry.entity.id === "string" && entry.entity.id.length > 0) {
+            return `id:${entry.entity.id}`;
+        }
+        return `fallback:${entry.sourceFile ?? entry.entity.source ?? ""}\u0000${entry.entity.title}`;
+    };
+    const authoredSymbolIndexByKey = new Map();
+    const manifestResultIndexByKey = new Map();
+    const stagedAuthoredSymbolIndexByKey = new Map();
+    const upsertResult = (results, indexByKey, result, preferNew = false) => {
+        const key = makeLookupKey(result);
+        const existingIndex = indexByKey.get(key);
+        if (existingIndex === undefined) {
+            indexByKey.set(key, results.length);
+            results.push(result);
+            return;
+        }
+        if (preferNew) {
+            results[existingIndex] = result;
+        }
+    };
     // Pre-populate lookup from working-tree manifests so that code-only changes
     // (where symbols.yaml is not staged) still resolve to the correct symbol IDs
     // and relationships already defined on disk.
@@ -57,7 +77,7 @@ function buildManifestLookup(stagedFiles) {
             try {
                 const entries = extractFromManifest(absSymbolsPath);
                 for (const entry of entries) {
-                    authoredSymbolResults.push(entry);
+                    upsertResult(authoredSymbolResults, authoredSymbolIndexByKey, entry);
                     const sourceFile = entry.sourceFile || entry.entity.source || absSymbolsPath;
                     const key = `${sourceFile}:${entry.entity.title}`;
                     manifestLookup.set(key, {
@@ -95,22 +115,23 @@ function buildManifestLookup(stagedFiles) {
         try {
             const entries = extractFromManifestString(manifestFile.content ?? "", manifestFile.path);
             for (const entry of entries) {
-                manifestResults.push({
+                const authoredSymbolResult = {
                     entity: entry.entity,
                     relationships: entry.relationships,
                     ...(entry.sourceFile !== undefined
                         ? { sourceFile: entry.sourceFile }
                         : {}),
-                });
-                const authoredSymbolResult = {
+                };
+                const manifestResult = {
                     entity: entry.entity,
                     relationships: entry.relationships,
                     ...(entry.sourceFile !== undefined
                         ? { sourceFile: entry.sourceFile }
                         : {}),
                 };
-                authoredSymbolResults.push(authoredSymbolResult);
-                stagedAuthoredSymbolResults.push(authoredSymbolResult);
+                upsertResult(manifestResults, manifestResultIndexByKey, manifestResult, true);
+                upsertResult(authoredSymbolResults, authoredSymbolIndexByKey, authoredSymbolResult, true);
+                upsertResult(stagedAuthoredSymbolResults, stagedAuthoredSymbolIndexByKey, authoredSymbolResult);
                 const sourceFile = entry.sourceFile || entry.entity.source || manifestFile.path;
                 const key = `${sourceFile}:${entry.entity.title}`;
                 manifestLookup.set(key, {
@@ -137,70 +158,6 @@ function buildManifestLookup(stagedFiles) {
         stagedAuthoredSymbolResults,
     };
 }
-function hasTraceabilityRelationship(result) {
-    return result.relationships.some((relationship) => isTraceabilityRelationshipType(relationship.type));
-}
-function hasValidGranularityReason(result) {
-    return isAllowedGranularityReason(result.entity.granularity_reason);
-}
-function createSymbolGranularityDiagnostics(options) {
-    const diagnostics = [];
-    for (const result of options.manifestResults) {
-        if (!result.sourceFile)
-            continue;
-        if (!hasTraceabilityRelationship(result))
-            continue;
-        if (hasValidGranularityReason(result))
-            continue;
-        const granularSymbols = getGranularSymbolsForSourceFile(result.sourceFile, options.symbolsByFile, options.sourceContentByFile);
-        if (granularSymbols.length === 0)
-            continue;
-        const granularNames = [
-            ...new Set(granularSymbols.map((s) => s.name)),
-        ].sort();
-        if (granularNames.includes(result.entity.title))
-            continue;
-        const behavioralNames = getBehavioralSymbolNames(granularSymbols);
-        if (behavioralNames.length === 0)
-            continue;
-        const nonBehavioralNames = getNonBehavioralSymbolNames(granularSymbols);
-        const ignoredSymbolsSuggestion = nonBehavioralNames.length > 0
-            ? ` Non-behavioral symbols ignored for this decision: ${nonBehavioralNames.join(", ")}.`
-            : "";
-        diagnostics.push({
-            id: "symbol_granularity_violation",
-            severity: "error",
-            files: [result.entity.source, result.sourceFile],
-            docs: ["docs/symbol-traceability-taxonomy.md"],
-            message: `Symbol ${result.entity.id} links ${result.sourceFile} coarsely while granular symbols are available (behavioral only): ${behavioralNames.join(", ")}`,
-            suggestion: `Move ownership/coverage/test relationships to the narrow behavioral symbol, add a manifest behavioral anchor, or add granularity_reason with config-artifact, module-level-behavior, extractor-miss, or legacy-link when the coarse symbol is intentional.${ignoredSymbolsSuggestion}`,
-        });
-    }
-    return diagnostics;
-}
-function getGranularSymbolsForSourceFile(sourceFile, symbolsByFile, sourceContentByFile) {
-    const stagedContent = sourceContentByFile.get(sourceFile);
-    if (stagedContent !== undefined) {
-        return extractSymbolsFromStagedFile({
-            path: sourceFile,
-            status: "M",
-            hunkRanges: [{ start: 1, end: Number.MAX_SAFE_INTEGER }],
-            content: stagedContent,
-        });
-    }
-    const absolutePath = path.isAbsolute(sourceFile)
-        ? sourceFile
-        : path.resolve(process.cwd(), sourceFile);
-    if (!existsSync(absolutePath)) {
-        return [];
-    }
-    return extractSymbolsFromStagedFile({
-        path: sourceFile,
-        status: "M",
-        hunkRanges: [{ start: 1, end: Number.MAX_SAFE_INTEGER }],
-        content: readFileSync(absolutePath, "utf8"),
-    });
-}
 const KIBI_ENTITY_TYPES = new Set([
     "req",
     "scenario",
@@ -257,7 +214,9 @@ function getStagedDiffText(stagedFile) {
 function formatStagedKibiDiagnostics(diagnostics) {
     return diagnostics
         .map((diagnostic) => {
-        const lines = [`[${diagnostic.id}] ${diagnostic.message}`];
+        const lines = [
+            `[${diagnostic.severity.toUpperCase()} ${diagnostic.id}] ${diagnostic.message}`,
+        ];
         if (diagnostic.files.length > 0) {
             lines.push(`  Files: ${diagnostic.files.join(", ")}`);
         }
@@ -269,11 +228,48 @@ function formatStagedKibiDiagnostics(diagnostics) {
     })
         .join("\n\n");
 }
+function formatQualityDiagnostics(diagnostics) {
+    if (diagnostics.length === 0) {
+        return "";
+    }
+    const details = diagnostics.map((diagnostic) => {
+        const lines = [
+            `[${diagnostic.severity.toUpperCase()} ${diagnostic.id}] ${diagnostic.message}`,
+        ];
+        if (diagnostic.entityId !== undefined) {
+            lines.push(`  Entity: ${diagnostic.entityId}`);
+        }
+        if (diagnostic.files !== undefined && diagnostic.files.length > 0) {
+            lines.push(`  Files: ${diagnostic.files.join(", ")}`);
+        }
+        if (diagnostic.docs !== undefined && diagnostic.docs.length > 0) {
+            lines.push(`  Docs: ${diagnostic.docs.join(", ")}`);
+        }
+        lines.push(`  Blocking: ${diagnostic.blocking ? "yes" : "no"}`);
+        lines.push(`  Suggestion: ${diagnostic.suggestion}`);
+        return lines.join("\n");
+    });
+    return `Quality diagnostics (${diagnostics.length}):\n${details.join("\n\n")}`;
+}
+function printStructuredCheckResult(input) {
+    console.log(JSON.stringify({
+        structuredContent: {
+            violations: input.violations,
+            count: input.violations.length,
+            diagnostics: [],
+            qualityDiagnostics: input.qualityDiagnostics,
+        },
+    }));
+}
 function uniqueSorted(values) {
     return Array.from(new Set(values)).sort();
 }
+function hasYamlFrontmatter(content) {
+    const trimmed = content.trimStart();
+    return trimmed.startsWith("---") && trimmed.slice(3).includes("\n---");
+}
 function buildStagedKibiImpactEvidence(options) {
-    const { stagedFiles, sourceFiles, markdownFiles, markdownResults, symbolsByFile, symbolsManifestPath, } = options;
+    const { stagedFiles, sourceFiles, markdownFiles, markdownResultsByPath, symbolsByFile, symbolsManifestPath, } = options;
     const sourceChanges = sourceFiles.map((file) => {
         const symbolsForFile = symbolsByFile.get(file.path) ?? [];
         const behaviorCandidate = !isTestOnlySourcePath(file.path) &&
@@ -304,13 +300,6 @@ function buildStagedKibiImpactEvidence(options) {
         stagedFiles,
         sourceFiles: behaviorSourceFiles,
     });
-    const markdownResultsByPath = new Map();
-    for (const [index, file] of markdownFiles.entries()) {
-        const result = markdownResults[index];
-        if (result) {
-            markdownResultsByPath.set(file.path, result);
-        }
-    }
     const resolvedKbArtifacts = [];
     let override = null;
     for (const file of markdownFiles) {
@@ -345,12 +334,12 @@ function buildStagedKibiImpactEvidence(options) {
             rationale: parsedOverride.rationale ?? "",
         };
     }
-    if (stagedAuthoredSymbolsEvidence.entries.length > 0) {
+    if (stagedAuthoredSymbolsEvidence.changedEntityIds.length > 0) {
         resolvedKbArtifacts.push({
             kind: "symbols_manifest",
             path: stagedAuthoredSymbolsEvidence.path,
             entityTypes: ["symbol"],
-            entityIds: uniqueSorted(stagedAuthoredSymbolsEvidence.entries.flatMap((entry) => entry.entityIds)),
+            entityIds: stagedAuthoredSymbolsEvidence.changedEntityIds,
             sourcePaths: uniqueSorted(stagedAuthoredSymbolsEvidence.entries.map((entry) => entry.sourcePath)),
         });
     }
@@ -442,40 +431,63 @@ export async function checkCommand(options) {
                         console.error(`Error extracting symbols from staged file ${f.path}: ${e instanceof Error ? e.message : String(e)}`);
                     }
                 }
-                const markdownResults = markdownFiles.map((file) => extractFromMarkdownString(file.content ?? "", file.path));
+                const markdownResultsByPath = new Map();
+                for (const file of markdownFiles) {
+                    const content = file.content ?? "";
+                    if (hasYamlFrontmatter(content)) {
+                        markdownResultsByPath.set(file.path, extractFromMarkdownString(content, file.path));
+                    }
+                }
                 const stagedSourceFilePaths = new Set(sourceFiles.map((file) => file.path));
                 const scopedManifestResults = manifestResults.filter((result) => result.sourceFile !== undefined &&
                     stagedSourceFilePaths.has(result.sourceFile));
                 const stagedEntityResults = [
                     ...scopedManifestResults,
-                    ...markdownResults,
+                    ...markdownResultsByPath.values(),
                 ];
                 const stagedKibiEvidence = buildStagedKibiImpactEvidence({
                     stagedFiles,
                     sourceFiles,
                     markdownFiles,
-                    markdownResults,
+                    markdownResultsByPath,
                     symbolsByFile,
                     symbolsManifestPath,
                 });
                 const stagedKibiDiagnostics = collectStagedKibiDiagnostics(stagedKibiEvidence);
-                const stagedAuthoredSymbolSet = new Set(stagedAuthoredSymbolResults);
+                const activeStagedSymbolEntityIds = new Set(stagedKibiEvidence.mode.kind === "kb_changes"
+                    ? stagedKibiEvidence.mode.kbArtifacts
+                        .filter((artifact) => artifact.kind === "symbols_manifest")
+                        .flatMap((artifact) => artifact.entityIds)
+                    : []);
                 const stagedSourcePaths = new Set(sourceFiles.map((file) => file.path));
-                const activeGranularityResults = authoredSymbolResults.filter((result) => stagedAuthoredSymbolSet.has(result) ||
+                const activeGranularityResults = authoredSymbolResults.filter((result) => activeStagedSymbolEntityIds.has(result.entity.id) ||
                     (result.sourceFile !== undefined &&
                         stagedSourcePaths.has(result.sourceFile)));
                 stagedKibiDiagnostics.push(...createSymbolGranularityDiagnostics({
                     manifestResults: activeGranularityResults,
+                    ...(activeStagedSymbolEntityIds.size > 0
+                        ? { activeEntityIds: activeStagedSymbolEntityIds }
+                        : {}),
                     symbolsByFile,
                     sourceContentByFile,
-                }));
+                }), ...createSymbolQualityDiagnostics({
+                    manifestResults: activeGranularityResults,
+                    ...(activeStagedSymbolEntityIds.size > 0
+                        ? { activeEntityIds: activeStagedSymbolEntityIds }
+                        : {}),
+                    symbolsByFile,
+                }), ...createSemanticReviewDiagnostics({ symbolsByFile }));
                 if (allSymbols.length === 0 && stagedEntityResults.length === 0) {
                     if (stagedKibiDiagnostics.length > 0) {
                         console.log(formatStagedKibiDiagnostics(stagedKibiDiagnostics));
                         if (options.dryRun) {
                             return { exitCode: 0 };
                         }
-                        return { exitCode: 1 };
+                        return {
+                            exitCode: hasBlockingImpactDiagnostics(stagedKibiDiagnostics)
+                                ? 1
+                                : 0,
+                        };
                     }
                     console.log("No exported symbols or staged entities found in staged files.");
                     return { exitCode: 0 };
@@ -486,7 +498,11 @@ export async function checkCommand(options) {
                         if (options.dryRun) {
                             return { exitCode: 0 };
                         }
-                        return { exitCode: 1 };
+                        return {
+                            exitCode: hasBlockingImpactDiagnostics(stagedKibiDiagnostics)
+                                ? 1
+                                : 0,
+                        };
                     }
                     console.log("✓ No violations found in staged files.");
                     return { exitCode: 0 };
@@ -523,7 +539,13 @@ export async function checkCommand(options) {
                     if (options.dryRun) {
                         return { exitCode: 0 };
                     }
-                    return { exitCode: 1 };
+                    if (!hasBlockingImpactDiagnostics(stagedKibiDiagnostics)) {
+                        console.log("✓ No violations found in staged symbols.");
+                        return { exitCode: 0 };
+                    }
+                    return {
+                        exitCode: 1,
+                    };
                 }
                 console.log("✓ No violations found in staged symbols.");
                 await cleanupTempKb(tempCtx.tempDir);
@@ -552,71 +574,38 @@ export async function checkCommand(options) {
             return { exitCode: 1 };
         }
         attached = true;
-        const violations = [];
-        const config = loadConfig(process.cwd());
-        const checksConfig = config.checks ?? {
-            rules: Object.fromEntries(RULES.map((r) => [r.name, true])),
-            symbolTraceability: { requireAdr: false },
-        };
-        const effectiveRules = getEffectiveRules(checksConfig.rules, options.rules);
-        // Helper to conditionally run a check by name
-        async function runCheck(name, fn, ...args) {
-            if (!effectiveRules.has(name))
-                return;
-            if (!prolog) {
-                throw new Error("Prolog process not initialized");
-            }
-            const res = await fn(prolog, ...args);
-            if (res?.length)
-                violations.push(...res);
-        }
         if (!prolog) {
             throw new Error("Prolog process not initialized");
         }
         const activeProlog = prolog;
-        // Use aggregated checks (single Prolog call) when possible for better performance
-        // This is significantly faster in Bun/Docker environments where one-shot mode
-        // spawns a new Prolog process for each query
-        const supportedRules = [
-            "must-priority-coverage",
-            "symbol-coverage",
-            "symbol-traceability",
-            "no-dangling-refs",
-            "no-cycles",
-            "required-fields",
-            "deprecated-adr-no-successor",
-            "domain-contradictions",
-            "strict-fact-shape",
-            "strict-req-fact-pairing",
-            "strict-readiness",
-        ];
-        const canUseAggregated = Array.from(effectiveRules).every((r) => supportedRules.includes(r));
-        if (canUseAggregated) {
-            // Fast path: single Prolog call returning all violations
-            // Pass the requireAdr option for symbol-traceability
-            const aggregatedViolations = await runAggregatedChecks(activeProlog, effectiveRules, checksConfig.symbolTraceability?.requireAdr ?? false);
-            violations.push(...aggregatedViolations);
-        }
-        else {
-            // Legacy path: individual checks for backward compatibility
-            await runCheck("must-priority-coverage", checkMustPriorityCoverage);
-            await runCheck("symbol-coverage", checkSymbolCoverage);
-            await runCheck("symbol-traceability", (p) => checkSymbolTraceability(p, checksConfig.symbolTraceability?.requireAdr ?? false));
-            await runCheck("no-dangling-refs", checkNoDanglingRefs);
-            await runCheck("no-cycles", checkNoCycles);
-            const allEntityIds = await getAllEntityIds(activeProlog);
-            if (effectiveRules.has("required-fields")) {
-                const requiredViolations = await checkRequiredFields(activeProlog, allEntityIds);
-                violations.push(...requiredViolations);
-            }
-            await runCheck("deprecated-adr-no-successor", checkDeprecatedAdrs);
-            await runCheck("domain-contradictions", checkDomainContradictions);
-            await runCheck("strict-fact-shape", checkStrictFactShape);
-            await runCheck("strict-req-fact-pairing", checkStrictReqFactPairing);
-            await runCheck("strict-readiness", checkStrictReadiness);
+        const rules = options.rules
+            ?.split(",")
+            .map((rule) => rule.trim())
+            .filter((rule) => rule.length > 0);
+        const result = await executeCheck(rules === undefined ? {} : { rules }, {
+            workspaceRoot: process.cwd(),
+            signal: new AbortController().signal,
+            clock: () => new Date(),
+            prolog: {
+                query: (goal) => activeProlog.query(goal),
+                nextSolution: async () => null,
+                invalidateCache: () => activeProlog.invalidateCache(),
+                save: () => activeProlog.query("kb_save"),
+            },
+        }, { collectFullQualityDiagnosticsForExplicitRules: true });
+        const violations = result.structuredContent?.violations ?? [];
+        const qualityDiagnostics = result.structuredContent?.qualityDiagnostics ?? [];
+        if (options.format === "json") {
+            printStructuredCheckResult({ violations, qualityDiagnostics });
+            return { exitCode: violations.length === 0 ? 0 : 1 };
         }
+        const qualityOutput = formatQualityDiagnostics(qualityDiagnostics);
         if (violations.length === 0) {
             console.log("✓ No violations found. KB is valid.");
+            if (qualityOutput.length > 0) {
+                console.log();
+                console.log(qualityOutput);
+            }
             return { exitCode: 0 };
         }
         console.log(`Found ${violations.length} violation(s):`);
@@ -636,6 +625,10 @@ export async function checkCommand(options) {
             }
             console.log();
         }
+        if (qualityOutput.length > 0) {
+            console.log(qualityOutput);
+            console.log();
+        }
         return { exitCode: 1 };
     }
     catch (error) {

package/dist/commands/coverage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/commands/coverage.ts"],"names":[],"mappings":"AAQA,UAAU,eAAe;IACvB,EAAE,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAGD,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAgC7E"}
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/commands/coverage.ts"],"names":[],"mappings":"AAMA,UAAU,eAAe;IACvB,EAAE,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAGD,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAmB7E"}

package/dist/commands/coverage.js

@@ -1,24 +1,19 @@
-import { escapeAtom } from "../prolog/codec.js";
-import { printDiscoveryResult, resolveCurrentKbPath, runJsonModuleQuery, withPrologProcess, } from "./discovery-shared.js";
+import { coverageSpec } from "../public/operations/index.js";
+import { executeReportingSpec, printDiscoveryResult, } from "./discovery-shared.js";
 // implements REQ-002, REQ-003
 export async function coverageCommand(options) {
-    await withPrologProcess(async (prolog) => {
-        const kbPath = await resolveCurrentKbPath();
-        const by = options.by || "req";
-        const tags = options.tag
-            ? `[${options.tag
+    const result = await executeReportingSpec(coverageSpec, {
+        by: options.by ?? "req",
+        tags: options.tag
+            ? options.tag
                 .split(",")
                 .map((item) => item.trim())
                 .filter(Boolean)
-                .map((item) => `'${escapeAtom(item)}'`)
-                .join(",")}]`
-            : "[]";
-        const includePassing = options.includePassing ?? false;
-        const includeTransitive = options.includeTransitive ?? true;
-        const limit = Number.parseInt(options.limit || "100", 10);
-        const offset = Number.parseInt(options.offset || "0", 10);
-        const result = await runJsonModuleQuery(prolog, "discovery.pl", `discovery:coverage_report_json('${by}', ${tags}, ${includePassing}, ${includeTransitive}, ${limit}, ${offset}, JsonString)`, "coverage query failed", kbPath);
-        const summary = (result.summary ?? {});
-        printDiscoveryResult(options.format, result, `Coverage summary: ${summary.fullyCovered ?? 0} fully covered out of ${summary.total ?? 0}.`);
+            : [],
+        includePassing: options.includePassing ?? false,
+        includeTransitive: options.includeTransitive ?? true,
+        limit: Number.parseInt(options.limit || "100", 10),
+        offset: Number.parseInt(options.offset || "0", 10),
     });
+    printDiscoveryResult(options.format, result.structuredContent, result.content[0]?.text ?? "Coverage summary unavailable.");
 }

package/dist/commands/discovery-shared.d.ts

@@ -1,4 +1,6 @@
 import { PrologProcess, resolveKbPlPath } from "../prolog.js";
+import { type OperationSpec, type RuntimeOptions } from "../public/operations/index.js";
+export { renderCoverageTable } from "./discovery-table.js";
 export interface DiscoveryCommandOptions {
     format?: "json" | "table";
 }
@@ -9,8 +11,8 @@ export interface DiscoveryDeps {
     }) => PrologProcess;
     resolveKbPl: typeof resolveKbPlPath;
 }
+export declare function executeReportingSpec<TInput, TOutput>(spec: OperationSpec<TInput, TOutput>, input: TInput, options?: RuntimeOptions): Promise<import("../public/operations/types.js").OperationResult<TOutput>>;
 export declare function withAttachedBranchProlog<T>(callback: (prolog: PrologProcess) => Promise<T>, deps?: Partial<DiscoveryDeps>): Promise<T>;
-export declare function withPrologProcess<T>(callback: (prolog: PrologProcess) => Promise<T>, deps?: Partial<DiscoveryDeps>): Promise<T>;
 export declare function resolveCurrentKbPath(): Promise<string>;
 export declare function resolveCoreModulePath(fileName: string, deps?: Partial<DiscoveryDeps>): string;
 export declare function runJsonModuleQuery<T>(prolog: PrologProcess, fileName: string, goal: string, errorLabel: string, kbPath?: string, deps?: Partial<DiscoveryDeps>): Promise<T>;

package/dist/commands/discovery-shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery-shared.d.ts","sourceRoot":"","sources":["../../src/commands/discovery-shared.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAK9D,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAED,qDAAqD;AACrD,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,aAAa,CAAC;IAC3D,WAAW,EAAE,OAAO,eAAe,CAAC;CACrC;AAGD,wBAAsB,wBAAwB,CAAC,CAAC,EAC9C,QAAQ,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC,EAC/C,IAAI,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAC5B,OAAO,CAAC,CAAC,CAAC,CAmCZ;AAGD,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,QAAQ,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC,EAC/C,IAAI,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAC5B,OAAO,CAAC,CAAC,CAAC,CAmBZ;AAGD,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAS5D;AAGD,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAC5B,MAAM,CAGR;AAGD,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAC5B,OAAO,CAAC,CAAC,CAAC,CAwBZ;AAGD,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,EACpC,UAAU,EAAE,OAAO,EACnB,YAAY,EAAE,MAAM,GACnB,IAAI,CAQN"}
+{"version":3,"file":"discovery-shared.d.ts","sourceRoot":"","sources":["../../src/commands/discovery-shared.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE9D,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,cAAc,EAEpB,MAAM,+BAA+B,CAAC;AAMvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE3D,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAED,qDAAqD;AACrD,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,aAAa,CAAC;IAC3D,WAAW,EAAE,OAAO,eAAe,CAAC;CACrC;AAGD,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EACxD,IAAI,EAAE,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,cAAmB,6EAG7B;AAGD,wBAAsB,wBAAwB,CAAC,CAAC,EAC9C,QAAQ,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC,EAC/C,IAAI,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAC5B,OAAO,CAAC,CAAC,CAAC,CAmCZ;AAID,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAS5D;AAGD,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAC5B,MAAM,CAGR;AAGD,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAC5B,OAAO,CAAC,CAAC,CAAC,CAwBZ;AAGD,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,EACpC,UAAU,EAAE,OAAO,EACnB,YAAY,EAAE,MAAM,GACnB,IAAI,CAQN"}