kibi-cli 1.0.1 → 2.1.0

package/dist/commands/check.js

@@ -22,20 +22,21 @@ import { 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 { escapeAtom, normalizeEntityId, parseTriples, parseViolationRows, } from "../prolog/codec.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, KIBI_SYMBOL_COORDINATES_PATH, } from "../traceability/evidence-model.js";
-import { getStagedFiles } from "../traceability/git-staged.js";
+import { getStagedInventory, supportedStagedFiles, } from "../traceability/git-staged.js";
 import { validateStagedMarkdown } from "../traceability/markdown-validate.js";
 import { collectStagedKibiDiagnostics, } from "../traceability/staged-diagnostics.js";
+import { analyzeStagedFileCoverage, } from "../traceability/staged-file-coverage.js";
 import { classifyKibiImpactEvidence, isBehaviorSourceEdit, parseKibiImpactOverride, } from "../traceability/staged-impact-contract.js";
 import { assessStagedSymbolsManifest, collectStagedAuthoredSymbolsManifestEvidence, } from "../traceability/staged-symbols-manifest.js";
-import { createManifestLookupSentinelKey, extractSymbolsFromStagedFile, } from "../traceability/symbol-extract.js";
+import { createManifestLookupSentinelKey, extractSymbolsFromStagedFileAsync, } from "../traceability/symbol-extract.js";
 import { cleanupTempKb, consultOverlay, createOverlayFacts, createTempKb, projectStagedEntities, } from "../traceability/temp-kb.js";
 import { formatViolations as formatStagedViolations, validateStagedSymbols, } from "../traceability/validate.js";
 import { resolveBranchAttachment } from "../utils/branch-resolver.js";
-import { CANONICAL_ENTITY_PATHS } from "../utils/kb-paths.js";
+import { CANONICAL_ENTITY_PATHS, isEntityLanePath } from "../utils/kb-paths.js";
 import { safeCleanupProlog } from "../utils/prolog-cleanup.js";
 function getMatchGroup(match, index = 1) {
     const value = match?.[index];
@@ -198,6 +199,9 @@ function formatStagedKibiDiagnostics(diagnostics) {
         if (diagnostic.files.length > 0) {
             lines.push(`  Files: ${diagnostic.files.join(", ")}`);
         }
+        for (const detail of diagnostic.details ?? []) {
+            lines.push(`  Detail: ${detail}`);
+        }
         if (diagnostic.docs.length > 0) {
             lines.push(`  Docs: ${diagnostic.docs.join(", ")}`);
         }
@@ -239,6 +243,66 @@ function printStructuredCheckResult(input) {
         },
     }));
 }
+function formatStagedCoverage(result) {
+    const counts = {
+        symbol: result.files.filter((file) => file.analysisDepth === "symbol")
+            .length,
+        metadata: result.files.filter((file) => file.analysisDepth === "metadata")
+            .length,
+        file: result.files.filter((file) => file.analysisDepth === "file").length,
+        skipped: result.files.filter((file) => file.disposition === "skipped")
+            .length,
+    };
+    const lines = [
+        `Staged files: ${result.files.length} total; ${counts.symbol} symbol-level; ${counts.metadata} metadata; ${counts.file} file-level; ${counts.skipped} skipped.`,
+    ];
+    for (const file of result.files) {
+        const details = [file.analysisDepth, file.disposition];
+        if (file.reason)
+            details.push(file.reason);
+        if (file.requirementIds.length > 0) {
+            details.push(`requirements: ${file.requirementIds.join(", ")}`);
+        }
+        if (file.evidencePaths.length > 0) {
+            details.push(`evidence: ${file.evidencePaths.join(", ")}`);
+        }
+        lines.push(`  ${file.status} ${file.path} [${details.join("; ")}]`);
+    }
+    if (result.diagnostics.length > 0) {
+        lines.push("", `Advisory staged-file diagnostics (${result.diagnostics.length}):`);
+        for (const diagnostic of result.diagnostics) {
+            lines.push(`  [${diagnostic.id}] ${diagnostic.message}`);
+            lines.push(`    Suggestion: ${diagnostic.suggestion}`);
+        }
+    }
+    return lines.join("\n");
+}
+function printStagedResult(input) {
+    const violations = input.violations ?? [];
+    const qualityDiagnostics = input.qualityDiagnostics ?? [];
+    if (input.format === "json") {
+        console.log(JSON.stringify({
+            structuredContent: {
+                violations,
+                count: violations.length,
+                diagnostics: input.coverage?.diagnostics ?? [],
+                qualityDiagnostics,
+                staged: input.coverage,
+                messages: input.messages ?? [],
+                ...(input.operationalError
+                    ? { operationalError: input.operationalError }
+                    : {}),
+            },
+        }));
+        return;
+    }
+    if (input.coverage)
+        console.log(formatStagedCoverage(input.coverage));
+    for (const message of input.messages ?? [])
+        console.log(message);
+    if (input.operationalError)
+        console.error(input.operationalError);
+}
 function uniqueSorted(values) {
     return Array.from(new Set(values)).sort();
 }
