kibi-cli 2.0.0 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
@@ -10,14 +10,7 @@
   "bin": {
     "kibi": "bin/kibi"
   },
-  "files": [
-    "dist",
-    "bin",
-    "schema",
-    "src/schemas",
-    "src/public",
-    "templates"
-  ],
+  "files": ["dist", "bin", "schema", "src/schemas", "src/public", "templates"],
   "scripts": {
     "build": "tsc -p tsconfig.json && rm -rf dist/public/skills && mkdir -p dist/public/skills dist/report && cp -r src/public/skills/. dist/public/skills/ && cp src/report/html-report.css dist/report/html-report.css && node ../../scripts/generate-entity-schema.mjs --check",
     "test": "node ../../scripts/run-owned-engine-tests.mjs -- bun test --timeout 15000 .",
@@ -55,6 +48,10 @@
       "types": "./dist/runtime/cli-runtime.d.ts",
       "default": "./dist/runtime/cli-runtime.js"
     },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.ts",
+      "default": "./dist/plugins/index.js"
+    },
     "./operations/node-ports": {
       "types": "./dist/public/operations/node-ports.d.ts",
       "default": "./dist/public/operations/node-ports.js"
@@ -216,6 +213,10 @@
       "types": "./dist/public/ignore-policy.d.ts",
       "import": "./dist/public/ignore-policy.js",
       "default": "./dist/public/ignore-policy.js"
+    },
+    "./env-bootstrap": {
+      "types": "./dist/env/bootstrap.d.ts",
+      "default": "./dist/env/bootstrap.js"
     }
   },
   "types": "./dist/cli.d.ts",
@@ -226,15 +227,17 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.12.0",
+    "kibi-core": "^0.14.0",
+    "kibi-plugin-builtin": "^0.3.0",
+    "kibi-plugin-sdk": "^0.3.0",
     "saxes": "^6.0.0",
-    "ts-morph": "^23.0.0",
     "ignore": "^5.3.0",
     "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@types/node": "latest",
     "semver": "^7.7.4",
+    "ts-morph": "^23.0.0",
     "typescript": "^5.7.0"
   },
   "license": "AGPL-3.0-or-later",

package/schema/entities.pl

@@ -3,6 +3,7 @@
 :- module(kibi_entities, [entity_type/1, entity_property/3, required_property/2, optional_property/2]).
 
 % Entity types
+% implements REQ-004
 entity_type(req).
 entity_type(scenario).
 entity_type(test).
@@ -20,7 +21,6 @@ entity_property(_, status, atom).
 entity_property(_, created_at, datetime).
 entity_property(_, updated_at, datetime).
 entity_property(_, source, uri).
-entity_property(_, sourceFile, uri).
 
 % Optional properties
 entity_property(_, tags, list).
@@ -29,6 +29,16 @@ entity_property(_, priority, atom).
 entity_property(_, severity, atom).
 entity_property(_, links, list).
 entity_property(_, text_ref, uri).
+entity_property(_, sourceFile, uri).
+entity_property(req, semantic_text, string).
+entity_property(req, logic_claims, list).
+entity_property(req, semantic_clauses, list).
+entity_property(req, semantic_inventory_version, string).
+entity_property(req, semantic_source_field, string).
+entity_property(req, semantic_source_hash, string).
+entity_property(req, semantic_inventory, list_or_json).
+entity_property(req, proof_exempt, boolean).
+entity_property(req, proof_exempt_reason, string).
 
 % Typed fact fields - only valid for fact entities
 entity_property(fact, fact_kind, atom).
@@ -47,10 +57,45 @@ entity_property(fact, closed_world, boolean).
 entity_property(fact, valid_from, datetime).
 entity_property(fact, valid_to, datetime).
 entity_property(fact, canonical_key, string).
+entity_property(fact, claim_key, string).
+entity_property(fact, claim_text, string).
+entity_property(fact, predicate_name, string).
+entity_property(fact, predicate_namespace, string).
+entity_property(fact, predicate_arity, integer).
+entity_property(fact, argument_names, list).
+entity_property(fact, argument_types, list).
+entity_property(fact, argument_descriptions, list).
+% Predicate-schema vocabularies are JSON objects serialized as strings.
+entity_property(fact, argument_constants, string).
+entity_property(fact, argument_aliases, string).
+entity_property(fact, aliases, list).
+entity_property(fact, examples, list).
+entity_property(fact, predicate_args, list).
+entity_property(fact, rule_ir, string).
+entity_property(fact, rule_hash, string).
+% Rule schema references are JSON strings at the public boundary, but the
+% Prolog peer represents entity identifiers as atoms.  Accept both forms so
+% decoded rule facts validate without losing the typed reference.
+entity_property(fact, rule_schema_id, atom_or_string).
+entity_property(fact, rule_name, string).
+entity_property(fact, semantic_key, string).
+entity_property(fact, claim_span_start, integer).
+entity_property(fact, claim_span_end, integer).
 
 % Typed symbol metadata fields - only valid for symbol entities
 entity_property(symbol, symbol_role, atom).
 entity_property(symbol, granularity_reason, atom).
