kibi-cli 2.19.0 → 2.21.0

package/dist/operations/semantic-advisor/clauses.js

@@ -1,11 +1,12 @@
 import { createHash } from "node:crypto";
-// An explicit grant ("are allowed to", "is permitted to") asserts a
-// permission just as "denied"/"forbidden" assert a prohibition. Bare "can" and
-// "may" are accepted by the predicate applicability gate but not here: stored
-// clause roles are derived from this pattern, and "it can be restricted to …"
-// style capability prose would turn existing descriptive inventories into
-// unmodeled normative clauses.
-const NORMATIVE_ASSERTION_PATTERN = /\b(?:must|shall|should|required|requires?|may\s+only|(?:is|are)\s+(?:not\s+)?(?:allowed|permitted)\s+to|permitted|may\s+(?:not\s+)?(?:be\s+)?\w+\s+only\b|may\s+(?:have\s+)?(?:at\s+most|at\s+least|exactly|no\s+more\s+than|up\s+to)|only\s+.+?\s+(?:may|can)|must\s+not|shall\s+not|cannot|can't|denied|forbidden|prohibited|(?:is|are|be|become|becomes|remain|remains)\s+(?:invalid|rejected|prohibited|forbidden)|(?:reject|rejects|rejected|rejection)\s+(?:invalid|unresolved|ambiguous)|fail(?:s|ed)?\s+(?:clearly|explicitly|with)|expires?\s+(?:after|within|in)|failure\s+(?:behavior|policy|outcome)|error\s+(?:handling|behavior|policy|outcome)|required\s+outcome|defaults?\s+to)\b/i;
+// An explicit grant ("are allowed to", "is permitted to", "have permission
+// to", "are entitled to") asserts a permission just as "denied"/"forbidden"
+// assert a prohibition. Bare "can", "may" and "are able to" are accepted by
+// the predicate applicability gate but not here: stored clause roles are
+// derived from this pattern, and "it can be restricted to …" style capability
+// prose would turn existing descriptive inventories into unmodeled normative
+// clauses ("must be able to" is already normative through "must").
+const NORMATIVE_ASSERTION_PATTERN = /\b(?:must|shall|should|required|requires?|may\s+only|(?:is|are)\s+(?:not\s+)?(?:allowed|permitted|entitled)\s+to|ha(?:s|ve)\s+(?:no\s+)?permission\s+to|permitted|may\s+(?:not\s+)?(?:be\s+)?\w+\s+only\b|may\s+(?:have\s+)?(?:at\s+most|at\s+least|exactly|no\s+more\s+than|up\s+to)|only\s+.+?\s+(?:may|can)|must\s+not|shall\s+not|cannot|can't|denied|forbidden|prohibited|(?:is|are|be|become|becomes|remain|remains)\s+(?:invalid|rejected|prohibited|forbidden)|(?:reject|rejects|rejected|rejection)\s+(?:invalid|unresolved|ambiguous)|fail(?:s|ed)?\s+(?:clearly|explicitly|with)|expires?\s+(?:after|within|in)|failure\s+(?:behavior|policy|outcome)|error\s+(?:handling|behavior|policy|outcome)|required\s+outcome|defaults?\s+to)\b/i;
 // Conditional/temporal cues help discover clauses but do not by themselves
 // turn explanatory or subjective context into an asserted obligation.
 const NORMATIVE_PATTERN = new RegExp(`${NORMATIVE_ASSERTION_PATTERN.source}|\\b(?:before|unless|when|if)\\b`, "i");
@@ -37,6 +38,30 @@ export function semanticClaimKey(text) {
     const digest = createHash("sha256").update(normalized).digest("hex");
     return `CLAIM-${digest.slice(0, 16).toUpperCase()}`;
 }
+/** Fact kinds that quote a claim as a review note and never ground it. */
+const NON_GROUNDING_FACT_KINDS = new Set(["observation", "meta"]);
+/**
+ * Fill `claim_key` from `claim_text` on a fact that may ground a claim.
+ *
+ * The key is a pure function of the text, so a caller that sends the text
+ * alone has given Kibi everything it needs; a supplied key is still checked
+ * against the derived one by the entity validators. Observation and meta
+ * facts quote a claim without owning it, so they stay keyless.
+ */
+// implements REQ-kibi-review-observation-claim-text-v2
+export function deriveFactClaimKey(entity) {
+    if (entity.type !== "fact")
+        return;
+    if (entity.claim_key !== undefined)
+        return;
+    if (typeof entity.claim_text !== "string")
+        return;
+    if (typeof entity.fact_kind === "string" &&
+        NON_GROUNDING_FACT_KINDS.has(entity.fact_kind)) {
+        return;
+    }
+    entity.claim_key = semanticClaimKey(entity.claim_text);
+}
 function detectedClauses(text) {
     return text
         .split(/(?:\r?\n)+|;|(?<=[.!?])\s+(?=[A-Z0-9])/)

package/dist/prolog/janitor.d.ts

@@ -25,7 +25,20 @@ export interface SocketFinding {
     readonly holderState: StoreLockHolderState;
     readonly action: "clean" | "keep";
 }
-export type JanitorFinding = StoreLockFinding | SocketFinding;
+/**
+ * A stale-lock takeover record past its visibility window: kb_status no
+ * longer reports it, so it is only clutter in the branch store.
+ */
+export interface TakeoverRecordFinding {
+    readonly kind: "takeover-record";
+    readonly storePath: string;
+    readonly recordPath: string;
+    /** When the takeover happened (the file's mtime for an unreadable record). */
+    readonly at: string;
+    readonly brokenPid?: number;
+    readonly action: "clean";
+}
+export type JanitorFinding = StoreLockFinding | SocketFinding | TakeoverRecordFinding;
 export interface JanitorOptions {
     /** Branch stores live under <workspaceRoot>/.kb/branches. */
     readonly workspaceRoot: string;
@@ -35,16 +48,27 @@ export interface JanitorOptions {
     readonly all?: boolean;
     /** Execute cleanups; when false the scan only reports (dry run). */
     readonly apply?: boolean;
+    /** Clock for the takeover-record age; defaults to the current time. */
+    readonly now?: Date;
 }
 /** Scan one branch store's ownership journal and clean stale artifacts. */
 export declare function sweepStoreLock(storePath: string, apply: boolean): StoreLockFinding | null;
 /** Scan all branch stores under <workspaceRoot>/.kb/branches. */
 export declare function sweepWorkspaceStoreLocks(options: JanitorOptions): StoreLockFinding[];
+/**
+ * Report, and with apply delete, the stale-lock takeover records under
+ * <workspaceRoot>/.kb/branches that are older than the window kb_status
+ * shows them for. Fresh records are kept and not reported.
+ */
+export declare function sweepStoreLockTakeoverRecords(options: JanitorOptions): TakeoverRecordFinding[];
 /**
  * Sweep runtime-directory daemon sockets. A socket is stale when its pid
  * file records a dead process or a connect attempt is refused.
  */
 export declare function sweepRuntimeSockets(options: JanitorOptions): SocketFinding[];
-/** Full janitor sweep across branch stores and (optionally) runtime sockets. */
+/**
+ * Full janitor sweep across branch stores, expired takeover records and
+ * (optionally) runtime sockets.
+ */
 export declare function runJanitor(options: JanitorOptions): JanitorFinding[];
 //# sourceMappingURL=janitor.d.ts.map

package/dist/prolog/janitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"janitor.d.ts","sourceRoot":"","sources":["../../src/prolog/janitor.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,KAAK,oBAAoB,EAK1B,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;GAQG;AAGH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,GAAG,MAAM,CAAC;CACtD;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;CACnC;AAED,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG,aAAa,CAAC;AAE9D,MAAM,WAAW,cAAc;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,8DAA8D;IAC9D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,kEAAkE;IAClE,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IACvB,oEAAoE;IACpE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,2EAA2E;AAE3E,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,GACb,gBAAgB,GAAG,IAAI,CA+CzB;AAED,iEAAiE;AAEjE,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,cAAc,GACtB,gBAAgB,EAAE,CAepB;AAED;;;GAGG;AAEH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,cAAc,GAAG,aAAa,EAAE,CA8C5E;AAED,gFAAgF;AAEhF,wBAAgB,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,EAAE,CAKpE"}
+{"version":3,"file":"janitor.d.ts","sourceRoot":"","sources":["../../src/prolog/janitor.ts"],"names":[],"mappings":"AA0BA,OAAO,EAGL,KAAK,oBAAoB,EAM1B,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;GAQG;AAGH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,GAAG,MAAM,CAAC;CACtD;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;CACnC;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,MAAM,cAAc,GACtB,gBAAgB,GAChB,aAAa,GACb,qBAAqB,CAAC;AAE1B,MAAM,WAAW,cAAc;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,8DAA8D;IAC9D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,kEAAkE;IAClE,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IACvB,oEAAoE;IACpE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;CACrB;AAED,2EAA2E;AAE3E,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,GACb,gBAAgB,GAAG,IAAI,CA+CzB;AAED,iEAAiE;AAEjE,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,cAAc,GACtB,gBAAgB,EAAE,CAepB;AAED;;;;GAIG;AAEH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,cAAc,GACtB,qBAAqB,EAAE,CAmCzB;AAED;;;GAGG;AAEH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,cAAc,GAAG,aAAa,EAAE,CA8C5E;AAED;;;GAGG;AAEH,wBAAgB,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,EAAE,CAMpE"}

package/dist/prolog/janitor.js

@@ -15,9 +15,9 @@
  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 { existsSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, rmSync, statSync, } from "node:fs";
 import { join } from "node:path";
-import { breakStoreLock, classifyStoreLockHolder, isProcessAlive, readStoreLockOwner, } from "./store-lock.js";
+import { STORE_LOCK_TAKEOVER_FILE, STORE_LOCK_TAKEOVER_VISIBLE_MS, breakStoreLock, classifyStoreLockHolder, isProcessAlive, readStoreLockOwner, readStoreLockTakeover, } from "./store-lock.js";
 /** Scan one branch store's ownership journal and clean stale artifacts. */
 // implements REQ-core-journaled-engine-persistence
 export function sweepStoreLock(storePath, apply) {
@@ -90,6 +90,54 @@ export function sweepWorkspaceStoreLocks(options) {
     }
     return findings;
 }
+/**
+ * Report, and with apply delete, the stale-lock takeover records under
+ * <workspaceRoot>/.kb/branches that are older than the window kb_status
+ * shows them for. Fresh records are kept and not reported.
+ */
+// implements REQ-core-journaled-engine-persistence
+export function sweepStoreLockTakeoverRecords(options) {
+    const branchesDir = join(options.workspaceRoot, ".kb", "branches");
+    if (!existsSync(branchesDir))
+        return [];
+    const now = (options.now ?? new Date()).getTime();
+    const findings = [];
+    for (const entry of readdirSync(branchesDir)) {
+        const storePath = join(branchesDir, entry);
+        const recordPath = join(storePath, STORE_LOCK_TAKEOVER_FILE);
+        let at;
+        let brokenPid = null;
+        try {
+            const record = readStoreLockTakeover(storePath);
+            if (record !== null) {
+                at = record.at;
+                brokenPid = record.brokenPid;
+            }
+            else if (existsSync(recordPath)) {
+                at = statSync(recordPath).mtime.toISOString();
+            }
+            else {
+                continue;
+            }
+        }
+        catch {
+            continue;
+        }
+        if (now - Date.parse(at) <= STORE_LOCK_TAKEOVER_VISIBLE_MS)
+            continue;
+        if (options.apply === true)
+            rmSync(recordPath, { force: true });
+        findings.push({
+            kind: "takeover-record",
+            storePath,
+            recordPath,
+            at,
+            ...(brokenPid !== null ? { brokenPid } : {}),
+            action: "clean",
+        });
+    }
+    return findings;
+}
 /**
  * Sweep runtime-directory daemon sockets. A socket is stale when its pid
  * file records a dead process or a connect attempt is refused.
@@ -144,11 +192,15 @@ export function sweepRuntimeSockets(options) {
     }
     return findings;
 }
-/** Full janitor sweep across branch stores and (optionally) runtime sockets. */
+/**
+ * Full janitor sweep across branch stores, expired takeover records and
+ * (optionally) runtime sockets.
+ */
 // implements REQ-core-journaled-engine-persistence
 export function runJanitor(options) {
     return [
         ...sweepWorkspaceStoreLocks(options),
+        ...sweepStoreLockTakeoverRecords(options),
         ...sweepRuntimeSockets(options),
     ];
 }

package/dist/prolog/store-lock.d.ts

@@ -66,12 +66,37 @@ export interface StoreLockTakeoverDecision {
     readonly action: "break" | "surface";
     readonly reason: string;
 }
+/** Reason prefix of a takeover that removed lock artifacts copied in. */
+export declare const FOREIGN_STORE_LOCK_REASON_PREFIX = "journal belongs to another workspace";
+/**
+ * The recorded root of an ownership journal that another workspace wrote,
+ * or null when the journal belongs to this store (or cannot be judged).
+ *
+ * kb.pl records the attached store directory as `workspaceRoot`; a journal
+ * may also name a workspace root. Either way it is foreign only when the
+ * workspace it names differs from the one that owns `storePath`, which
+ * happens when a `.kb` was copied (`cp -a`, a backup restore) while another
+ * workspace's engine held its store. An advisory lock is never inherited by
+ * a copied file, so nobody holds this store on the journal's behalf.
+ *
+ * The journal is judged only when that is safe: when the store's `rdf/lock`
+ * names a different pid than the journal, a process of this workspace has
+ * locked the store since the copy; when the recorded path no longer exists,
+ * the store may have been moved here while its holder still runs; and a
+ * recorded path that is this very directory (a bind mount) is not another
+ * workspace. Each of those returns null.
+ */
+export declare function foreignStoreLockJournalRoot(owner: PrologStoreLockOwner | null, storePath: string): string | null;
 /**
  * Decide whether a store-locked failure may be auto-healed. Only a provably
- * dead holder (or a holder from a previous boot) is broken; live or unknown
- * holders are surfaced so the operator can close the real session.
+ * dead holder (or a holder from a previous boot) is broken, and, when the
+ * caller names the store being attached, a journal copied in from another
+ * workspace; live or unknown holders are surfaced so the operator can close
+ * the real session.
  */
-export declare function decideStoreLockTakeover(owner: PrologStoreLockOwner | null): StoreLockTakeoverDecision;
+export declare function decideStoreLockTakeover(owner: PrologStoreLockOwner | null, options?: {
+    readonly storePath?: string;
+}): StoreLockTakeoverDecision;
 export interface StoreLockRetryContext {
     readonly query: (goal: string) => Promise<QueryResult>;
 }

package/dist/prolog/store-lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-lock.d.ts","sourceRoot":"","sources":["../../src/prolog/store-lock.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,OAAO,KAAK,EAAqB,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAgBhF,8EAA8E;AAC9E,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAa7C;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAUnD;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;AAEzE,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,oBAAoB,GAAG,IAAI,GACjC,oBAAoB,CAYtB;AAED;;;;;GAKG;AAEH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,GAChB;IAAE,KAAK,EAAE,oBAAoB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA4B7D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAWzD;AAED,qEAAqE;AACrE,eAAO,MAAM,wBAAwB,6BAA6B,CAAC;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,QAAsB,CAAC;AAElE,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CAAC;AAEH;;;GAGG;AAEH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,MAAM,EAAE,MAAM,EACd,EAAE,GAAE,IAAiB,GACpB,IAAI,CAUN;AAED,iFAAiF;AAEjF,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,GAChB,uBAAuB,GAAG,IAAI,CAmBhC;AAED,sEAAsE;AAEtE,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ9D;AAED;;;;;;;;;;;;;;;GAeG;AAEH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,CAerE;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,oBAAoB,GAAG,IAAI,GACjC,yBAAyB,CAoB3B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;CACxD;AAED;;;;;;GAMG;AAEH,wBAAsB,iCAAiC,CACrD,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,WAAW,CAAC,CAiCtB"}
+{"version":3,"file":"store-lock.d.ts","sourceRoot":"","sources":["../../src/prolog/store-lock.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,OAAO,KAAK,EAAqB,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAgBhF,8EAA8E;AAC9E,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAa7C;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAUnD;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;AAEzE,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,oBAAoB,GAAG,IAAI,GACjC,oBAAoB,CAYtB;AAED;;;;;GAKG;AAEH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,GAChB;IAAE,KAAK,EAAE,oBAAoB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA4B7D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAWzD;AAED,qEAAqE;AACrE,eAAO,MAAM,wBAAwB,6BAA6B,CAAC;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,QAAsB,CAAC;AAElE,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CAAC;AAEH;;;GAGG;AAEH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,MAAM,EAAE,MAAM,EACd,EAAE,GAAE,IAAiB,GACpB,IAAI,CAUN;AAED,iFAAiF;AAEjF,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,GAChB,uBAAuB,GAAG,IAAI,CAmBhC;AAED,sEAAsE;AAEtE,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ9D;AAED;;;;;;;;;;;;;;;GAeG;AAEH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,CAerE;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,yEAAyE;AACzE,eAAO,MAAM,gCAAgC,yCACL,CAAC;AAoCzC;;;;;;;;;;;;;;;;;GAiBG;AAEH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,oBAAoB,GAAG,IAAI,EAClC,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI,CAcf;AAED;;;;;;GAMG;AAEH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,oBAAoB,GAAG,IAAI,EAClC,OAAO,GAAE;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAC5C,yBAAyB,CA+B3B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;CACxD;AAED;;;;;;GAMG;AAEH,wBAAsB,iCAAiC,CACrD,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,WAAW,CAAC,CAmCtB"}

package/dist/prolog/store-lock.js

@@ -15,9 +15,9 @@
  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 { existsSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, realpathSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { escapeAtom } from "./codec.js";
 /**
  * Stewardship for the branch-store lock.
@@ -216,25 +216,114 @@ export function noteDeadHolderBeforeAttach(kbPath) {
         : lockPid !== null
             ? { pid: lockPid }
             : null;
-    const decision = decideStoreLockTakeover(owner);
+    const decision = decideStoreLockTakeover(owner, { storePath: kbPath });
     if (decision.action !== "break")
         return () => undefined;
     const brokenPid = owner?.pid ?? null;
     return () => recordStoreLockTakeover(kbPath, brokenPid, decision.reason);
 }
+/** Reason prefix of a takeover that removed lock artifacts copied in. */
+export const FOREIGN_STORE_LOCK_REASON_PREFIX = "journal belongs to another workspace";
+function existingRealPath(pathname) {
+    try {
+        return realpathSync(pathname);
+    }
+    catch {
+        return null;
+    }
+}
+function sameDirectory(left, right) {
+    try {
+        const a = statSync(left);
+        const b = statSync(right);
+        return a.dev === b.dev && a.ino === b.ino;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The workspace that owns a branch store: `<root>/.kb/branches/<key>` (a
+ * legacy key may span several segments) is owned by `<root>`. Null for a
+ * path outside that layout.
+ */
+function owningWorkspaceRoot(storePath) {
+    let current = storePath;
+    for (;;) {
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        if (basename(parent) === "branches" && basename(dirname(parent)) === ".kb")
+            return dirname(dirname(parent));
+        current = parent;
+    }
+}
+/**
+ * The recorded root of an ownership journal that another workspace wrote,
+ * or null when the journal belongs to this store (or cannot be judged).
+ *
+ * kb.pl records the attached store directory as `workspaceRoot`; a journal
+ * may also name a workspace root. Either way it is foreign only when the
+ * workspace it names differs from the one that owns `storePath`, which
+ * happens when a `.kb` was copied (`cp -a`, a backup restore) while another
+ * workspace's engine held its store. An advisory lock is never inherited by
+ * a copied file, so nobody holds this store on the journal's behalf.
+ *
+ * The journal is judged only when that is safe: when the store's `rdf/lock`
+ * names a different pid than the journal, a process of this workspace has
+ * locked the store since the copy; when the recorded path no longer exists,
+ * the store may have been moved here while its holder still runs; and a
+ * recorded path that is this very directory (a bind mount) is not another
+ * workspace. Each of those returns null.
+ */
+// implements REQ-core-journaled-engine-persistence
+export function foreignStoreLockJournalRoot(owner, storePath) {
+    const recorded = owner?.workspaceRoot;
+    if (recorded === undefined || recorded === "")
+        return null;
+    const store = existingRealPath(storePath);
+    if (store === null)
+        return null;
+    const ownWorkspace = owningWorkspaceRoot(store);
+    if (ownWorkspace === null)
+        return null;
+    const lockPid = readRdfLockPid(join(storePath, "rdf", "lock"));
+    if (lockPid !== null && lockPid !== owner?.pid)
+        return null;
+    const recordedPath = existingRealPath(recorded);
+    if (recordedPath === null || recordedPath === store)
+        return null;
+    if (sameDirectory(recordedPath, store))
+        return null;
+    const recordedWorkspace = owningWorkspaceRoot(recordedPath) ?? recordedPath;
+    return recordedWorkspace === ownWorkspace ? null : recorded;
+}
 /**
  * Decide whether a store-locked failure may be auto-healed. Only a provably
- * dead holder (or a holder from a previous boot) is broken; live or unknown
- * holders are surfaced so the operator can close the real session.
+ * dead holder (or a holder from a previous boot) is broken, and, when the
+ * caller names the store being attached, a journal copied in from another
+ * workspace; live or unknown holders are surfaced so the operator can close
+ * the real session.
  */
-export function decideStoreLockTakeover(owner) {
+// implements REQ-core-journaled-engine-persistence
+export function decideStoreLockTakeover(owner, options = {}) {
     const state = classifyStoreLockHolder(owner);
+    if (state === "dead") {
+        return {
+            action: "break",
+            reason: `recorded holder pid ${owner?.pid ?? "?"} is no longer running`,
+        };
+    }
+    const foreignRoot = options.storePath === undefined
+        ? null
+        : foreignStoreLockJournalRoot(owner, options.storePath);
+    if (foreignRoot !== null) {
+        return {
+            action: "break",
+            reason: `${FOREIGN_STORE_LOCK_REASON_PREFIX} ${foreignRoot}`,
+        };
+    }
     switch (state) {
-        case "dead":
-            return {
-                action: "break",
-                reason: `recorded holder pid ${owner?.pid ?? "?"} is no longer running`,
-            };
         case "unknown":
             return {
                 action: "surface",
@@ -261,7 +350,9 @@ export async function retryAttachAfterBreakingStaleLock(prolog, kbPath, failed)
     const storeLocked = record?.storeLocked;
     if (storeLocked === undefined)
         return failed;
-    const decision = decideStoreLockTakeover(storeLocked.owner);
+    const decision = decideStoreLockTakeover(storeLocked.owner, {
+        storePath: kbPath,
+    });
     if (decision.action !== "break") {
         const holderSummary = storeLocked.owner === null
             ? decision.reason

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

@@ -190,8 +190,8 @@ export declare const OPERATION_CATALOG: readonly [{
             readonly limit: {
                 readonly type: "integer";
                 readonly minimum: 0;
-                readonly default: 20;
-                readonly description: "Optional max rows to return after ranking. Default: 20.";
+                readonly default: 10;
+                readonly description: "Optional max rows to return after ranking. Default: 10; raise it or page with offset when the answer layer is not enough.";
             };
             readonly offset: {
                 readonly type: "integer";
@@ -718,7 +718,7 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_model";
     readonly cliName: "model";
-    readonly description: "Turn requirement prose into checkable structure without writing the KB. mode:analyze returns the semantic advisor receipt: the clause ledger, what is grounded, what is ambiguous and suggested modeling (pass clauses for compound prose and optional typed kibi.logic.v1 interpretations). mode:requirement converts one claim (subjectKey, propertyKey, operator, value, or typed logic) into a strict-lane write set and applyPlan. mode:predicates ranks ontology predicate schemas and returns an applicable predicate-fact plan only for reviewed bindings, otherwise an ontology-gap observation. Apply returned plans with kb_upsert.";
+    readonly description: "Turn requirement prose into checkable structure without writing the KB. mode:analyze returns the semantic advisor receipt: the clause ledger, what is grounded, what is ambiguous and suggested modeling (pass clauses for compound prose and optional typed kibi.logic.v1 interpretations). mode:requirement converts one claim (subjectKey, propertyKey, operator, value, or typed logic) into a strict-lane write set and applyPlan. mode:predicates ranks ontology predicate schemas and returns an applicable predicate-fact plan only for reviewed bindings, otherwise an ontology-gap observation. With requirementId, mode:predicates also returns a hash-bound plan (fact write plus requires_predicate link) for kb_apply_plan, whose contradictionAnalysis is the what-if over the current KB; other returned plans apply with kb_upsert, and kb_upsert dryRun with plannedFacts previews a requirement before its facts exist.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["mode", "text"];
@@ -1521,11 +1521,11 @@ export declare const OPERATION_CATALOG: readonly [{
                     readonly claim_key: {
                         readonly type: "string";
                         readonly pattern: "^CLAIM-[A-F0-9]{16}$";
-                        readonly description: "Stable semantic-advisor key for the atomic prose clause grounded by this fact.";
+                        readonly description: "Stable key of the atomic prose clause grounded by this fact, derived from claim_text. Optional: when omitted, Kibi derives it; when sent, it must equal the derived key.";
                     };
                     readonly claim_text: {
                         readonly type: "string";
-                        readonly description: "Exact atomic requirement clause represented by this fact, retained for human audit. Requires claim_key, except on an observation or meta fact, which may quote the clause it is about without claim_key.";
+                        readonly description: "Exact atomic requirement clause represented by this fact, retained for human audit. On a grounding fact Kibi derives claim_key from it; an observation or meta fact quotes the clause it is about without a key.";
                     };
                     readonly predicate_name: {
                         readonly type: "string";
@@ -1689,6 +1689,50 @@ export declare const OPERATION_CATALOG: readonly [{
                 readonly default: false;
                 readonly description: "Validate the payload and return schema/modeling errors, a normalized preview and the semantic advisor receipt without writing the KB or workspace. Use it as the preflight before the real write.";
             };
+            readonly plannedFacts: {
+                readonly type: "array";
+                readonly description: "dryRun only. Fact upsert payloads (type, id, properties, optional relationships) that will be written before this payload, typically the applyPlan entries kb_model returned. They are validated in order and staged with the payload, so a requires_predicate or requires_property target that does not exist yet resolves, its claim_key is read from the plan, and the contradiction preview runs against the KB as it would be after the whole batch (result: stagedFacts, whatIf). A conflict the batch would introduce, such as an allow and a deny permission_rule on the same key, is refused as the commit would refuse it. Rejected without dryRun: write the facts first.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["type", "id", "properties"];
+                    readonly properties: {
+                        readonly type: {
+                            readonly type: "string";
+                            readonly const: "fact";
+                        };
+                        readonly id: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly properties: {
+                            readonly type: "object";
+                        };
+                        readonly relationships: {
+                            readonly type: "array";
+                            readonly description: "Optional relationship rows to create in the same call. For requirement encoding, prefer `constrains` + `requires_property` for strict property facts or `requires_predicate` for ontology predicate facts. Side effect: asserts edges in KB.";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly required: readonly ["type", "from", "to"];
+                                readonly properties: {
+                                    readonly type: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["depends_on", "specified_by", "verified_by", "validates", "implements", "covered_by", "executable_for", "constrained_by", "constrains", "requires_property", "requires_predicate", "requires_rule", "guards", "publishes", "consumes", "supersedes", "restates", "assumes", "exempts", "relates_to"];
+                                        readonly description: "Relationship type enum. Use only supported values. Direction semantics follow KB model (e.g., implements symbol->req, verified_by req/scenario->test, executable_for symbol->test).";
+                                    };
+                                    readonly from: {
+                                        readonly type: "string";
+                                        readonly description: "Source entity ID (must exist). Example: 'SYM-login-handler'.";
+                                    };
+                                    readonly to: {
+                                        readonly type: "string";
+                                        readonly description: "Target entity ID (must exist). Example: 'REQ-cli-gc'.";
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
             readonly document: {
                 readonly type: "object";
                 readonly additionalProperties: false;

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":"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"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/public/operations/catalog.ts"],"names":[],"mappings":"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"}

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

@@ -1,5 +1,5 @@
 import type { Violation } from "../check-types.js";
-import { type CheckDiagnostic, type CheckStructuredContent, buildStructuredContent, buildSummary } from "./check-format-shared.js";
+import { type CheckDiagnostic, type CheckEvaluated, type CheckStructuredContent, buildStructuredContent, buildSummary } from "./check-format-shared.js";
 import { getEffectiveRules, resolveCheckRules } from "./check-helpers.js";
 import type { OperationContext } from "./runtime-types.js";
 import type { OperationResult } from "./types.js";
@@ -13,7 +13,7 @@ export type CheckInput = {
     readonly maxDiagnostics?: number;
 };
 export type CheckPayload = CheckStructuredContent;
-export type { CheckDiagnostic, CheckStructuredContent };
+export type { CheckDiagnostic, CheckEvaluated, CheckStructuredContent };
 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":"AAwBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,sBAAsB,EACtB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAGL,iBAAiB,EAGjB,iBAAiB,EAElB,MAAM,oBAAoB,CAAC;AAW5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAMvE,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;IACjE;;;;;;OAMG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACxC,CAAC;AAoDF;;;;;GAKG;AAEH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,gBAAgB,EACzB,aAAa,EAAE,MAAM,GACpB,SAAS,GAAG,IAAI,CAgClB;AAGD,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAgOxC"}
+{"version":3,"file":"check-executor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-executor.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,sBAAsB,EACtB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAGL,iBAAiB,EAGjB,iBAAiB,EAElB,MAAM,oBAAoB,CAAC;AAW5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAMvE,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,cAAc,EAAE,sBAAsB,EAAE,CAAC;AACxE,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,GAClB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,6CAA6C,CAAC,EAAE,OAAO,CAAC;IACjE;;;;;;OAMG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACxC,CAAC;AAoFF;;;;;GAKG;AAEH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,gBAAgB,EACzB,aAAa,EAAE,MAAM,GACpB,SAAS,GAAG,IAAI,CAgClB;AAGD,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CA0OxC"}

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

@@ -14,6 +14,31 @@ import { SOURCE_PATH_DANGLING_RULE, collectSourcePathDanglingViolations, } from
 import { collectSourceRelationshipParityViolations } from "./source-relationship-parity.js";
 import { readWorkspaceSnapshot } from "./workspace-snapshot.js";
 export { buildStructuredContent, buildSummary, getEffectiveRules, resolveCheckRules, };
+// implements REQ-search-answer-hygiene
+/**
+ * What this run evaluated: the rules that ran, in registry order, and for
+ * `domain-contradictions` the number of requirement fact pairs the rule
+ * compared, read from the engine after the rules ran on the same store. A
+ * count the engine cannot give (an older engine) is left out rather than
+ * reported as zero.
+ */
+async function describeEvaluation(prolog, rules) {
+    const evaluated = {
+        rules: [...rules],
+    };
+    if (!rules.has("domain-contradictions"))
+        return evaluated;
+    try {
+        const result = await prolog.query("kb_domain_contradiction_pairs_examined(Count)");
+        const count = Number(result.bindings.Count);
+        if (result.success && Number.isInteger(count) && count >= 0)
+            evaluated.domainContradictions = { factPairsExamined: count };
+    }
+    catch {
+        // An engine without the predicate leaves the count out.
+    }
+    return evaluated;
+}
 function requireProlog(context) {
     if (context.prolog === undefined) {
         throw new Error("Check operation requires a Prolog runtime");
@@ -121,12 +146,15 @@ export async function executeCheck(args, context, options = {}) {
             const violations = [uncompiled];
             const statusPlan = await readStatusMigrationPlan(context);
             const migrationPlan = await migrationPlanForCheck(context, violations, [], statusPlan);
+            // Every store-backed rule was skipped: only this one was evaluated.
+            const evaluated = { rules: [BRANCH_STORE_NOT_COMPILED_RULE] };
             return {
                 content: [
                     {
                         type: "text",
                         text: buildSummary({
                             violations,
+                            evaluated,
                             impactResult,
                             qualityDiagnostics: [],
                         }),
@@ -134,6 +162,7 @@ export async function executeCheck(args, context, options = {}) {
                 ],
                 structuredContent: buildStructuredContent({
                     violations,
+                    evaluated,
                     diagnostics: [
                         {
                             category: "SYNC_ERROR",
@@ -169,12 +198,14 @@ export async function executeCheck(args, context, options = {}) {
                     });
             const statusPlan = await readStatusMigrationPlan(context);
             const migrationPlan = await migrationPlanForCheck(context, [], qualityDiagnostics, statusPlan);
+            const evaluated = { rules: [] };
             return {
                 content: [
                     {
                         type: "text",
                         text: buildSummary({
                             violations: [],
+                            evaluated,
                             impactResult,
                             qualityDiagnostics,
                         }),
@@ -182,6 +213,7 @@ export async function executeCheck(args, context, options = {}) {
                 ],
                 structuredContent: buildStructuredContent({
                     violations: [],
+                    evaluated,
                     diagnostics: [],
                     qualityDiagnostics,
                     impactResult,
@@ -217,6 +249,7 @@ export async function executeCheck(args, context, options = {}) {
             ...checkPolicyFindings,
         ]);
         const violations = partitioned.violations;
+        const evaluated = await describeEvaluation(prolog, rulesAllowlist);
         const diagnostics = violations.map((v) => ({
             category: "SYNC_ERROR",
             severity: "error",
@@ -251,6 +284,7 @@ export async function executeCheck(args, context, options = {}) {
                     type: "text",
                     text: buildSummary({
                         violations,
+                        evaluated,
                         impactResult,
                         qualityDiagnostics,
                     }),
@@ -258,6 +292,7 @@ export async function executeCheck(args, context, options = {}) {
             ],
             structuredContent: buildStructuredContent({
                 violations,
+                evaluated,
                 diagnostics,
                 qualityDiagnostics,
                 impactResult,