kibi-cli 0.18.1 → 1.0.1

package/dist/public/operations/catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/public/operations/catalog.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE/D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBe,CAAC;AAO9C,wBAAgB,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,CAM1D;AAGD,wBAAgB,SAAS,IAAI,SAAS,aAAa,EAAE,CAEpD"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/public/operations/catalog.ts"],"names":[],"mappings":"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"}

package/dist/public/operations/catalog.js

@@ -1,12 +1,15 @@
-import { autopilotGenerateSpec } from "./specs/autopilot.js";
+import { OPERATION_DATA_SCHEMAS, declaredEffects, } from "./contracts.js";
+import { planBootstrapSpec } from "./specs/bootstrap.js";
 import { checkSpec } from "./specs/check.js";
 import { querySpec, searchSpec, statusSpec } from "./specs/discovery.js";
 import { modelRequirementSpec, suggestPredicatesSpec, } from "./specs/modeling.js";
 import { deleteSpec, upsertSpec, validateUpsertSpec, } from "./specs/mutation.js";
+import { applyPlanSpec, compileIntentSpec } from "./specs/planning.js";
 import { coverageSpec, findGapsSpec, graphSpec } from "./specs/reporting.js";
 import { semanticAdvisorSpec } from "./specs/semantic.js";
 import { skillsListSpec, skillsLoadSpec, skillsReadSpec, } from "./specs/skills.js";
 import { sparqlRemoteSpec } from "./specs/sparql.js";