+entity_property(symbol, sourceLine, integer).
+entity_property(symbol, sourceColumn, integer).
+entity_property(symbol, sourceEndLine, integer).
+entity_property(symbol, sourceEndColumn, integer).
+
+% Typed test verification fields - only valid for test entities
+entity_property(test, verification_scope, atom).
+entity_property(test, verification_perspective, atom).
+entity_property(test, proof_contract, list_or_json).
+entity_property(test, proof_bindings, string).
+entity_property(test, proof_receipts, string).
 
 % Required properties for all entity types
 required_property(Type, id) :- entity_type(Type).
@@ -67,6 +112,20 @@ optional_property(Type, priority) :- entity_type(Type).
 optional_property(Type, severity) :- entity_type(Type).
 optional_property(Type, links) :- entity_type(Type).
 optional_property(Type, text_ref) :- entity_type(Type).
+optional_property(req, semantic_text).
+optional_property(req, logic_claims).
+optional_property(req, semantic_clauses).
+optional_property(req, semantic_inventory_version).
+optional_property(req, semantic_source_field).
+optional_property(req, semantic_source_hash).
+optional_property(req, semantic_inventory).
+optional_property(req, proof_exempt).
+optional_property(req, proof_exempt_reason).
+optional_property(test, verification_scope).
+optional_property(test, verification_perspective).
+optional_property(test, proof_contract).
+optional_property(test, proof_bindings).
+optional_property(test, proof_receipts).
 
 % Documentation helpers
 % list all entity types

package/schema/relationships.pl

@@ -3,32 +3,36 @@
 :- module(kibi_relationships, [relationship_type/1, valid_relationship/3, relationship_metadata/1]).
 
 % Relationship types
+% implements REQ-005
 relationship_type(depends_on).
+relationship_type(executable_for).
 relationship_type(specified_by).
 relationship_type(verified_by).
 relationship_type(validates).
 relationship_type(implements).
 relationship_type(covered_by).
-relationship_type(executable_for).
 relationship_type(constrained_by).
 relationship_type(guards).
 relationship_type(publishes).
 relationship_type(consumes).
 relationship_type(relates_to).
 relationship_type(supersedes).
+relationship_type(restates).
 relationship_type(constrains).
 relationship_type(requires_property).
+relationship_type(requires_predicate).
+relationship_type(requires_rule).
 
 % valid_relationship(RelType, FromType, ToType).
 valid_relationship(depends_on, req, req).
+valid_relationship(executable_for, symbol, test).
 valid_relationship(specified_by, req, scenario).
 valid_relationship(verified_by, req, test).
+valid_relationship(verified_by, scenario, test).
 valid_relationship(validates, test, req).
+valid_relationship(validates, test, scenario).
 valid_relationship(implements, symbol, req).
 valid_relationship(covered_by, symbol, test).
-valid_relationship(executable_for, symbol, test).
-valid_relationship(verified_by, scenario, test).
-valid_relationship(validates, test, scenario).
 valid_relationship(constrained_by, symbol, adr).
 % guards can target symbol, event, or req
 valid_relationship(guards, flag, symbol).
@@ -38,12 +42,21 @@ valid_relationship(publishes, symbol, event).
 valid_relationship(consumes, symbol, event).
 valid_relationship(constrains, req, fact).
 valid_relationship(requires_property, req, fact).
+valid_relationship(requires_predicate, req, fact).
+valid_relationship(requires_rule, req, fact).
 
 %% supersedes(+NewAdrId, +OldAdrId)
 %% NewAdrId is the decision that replaces OldAdrId.
 %% OldAdrId's status should be archived or deprecated as a consequence.
 valid_relationship(supersedes, adr, adr).
 valid_relationship(supersedes, req, req).
