kibi-cli 2.14.0 → 2.16.0

package/dist/utils/branch-store.d.ts

@@ -1,3 +1,7 @@
+/** Stale-reason code of a branch store that was never compiled. */
+export declare const BRANCH_STORE_NOT_COMPILED = "branch_store_not_compiled";
+/** The kb_check rule that reports it. */
+export declare const BRANCH_STORE_NOT_COMPILED_RULE = "branch-store-not-compiled";
 export type BranchStoreState = "healthy" | "missing" | "incomplete" | "unreadable";
 export type BranchStoreInspection = Readonly<{
     state: BranchStoreState;
@@ -18,4 +22,32 @@ export declare function inspectBranchStore(workspaceRoot: string, branch: string
  */
 export declare function storeLockJournalReason(storePath: string): Record<string, unknown> | null;
 export declare function branchStoreReason(inspection: BranchStoreInspection): Record<string, unknown> | null;
+/**
+ * The number of authored source files under `.kb/`: entity Markdown in the
+ * entity lanes plus relationship shards. Filesystem only, like
+ * inspectBranchStore, so a status read never compiles anything.
+ */
+export declare function countAuthoredKbSources(workspaceRoot: string): number;
+export type BranchStoreCompilation = Readonly<{
+    /** True once a sync (or any write) has committed into the store. */
+    compiled: boolean;
+    /** The journal CURRENT pointer (`generation-<id>:<sequence>`), if any. */
+    generation: string | null;
+}>;
+/**
+ * Whether the branch store holds a compilation. A missing store holds none;
+ * a journaled store whose CURRENT sequence is still 0 and whose journal holds
+ * no graph data was created (by `kibi branch ensure` or by an engine
+ * attaching to a new branch) but nothing was ever committed into it, so it is
+ * empty. A legacy kb.rdf store counts as compiled.
+ */
+export declare function branchStoreCompilation(inspection: BranchStoreInspection): BranchStoreCompilation;
+/**
+ * The single blocking reason for a branch whose store was never compiled
+ * while `.kb/` holds authored sources: Kibi stores are per branch and never
+ * copied, so a fresh branch (no post-checkout hook) starts empty. Every
+ * check against that store would report each authored relationship as
+ * missing; the one fix is `kibi sync`.
+ */
+export declare function uncompiledBranchStoreReason(workspaceRoot: string, inspection: BranchStoreInspection, branch: string): Record<string, unknown> | null;
 //# sourceMappingURL=branch-store.d.ts.map

package/dist/utils/branch-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"branch-store.d.ts","sourceRoot":"","sources":["../../src/utils/branch-store.ts"],"names":[],"mappings":"AAiBA,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,SAAS,GACT,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC,CAAC;AAEH;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,GACb,qBAAqB,CA0GvB;AAED;;;;GAIG;AAEH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAiBhC;AAED,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,qBAAqB,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAWhC"}
+{"version":3,"file":"branch-store.d.ts","sourceRoot":"","sources":["../../src/utils/branch-store.ts"],"names":[],"mappings":"AAwBA,mEAAmE;AACnE,eAAO,MAAM,yBAAyB,8BAA8B,CAAC;AACrE,yCAAyC;AACzC,eAAO,MAAM,8BAA8B,8BAA8B,CAAC;AAE1E,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,SAAS,GACT,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC,CAAC;AAEH;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,GACb,qBAAqB,CA0GvB;AAED;;;;GAIG;AAEH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAiBhC;AAED,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,qBAAqB,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAWhC;AA6BD;;;;GAIG;AAEH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAOpE;AAED,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC,CAAC;AAEH;;;;;;GAMG;AAEH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,qBAAqB,GAChC,sBAAsB,CAwBxB;AAkBD;;;;;;GAMG;AAEH,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,qBAAqB,EACjC,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAwBhC"}

package/dist/utils/branch-store.js

@@ -2,10 +2,15 @@
  Kibi — repo-local, per-branch, queryable long-term memory for software projects
  Copyright (C) 2026 Piotr Franczyk
 */
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync, } from "node:fs";
 import * as path from "node:path";
 import { classifyStoreLockHolder, readStoreLockOwner, } from "../prolog/store-lock.js";
 import { branchStoreManifestMatches, branchStorePath, legacyBranchStorePath, } from "./branch-store-locator.js";
