kibi-cli 2.18.0 → 2.20.0

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

@@ -43,16 +43,60 @@ export type StoreLockTakeoverRecord = Readonly<{
 export declare function recordStoreLockTakeover(storePath: string, brokenPid: number | null, reason: string, at?: Date): void;
 /** The last takeover record of a branch store, or null when none is readable. */
 export declare function readStoreLockTakeover(storePath: string): StoreLockTakeoverRecord | null;
+/** The holder pid an rdf_persistency `lock` file records, or null. */
+export declare function readRdfLockPid(lockPath: string): number | null;
+/**
+ * Note, before `kb_attach`, whether a dead holder left this branch store
+ * locked, and return the step that records the takeover once the attach has
+ * succeeded.
+ *
+ * rdf_persistency locks the store with an OS advisory lock that the kernel
+ * releases when its holder dies, so a killed engine never makes the next
+ * attach fail with `store_locked`: the attach simply takes the store over.
+ * The only trace is the `rdf/lock` file, which SWI deletes on every detach
+ * and halt; one that is still present was left by a holder that crashed or
+ * was killed. Its holder (the ownership journal when it names the same
+ * process, which adds the boot id, else the lock file's pid) is classified
+ * the same way a `store_locked` failure is. The returned step is a no-op
+ * unless that holder is provably dead; callers run it only after a
+ * successful attach, which proves the holder no longer held the lock.
+ */
+export declare function noteDeadHolderBeforeAttach(kbPath: string): () => void;
 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,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.
@@ -176,19 +176,154 @@ export function readStoreLockTakeover(storePath) {
         return null;
     }
 }