@@ -327,6 +391,9 @@ function buildStagedKibiImpactEvidence(options) {
             path: stagedSymbolsManifest.path,
             state: stagedSymbolsManifest.state,
             sourcePaths: stagedSymbolsManifest.sourcePaths,
+            ...(stagedSymbolsManifest.fileDetails
+                ? { fileDetails: stagedSymbolsManifest.fileDetails }
+                : {}),
         },
         mode: resolvedKbArtifacts.length > 0
             ? { kind: "kb_changes", kbArtifacts: resolvedKbArtifacts }
@@ -335,6 +402,13 @@ function buildStagedKibiImpactEvidence(options) {
                 : { kind: "missing" },
     };
 }
+export function requireActiveProlog(engine, prolog) {
+    const activeProlog = engine ?? prolog;
+    if (activeProlog == null) {
+        throw new Error("Prolog runtime not initialized");
+    }
+    return activeProlog;
+}
 // implements REQ-006
 export async function checkCommand(options) {
     let prolog = null;
@@ -358,17 +432,27 @@ export async function checkCommand(options) {
         }
         if (options.staged) {
             const minLinks = options.minLinks ? Number(options.minLinks) : 1;
+            let stagedCoverage = null;
             let tempCtx = null;
             try {
-                const stagedFiles = getStagedFiles();
-                if (!stagedFiles || stagedFiles.length === 0) {
-                    console.log("No staged files found.");
+                const stagedInventory = getStagedInventory();
+                stagedCoverage = analyzeStagedFileCoverage(stagedInventory);
+                const stagedFiles = supportedStagedFiles(stagedInventory);
+                if (stagedInventory.length === 0) {
+                    printStagedResult({
+                        format: options.format,
+                        coverage: stagedCoverage,
+                        messages: ["No staged files found."],
+                    });
                     return { exitCode: 0 };
                 }
                 const { manifestLookup, manifestResults, authoredSymbolResults, stagedAuthoredSymbolResults, } = buildManifestLookup(stagedFiles);
                 const symbolsManifestPath = KIBI_SYMBOLS_MANIFEST_PATH;
-                const sourceFiles = stagedFiles.filter((file) => !file.path.endsWith(".md") && !isStagedManifestPath(file.path));
-                const markdownFiles = stagedFiles.filter((f) => f.path.endsWith(".md"));
+                const symbolPaths = new Set(stagedInventory
+                    .filter((file) => file.analysisDepth === "symbol")
+                    .map((file) => file.path));
+                const sourceFiles = stagedFiles.filter((file) => symbolPaths.has(file.path));
+                const markdownFiles = stagedFiles.filter((file) => file.path.endsWith(".md") && isEntityLanePath(file.path));
                 const markdownErrors = [];
                 for (const f of markdownFiles) {
                     const result = validateStagedMarkdown(f.path, f.content || "");
@@ -377,11 +461,18 @@ export async function checkCommand(options) {
                     }
                 }
                 if (markdownErrors.length > 0) {
-                    console.log("Found embedded entity violations in staged markdown files:");
-                    for (const err of markdownErrors) {
-                        console.log(err);
-                        console.log();
-                    }
+                    printStagedResult({
+                        format: options.format,
+                        coverage: stagedCoverage,
+                        violations: markdownErrors.map((message) => ({
+                            rule: "staged-markdown",
+                            message,
+                        })),
+                        messages: [
+                            "Found embedded entity violations in staged markdown files:",
+                            ...markdownErrors,
+                        ],
+                    });
                     if (options.dryRun) {
                         return { exitCode: 0 };
                     }
@@ -395,14 +486,17 @@ export async function checkCommand(options) {
                         if (f.content !== undefined) {
                             sourceContentByFile.set(f.path, f.content);
                         }
-                        const symbols = extractSymbolsFromStagedFile(f, manifestLookup);
+                        // Maintenance path: builtin-only (no CapabilityRegistry / workspaceRoot).
+                        const symbols = await extractSymbolsFromStagedFileAsync(f, manifestLookup, {});
                         symbolsByFile.set(f.path, symbols);
                         if (symbols?.length) {
                             allSymbols.push(...symbols);
                         }
                     }
                     catch (e) {
-                        console.error(`Error extracting symbols from staged file ${f.path}: ${e instanceof Error ? e.message : String(e)}`);
+                        const message = `Error extracting symbols from staged file ${f.path}: ${e instanceof Error ? e.message : String(e)}`;
+                        if (options.format !== "json")
+                            console.error(message);
                     }
                 }
                 const markdownResultsByPath = new Map();
@@ -453,7 +547,12 @@ export async function checkCommand(options) {
                 }), ...createSemanticReviewDiagnostics({ symbolsByFile }));
                 if (allSymbols.length === 0 && stagedEntityResults.length === 0) {
                     if (stagedKibiDiagnostics.length > 0) {
-                        console.log(formatStagedKibiDiagnostics(stagedKibiDiagnostics));
+                        printStagedResult({
+                            format: options.format,
+                            coverage: stagedCoverage,
+                            qualityDiagnostics: stagedKibiDiagnostics,
+                            messages: [formatStagedKibiDiagnostics(stagedKibiDiagnostics)],
+                        });
                         if (options.dryRun) {
                             return { exitCode: 0 };
                         }
@@ -463,12 +562,23 @@ export async function checkCommand(options) {
                                 : 0,
                         };
                     }
-                    console.log("No exported symbols or staged entities found in staged files.");
+                    printStagedResult({
+                        format: options.format,
+                        coverage: stagedCoverage,
+                        messages: [
+                            "No exported symbols or staged entities found in staged files.",
+                        ],
+                    });
                     return { exitCode: 0 };
                 }
                 if (allSymbols.length === 0) {
                     if (stagedKibiDiagnostics.length > 0) {
-                        console.log(formatStagedKibiDiagnostics(stagedKibiDiagnostics));
+                        printStagedResult({
+                            format: options.format,
+                            coverage: stagedCoverage,
+                            qualityDiagnostics: stagedKibiDiagnostics,
+                            messages: [formatStagedKibiDiagnostics(stagedKibiDiagnostics)],
+                        });
                         if (options.dryRun) {
                             return { exitCode: 0 };
                         }
@@ -478,7 +588,11 @@ export async function checkCommand(options) {
                                 : 0,
                         };
                     }
-                    console.log("✓ No violations found in staged files.");
+                    printStagedResult({
+                        format: options.format,
+                        coverage: stagedCoverage,
+                        messages: ["✓ No violations found in staged files."],
+                    });
                     return { exitCode: 0 };
                 }
                 // Create temp KB
@@ -496,12 +610,19 @@ export async function checkCommand(options) {
                     prolog: tempCtx.prolog,
                 });
                 const violationsFormatted = formatStagedViolations(violationsRaw);
-                if (stagedKibiDiagnostics.length > 0) {
-                    console.log(formatStagedKibiDiagnostics(stagedKibiDiagnostics));
-                    console.log();
-                }
                 if (violationsRaw && violationsRaw.length > 0) {
-                    console.log(violationsFormatted);
+                    printStagedResult({
+                        format: options.format,
+                        coverage: stagedCoverage,
+                        violations: violationsRaw,
+                        qualityDiagnostics: stagedKibiDiagnostics,
+                        messages: [
+                            ...(stagedKibiDiagnostics.length > 0
+                                ? [formatStagedKibiDiagnostics(stagedKibiDiagnostics)]
+                                : []),
+                            violationsFormatted,
+                        ],
+                    });
                     await cleanupTempKb(tempCtx.tempDir);
                     if (options.dryRun) {
                         return { exitCode: 0 };
@@ -510,23 +631,38 @@ export async function checkCommand(options) {
                 }
                 if (stagedKibiDiagnostics.length > 0) {
                     await cleanupTempKb(tempCtx.tempDir);
+                    const blocking = hasBlockingImpactDiagnostics(stagedKibiDiagnostics);
+                    printStagedResult({
+                        format: options.format,
+                        coverage: stagedCoverage,
+                        qualityDiagnostics: stagedKibiDiagnostics,
+                        messages: [
+                            formatStagedKibiDiagnostics(stagedKibiDiagnostics),
+                            ...(!blocking
+                                ? ["✓ No violations found in staged symbols."]
+                                : []),
+                        ],
+                    });
                     if (options.dryRun) {
                         return { exitCode: 0 };
                     }
-                    if (!hasBlockingImpactDiagnostics(stagedKibiDiagnostics)) {
-                        console.log("✓ No violations found in staged symbols.");
+                    if (!blocking) {
                         return { exitCode: 0 };
                     }
                     return {
                         exitCode: 1,
                     };
                 }
-                console.log("✓ No violations found in staged symbols.");
+                printStagedResult({
+                    format: options.format,
+                    coverage: stagedCoverage,
+                    messages: ["✓ No violations found in staged symbols."],
+                });
                 await cleanupTempKb(tempCtx.tempDir);
                 return { exitCode: 0 };
             }
             catch (err) {
-                console.error(`Error running staged validation: ${err instanceof Error ? err.message : String(err)}`);
+                const message = `Error running staged validation: ${err instanceof Error ? err.message : String(err)}`;
                 if (tempCtx) {
                     try {
                         await cleanupTempKb(tempCtx.tempDir);
@@ -535,6 +671,11 @@ export async function checkCommand(options) {
                         // best-effort: temp directory may already be cleaned up
                     }
                 }
+                printStagedResult({
+                    format: options.format,
+                    coverage: stagedCoverage,
+                    operationalError: message,
+                });
                 return { exitCode: 1 };
             }
         }
@@ -561,10 +702,7 @@ export async function checkCommand(options) {
             }
             attached = true;
         }
-        const activeProlog = engine ?? prolog;
-        if (!activeProlog) {
-            throw new Error("Prolog runtime not initialized");
-        }
+        const activeProlog = requireActiveProlog(engine, prolog);
         const rules = options.rules
             ?.split(",")
             .map((rule) => rule.trim())
@@ -575,6 +713,9 @@ export async function checkCommand(options) {
             clock: () => new Date(),
             prolog: {
                 query: (goal) => activeProlog.query(goal),
+                ...(activeProlog instanceof EngineClient
+                    ? { queryEntities: activeProlog.queryEntities.bind(activeProlog) }
+                    : {}),
                 nextSolution: async () => null,
                 invalidateCache: () => activeProlog.invalidateCache(),
                 save: () => activeProlog.query("kb_save"),
@@ -628,7 +769,7 @@ export async function checkCommand(options) {
         await safeCleanupProlog(prolog);
     }
 }
-async function checkMustPriorityCoverage(prolog) {
+export async function checkMustPriorityCoverage(prolog) {
     const violations = [];
     const mustReqs = await findMustPriorityReqs(prolog);
     for (const reqId of mustReqs) {
@@ -667,7 +808,9 @@ async function checkMustPriorityCoverage(prolog) {
     }
     return violations;
 }
-async function findMustPriorityReqs(prolog) {
+// implements REQ-cli-check
+// covered_by TEST-004
+export async function findMustPriorityReqs(prolog) {
     const query = `findall(Id, (kb_entity(Id, req, Props), memberchk(priority=P, Props), (P = ^^("must", _) ; P = "must" ; P = 'must' ; (atom(P), atom_string(P, PS), sub_string(PS, _, 4, 0, "must")))), Ids)`;
     const result = await prolog.query(query);
     if (!result.success || !result.bindings.Ids) {
@@ -681,7 +824,7 @@ async function findMustPriorityReqs(prolog) {
     }
     return content.split(",").map((id) => id.trim().replace(/^'|'$/g, ""));
 }
-async function getAllEntityIds(prolog, type) {
+export async function getAllEntityIds(prolog, type) {
     const typeFilter = type ? `, Type = ${type}` : "";
     const query = `findall(Id, (kb_entity(Id, Type, _)${typeFilter}), Ids)`;
     const result = await prolog.query(query);
@@ -696,7 +839,7 @@ async function getAllEntityIds(prolog, type) {
     }
     return content.split(",").map((id) => id.trim().replace(/^'|'$/g, ""));
 }
-async function checkNoDanglingRefs(prolog) {
+export async function checkNoDanglingRefs(prolog) {
     const violations = [];
     const allEntityIds = new Set(await getAllEntityIds(prolog));
     const relTypes = [
@@ -751,7 +894,9 @@ async function checkNoDanglingRefs(prolog) {
     }
     return violations;
 }
-async function checkNoCycles(prolog) {
+// implements REQ-cli-check
+// covered_by TEST-cli-check-integrity
+export async function checkNoCycles(prolog) {
     const violations = [];
     const depsResult = await prolog.query("findall([From,To], kb_relationship(depends_on, From, To), Deps)");
     if (!depsResult.success || !depsResult.bindings.Deps) {
@@ -835,7 +980,7 @@ async function checkNoCycles(prolog) {
     }
     return violations;
 }
-async function checkRequiredFields(prolog, allEntityIds) {
+export async function checkRequiredFields(prolog, allEntityIds) {
     const violations = [];
     const required = [
         "id",
@@ -871,7 +1016,7 @@ async function checkRequiredFields(prolog, allEntityIds) {
     }
     return violations;
 }
-async function checkDeprecatedAdrs(prolog) {
+export async function checkDeprecatedAdrs(prolog) {
     const violations = [];
     // Use Prolog predicate to find deprecated ADRs without successors
     const result = await prolog.query("setof(Id, deprecated_no_successor(Id), Ids)");
@@ -908,14 +1053,16 @@ async function checkDeprecatedAdrs(prolog) {
     }
     return violations;
 }
-async function checkDomainContradictions(prolog) {
+export async function checkDomainContradictions(prolog) {
     const violations = [];
     const result = await prolog.query("setof([A,B,Reason], contradicting_reqs(A, B, Reason), Rows)");
     if (!result.success || !result.bindings.Rows) {
         return violations;
     }
     const rows = parseTriples(result.bindings.Rows);
-    for (const [reqA, reqB, reason] of rows) {
+    for (const [rawReqA, rawReqB, reason] of rows) {
+        const reqA = normalizeEntityId(rawReqA);
+        const reqB = normalizeEntityId(rawReqB);
         violations.push({
             rule: "domain-contradictions",
             entityId: `${reqA}/${reqB}`,
@@ -925,7 +1072,7 @@ async function checkDomainContradictions(prolog) {
     }
     return violations;
 }
-async function checkStrictFactShape(prolog) {
+export async function checkStrictFactShape(prolog) {
     const violations = [];
     const result = await prolog.query(`findall(violation(Rule, EntityId, Desc, Sugg, Src),
       checks:strict_fact_shape_violation(violation(Rule, EntityId, Desc, Sugg, Src)),
@@ -941,7 +1088,7 @@ async function checkStrictFactShape(prolog) {
     }
     return violations;
 }
-async function checkStrictReqFactPairing(prolog) {
+export async function checkStrictReqFactPairing(prolog) {
     const violations = [];
     const result = await prolog.query(`findall(violation(Rule, EntityId, Desc, Sugg, Src),
       checks:strict_req_fact_pairing_violation(violation(Rule, EntityId, Desc, Sugg, Src)),
@@ -957,7 +1104,7 @@ async function checkStrictReqFactPairing(prolog) {
     }
     return violations;
 }
-async function checkStrictReadiness(prolog) {
+export async function checkStrictReadiness(prolog) {
     const violations = [];
     const result = await prolog.query(`findall(violation(Rule, EntityId, Desc, Sugg, Src),
       checks:strict_readiness_violation(violation(Rule, EntityId, Desc, Sugg, Src)),
@@ -973,7 +1120,7 @@ async function checkStrictReadiness(prolog) {
     }
     return violations;
 }
-async function checkSymbolCoverage(prolog) {
+export async function checkSymbolCoverage(prolog) {
     const violations = [];
     const uncoveredResult = await prolog.query("setof(Symbol, symbol_no_req_coverage(Symbol, _), Symbols)");
     if (uncoveredResult.success && uncoveredResult.bindings.Symbols) {

package/dist/commands/coverage.d.ts

@@ -2,6 +2,7 @@ interface CoverageOptions {
     by?: "req" | "symbol" | "type";
     tag?: string;
     includePassing?: boolean;
+    status?: string;
     includeTransitive?: boolean;
     limit?: string;
     offset?: string;

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

@@ -1 +1 @@
-{"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,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAGD,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA6B7E"}
+{"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,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAGD,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAmC7E"}

package/dist/commands/coverage.js

@@ -11,6 +11,12 @@ export async function coverageCommand(options) {
                 .filter(Boolean)
             : [],
         includePassing: options.includePassing ?? false,
+        statuses: options.status
+            ? options.status
+                .split(",")
+                .map((item) => item.trim())
+                .filter(Boolean)
+            : [],
         includeTransitive: options.includeTransitive ?? true,
         limit: Number.parseInt(options.limit || "100", 10),
         offset: Number.parseInt(options.offset || "0", 10),

package/dist/commands/doctor.d.ts

@@ -4,4 +4,26 @@ export interface DoctorOptions {
 export declare function doctorCommand(options?: DoctorOptions): Promise<{
     exitCode: number;
 }>;
+export declare function detectExecuteApplyPlanExport(load?: () => Promise<{
+    executeApplyPlan?: unknown;
+}>): Promise<boolean>;
+export declare function packageMigrationActions(runtime: Readonly<Record<string, unknown>>): Promise<Readonly<{
+    id: string;
+    code: string;
+    category: "package" | "branch" | "storage" | "schema" | "freshness" | "relationship" | "symbol" | "semantic" | "proof" | "quality";
+    state: import("../public/operations/migration-plan.js").MigrationActionState;
+    safety: import("../public/operations/migration-plan.js").MigrationSafety;
+    invocation: import("../public/operations/migration-plan.js").MigrationInvocation;
+    affectedEntityIds: readonly string[];
+    affectedFiles: readonly string[];
+    dependsOn: readonly string[];
+    preconditions: readonly Readonly<Record<string, unknown>>[];
+    postconditions: readonly Readonly<Record<string, unknown>>[];
+    evidence: Readonly<Record<string, unknown>>;
+    autoApplicable: boolean;
+    dispositionRequired: boolean;
+    allowedDispositions: readonly import("../public/operations/migration-plan.js").MigrationDisposition[];
+}>[]>;
+export declare function nextAncestorDirectory(current: string): string | undefined;
+export declare function nearestNamedPackageManifest(startDir: string, name: string): string | undefined;
 //# sourceMappingURL=doctor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAmCA,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAGD,wBAAsB,aAAa,CACjC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAiF/B"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AA6DA,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B;AAGD,wBAAsB,aAAa,CACjC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAwF/B;AAED,wBAAsB,4BAA4B,CAChD,IAAI,GAAE,MAAM,OAAO,CAAC;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAE,CACT,GACxC,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;;;;;;;;;;;;;;;;MAkE3C;AAkGD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGzE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,SAAS,CAepB"}