+import { ENTITY_LANES, KB_ROOT } from "./kb-paths.js";
+/** Stale-reason code of a branch store that was never compiled. */
+export const BRANCH_STORE_NOT_COMPILED = "branch_store_not_compiled";
+/** The kb_check rule that reports it. */
+export const BRANCH_STORE_NOT_COMPILED_RULE = "branch-store-not-compiled";
 /**
  * Performs only filesystem checks. It deliberately never starts the engine or
  * attaches Prolog, so callers can still explain a broken branch store.
@@ -155,3 +160,119 @@ export function branchStoreReason(inspection) {
             : { command_argv: ["kibi", "branch", "ensure"], applyRequired: false },
     };
 }
+/** Directories under .kb/ that hold authored, Git-tracked entity sources. */
+const AUTHORED_SOURCE_DIRECTORIES = [
+    ...ENTITY_LANES.map((lane) => [lane, ".md"]),
+    ["adrs", ".md"],
+    ["relationships", ".yaml"],
+];
+function countFiles(directory, extension) {
+    let count = 0;
+    let entries;
+    try {
+        entries = readdirSync(directory, { withFileTypes: true });
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            count += countFiles(path.join(directory, entry.name), extension);
+        }
+        else if (entry.isFile() && entry.name.endsWith(extension)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+/**
+ * The number of authored source files under `.kb/`: entity Markdown in the
+ * entity lanes plus relationship shards. Filesystem only, like
+ * inspectBranchStore, so a status read never compiles anything.
+ */
+// implements REQ-cli-status-pre-first-sync
+export function countAuthoredKbSources(workspaceRoot) {
+    const kbRoot = path.join(workspaceRoot, KB_ROOT);
+    return AUTHORED_SOURCE_DIRECTORIES.reduce((total, [directory, extension]) => total + countFiles(path.join(kbRoot, directory), extension), 0);
+}
+/**
+ * Whether the branch store holds a compilation. A missing store holds none;
+ * a journaled store whose CURRENT sequence is still 0 and whose journal holds
+ * no graph data was created (by `kibi branch ensure` or by an engine
+ * attaching to a new branch) but nothing was ever committed into it, so it is
+ * empty. A legacy kb.rdf store counts as compiled.
+ */
+// implements REQ-cli-status-pre-first-sync
+export function branchStoreCompilation(inspection) {
+    if (inspection.state === "missing") {
+        return { compiled: false, generation: null };
+    }
+    const currentPath = path.join(inspection.path, "CURRENT");
+    let current = "";
+    try {
+        current = existsSync(currentPath)
+            ? readFileSync(currentPath, "utf8").trim()
+            : "";
+    }
+    catch {
+        current = "";
+    }
+    if (current === "") {
+        // A healthy store without CURRENT is a legacy kb.rdf store.
+        return { compiled: inspection.state === "healthy", generation: null };
+    }
+    const sequence = Number(current.split(":").at(-1));
+    return {
+        compiled: (Number.isFinite(sequence) && sequence > 0) ||
+            journalHoldsGraphData(inspection.path),
+        generation: current,
+    };
+}
+/**
+ * Whether the journal directory holds persisted graph data. An empty store
+ * has only `rdf/lock`; a store migrated from a legacy kb.rdf holds the
+ * imported graph under a fresh `generation-…:0` pointer, so it is compiled
+ * although its sequence is still 0.
+ */
+function journalHoldsGraphData(storePath) {
+    try {
+        return readdirSync(path.join(storePath, "rdf")).some((entry) => entry !== "lock" && !entry.startsWith("."));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The single blocking reason for a branch whose store was never compiled
+ * while `.kb/` holds authored sources: Kibi stores are per branch and never
+ * copied, so a fresh branch (no post-checkout hook) starts empty. Every
+ * check against that store would report each authored relationship as
+ * missing; the one fix is `kibi sync`.
+ */
+// implements REQ-cli-status-pre-first-sync
+export function uncompiledBranchStoreReason(workspaceRoot, inspection, branch) {
+    if (inspection.state !== "healthy" && inspection.state !== "missing") {
+        return null;
+    }
+    const compilation = branchStoreCompilation(inspection);
+    if (compilation.compiled)
+        return null;
+    const authoredSources = countAuthoredKbSources(workspaceRoot);
+    if (authoredSources === 0)
+        return null;
+    const storeState = inspection.state === "missing"
+        ? "does not exist yet"
+        : `is empty (${compilation.generation ?? "no generation"}: nothing compiled)`;
+    return {
+        code: BRANCH_STORE_NOT_COMPILED,
+        path: inspection.path,
+        entityIds: [],
+        detail: `The KB store for branch ${branch} ${storeState}, while .kb/ holds ${authoredSources} authored source file(s). Kibi compiles one store per branch and never copies another branch's, so every query and check reads an empty KB until this branch is compiled.`,
+        remediation: { command_argv: ["kibi", "sync"], applyRequired: false },
+        blocking: true,
+        authoredSources,
+        ...(compilation.generation !== null
+            ? { generation: compilation.generation }
+            : {}),
+    };
+}

package/dist/utils/rule-registry.generated.d.ts

@@ -23,6 +23,11 @@ export declare const GENERATED_RULES: readonly [{
     readonly description: "Authored Markdown and relationship-shard edges must exactly match the compiled KB";
     readonly enforcementClass: "canonical";
     readonly category: "integrity";
+}, {
+    readonly name: "branch-store-not-compiled";
+    readonly description: "The current branch's KB store must be compiled from the authored .kb/ sources; a missing or empty store is reported once, naming kibi sync, instead of every store-backed rule reading an empty KB";
+    readonly enforcementClass: "canonical";
+    readonly category: "integrity";
 }, {
     readonly name: "source-path-dangling";
     readonly description: "An authored entity's source field must name an existing workspace path (a #anchor suffix is ignored), an existing entity id, or an http(s) URL; a missing source is allowed";
@@ -223,5 +228,15 @@ export declare const GENERATED_RULES: readonly [{
     readonly enforcementClass: "advisory";
     readonly category: "lifecycle";
     readonly diagnosticSeverity: "info";
+}, {
+    readonly name: "policy-ownership";
+    readonly description: "When a plugin activated for kibi.check-policy.v1 declares ownership rules, every production symbol in a rule's file set must implement a current requirement grounded (requires_predicate) in one of the rule's predicates; projects without an activated check policy are unaffected";
+    readonly enforcementClass: "canonical";
+    readonly category: "traceability";
+}, {
+    readonly name: "policy-markers";
+    readonly description: "When a plugin activated for kibi.check-policy.v1 declares marker rules, every file implementing a requirement grounded in the rule's pattern predicate (with its declared sibling files) must contain each marker the KB declares for that pattern";
+    readonly enforcementClass: "canonical";
+    readonly category: "traceability";
 }];
 //# sourceMappingURL=rule-registry.generated.d.ts.map

package/dist/utils/rule-registry.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuTlB,CAAC"}
+{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4UlB,CAAC"}

package/dist/utils/rule-registry.generated.js

@@ -38,6 +38,12 @@ export const GENERATED_RULES = [
         enforcementClass: "canonical",
         category: "integrity",
     },
+    {
+        name: "branch-store-not-compiled",
+        description: "The current branch's KB store must be compiled from the authored .kb/ sources; a missing or empty store is reported once, naming kibi sync, instead of every store-backed rule reading an empty KB",
+        enforcementClass: "canonical",
+        category: "integrity",
+    },
     {
         name: "source-path-dangling",
         description: "An authored entity's source field must name an existing workspace path (a #anchor suffix is ignored), an existing entity id, or an http(s) URL; a missing source is allowed",
@@ -277,4 +283,16 @@ export const GENERATED_RULES = [
         category: "lifecycle",
         diagnosticSeverity: "info",
     },
+    {
+        name: "policy-ownership",
+        description: "When a plugin activated for kibi.check-policy.v1 declares ownership rules, every production symbol in a rule's file set must implement a current requirement grounded (requires_predicate) in one of the rule's predicates; projects without an activated check policy are unaffected",
+        enforcementClass: "canonical",
+        category: "traceability",
+    },
+    {
+        name: "policy-markers",
+        description: "When a plugin activated for kibi.check-policy.v1 declares marker rules, every file implementing a requirement grounded in the rule's pattern predicate (with its declared sibling files) must contain each marker the KB declares for that pattern",
+        enforcementClass: "canonical",
+        category: "traceability",
+    },
 ];

package/dist/utils/strict-modeling.d.ts

@@ -12,6 +12,12 @@ export interface SemanticClaim {
 export interface StrictModelInput {
     claim: SemanticClaim;
     statement: string;
+    /**
+     * The requirement the write set updates. When set it replaces the minted
+     * REQ-AUTO-<hash> id; fact ids, subject_key and the claim stay derived from
+     * the claim.
+     */
+    requirementId?: string;
 }
 type EntityProperties = Partial<Omit<BaseEntity, "created_at" | "updated_at"> & FactFields> & {
     id: string;
@@ -65,5 +71,11 @@ export declare function buildStrictWriteSet(input: StrictModelInput): StrictWrit
 export declare function modelRequirementClaims(inputs: ReadonlyArray<StrictModelInput>): StrictWriteSet[];
 export declare function normalizeSourceKey(value: string): string;
 export declare function normalizeTextRef(provenance: string | undefined, source: string): string;
+/**
+ * The file an authored fact lives in: `.kb/facts/<id>.md`. Kibi writes every
+ * fact there (the filename stem equals the id), so a plan that points at an
+ * existing fact names this path.
+ */
+export declare function factSourcePath(factId: string): string;
 export {};
 //# sourceMappingURL=strict-modeling.d.ts.map

package/dist/utils/strict-modeling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strict-modeling.d.ts","sourceRoot":"","sources":["../../src/utils/strict-modeling.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"strict-modeling.d.ts","sourceRoot":"","sources":["../../src/utils/strict-modeling.ts"],"names":[],"mappings":"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"}

package/dist/utils/strict-modeling.js

@@ -83,7 +83,9 @@ export function buildStableRequirementIds(claim) {
 export function buildStrictWriteSet(input) {
     const statement = normalizeStatement(input.statement);
     const confidence = normalizeConfidence(input.claim.confidence);
-    const ids = buildStableRequirementIds(input.claim);
+    const minted = buildStableRequirementIds(input.claim);
+    const requirementId = input.requirementId?.trim();
+    const ids = requirementId ? { ...minted, reqId: requirementId } : minted;
     const textRef = normalizeTextRef(input.claim.provenance, input.claim.source);
     const metadataTags = buildMetadataTags({
         confidence,
@@ -409,3 +411,12 @@ function normalizeEntityDirectory(directory) {
 function buildEntitySourcePath(directory, entityId) {
     return `${directory}/${entityId}.md`;
 }
+/**
+ * The file an authored fact lives in: `.kb/facts/<id>.md`. Kibi writes every
+ * fact there (the filename stem equals the id), so a plan that points at an
+ * existing fact names this path.
+ */
+// implements REQ-kibi-subject-vocabulary
+export function factSourcePath(factId) {
+    return buildEntitySourcePath(resolveEntitySourcePaths().facts, factId);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "2.14.0",
+  "version": "2.16.0",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
@@ -235,9 +235,9 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.17.3",
-    "kibi-plugin-builtin": "^0.4.2",
-    "kibi-plugin-sdk": "^0.4.1",
+    "kibi-core": "^0.18.1",
+    "kibi-plugin-builtin": "^0.5.0",
+    "kibi-plugin-sdk": "^0.5.0",
     "kibi-swipl": "^1.0.1",
     "saxes": "^6.0.0",
     "ignore": "^5.3.0",

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

@@ -1,4 +1,10 @@
 import { runAggregatedChecks } from "../../commands/aggregated-checks.js";
+import { resolveBranchAttachment } from "../../utils/branch-resolver.js";
+import {
+  BRANCH_STORE_NOT_COMPILED_RULE,
+  inspectBranchStore,
+  uncompiledBranchStoreReason,
+} from "../../utils/branch-store.js";
 /*
  Kibi — repo-local, per-branch, queryable long-term memory for software projects
  Copyright (C) 2026 Piotr Franczyk
@@ -33,6 +39,7 @@ import {
   resolveCheckRules,
   stagedEntityIdStyleDiagnostics,
 } from "./check-helpers.js";
+import { collectCheckPolicyViolations } from "./check-policy-rules.js";
 import { executeStatus } from "./discovery-executors.js";
 import { collectEntityContextViolations } from "./entity-context.js";
 import {
@@ -73,6 +80,14 @@ export {
 
 export type CheckExecutionOptions = {
   readonly collectFullQualityDiagnosticsForExplicitRules?: boolean;
+  /**
+   * The engine reads the current branch's store although the context carries
+   * no branch attachment (the `kibi check` engine path). A context with a
+   * branch attachment (the CLI and MCP runtimes) implies it; without either,
+   * the attached store is unknown (an explicit --kb-path store or an injected
+   * test store) and the branch-store compilation check is skipped.
+   */
+  readonly branchStoreAttached?: boolean;
 };
 
 function requireProlog(context: OperationContext): PrologPort {
@@ -125,6 +140,50 @@ async function readStatusMigrationPlan(
   }
 }
 
+/**
+ * The one finding for a branch whose store was never compiled while .kb/
+ * holds authored sources. Every store-backed rule would read an empty KB
+ * (source-relationship-parity alone reports each authored relationship as
+ * missing), so kb_check reports this instead of any of them.
+ */
+// implements REQ-cli-status-pre-first-sync
+export function uncompiledBranchStoreViolation(
+  context: OperationContext,
+  workspaceRoot: string,
+): Violation | null {
+  let attachment: ReturnType<typeof resolveBranchAttachment>;
+  try {
+    attachment =
+      context.branchAttachment ?? resolveBranchAttachment(workspaceRoot);
+  } catch {
+    return null;
+  }
+  if ("error" in attachment) return null;
+  const store = inspectBranchStore(workspaceRoot, attachment.kbBranch);
+  const reason = uncompiledBranchStoreReason(
+    workspaceRoot,
+    store,
+    attachment.kbBranch,
+  );
+  if (reason === null) return null;
+  return {
+    rule: BRANCH_STORE_NOT_COMPILED_RULE,
+    entityId: attachment.kbBranch,
+    description: String(reason.detail),
+    suggestion:
+      "Run kibi sync to compile this branch's store from the authored .kb/ sources (or apply the branch-store-compile action of the returned migrationPlan with kb_apply_plan), then rerun kb_check. Run kibi init once to install the git hooks that compile a new branch on checkout.",
+    source: store.path,
+    evidence: {
+      store: { state: store.state, path: store.path },
+      authoredSources: reason.authoredSources,
+      ...(reason.generation !== undefined
+        ? { generation: reason.generation }
+        : {}),
+      remediation: reason.remediation,
+    },
+  };
+}
+
 // implements REQ-kibi-operation-interface-parity, REQ-002
 export async function executeCheck(
   args: CheckInput,
@@ -153,6 +212,53 @@ export async function executeCheck(
         ? { maxDiagnostics: args.maxDiagnostics }
         : {};
 
+    const uncompiled =
+      context.branchAttachment !== undefined ||
+      options.branchStoreAttached === true
+        ? uncompiledBranchStoreViolation(context, workspaceRoot)
+        : null;
+    if (uncompiled !== null) {
+      const violations = [uncompiled];
+      const statusPlan = await readStatusMigrationPlan(context);
+      const migrationPlan = await migrationPlanForCheck(
+        context,
+        violations,
+        [],
+        statusPlan,
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: buildSummary({
+              violations,
+              impactResult,
+              qualityDiagnostics: [],
+            }),
+          },
+        ],
+        structuredContent: buildStructuredContent({
+          violations,
+          diagnostics: [
+            {
+              category: "SYNC_ERROR",
+              severity: "error",
+              message: uncompiled.description,
+              ...(uncompiled.source !== undefined
+                ? { file: uncompiled.source }
+                : {}),
+              ...(uncompiled.suggestion !== undefined
+                ? { suggestion: uncompiled.suggestion }
+                : {}),
+            },
+          ],
+          qualityDiagnostics: [],
+          impactResult,
+          migrationPlan,
+        }),
+      };
+    }
+
     if (rulesAllowlist.size === 0) {
       const qualityDiagnostics =
         hasExplicitRules &&
@@ -229,6 +335,11 @@ export async function executeCheck(
       rulesAllowlist,
       workspaceRoot,
     );
+    const checkPolicyFindings = await collectCheckPolicyViolations(
+      prolog,
+      rulesAllowlist,
+      workspaceRoot,
+    );
     const partitioned = partitionCheckFindings([
       ...aggregatedFindings,
       ...queryPlanViolations,
@@ -237,6 +348,7 @@ export async function executeCheck(
       ...predicateConformanceFindings,
       ...originReviewFindings,
       ...entityContextFindings,
+      ...checkPolicyFindings,
     ]);
     const violations: Violation[] = partitioned.violations;