+
+%% restates(+ReqId, +OtherReqId)
+%% ReqId intentionally restates OtherReqId (for example a product requirement
+%% echoed in a platform requirement). Both stay current; the pair is exempt
+%% from domain-redundancy. Use supersedes when one replaces the other.
+% implements REQ-kibi-restates-relationship
+valid_relationship(restates, req, req).
 % escape hatch - allow any to any
 valid_relationship(relates_to, _, _).
 

package/schema/validation.pl

@@ -42,8 +42,10 @@ validate_property_type(Type, Prop, Value) :-
 % check_kind(Kind, Value) succeeds if Value matches Kind
 check_kind(atom, V) :- atom(V).
 check_kind(string, V) :- string(V).
+check_kind(atom_or_string, V) :- atom(V) ; string(V).
 check_kind(datetime, V) :- string(V). % accept ISO strings for now
 check_kind(list, V) :- is_list(V).
+check_kind(list_or_json, V) :- is_list(V) ; string(V) ; atom(V).
 check_kind(uri, V) :- string(V).
 check_kind(integer, V) :- integer(V).
 check_kind(number, V) :- number(V).
@@ -59,11 +61,24 @@ validate_entity_shape(fact, Props) :-
     !,
     valid_optional_fact_enums(Props),
     valid_polarity_in_props(Props),
+    valid_claim_provenance(Props),
     ( memberchk(fact_kind=RawKind, Props) -> validate_fact_shape(RawKind, Props) ; true ).
+validate_entity_shape(test, Props) :-
+    !,
+    valid_optional_test_enums(Props),
+    forall(member(Key=_, Props), \+ is_fact_only_field(Key)).
+validate_entity_shape(req, Props) :-
+    !,
+    forall(member(Key=_, Props), \+ is_fact_only_field(Key)),
+    forall(member(Key=_, Props), \+ is_test_only_field(Key)).
 validate_entity_shape(Type, Props) :-
     Type \= fact,
-    % Non-fact entities cannot have fact-only fields
-    forall(member(Key=_Val, Props), \+ is_fact_only_field(Key)).
+    Type \= test,
+    Type \= req,
+    % Non-fact/non-test entities cannot have type-specific fields
+    forall(member(Key=_, Props), \+ is_fact_only_field(Key)),
+    forall(member(Key=_, Props), \+ is_test_only_field(Key)),
+    forall(member(Key=_, Props), Key \= logic_claims).
 
 % is_fact_only_field(+Key) - true if Key is a fact-specific field
 is_fact_only_field(fact_kind).
@@ -82,12 +97,39 @@ is_fact_only_field(closed_world).
 is_fact_only_field(valid_from).
 is_fact_only_field(valid_to).
 is_fact_only_field(canonical_key).
+is_fact_only_field(claim_key).
+is_fact_only_field(claim_text).
+is_fact_only_field(predicate_name).
+is_fact_only_field(predicate_namespace).
+is_fact_only_field(predicate_arity).
+is_fact_only_field(argument_names).
+is_fact_only_field(argument_types).
+is_fact_only_field(argument_descriptions).
+is_fact_only_field(argument_constants).
+is_fact_only_field(argument_aliases).
+is_fact_only_field(aliases).
+is_fact_only_field(examples).
+is_fact_only_field(predicate_args).
+is_fact_only_field(rule_ir).
+is_fact_only_field(rule_hash).
+is_fact_only_field(rule_schema_id).
+is_fact_only_field(rule_name).
+is_fact_only_field(semantic_key).
+is_fact_only_field(claim_span_start).
+is_fact_only_field(claim_span_end).
+
+% is_test_only_field(+Key) - true if Key is a test-specific field
+is_test_only_field(verification_scope).
+is_test_only_field(verification_perspective).
+is_test_only_field(proof_contract).
+is_test_only_field(proof_bindings).
+is_test_only_field(proof_receipts).
 
 % validate_fact_shape(+Kind, +Props)
 validate_fact_shape(subject, Props) :-
     memberchk(subject_key=_Val, Props),
     valid_optional_fact_enums(Props),
-    valid_polarity_in_props(Props).
+    valid_strict_polarity_in_props(Props), !.
 validate_fact_shape(property_value, Props) :-
     memberchk(subject_key=_Subject, Props),
     memberchk(property_key=_Property, Props),
@@ -98,48 +140,104 @@ validate_fact_shape(property_value, Props) :-
     exactly_one_value_field(Props),
     value_type_matches_field(VT, Props),
     valid_optional_fact_enums(Props),
-    valid_polarity_in_props(Props).
+    valid_strict_polarity_in_props(Props), !.
 validate_fact_shape(observation, Props) :-