+import { ingestVerificationSpec } from "./specs/verification.js";
 export const OPERATION_CATALOG = [
     skillsListSpec,
     skillsLoadSpec,
@@ -20,14 +23,133 @@ export const OPERATION_CATALOG = [
     semanticAdvisorSpec,
     modelRequirementSpec,
     suggestPredicatesSpec,
-    autopilotGenerateSpec,
+    planBootstrapSpec,
     validateUpsertSpec,
     upsertSpec,
     deleteSpec,
     checkSpec,
     sparqlRemoteSpec,
+    compileIntentSpec,
+    applyPlanSpec,
+    ingestVerificationSpec,
 ];
-const SPECS_BY_NAME = new Map(OPERATION_CATALOG.map((spec) => [spec.name, spec]));
+function envelopeSchema(spec, resultVersion) {
+    const data = OPERATION_DATA_SCHEMAS[spec.name];
+    if (!data)
+        throw new Error(`Missing output contract for ${spec.name}`);
+    return {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        type: "object",
+        additionalProperties: false,
+        required: [
+            "kibiProtocol",
+            "operation",
+            "resultVersion",
+            "status",
+            "data",
+            "effects",
+            "diagnostics",
+            "nextActions",
+        ],
+        properties: {
+            kibiProtocol: { const: 1 },
+            operation: { const: spec.name },
+            resultVersion: { const: resultVersion },
+            status: { enum: ["success", "committed_with_repairs", "error"] },
+            data,
+            effects: {
+                type: "array",
+                minItems: spec.effects.length,
+                items: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["kind", "status"],
+                    properties: {
+                        kind: { type: "string" },
+                        status: { enum: ["completed", "failed", "not_applicable"] },
+                        detail: {},
+                        errorCode: { type: "string" },
+                    },
+                },
+            },
+            diagnostics: {
+                type: "array",
+                items: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["message"],
+                    properties: {
+                        code: { type: "string" },
+                        severity: { enum: ["info", "warning", "error"] },
+                        message: { type: "string" },
+                        detail: {},
+                        category: { type: "string" },
+                        suggestion: { type: "string" },
+                        file: { type: "string" },
+                    },
+                },
+            },
+            nextActions: {
+                type: "array",
+                items: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["operation", "reason", "required"],
+                    properties: {
+                        operation: { type: "string" },
+                        input: {},
+                        reason: { type: "string" },
+                        required: { type: "boolean" },
+                    },
+                },
+            },
+            error: {
+                type: "object",
+                additionalProperties: false,
+                required: ["code", "message", "retryable"],
+                properties: {
+                    code: { type: "string" },
+                    message: { type: "string" },
+                    retryable: { type: "boolean" },
+                    details: {},
+                },
+            },
+        },
+    };
+}
+export function withContractDefaults(spec) {
+    const resultVersion = spec.resultVersion ?? `kibi.${spec.name}.v1`;
+    // Resolve the generated contract on the canonical spec object itself. The
+    // implementation loader and the public catalog must share one identity so
+    // adapters cannot accidentally execute an uncontracted compatibility copy.
+    const resolved = spec;
+    if (resolved.resultVersion === undefined) {
+        Object.defineProperty(resolved, "resultVersion", {
+            value: resultVersion,
+            enumerable: true,
+            configurable: false,
+            writable: false,
+        });
+    }
+    if (resolved.outputSchema === undefined) {
+        Object.defineProperty(resolved, "outputSchema", {
+            value: envelopeSchema(spec, resultVersion),
+            enumerable: true,
+            configurable: false,
+            writable: false,
+        });
+    }
+    if (resolved.declaredEffects === undefined) {
+        Object.defineProperty(resolved, "declaredEffects", {
+            value: declaredEffects(spec.name, spec.effects),
+            enumerable: true,
+            configurable: false,
+            writable: false,
+        });
+    }
+    return resolved;
+}
+const SPECS_BY_NAME = new Map(OPERATION_CATALOG.map((spec) => [spec.name, withContractDefaults(spec)]));
 // implements REQ-kibi-operation-interface-parity
 export function getSpec(name) {
     const spec = SPECS_BY_NAME.get(name);
@@ -38,5 +160,5 @@ export function getSpec(name) {
 }
 // implements REQ-kibi-operation-interface-parity
 export function listSpecs() {
-    return OPERATION_CATALOG;
+    return OPERATION_CATALOG.map(withContractDefaults);
 }

package/dist/public/operations/check-executor.d.ts

@@ -1,5 +1,5 @@
 import { type CheckDiagnostic, type CheckStructuredContent, buildStructuredContent, buildSummary } from "./check-format-shared.js";
-import { getEffectiveRules, loadChecksConfig } from "./check-helpers.js";
+import { getEffectiveRules, resolveCheckRules } from "./check-helpers.js";
 import type { OperationContext } from "./runtime-types.js";
 import type { OperationResult } from "./types.js";
 export type CheckInput = {
@@ -13,7 +13,7 @@ export type CheckInput = {
 };
 export type CheckPayload = CheckStructuredContent;
 export type { CheckDiagnostic, CheckStructuredContent };
-export { buildStructuredContent, buildSummary, getEffectiveRules, loadChecksConfig, };
+export { buildStructuredContent, buildSummary, getEffectiveRules, resolveCheckRules, };
 export type CheckExecutionOptions = {
     readonly collectFullQualityDiagnosticsForExplicitRules?: boolean;
 };

package/dist/public/operations/check-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-executor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-executor.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,sBAAsB,EACtB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAGL,iBAAiB,EACjB,gBAAgB,EAEjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAClD,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,CAAC;AACxD,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,GACjB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,6CAA6C,CAAC,EAAE,OAAO,CAAC;CAClE,CAAC;AAcF,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAgHxC"}
+{"version":3,"file":"check-executor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-executor.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,sBAAsB,EACtB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAGL,iBAAiB,EAGjB,iBAAiB,EAClB,MAAM,oBAAoB,CAAC;AAO5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAEvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAClD,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,CAAC;AACxD,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,GAClB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,6CAA6C,CAAC,EAAE,OAAO,CAAC;CAClE,CAAC;AAqDF,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAuJxC"}

package/dist/public/operations/check-executor.js

@@ -1,8 +1,12 @@
 import { runAggregatedChecks } from "../../commands/aggregated-checks.js";
 import { collectFullKbQualityDiagnostics } from "../impact-diagnostics.js";
 import { buildStructuredContent, buildSummary, } from "./check-format-shared.js";
-import { analyzeKbCheckImpact, collectQueryPlanSafetyViolations, getEffectiveRules, loadChecksConfig, qualityDiagnosticsFromImpact, } from "./check-helpers.js";
-export { buildStructuredContent, buildSummary, getEffectiveRules, loadChecksConfig, };
+import { analyzeKbCheckImpact, collectQueryPlanSafetyViolations, getEffectiveRules, partitionCheckFindings, qualityDiagnosticsFromImpact, resolveCheckRules, } from "./check-helpers.js";
+import { executeStatus } from "./discovery-executors.js";
+import { buildActionsFromCheck, buildMigrationPlan, mergeMigrationPlans, } from "./migration-plan.js";
+import { collectSourceRelationshipParityViolations } from "./source-relationship-parity.js";
+import { readWorkspaceSnapshot } from "./workspace-snapshot.js";
+export { buildStructuredContent, buildSummary, getEffectiveRules, resolveCheckRules, };
 function requireProlog(context) {
     if (context.prolog === undefined) {
         throw new Error("Check operation requires a Prolog runtime");
@@ -12,17 +16,49 @@ function requireProlog(context) {
 function invalidatePrologCache(prolog) {
     prolog.invalidateCache?.();
 }
+async function migrationPlanForCheck(context, violations, qualityDiagnostics, statusPlan) {
+    const checkPlan = buildMigrationPlan({
+        expected: {
+            branch: context.branchAttachment?.gitBranch ?? null,
+            kbBranch: context.branchAttachment?.kbBranch ?? null,
+        },
+        evaluatedDomains: ["quality"],
+        actions: buildActionsFromCheck({
+            violations: violations,
+            qualityDiagnostics,
+        }),
+    });
+    return statusPlan ? mergeMigrationPlans([statusPlan, checkPlan]) : checkPlan;
+}
+async function readStatusMigrationPlan(context) {
+    try {
+        const statusResult = await executeStatus({}, context);
+        return statusResult.structuredContent?.migrationPlan;
+    }
+    catch (error) {
+        // A check can still provide a complete quality-domain plan in a detached
+        // or synthetic workspace used by an agent/test harness. Status remains a
+        // separately actionable domain; preserve the check result rather than
+        // turning a missing Git attachment into a check failure.
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("Failed to resolve active branch"))
+            return undefined;
+        throw error;
+    }
+}
 // implements REQ-kibi-operation-interface-parity, REQ-002
 export async function executeCheck(args, context, options = {}) {
     try {
         const workspaceRoot = args.workspaceRoot ?? context.workspaceRoot;
         const prolog = requireProlog(context);
-        const checksConfig = await loadChecksConfig(workspaceRoot);
-        const rulesAllowlist = args.rules === undefined
-            ? getEffectiveRules(checksConfig.rules)
-            : args.rules.length === 0
-                ? new Set()
-                : getEffectiveRules(undefined, args.rules.join(","));
+        const snapshotEvidence = await readWorkspaceSnapshot(context);
+        const verificationSnapshot = snapshotEvidence.available
+            ? snapshotEvidence.snapshot.hash
+            : undefined;
+        const checkedAt = context.clock().toISOString();
+        // Enforcement policy is Kibi-owned and deterministic from the installed
+        // version. `args.rules` is an invocation-time diagnostic selector only.
+        const rulesAllowlist = resolveCheckRules(args);
         const hasExplicitRules = args.rules !== undefined;
         const impactResult = analyzeKbCheckImpact(workspaceRoot, args);
         const impactQualityDiagnostics = qualityDiagnosticsFromImpact(impactResult);
@@ -38,9 +74,15 @@ export async function executeCheck(args, context, options = {}) {
                     : await collectFullKbQualityDiagnostics({
                         prolog,
                         workspaceRoot,
+                        ...(verificationSnapshot !== undefined
+                            ? { verificationSnapshot }
+                            : {}),
+                        checkedAt,
                         now: context.clock(),
                         ...maxDiagnosticsOption,
                     });
+            const statusPlan = await readStatusMigrationPlan(context);
+            const migrationPlan = await migrationPlanForCheck(context, [], qualityDiagnostics, statusPlan);
             return {
                 content: [
                     {
@@ -57,18 +99,24 @@ export async function executeCheck(args, context, options = {}) {
                     diagnostics: [],
                     qualityDiagnostics,
                     impactResult,
+                    migrationPlan,
                 }),
             };
         }
         invalidatePrologCache(prolog);
-        const aggregatedViolations = await runAggregatedChecks(prolog, rulesAllowlist, checksConfig.symbolTraceability.requireAdr);
+        const aggregatedFindings = await runAggregatedChecks(prolog, rulesAllowlist);
         const queryPlanViolations = rulesAllowlist.has("query-plan-safety")
             ? collectQueryPlanSafetyViolations()
             : [];
-        const violations = [
-            ...aggregatedViolations,
+        const sourceRelationshipParityViolations = rulesAllowlist.has("source-relationship-parity")
+            ? await collectSourceRelationshipParityViolations(workspaceRoot, prolog)
+            : [];
+        const partitioned = partitionCheckFindings([
+            ...aggregatedFindings,
             ...queryPlanViolations,
-        ];
+            ...sourceRelationshipParityViolations,
+        ]);
+        const violations = partitioned.violations;
         const diagnostics = violations.map((v) => ({
             category: "SYNC_ERROR",
             severity: "error",
@@ -78,7 +126,7 @@ export async function executeCheck(args, context, options = {}) {
         }));
         const collectFullQualityDiagnostics = !hasExplicitRules ||
             options.collectFullQualityDiagnosticsForExplicitRules === true;
-        const qualityDiagnostics = !collectFullQualityDiagnostics
+        const extraQualityDiagnostics = !collectFullQualityDiagnostics
             ? impactQualityDiagnostics
             : impactResult
                 ? impactQualityDiagnostics
@@ -86,9 +134,19 @@ export async function executeCheck(args, context, options = {}) {
                     prolog,
                     hardViolationEntityIds: new Set(violations.map((v) => v.entityId)),
                     workspaceRoot,
+                    ...(verificationSnapshot !== undefined
+                        ? { verificationSnapshot }
+                        : {}),
+                    checkedAt,
                     now: context.clock(),
                     ...maxDiagnosticsOption,
                 });
+        const qualityDiagnostics = [
+            ...partitioned.qualityDiagnostics,
+            ...extraQualityDiagnostics,
+        ];
+        const statusPlan = await readStatusMigrationPlan(context);
+        const migrationPlan = await migrationPlanForCheck(context, violations, qualityDiagnostics, statusPlan);
         return {
             content: [
                 {
@@ -105,6 +163,7 @@ export async function executeCheck(args, context, options = {}) {
                 diagnostics,
                 qualityDiagnostics,
                 impactResult,
+                migrationPlan,
             }),
         };
     }

package/dist/public/operations/check-format-shared.d.ts

@@ -1,6 +1,7 @@
 import type { Violation } from "../check-types.js";
 import type { ChangedFileImpactResult } from "../impact-diagnostics.js";
 import type { QualityDiagnostic } from "../impact-diagnostics.js";
+import type { MigrationPlan } from "./migration-plan.js";
 export interface CheckDiagnostic {
     readonly category: string;
     readonly severity: "error" | "warning";
@@ -18,6 +19,7 @@ export interface CheckStructuredContent {
     readonly extractedSymbols?: ChangedFileImpactResult["extractedSymbols"];
     readonly linkedEntities?: ChangedFileImpactResult["linkedEntities"];
     readonly nextActions?: ChangedFileImpactResult["nextActions"];
+    readonly migrationPlan?: MigrationPlan;
 }
 export declare function formatImpactText(impactResult: ChangedFileImpactResult): string;
 export declare function formatQualityDiagnosticsText(diagnostics: readonly QualityDiagnostic[]): string;
@@ -27,6 +29,7 @@ export declare function buildStructuredContent(input: {
     diagnostics: readonly CheckDiagnostic[];
     qualityDiagnostics?: readonly QualityDiagnostic[];
     impactResult: ChangedFileImpactResult | undefined;
+    migrationPlan?: MigrationPlan;
 }): CheckStructuredContent;
 export declare function buildSummary(input: {
     readonly violations: readonly Violation[];

package/dist/public/operations/check-format-shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-format-shared.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-format-shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAkBnD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAGD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,SAAS,eAAe,EAAE,CAAC;IACjD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC3D,QAAQ,CAAC,iBAAiB,CAAC,EAAE,uBAAuB,CAAC,mBAAmB,CAAC,CAAC;IAC1E,QAAQ,CAAC,WAAW,CAAC,EAAE,uBAAuB,CAAC,aAAa,CAAC,CAAC;IAC9D,QAAQ,CAAC,gBAAgB,CAAC,EAAE,uBAAuB,CAAC,kBAAkB,CAAC,CAAC;IACxE,QAAQ,CAAC,cAAc,CAAC,EAAE,uBAAuB,CAAC,gBAAgB,CAAC,CAAC;IACpE,QAAQ,CAAC,WAAW,CAAC,EAAE,uBAAuB,CAAC,aAAa,CAAC,CAAC;CAC/D;AAaD,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,uBAAuB,GACpC,MAAM,CAaR;AAaD,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,SAAS,iBAAiB,EAAE,GACxC,MAAM,CA4BR;AAGD,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAmB5E;AAGD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IACjC,WAAW,EAAE,SAAS,eAAe,EAAE,CAAC;IACxC,kBAAkB,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAClD,YAAY,EAAE,uBAAuB,GAAG,SAAS,CAAC;CACnD,GAAG,sBAAsB,CAmBzB;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAClC,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,YAAY,EAAE,uBAAuB,GAAG,SAAS,CAAC;IAC3D,QAAQ,CAAC,kBAAkB,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC3D,GAAG,MAAM,CAST"}
+{"version":3,"file":"check-format-shared.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-format-shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAkBnD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAGD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,SAAS,eAAe,EAAE,CAAC;IACjD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC3D,QAAQ,CAAC,iBAAiB,CAAC,EAAE,uBAAuB,CAAC,mBAAmB,CAAC,CAAC;IAC1E,QAAQ,CAAC,WAAW,CAAC,EAAE,uBAAuB,CAAC,aAAa,CAAC,CAAC;IAC9D,QAAQ,CAAC,gBAAgB,CAAC,EAAE,uBAAuB,CAAC,kBAAkB,CAAC,CAAC;IACxE,QAAQ,CAAC,cAAc,CAAC,EAAE,uBAAuB,CAAC,gBAAgB,CAAC,CAAC;IACpE,QAAQ,CAAC,WAAW,CAAC,EAAE,uBAAuB,CAAC,aAAa,CAAC,CAAC;IAC9D,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;CACxC;AAaD,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,uBAAuB,GACpC,MAAM,CAaR;AAaD,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,SAAS,iBAAiB,EAAE,GACxC,MAAM,CA4BR;AAGD,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAmB5E;AAGD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IACjC,WAAW,EAAE,SAAS,eAAe,EAAE,CAAC;IACxC,kBAAkB,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAClD,YAAY,EAAE,uBAAuB,GAAG,SAAS,CAAC;IAClD,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B,GAAG,sBAAsB,CAsBzB;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAClC,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,YAAY,EAAE,uBAAuB,GAAG,SAAS,CAAC;IAC3D,QAAQ,CAAC,kBAAkB,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC3D,GAAG,MAAM,CAST"}

package/dist/public/operations/check-format-shared.js

@@ -92,6 +92,9 @@ export function buildStructuredContent(input) {
                 nextActions: input.impactResult.nextActions,
             }
             : {}),
+        ...(input.migrationPlan !== undefined
+            ? { migrationPlan: input.migrationPlan }
+            : {}),
     };
 }
 // implements REQ-mcp-tool-check

package/dist/public/operations/check-helpers.d.ts

@@ -1,9 +1,34 @@
-import { type ChecksConfig, RULE_NAMES, type Violation, getEffectiveRules } from "../../utils/rule-registry.js";
+import { RULE_NAMES, type Violation, getEffectiveRules } from "../../utils/rule-registry.js";
 import { type ChangedFileImpactResult, type QualityDiagnostic } from "../impact-diagnostics.js";
 import type { CheckInput } from "./check-executor.js";
 export { RULE_NAMES, getEffectiveRules };
+/**
+ * Split Prolog/check findings by enforcement class so advisory and
+ * migration results cannot gate canonical health.
+ *
+ * Canonical findings stay in `violations` (blocking). Advisory findings
+ * always become non-blocking quality diagnostics. Migration findings are
+ * also non-blocking and only appear when that rule was selected to run.
+ */
+export declare function partitionCheckFindings(findings: readonly Violation[]): {
+    violations: Violation[];
+    qualityDiagnostics: QualityDiagnostic[];
+};
 export declare function collectQueryPlanSafetyViolations(): Violation[];
-export declare function loadChecksConfig(workspaceRoot: string): Promise<ChecksConfig>;
+/**
+ * Resolve the rules for one check invocation.
+ *
+ * Enforcement policy is Kibi-owned: repositories cannot disable canonical
+ * checks. `args.rules` is an invocation-time diagnostic selector that never
+ * persists and never redefines project health.
+ */
+export declare function resolveCheckRules(args: Pick<CheckInput, "rules">): Set<string>;
+/**
+ * Read whether the workspace still carries a legacy `.kb/config.json`.
+ * Retained only so check summaries can point operators at migration; the
+ * document never alters rule selection.
+ */
+export declare function readLegacyChecksHint(workspaceRoot: string): Promise<string | null>;
 export declare function hasImpactOptions(args: CheckInput): boolean;
 export declare function analyzeKbCheckImpact(workspaceRoot: string, args: CheckInput): ChangedFileImpactResult | undefined;
 export declare function qualityDiagnosticsFromImpact(impactResult: ChangedFileImpactResult | undefined): readonly QualityDiagnostic[];

package/dist/public/operations/check-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-helpers.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-helpers.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,KAAK,YAAY,EAEjB,UAAU,EACV,KAAK,SAAS,EACd,iBAAiB,EAClB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EAEvB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC;AAQzC,wBAAgB,gCAAgC,IAAI,SAAS,EAAE,CAU9D;AAGD,wBAAsB,gBAAgB,CACpC,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,YAAY,CAAC,CAkCvB;AAGD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAO1D;AAGD,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,UAAU,GACf,uBAAuB,GAAG,SAAS,CAoBrC;AAGD,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,uBAAuB,GAAG,SAAS,GAChD,SAAS,iBAAiB,EAAE,CAK9B"}
+{"version":3,"file":"check-helpers.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-helpers.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,UAAU,EACV,KAAK,SAAS,EACd,iBAAiB,EAGlB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EAEvB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC;AAEzC;;;;;;;GAOG;AAEH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,GAAG;IACtE,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;CACzC,CA0BA;AAQD,wBAAgB,gCAAgC,IAAI,SAAS,EAAE,CAU9D;AAED;;;;;;GAMG;AAEH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,GAC9B,GAAG,CAAC,MAAM,CAAC,CAQb;AAED;;;;GAIG;AAEH,wBAAsB,oBAAoB,CACxC,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAQxB;AAGD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAO1D;AAGD,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,UAAU,GACf,uBAAuB,GAAG,SAAS,CAoBrC;AAGD,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,uBAAuB,GAAG,SAAS,GAChD,SAAS,iBAAiB,EAAE,CAK9B"}

package/dist/public/operations/check-helpers.js

@@ -1,4 +1,6 @@
 import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
 /*
  Kibi — repo-local, per-branch, queryable long-term memory for software projects
  Copyright (C) 2026 Piotr Franczyk
@@ -16,14 +18,45 @@ import { readFileSync } from "node:fs";
  You should have received a copy of the GNU Affero General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-import { readFile } from "node:fs/promises";
-import path from "node:path";
 import { getKbPlPathOverride } from "../../env.js";
 import { resolveKbPlPath } from "../../prolog.js";
 import { analyzePrologQueryPlanSafety } from "../../utils/prolog-query-plan-safety.js";
-import { DEFAULT_CHECKS_CONFIG, RULE_NAMES, getEffectiveRules, } from "../../utils/rule-registry.js";
+import { RULE_NAMES, getEffectiveRules, getRuleDefinition, getRuleEnforcementClass, } from "../../utils/rule-registry.js";
 import { analyzeChangedFileImpact, } from "../impact-diagnostics.js";
 export { RULE_NAMES, getEffectiveRules };
+/**
+ * Split Prolog/check findings by enforcement class so advisory and
+ * migration results cannot gate canonical health.
+ *
+ * Canonical findings stay in `violations` (blocking). Advisory findings
+ * always become non-blocking quality diagnostics. Migration findings are
+ * also non-blocking and only appear when that rule was selected to run.
+ */
+// implements REQ-cli-check, REQ-mcp-tool-check
+export function partitionCheckFindings(findings) {
+    const violations = [];
+    const qualityDiagnostics = [];
+    for (const finding of findings) {
+        const enforcement = getRuleEnforcementClass(finding.rule) ?? "canonical";
+        if (enforcement === "canonical") {
+            violations.push(finding);
+            continue;
+        }
+        const definition = getRuleDefinition(finding.rule);
+        qualityDiagnostics.push({
+            id: `rule.${finding.rule}`,
+            severity: "warning",
+            blocking: false,
+            category: definition?.category ?? "integrity",
+            ...(finding.entityId !== undefined ? { entityId: finding.entityId } : {}),
+            ...(finding.source !== undefined ? { source: finding.source } : {}),
+            message: finding.description,
+            suggestion: finding.suggestion ?? "",
+            ...(finding.evidence !== undefined ? { evidence: finding.evidence } : {}),
+        });
+    }
+    return { violations, qualityDiagnostics };
+}
 function resolveChecksPlPath() {
     const override = getKbPlPathOverride();
     return path.join(path.dirname(override ?? resolveKbPlPath()), "checks.pl");
@@ -40,35 +73,38 @@ export function collectQueryPlanSafetyViolations() {
         source: `${checksPlPath}:${v.line}`,
     }));
 }
+/**
+ * Resolve the rules for one check invocation.
+ *
+ * Enforcement policy is Kibi-owned: repositories cannot disable canonical
+ * checks. `args.rules` is an invocation-time diagnostic selector that never
+ * persists and never redefines project health.
+ */
+// implements REQ-mcp-tool-check
+export function resolveCheckRules(args) {
+    if (args.rules === undefined) {
+        return getEffectiveRules();
+    }
+    if (args.rules.length === 0) {
+        return new Set();
+    }
+    return getEffectiveRules(args.rules);
+}
+/**
+ * Read whether the workspace still carries a legacy `.kb/config.json`.
+ * Retained only so check summaries can point operators at migration; the
+ * document never alters rule selection.
+ */
 // implements REQ-mcp-tool-check
-export async function loadChecksConfig(workspaceRoot) {
+export async function readLegacyChecksHint(workspaceRoot) {
     const configPath = path.join(workspaceRoot, ".kb", "config.json");
     try {
-        const content = await readFile(configPath, "utf8");
-        const parsed = JSON.parse(content);
-        const parsedRules = parsed.checks?.rules;
-        const normalizedRules = {
-            ...DEFAULT_CHECKS_CONFIG.rules,
-        };
-        if (parsedRules && typeof parsedRules === "object") {
-            for (const [key, value] of Object.entries(parsedRules)) {
-                if (typeof value === "boolean") {
-                    normalizedRules[key] = value;
-                }
-            }
-        }
-        const parsedSt = parsed.checks?.symbolTraceability;
-        const normalizedSt = { ...DEFAULT_CHECKS_CONFIG.symbolTraceability };
-        if (parsedSt &&
-            typeof parsedSt === "object" &&
-            typeof parsedSt.requireAdr === "boolean") {
-            normalizedSt.requireAdr = parsedSt.requireAdr;
-        }
-        return { rules: normalizedRules, symbolTraceability: normalizedSt };
+        await readFile(configPath, "utf8");
     }
     catch {
-        return DEFAULT_CHECKS_CONFIG;
+        return null;
     }
+    return `Legacy ${path.join(".kb", "config.json")} is present. Kibi no longer reads project check or path configuration; run 'kibi migrate' to adopt the canonical .kb/ layout and retire this file.`;
 }
 // implements REQ-mcp-tool-check
 export function hasImpactOptions(args) {

package/dist/public/operations/contracts.d.ts

@@ -0,0 +1,11 @@
+import type { OperationEffect, OperationEffectDeclaration, OperationName } from "./types.js";
+/** A JSON Schema object emitted in the public operation catalog. */
+export type OperationJsonSchema = Readonly<Record<string, unknown>>;
+/**
+ * The data contract is deliberately maintained separately from the operation
+ * implementations.  Every catalog entry therefore has a concrete payload
+ * shape, while nested domain records can still evolve independently.
+ */
+export declare const OPERATION_DATA_SCHEMAS: Readonly<Record<OperationName, OperationJsonSchema>>;
+export declare function declaredEffects(operation: OperationName, effects: readonly OperationEffect[]): readonly OperationEffectDeclaration[];
+//# sourceMappingURL=contracts.d.ts.map

package/dist/public/operations/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../src/public/operations/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,0BAA0B,EAC1B,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB,oEAAoE;AACpE,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAgDpE;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAuO3C,CAAC;AAgDF,wBAAgB,eAAe,CAC7B,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,SAAS,0BAA0B,EAAE,CAsBvC"}