+/** The holder pid an rdf_persistency `lock` file records, or null. */
+// implements REQ-core-journaled-engine-persistence
+export function readRdfLockPid(lockPath) {
+    try {
+        const match = /pid\((\d+)\)/.exec(readFileSync(lockPath, "utf8"));
+        const pid = Number.parseInt(match?.[1] ?? "", 10);
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Note, before `kb_attach`, whether a dead holder left this branch store
+ * locked, and return the step that records the takeover once the attach has
+ * succeeded.
+ *
+ * rdf_persistency locks the store with an OS advisory lock that the kernel
+ * releases when its holder dies, so a killed engine never makes the next
+ * attach fail with `store_locked`: the attach simply takes the store over.
+ * The only trace is the `rdf/lock` file, which SWI deletes on every detach
+ * and halt; one that is still present was left by a holder that crashed or
+ * was killed. Its holder (the ownership journal when it names the same
+ * process, which adds the boot id, else the lock file's pid) is classified
+ * the same way a `store_locked` failure is. The returned step is a no-op
+ * unless that holder is provably dead; callers run it only after a
+ * successful attach, which proves the holder no longer held the lock.
+ */
+// implements REQ-core-journaled-engine-persistence
+export function noteDeadHolderBeforeAttach(kbPath) {
+    const lockPath = join(kbPath, "rdf", "lock");
+    if (!existsSync(lockPath))
+        return () => undefined;
+    const lockPid = readRdfLockPid(lockPath);
+    const journal = readStoreLockOwner(kbPath)?.owner ?? null;
+    const owner = journal !== null && (lockPid === null || journal.pid === lockPid)
+        ? journal
+        : lockPid !== null
+            ? { pid: lockPid }
+            : null;
+    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",
@@ -215,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/proof/inspect.d.ts

@@ -28,7 +28,7 @@ export type ProofInspection = Readonly<{
     integrationPlanReason: string;
 }>;
 export type ProofInspectionOptions = Readonly<{
-    /** Plan a replacement of this existing integration id. */
+    /** Plan adding this integration id, or replacing it when it exists. */
     update?: string;
     /** Command (argv) the proposed integration runs instead of the detected one. */
     command?: readonly string[];

package/dist/proof/inspect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../src/proof/inspect.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,uBAAuB,CAAC;AAM/B,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,gFAAgF;IAChF,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,yEAAyE;IACzE,mBAAmB,EAAE,SAAS,QAAQ,CAAC;QACrC,EAAE,EAAE,MAAM,CAAC;QACX,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;KAC5B,CAAC,EAAE,CAAC;IACL,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,qEAAqE;IACrE,mBAAmB,EAAE,mBAAmB,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAC/D,6EAA6E;IAC7E,gBAAgB,EAAE,mBAAmB,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC;IACjE;;;OAGG;IACH,eAAe,EAAE,aAAa,GAAG,IAAI,CAAC;IACtC,sDAAsD;IACtD,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC,CAAC;AAwIH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAMT;AA2BD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,sBAA2B,GACnC,eAAe,CA0GjB"}
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../src/proof/inspect.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,uBAAuB,CAAC;AAM/B,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,gFAAgF;IAChF,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,yEAAyE;IACzE,mBAAmB,EAAE,SAAS,QAAQ,CAAC;QACrC,EAAE,EAAE,MAAM,CAAC;QACX,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;KAC5B,CAAC,EAAE,CAAC;IACL,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,qEAAqE;IACrE,mBAAmB,EAAE,mBAAmB,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAC/D,6EAA6E;IAC7E,gBAAgB,EAAE,mBAAmB,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC;IACjE;;;OAGG;IACH,eAAe,EAAE,aAAa,GAAG,IAAI,CAAC;IACtC,sDAAsD;IACtD,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,CAAC,CAAC;AAwIH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAMT;AA2BD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,sBAA2B,GACnC,eAAe,CAiHjB"}

package/dist/proof/inspect.js

@@ -219,9 +219,16 @@ export function inspectProofEnvironment(root, options = {}) {
         : [];
     const planned = buildProofIntegrationPlan(root, options);
     const applyHint = "review integrationPlan, then apply it with kb_apply_plan (or `kibi apply-plan --input -`) passing plan, approvedPlanHash = plan.planHash and approvedActionIds";
+    const updateId = options.update?.trim() || undefined;
     let recommendation;
-    if (planned.plan !== null && options.update !== undefined) {
-        recommendation = `To replace integration '${options.update}', ${applyHint}.`;
+    if (planned.plan !== null && updateId !== undefined) {
+        // implements REQ-kibi-verification-evidence-contract
+        // The plan adds an id the file does not have yet; only an existing one is
+        // replaced.
+        const verb = currentIntegrations.some((entry) => entry.id === updateId)
+            ? "replace"
+            : "add";
+        recommendation = `To ${verb} integration '${updateId}', ${applyHint}.`;
     }
     else if (!integrations.available) {
         if (planned.plan === null) {

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

@@ -79,7 +79,7 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_query";
     readonly cliName: "query";
-    readonly description: "Read entities from the KB with filters. Use for discovery and lookup before edits. Do not use for writes. No mutation side effects. Tags filter by metadata tags only, not entity IDs.";
+    readonly description: "Read entities from the KB with exact filters, or ask typed fact questions. Use for lookup by id, type, tags or sourceFile, and for precise questions about modeled facts: predicate facts by name with named arguments (predicate + where), property facts of a subject (subjectKey + propertyKey), or the catalog of facts of one kind (factKind; 'predicate_schema' lists the predicates you can ask about with their argument names and constants). Typed answers return matching fact rows plus factQuery: the schema used, distinct counts, values that do exist when nothing matched, warnings about the question and the next call to make. Read-only. Tags filter by metadata tags only, not entity IDs.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -103,6 +103,55 @@ export declare const OPERATION_CATALOG: readonly [{
                 readonly type: "string";
                 readonly description: "Optional source-file substring filter. Example: 'src/auth/login.ts'. Uses KB source linkage, not file-system scanning.";
             };
+            readonly factKind: {
+                readonly type: "string";
+                readonly enum: readonly ["subject", "property_value", "predicate", "predicate_schema", "observation", "meta", "rule", "rule_schema"];
+                readonly description: "Typed fact filter: list facts of one kind with their typed fields. 'predicate_schema' returns the catalog of askable predicates (argument names, constants, fact counts). Example: 'predicate_schema'.";
+            };
+            readonly predicate: {
+                readonly type: "string";
+                readonly description: "Typed fact filter: predicate name to ask about, e.g. 'has_role' or 'permission_rule'. Combine with where for named arguments. Returns every stored fact of that predicate with its arguments, polarity and allow/deny effect.";
+            };
+            readonly namespace: {
+                readonly type: "string";
+                readonly description: "Optional predicate namespace when the same name exists in several. Default: any namespace.";
+            };
+            readonly where: {
+                readonly type: "object";
+                readonly additionalProperties: {
+                    readonly type: "string";
+                };
+                readonly description: "Named argument values for predicate, order-free, using the argument names from the predicate's schema. Example: {actor: 'admin', decision: 'allow'}. An unknown name returns a warning with the declared names; no match returns the values that do exist.";
+            };
+            readonly args: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly description: "Positional argument values for predicate when it has no schema; null matches any value. Example: ['admin', null, null, 'allow']. Prefer where.";
+            };
+            readonly polarity: {
+                readonly type: "string";
+                readonly enum: readonly ["assert", "deny"];
+                readonly description: "Optional polarity filter for predicate facts. Default: both.";
+            };
+            readonly scope: {
+                readonly type: "string";
+                readonly enum: readonly ["all", "current_requirements"];
+                readonly description: "Optional: 'current_requirements' keeps only facts a current (not superseded or retired) requirement requires.";
+            };
+            readonly distinct: {
+                readonly type: "string";
+                readonly description: "Optional argument name to count distinct values of across the matching predicate facts, e.g. distinct: 'role' with predicate 'has_role' and where {user: 'alice'} answers how many roles alice has.";
+            };
+            readonly subjectKey: {
+                readonly type: "string";
+                readonly description: "Typed fact filter: dotted subject key whose property facts to list, e.g. 'user.role_assignment'. Combine with propertyKey for one property.";
+            };
+            readonly propertyKey: {
+                readonly type: "string";
+                readonly description: "Optional property key under subjectKey, e.g. 'max_roles'. Returns operator, value and unit of each fact.";
+            };
             readonly limit: {
                 readonly type: "number";
                 readonly default: 100;
@@ -141,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";
@@ -669,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"];
@@ -1640,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"}