-    % Observation facts are allowed but don't require full strict property tuple yet
     valid_optional_fact_enums(Props),
-    valid_polarity_in_props(Props).
+    valid_polarity_in_props(Props), !.
 validate_fact_shape(meta, Props) :-
     % Meta facts are allowed but don't require full strict property tuple yet
     valid_optional_fact_enums(Props),
-    valid_polarity_in_props(Props).
+    valid_polarity_in_props(Props), !.
+validate_fact_shape(predicate_schema, Props) :-
+    memberchk(predicate_name=_Name, Props),
+    memberchk(predicate_arity=Arity, Props),
+    Arity >= 1,
+    memberchk(argument_names=ArgumentNames, Props),
+    memberchk(argument_types=ArgumentTypes, Props),
+    same_length(ArgumentNames, ArgumentTypes),
+    length(ArgumentNames, Arity),
+    valid_optional_fact_enums(Props),
+    valid_polarity_in_props(Props), !.
+validate_fact_shape(predicate, Props) :-
+    memberchk(predicate_name=_Name, Props),
+    memberchk(predicate_args=Args, Props),
+    Args \= [],
+    memberchk(canonical_key=_CanonicalKey, Props),
+    valid_optional_fact_enums(Props),
+    valid_predicate_polarity_in_props(Props), !.
+validate_fact_shape(rule_schema, Props) :-
+    memberchk(rule_name=_Name, Props),
+    memberchk(argument_names=ArgumentNames, Props),
+    memberchk(argument_types=ArgumentTypes, Props),
+    same_length(ArgumentNames, ArgumentTypes),
+    valid_optional_fact_enums(Props),
+    valid_polarity_in_props(Props), !.
+validate_fact_shape(rule, Props) :-
+    memberchk(rule_ir=RuleIr, Props),
+    nonempty_claim_value(RuleIr),
+    memberchk(rule_hash=_Hash, Props),
+    memberchk(rule_schema_id=_SchemaId, Props),
+    memberchk(semantic_key=_SemanticKey, Props),
+    valid_optional_fact_enums(Props),
+    valid_polarity_in_props(Props), !.
 validate_fact_shape(Kind, _Props) :-
     % Unknown fact_kind values fail validation
-    \+ memberchk(Kind, [subject, property_value, observation, meta]),
+    \+ memberchk(Kind, [subject, property_value, observation, meta, predicate_schema, predicate, rule_schema, rule]),
     fail.
 
 % valid_operator(+Op)
-valid_operator(eq).
-valid_operator(neq).
-valid_operator(lt).
-valid_operator(lte).
-valid_operator(gt).
-valid_operator(gte).
+valid_operator(Op) :- memberchk(Op, [eq, neq, lt, lte, gt, gte]), !.
 
 % valid_value_type(+VT)
-valid_value_type(string).
-valid_value_type(int).
-valid_value_type(number).
-valid_value_type(bool).
+valid_value_type(ValueType) :- memberchk(ValueType, [string, int, number, bool]), !.
 
 % valid_polarity_in_props(+Props)
 % Validates polarity if present; succeeds if no polarity in props
 valid_polarity_in_props(Props) :-
     ( memberchk(polarity=P, Props) -> valid_polarity(P) ; true ).
 
+valid_strict_polarity_in_props(Props) :-
+    ( memberchk(polarity=P, Props) -> valid_strict_polarity(P) ; true ).
+
+valid_predicate_polarity_in_props(Props) :-
+    ( memberchk(polarity=P, Props) -> valid_predicate_polarity(P) ; true ).
+
+% claim_key and claim_text form one auditable provenance pair.
+valid_claim_provenance(Props) :-
+    (   memberchk(claim_key=Key, Props)
+    ->  memberchk(claim_text=Text, Props),
+        nonempty_claim_value(Key),
+        nonempty_claim_value(Text)
+    ;   \+ memberchk(claim_text=_, Props)
+    ).
+
+nonempty_claim_value(Value) :- string(Value), Value \= "", !.
+nonempty_claim_value(Value) :- atom(Value), Value \= '', !.
+
 % valid_optional_fact_enums(+Props)
 % Validates enum-typed fact fields whenever they are present
 valid_optional_fact_enums(Props) :-
     ( memberchk(operator=Op, Props) -> valid_operator(Op) ; true ),
     ( memberchk(value_type=VT, Props) -> valid_value_type(VT) ; true ).
 
