kibi-cli 1.0.1 → 2.0.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 { 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 };
                     }
@@ -402,7 +493,9 @@ export async function checkCommand(options) {
                         }
                     }
                     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 +546,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 +561,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 +587,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 +609,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 +630,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 +670,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 +701,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 +712,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 +768,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 +807,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 +823,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 +838,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 +893,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 +979,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 +1015,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 +1052,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 +1071,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 +1087,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 +1103,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 +1119,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":"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;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"}

package/dist/commands/doctor.js

@@ -97,7 +97,16 @@ export async function doctorCommand(options = {}) {
     console.log("Some checks failed. Please address the issues above.");
     return { exitCode: 1 };
 }
-async function packageMigrationActions(runtime) {
+export async function detectExecuteApplyPlanExport(load = () => import("../public/operations/index.js")) {
+    try {
+        const operations = await load();
+        return typeof operations.executeApplyPlan === "function";
+    }
+    catch {
+        return false;
+    }
+}
+export async function packageMigrationActions(runtime) {
     const actions = [];
     const versions = ["cliVersion", "coreVersion", "mcpVersion"].filter((key) => runtime[key] === "unresolved" || runtime[key] === "unknown");
     if (versions.length > 0) {
@@ -175,15 +184,7 @@ async function runtimeProvenance() {
     }
     const core = resolveInstalledPackageInfo("kibi-core");
     const mcp = resolveInstalledPackageInfo("kibi-mcp");
-    let executeApplyPlanExported;
-    try {
-        const operations = await import("../public/operations/index.js");
-        executeApplyPlanExported =
-            typeof operations.executeApplyPlan === "function";
-    }
-    catch {
-        executeApplyPlanExported = false;
-    }
+    const executeApplyPlanExported = await detectExecuteApplyPlanExport();
     return {
         cliVersion: typeof cli.version === "string" ? cli.version : "unknown",
         coreVersion: core.version,
@@ -226,9 +227,13 @@ function packageInfoFromManifest(manifestPath) {
             : undefined,
     };
 }
-function nearestNamedPackageManifest(startDir, name) {
+export function nextAncestorDirectory(current) {
+    const parent = path.dirname(current);
+    return parent === current ? undefined : parent;
+}
+export function nearestNamedPackageManifest(startDir, name) {
     let current = startDir;
-    while (true) {
+    while (current !== undefined) {
         const candidate = path.join(current, "package.json");
         try {
             const metadata = JSON.parse(readFileSync(candidate, "utf8"));
@@ -238,11 +243,9 @@ function nearestNamedPackageManifest(startDir, name) {
         catch {
             // Keep walking; an unrelated or absent manifest is not a match.
         }
-        const parent = path.dirname(current);
-        if (parent === current)
-            return undefined;
-        current = parent;
+        current = nextAncestorDirectory(current);
     }
+    return undefined;
 }
 function resolveInstalledPackageInfo(name) {
     const require = createRequire(import.meta.url);
@@ -468,8 +471,13 @@ function checkPreCommitHook() {
         const preCommitExecutable = (preCommitStats.mode & 0o111) !== 0;
         // Read hook content to determine whether it's using the new staged check
         const content = readFileSync(preCommitPath, "utf-8");
-        const usesKibi = content.includes("kibi check");
-        const usesStaged = content.includes("kibi check --staged");
+        // Current templates resolve the kibi binary into KIBI_BIN before invoking
+        // it (git hooks do not get node_modules/.bin on PATH); legacy templates
+        // invoked bare `kibi`.
+        const resolvesKibi = content.includes("KIBI_BIN=");
+        const usesKibi = resolvesKibi || content.includes("kibi check");
+        const usesStaged = content.includes('"$KIBI_BIN" check --staged') ||
+            content.includes("kibi check --staged");
         if (!usesKibi) {
             // Fail if hook doesn't invoke kibi at all
             return {
@@ -480,15 +488,24 @@ function checkPreCommitHook() {
         }
         if (preCommitExecutable) {
             if (usesStaged) {
+                if (!resolvesKibi) {
+                    // Functional template that invokes bare `kibi`: it fails whenever
+                    // kibi is installed only as a project dependency.
+                    return {
+                        passed: true,
+                        message: "Installed and executable (legacy template without kibi CLI resolution — run 'kibi init' to regenerate so hooks work with local installs)",
+                        remediation: "Run: kibi init to update git hooks to the latest template",
+                    };
+                }
                 return {
                     passed: true,
-                    message: "Installed and executable (uses 'kibi check --staged')",
+                    message: "Installed and executable (resolves kibi CLI; uses 'kibi check --staged')",
                 };
             }
             // Warn but pass if using legacy kibi check without --staged
             return {
                 passed: true,
-                message: "Installed and executable (uses legacy 'kibi check' — consider running 'kibi init' to update hooks to use '--staged')",
+                message: "Installed and executable (uses legacy 'kibi check' — consider running 'kibi init' to update hooks to use '--staged' with CLI resolution)",
                 remediation: "Run: kibi init to update git hooks to the latest template",
             };
         }
@@ -529,9 +546,11 @@ function checkPostRewriteHook() {
     try {
         const postRewriteStats = statSync(postRewritePath);
         const postRewriteExecutable = (postRewriteStats.mode & 0o111) !== 0;
-        // Read hook content to verify it invokes kibi
+        // Read hook content to verify it invokes kibi. Current templates invoke
+        // the resolved KIBI_BIN; legacy templates invoked bare `kibi sync`.
         const content = readFileSync(postRewritePath, "utf-8");
-        const usesKibi = content.includes("kibi sync");
+        const usesKibi = content.includes('"$KIBI_BIN" sync') || content.includes("kibi sync");
+        const resolvesKibi = content.includes("KIBI_BIN=");
         if (!usesKibi) {
             return {
                 passed: false,
@@ -540,6 +559,13 @@ function checkPostRewriteHook() {
             };
         }
         if (postRewriteExecutable) {
+            if (!resolvesKibi) {
+                return {
+                    passed: true,
+                    message: "Installed and executable (legacy template without kibi CLI resolution — run 'kibi init' to regenerate so hooks work with local installs)",
+                    remediation: "Run: kibi init to update git hooks to the latest template",
+                };
+            }
             return {
                 passed: true,
                 message: "Installed and executable",