+% valid_optional_test_enums(+Props)
+% Validates enum-typed test fields whenever they are present
+valid_optional_test_enums(Props) :-
+    ( memberchk(verification_scope=Scope, Props) -> valid_verification_scope(Scope) ; true ),
+    ( memberchk(verification_perspective=Perspective, Props) -> valid_verification_perspective(Perspective) ; true ).
+
 % valid_polarity(+P)
-valid_polarity(require).
-valid_polarity(forbid).
+valid_polarity(Polarity) :- memberchk(Polarity, [require, forbid, assert, deny]), !.
+
+valid_strict_polarity(Polarity) :- memberchk(Polarity, [require, forbid]), !.
+
+valid_predicate_polarity(Polarity) :- memberchk(Polarity, [assert, deny]), !.
+
+% valid_verification_scope(+Scope)
+valid_verification_scope(Scope) :- memberchk(Scope, [unit, integration, end_to_end]), !.
+
+% valid_verification_perspective(+Perspective)
+valid_verification_perspective(Perspective) :- memberchk(Perspective, [internal, consumer]), !.
 
 % exactly_one_value_field(+Props)
 exactly_one_value_field(Props) :-

package/src/public/diagnostic-usage.ts

@@ -2,6 +2,11 @@ import { createHash, randomUUID } from "node:crypto";
 import { appendFileSync, mkdirSync } from "node:fs";
 import path from "node:path";
 
+import {
+  appendPayloadCountField,
+  normalizeResultPayload,
+} from "./operations/result-envelope.js";
+
 export interface DiagnosticUsageInput {
   readonly workspaceRoot: string;
   readonly tool: string;
@@ -20,16 +25,6 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
-function resultRecord(result: unknown): Record<string, unknown> | undefined {
-  if (!isRecord(result)) return undefined;
-  if (isRecord(result.structuredContent)) return result.structuredContent;
-  // CLI JSON operations return the same versioned KibiResult envelope as MCP
-  // structuredContent.  Unwrap its data before deriving operation-specific
-  // telemetry fields (coverage/proof fields in particular).
-  if (result.kibiProtocol === 1 && isRecord(result.data)) return result.data;
-  return result;
-}
-
 function stringArray(value: unknown): string[] {
   return Array.isArray(value)
     ? value.filter((item): item is string => typeof item === "string")
@@ -188,11 +183,7 @@ export function deriveDiagnosticUsageFields(
     }
   }
 
-  const structured = resultRecord(result);
-  const envelope =
-    isRecord(structured) && structured.kibiProtocol === 1
-      ? structured
-      : undefined;
+  const { envelope, data: structured } = normalizeResultPayload(result);
   if (envelope) {
     fields.protocol_version = envelope.kibiProtocol;
     fields.result_version =
@@ -214,18 +205,19 @@ export function deriveDiagnosticUsageFields(
     fields.unsafe_original_retry = telemetry?.unsafe_original_retry === true;
   }
   if (tool === "kb_query" || tool === "kb_search") {
-    const resultCount = Number(structured?.count ?? 0);
-    fields.result_count = resultCount;
-    fields.zero_results = resultCount === 0;
-    fields.result_summary =
-      resultCount === 0 ? "0 results" : `${resultCount} results`;
+    appendPayloadCountField(fields, "result_count", "results", structured);
+    if (typeof fields.result_count === "number") {
+      fields.zero_results = fields.result_count === 0;
+    }
   }
   if (tool === "kb_check") {
-    const count = Number(structured?.count ?? 0);
-    fields.violation_count = count;
+    appendPayloadCountField(
+      fields,
+      "violation_count",
+      "violations",
+      structured,
+    );
     fields.requested_rules = Array.isArray(args.rules) ? args.rules : [];
-    fields.result_summary =
-      count === 0 ? "0 violations" : `${count} violations`;
   }
   if (tool === "kb_coverage" && structured) {
     appendCoverageFields(fields, args, structured);

package/src/public/extractors/symbols-coordinator.ts

@@ -18,6 +18,7 @@
 
 export {
   analyzeSourceText,
+  analyzeSourceTextWithRegistry,
   enrichSymbolCoordinates,
   type ManifestSymbolEntry,
   type AnalyzeSourceTextOptions,

package/src/public/impact/analyzer.ts

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import type { ExtractedSymbol } from "../../traceability/symbol-extract.js";
-import { extractSymbolsFromStagedFile } from "../../traceability/symbol-extract.js";
+import { extractSymbolsFromStagedFileAsync } from "../../traceability/symbol-extract.js";
 import {
   createSemanticReviewDiagnostics,
   createSymbolGranularityDiagnostics,
@@ -21,9 +21,9 @@ import type {
   ChangedFileImpactResult,
 } from "./types.js";
 
-export function analyzeChangedFileImpact(
+export async function analyzeChangedFileImpact(
   options: ChangedFileImpactOptions,
-): ChangedFileImpactResult {
+): Promise<ChangedFileImpactResult> {
   const workspaceRoot = path.resolve(options.workspaceRoot);
   const sourceChanges = collectSourceChanges({ ...options, workspaceRoot });
   const sourceFiles = uniqueSorted(sourceChanges.map((change) => change.file));
@@ -34,17 +34,20 @@ export function analyzeChangedFileImpact(
 
   for (const change of sourceChanges) {
     sourceContentByFile.set(change.file, change.content);
+    // Maintenance path: builtin-only (do not pass registry / workspaceRoot).
+    const extracted = await extractSymbolsFromStagedFileAsync(
+      {
+        path: change.file,
+        status: change.status,
+        hunkRanges: [...change.hunkRanges],
+        content: change.content,
+      },
+      manifestLookup,
+      {},
+    );
     symbolsByFile.set(
       change.file,
-      extractSymbolsFromStagedFile(
-        {
-          path: change.file,
-          status: change.status,
-          hunkRanges: [...change.hunkRanges],
-          content: change.content,
-        },
-        manifestLookup,
-      ).filter((symbol) => symbol.hunkRanges.length > 0),
+      extracted.filter((symbol) => symbol.hunkRanges.length > 0),
     );
   }
 

package/src/public/impact/full-kb-quality.ts

@@ -568,22 +568,10 @@ export async function loadKbExtractionResults(
       prolog.queryEntities.bind(prolog),
     );
   } else {
-    const entityResult = await prolog.query(
-      "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)",
-    );
-    if (entityResult.success) {
-      entities = entityResult.bindings.Results
-        ? parseListOfLists(entityResult.bindings.Results).map(
-            parseEntityFromList,
-          )
-        : [];
-    } else if (isOutputCapacityError(entityResult.error)) {
-      entities = await loadBoundedEntityProjection(prolog);
-    } else {
-      throw new Error(
-        `Full KB entity projection query failed: ${entityResult.error ?? "Unknown error"}`,
-      );
-    }
+    // Never probe with an unbounded all-entities findall: receipt histories
+    // make that answer grow without limit, and an overflow terminates the
+    // interactive Prolog process that serves every later query.
+    entities = await loadBoundedEntityProjection(prolog);
   }
   const relationships = new Map<string, ExtractionResult["relationships"]>();
 

package/src/public/operations/check-executor.ts

@@ -31,6 +31,7 @@ import {
   partitionCheckFindings,
   qualityDiagnosticsFromImpact,
   resolveCheckRules,
+  stagedEntityIdStyleDiagnostics,
 } from "./check-helpers.js";
 import { executeStatus } from "./discovery-executors.js";
 import {
@@ -38,6 +39,7 @@ import {
   buildMigrationPlan,
   mergeMigrationPlans,
 } from "./migration-plan.js";
+import { collectPredicateSchemaConformanceViolations } from "./predicate-schema-conformance.js";
 import type { OperationContext, PrologPort } from "./runtime-types.js";
 import { collectSourceRelationshipParityViolations } from "./source-relationship-parity.js";
 import type { OperationResult } from "./types.js";
@@ -135,8 +137,11 @@ export async function executeCheck(
     // 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);
+    const impactResult = await analyzeKbCheckImpact(workspaceRoot, args);
+    const impactQualityDiagnostics = [
+      ...qualityDiagnosticsFromImpact(impactResult),
+      ...stagedEntityIdStyleDiagnostics(workspaceRoot, args),
+    ];
     const maxDiagnosticsOption =
       args.maxDiagnostics !== undefined
         ? { maxDiagnostics: args.maxDiagnostics }
@@ -201,10 +206,16 @@ export async function executeCheck(
     )
       ? await collectSourceRelationshipParityViolations(workspaceRoot, prolog)
       : [];
+    const predicateConformanceFindings = rulesAllowlist.has(
+      "predicate-schema-conformance",
+    )
+      ? await collectPredicateSchemaConformanceViolations(prolog)
+      : [];
     const partitioned = partitionCheckFindings([
       ...aggregatedFindings,
       ...queryPlanViolations,
       ...sourceRelationshipParityViolations,
+      ...predicateConformanceFindings,
     ]);
     const violations: Violation[] = partitioned.violations;