kibi-cli 2.1.0 → 2.2.0

package/dist/prolog.js

@@ -23,7 +23,7 @@ import { fileURLToPath } from "node:url";
 import { getKbPlPathOverride, isPrologDebugEnabled } from "./env.js";
 import { extractPrologErrorRecord, } from "./prolog/error-terms.js";
 const importMetaDir = path.dirname(fileURLToPath(import.meta.url));
-const PROLOG_OUTPUT_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
+const DEFAULT_PROLOG_OUTPUT_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
 const PROLOG_OUTPUT_OVERFLOW_ERROR = "Query exceeded bounded Prolog output capacity (ENOBUFS); narrow the operation or reduce stored entity size";
 const INTERACTIVE_QUERY_FRAME_END = "__KIBI_QUERY_FRAME_END__";
 const require = createRequire(import.meta.url);
@@ -79,6 +79,22 @@ export function resolveKbPlPath() {
     throw new Error("Unable to resolve kb.pl. Expected kibi-core to be installed (node_modules) " +
         "or to be running inside the monorepo checkout.");
 }
+/**
+ * Raised when a query reaches an interactive process that was started and
+ * later terminated (output overflow, timeout, crash, or explicit terminate).
+ * Such a port must be restarted by its owner (the engine daemon recycles it);
+ * it never degrades into isolated one-shot SWI processes, which would lose
+ * the attached KB and every module loaded into the interactive session.
+ */
+export class PrologProcessTerminatedError extends Error {
+    code = "prolog_process_terminated";
+    reason;
+    constructor(reason) {
+        super(`Kibi Prolog process is no longer running (${reason}); the interactive session and its attached KB were lost. The owning engine must restart it before serving more queries — run 'kibi engine stop' and retry if this persists.`);
+        this.name = "PrologProcessTerminatedError";
+        this.reason = reason;
+    }
+}
 // implements REQ-core-prolog-process-management
 export function registerProcessExitOnce(current, handler, on = (event, listener) => process.on(event, listener)) {
     if (current)
@@ -108,9 +124,23 @@ export class PrologProcess {
     useOneShotMode;
     attachedKbPath = null;
     onProcessExit = null;
+    maxOutputBytes;
+    /**
+     * Set once start() spawned an interactive process. From then on the
+     * isolated one-shot fallback is unreachable: a lost interactive process
+     * must fail loudly instead of silently changing execution semantics.
+     */
+    interactiveStarted = false;
+    terminationReason = null;
     constructor(options = {}) {
         this.swiplPath = options.swiplPath || "swipl";
         this.timeout = options.timeout || 30000;
+        this.maxOutputBytes =
+            options.maxOutputBytes !== undefined &&
+                Number.isInteger(options.maxOutputBytes) &&
+                options.maxOutputBytes > 0
+                ? options.maxOutputBytes
+                : DEFAULT_PROLOG_OUTPUT_MAX_BUFFER_BYTES;
         this.useOneShotMode =
             options.oneShot ??
                 (process.env.NODE_ENV === "test" &&
@@ -120,11 +150,28 @@ export class PrologProcess {
     attachProcessExitHandler(on = (event, listener) => process.on(event, listener)) {
         this.onProcessExit = bindProcessExitHandler(this.onProcessExit, () => this.terminate(), on);
     }
+    /**
+     * True when every query runs in its own isolated SWI process, so callers
+     * must not rely on state (loaded modules) carried between queries.
+     */
+    get oneShotMode() {
+        return this.useOneShotMode || !this.interactiveStarted;
+    }
+    /**
+     * True once a started interactive process has been lost. The owner must
+     * restart it (and re-establish its session state) before querying again.
+     */
+    needsRestart() {
+        return this.interactiveStarted && !this.isProcessUsable();
+    }
     async start() {
         if (!existsSync(this.swiplPath) && this.swiplPath !== "swipl") {
             throw new Error(`SWI-Prolog not found at ${this.swiplPath}. Please install SWI-Prolog or check your PATH.`);
         }
         const kbPath = resolveKbPlPath();
+        this.interactiveStarted = true;
+        this.terminationReason = null;
+        this.invalidateCache();
         this.process = spawn(this.swiplPath, [
             "-g",
             `use_module('${kbPath}'), use_module(library(semweb/rdf_db)), set_prolog_flag(answer_write_options, [max_depth(0), quoted(true)])`,
@@ -148,6 +195,16 @@ export class PrologProcess {
         this.process.stderr.on("data", (chunk) => {
             this.appendErrorChunk(chunk);
         });
+        // A write racing the child's death (native crash, external kill) fails
+        // asynchronously with EPIPE. Unhandled, that error event crashes the
+        // whole host (the engine daemon); record the loss instead so the owner
+        // sees needsRestart() and the in-flight query reports the termination.
+        const child = this.process;
+        child.stdin?.on("error", (error) => {
+            if (this.process === child) {
+                this.terminationReason ??= `stdin ${error.code ?? "error"}`;
+            }
+        });
         this.process.stdin.write("true.\n");
         this.attachProcessExitHandler();
         await this.waitForReady();
@@ -223,10 +280,10 @@ export class PrologProcess {
             // runtimes provide an EngineClient, while explicitly attached callers
             // call start() and stay interactive; this fallback never participates
             // in the engine-backed workflow.
-            if (this.process === null) {
+            if (this.process === null && !this.interactiveStarted) {
                 return this.execOneShot(goal, this.attachedKbPath);
             }
-            throw new Error("Prolog process not started");
+            throw this.lostProcessError();
         }
         const runInteractiveQuery = async () => {
             this.clearQueryBuffers();
@@ -264,6 +321,7 @@ export class PrologProcess {
                         console.error(`[prolog debug] runtime=${runtime ?? "unknown"} packages=${process.env.KIBI_PACKAGE_VERSIONS ?? KIBI_PACKAGE_VERSIONS}`);
                     }
                     settled = true;
+                    this.terminationReason = `query timeout: ${goalLabel}`;
                     void this.terminate().finally(() => {
                         reject(new Error(msg));
                     });
@@ -275,6 +333,7 @@ export class PrologProcess {
                     if (this.outputOverflowed) {
                         clearTimeout(timeoutId);
                         settled = true;
+                        this.terminationReason = `output overflow (ENOBUFS): ${goalLabel}`;
                         void this.terminate().finally(() => {
                             resolve({
                                 success: false,
@@ -287,6 +346,7 @@ export class PrologProcess {
                     if (!this.isProcessUsable()) {
                         clearTimeout(timeoutId);
                         settled = true;
+                        this.terminationReason ??= `process exited during query: ${goalLabel}`;
                         resolve({
                             success: false,
                             bindings: {},
@@ -358,7 +418,7 @@ export class PrologProcess {
         await previousQuery;
         try {
             if (!this.isProcessUsable()) {
-                throw new Error("Prolog process not started");
+                throw this.lostProcessError();
             }
             return await runInteractiveQuery();
         }
@@ -508,7 +568,7 @@ export class PrologProcess {
             if (outputOverflowed)
                 return;
             const bytes = target === "stdout" ? outputBytes : errorBytes;
-            const remaining = PROLOG_OUTPUT_MAX_BUFFER_BYTES - bytes;
+            const remaining = this.maxOutputBytes - bytes;
             if (chunk.byteLength > remaining) {
                 const clipped = chunk.subarray(0, Math.max(0, remaining)).toString();
                 if (target === "stdout")
@@ -624,10 +684,10 @@ export class PrologProcess {
     appendOutputChunk(chunk) {
         if (this.outputOverflowed)
             return;
-        const remaining = PROLOG_OUTPUT_MAX_BUFFER_BYTES - this.outputBufferBytes;
+        const remaining = this.maxOutputBytes - this.outputBufferBytes;
         if (chunk.byteLength > remaining) {
             this.outputBuffer += chunk.subarray(0, remaining).toString();
-            this.outputBufferBytes = PROLOG_OUTPUT_MAX_BUFFER_BYTES;
+            this.outputBufferBytes = this.maxOutputBytes;
             this.outputOverflowed = true;
             return;
         }
@@ -637,10 +697,10 @@ export class PrologProcess {
     appendErrorChunk(chunk) {
         if (this.outputOverflowed)
             return;
-        const remaining = PROLOG_OUTPUT_MAX_BUFFER_BYTES - this.errorBufferBytes;
+        const remaining = this.maxOutputBytes - this.errorBufferBytes;
         if (chunk.byteLength > remaining) {
             this.errorBuffer += chunk.subarray(0, remaining).toString();
-            this.errorBufferBytes = PROLOG_OUTPUT_MAX_BUFFER_BYTES;
+            this.errorBufferBytes = this.maxOutputBytes;
             this.outputOverflowed = true;
             return;
         }
@@ -827,7 +887,16 @@ export class PrologProcess {
     getPid() {
         return this.process?.pid || 0;
     }
+    lostProcessError() {
+        if (!this.interactiveStarted) {
+            return new Error("Prolog process not started");
+        }
+        return new PrologProcessTerminatedError(this.terminationReason ?? "process exited");
+    }
     async terminate() {
+        if (this.interactiveStarted) {
+            this.terminationReason ??= "terminated";
+        }
         if (this.terminationPromise) {
             await this.terminationPromise;
             return;

package/dist/public/diagnostic-usage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diagnostic-usage.d.ts","sourceRoot":"","sources":["../../src/public/diagnostic-usage.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzD,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAC7D,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAiCD,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACtC,MAAM,CAIR;AAkHD,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACvC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,EACnD,MAAM,EAAE,OAAO,GACd,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA2EzB;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,oBAAoB,GAAG,IAAI,CAgC1E"}
+{"version":3,"file":"diagnostic-usage.d.ts","sourceRoot":"","sources":["../../src/public/diagnostic-usage.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzD,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAC7D,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAuBD,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACtC,MAAM,CAIR;AAkHD,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACvC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,EACnD,MAAM,EAAE,OAAO,GACd,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwEzB;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,oBAAoB,GAAG,IAAI,CAgC1E"}

package/dist/public/diagnostic-usage.js

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

package/dist/public/impact/full-kb-quality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"full-kb-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/full-kb-quality.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAatC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAWjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AASpD,KAAK,+BAA+B,GAAG;IACrC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAAC,CAAC;IAC7D,QAAQ,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAmgBF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAAC,GAClD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA0D7B;AAED,wBAAgB,eAAe,CAC7B,UAAU,EAAE,OAAO,GAClB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAM/C;AA2ID,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAkCvC"}
+{"version":3,"file":"full-kb-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/full-kb-quality.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAatC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAWjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AASpD,KAAK,+BAA+B,GAAG;IACrC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAAC,CAAC;IAC7D,QAAQ,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAmgBF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAAC,GAClD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA8C7B;AAED,wBAAgB,eAAe,CAC7B,UAAU,EAAE,OAAO,GAClB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAM/C;AA2ID,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAkCvC"}

package/dist/public/impact/full-kb-quality.js

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

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

@@ -72,7 +72,7 @@ export declare const OPERATION_CATALOG: readonly [{
             };
             readonly id: {
                 readonly type: "string";
-                readonly description: "Optional exact entity ID. Example: 'REQ-001'. If omitted, returns matching entities by other filters.";
+                readonly description: "Optional exact entity ID. Example: 'REQ-cli-gc'. If omitted, returns matching entities by other filters.";
             };
             readonly tags: {
                 readonly type: "array";
@@ -216,6 +216,12 @@ export declare const OPERATION_CATALOG: readonly [{
                 readonly default: 0.18;
                 readonly description: "Intent-v1 acceptance threshold between 0 and 1. Low-confidence queries abstain instead of returning misleading matches.";
             };
+            readonly fields: {
+                readonly type: "string";
+                readonly enum: readonly ["summary", "full"];
+                readonly default: "summary";
+                readonly description: "Optional result detail. 'summary' returns identifying metadata plus the match snippet for discovery. Use 'full' to include complete entity bodies, or follow up with kb_query for the exact entities you need.";
+            };
         };
     };
     readonly requiresProlog: true;
@@ -759,7 +765,7 @@ export declare const OPERATION_CATALOG: readonly [{
             };
             readonly id: {
                 readonly type: "string";
-                readonly description: "Unique entity ID (string). Example: 'REQ-123'. Existing ID updates the entity; new ID creates it.";
+                readonly description: "Unique entity ID (string). Example: 'REQ-cli-gc'. Name entities by the behavior they govern (<TYPE>-<area>-<behavior>), never by the next free number. Existing ID updates the entity; new ID creates it.";
             };
             readonly properties: {
                 readonly type: "object";
@@ -775,7 +781,7 @@ export declare const OPERATION_CATALOG: readonly [{
                     };
                     readonly source: {
                         readonly type: "string";
-                        readonly description: "Optional provenance string. Example: 'docs/requirements/REQ-123.md'. Defaults to 'mcp://kibi/upsert'.";
+                        readonly description: "Optional provenance string. Example: '.kb/requirements/REQ-cli-gc.md'. Defaults to 'mcp://kibi/upsert'.";
                     };
                     readonly tags: {
                         readonly type: "array";
@@ -801,7 +807,7 @@ export declare const OPERATION_CATALOG: readonly [{
                         readonly items: {
                             readonly type: "string";
                         };
-                        readonly description: "Optional references. Example: ['REQ-010','https://example.com/spec'].";
+                        readonly description: "Optional references. Example: ['REQ-cli-gc','https://example.com/spec'].";
                     };
                     readonly text_ref: {
                         readonly type: "string";
@@ -1276,6 +1282,29 @@ export declare const OPERATION_CATALOG: readonly [{
                         };
                         readonly description: "Optional ordered argument explanations.";
                     };
+                    readonly argument_constants: {
+                        readonly type: "object";
+                        readonly additionalProperties: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly minItems: 1;
+                        };
+                        readonly description: "predicate_schema only: allowed constants keyed by argument name, e.g. {\"severity\": [\"warning\", \"info\"]}. Predicate facts must use a listed constant for those arguments; unlisted arguments stay open.";
+                    };
+                    readonly argument_aliases: {
+                        readonly type: "object";
+                        readonly additionalProperties: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                        readonly description: "predicate_schema only: legacy spellings keyed by argument name, each mapped to a declared constant, e.g. {\"severity\": {\"warn\": \"warning\"}}. kibi migrate rewrites facts that still use an alias.";
+                    };
                     readonly aliases: {
                         readonly type: "array";
                         readonly items: {
@@ -1345,7 +1374,7 @@ export declare const OPERATION_CATALOG: readonly [{
                     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", "relates_to"];
+                            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", "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: {
@@ -1354,7 +1383,7 @@ export declare const OPERATION_CATALOG: readonly [{
                         };
                         readonly to: {
                             readonly type: "string";
-                            readonly description: "Target entity ID (must exist). Example: 'REQ-001'.";
+                            readonly description: "Target entity ID (must exist). Example: 'REQ-cli-gc'.";
                         };
                     };
                 };
@@ -1451,7 +1480,7 @@ export declare const OPERATION_CATALOG: readonly [{
                     readonly type: "string";
                     readonly enum: readonly string[];
                 };
-                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, proof-contract-symbols. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
+                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, predicate-schema-conformance. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
             };
             readonly sourceFiles: {
                 readonly type: "array";

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.map

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

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

@@ -1,9 +1,10 @@
 import { runAggregatedChecks } from "../../commands/aggregated-checks.js";
 import { collectFullKbQualityDiagnostics } from "../impact-diagnostics.js";
 import { buildStructuredContent, buildSummary, } from "./check-format-shared.js";
-import { analyzeKbCheckImpact, collectQueryPlanSafetyViolations, getEffectiveRules, partitionCheckFindings, qualityDiagnosticsFromImpact, resolveCheckRules, } from "./check-helpers.js";
+import { analyzeKbCheckImpact, collectQueryPlanSafetyViolations, getEffectiveRules, partitionCheckFindings, qualityDiagnosticsFromImpact, resolveCheckRules, stagedEntityIdStyleDiagnostics, } from "./check-helpers.js";
 import { executeStatus } from "./discovery-executors.js";
 import { buildActionsFromCheck, buildMigrationPlan, mergeMigrationPlans, } from "./migration-plan.js";
+import { collectPredicateSchemaConformanceViolations } from "./predicate-schema-conformance.js";
 import { collectSourceRelationshipParityViolations } from "./source-relationship-parity.js";
 import { readWorkspaceSnapshot } from "./workspace-snapshot.js";
 export { buildStructuredContent, buildSummary, getEffectiveRules, resolveCheckRules, };
@@ -61,7 +62,10 @@ export async function executeCheck(args, context, options = {}) {
         const rulesAllowlist = resolveCheckRules(args);
         const hasExplicitRules = args.rules !== undefined;
         const impactResult = await analyzeKbCheckImpact(workspaceRoot, args);
-        const impactQualityDiagnostics = qualityDiagnosticsFromImpact(impactResult);
+        const impactQualityDiagnostics = [
+            ...qualityDiagnosticsFromImpact(impactResult),
+            ...stagedEntityIdStyleDiagnostics(workspaceRoot, args),
+        ];
         const maxDiagnosticsOption = args.maxDiagnostics !== undefined
             ? { maxDiagnostics: args.maxDiagnostics }
             : {};
@@ -109,10 +113,14 @@ export async function executeCheck(args, context, options = {}) {
         const sourceRelationshipParityViolations = rulesAllowlist.has("source-relationship-parity")
             ? await collectSourceRelationshipParityViolations(workspaceRoot, prolog)
             : [];
+        const predicateConformanceFindings = rulesAllowlist.has("predicate-schema-conformance")
+            ? await collectPredicateSchemaConformanceViolations(prolog)
+            : [];
         const partitioned = partitionCheckFindings([
             ...aggregatedFindings,
             ...queryPlanViolations,
             ...sourceRelationshipParityViolations,
+            ...predicateConformanceFindings,
         ]);
         const violations = partitioned.violations;
         const diagnostics = violations.map((v) => ({

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

@@ -31,5 +31,11 @@ export declare function resolveCheckRules(args: Pick<CheckInput, "rules">): Set<
 export declare function readLegacyChecksHint(workspaceRoot: string): Promise<string | null>;
 export declare function hasImpactOptions(args: CheckInput): boolean;
 export declare function analyzeKbCheckImpact(workspaceRoot: string, args: CheckInput): Promise<ChangedFileImpactResult | undefined>;
+/**
+ * Advisory naming-style review for entity Markdown staged as new. Runs only
+ * for `staged: true`, the creation boundary where a purely numeric ID can
+ * still be renamed cheaply; committed legacy entities are never evaluated.
+ */
+export declare function stagedEntityIdStyleDiagnostics(workspaceRoot: string, args: Pick<CheckInput, "staged">): readonly QualityDiagnostic[];
 export declare function qualityDiagnosticsFromImpact(impactResult: ChangedFileImpactResult | undefined): readonly QualityDiagnostic[];
 //# sourceMappingURL=check-helpers.d.ts.map

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

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

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

@@ -1,3 +1,4 @@
+import { execSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
@@ -20,6 +21,8 @@ import path from "node:path";
  */
 import { getKbPlPathOverride } from "../../env.js";
 import { resolveKbPlPath } from "../../prolog.js";
+import { getStagedFiles } from "../../traceability/git-staged.js";
+import { createStagedEntityIdStyleDiagnostics } from "../../traceability/staged-entity-id-style.js";
 import { analyzePrologQueryPlanSafety } from "../../utils/prolog-query-plan-safety.js";
 import { RULE_NAMES, getEffectiveRules, getRuleDefinition, getRuleEnforcementClass, } from "../../utils/rule-registry.js";
 import { analyzeChangedFileImpact, } from "../impact-diagnostics.js";
@@ -45,7 +48,7 @@ export function partitionCheckFindings(findings) {
         const definition = getRuleDefinition(finding.rule);
         qualityDiagnostics.push({
             id: `rule.${finding.rule}`,
-            severity: "warning",
+            severity: definition?.diagnosticSeverity ?? "warning",
             blocking: false,
             category: definition?.category ?? "integrity",
             ...(finding.entityId !== undefined ? { entityId: finding.entityId } : {}),
@@ -135,6 +138,23 @@ export async function analyzeKbCheckImpact(workspaceRoot, args) {
             : {}),
     });
 }
+/**
+ * Advisory naming-style review for entity Markdown staged as new. Runs only
+ * for `staged: true`, the creation boundary where a purely numeric ID can
+ * still be renamed cheaply; committed legacy entities are never evaluated.
+ */
+// implements REQ-kibi-entity-id-style
+export function stagedEntityIdStyleDiagnostics(workspaceRoot, args) {
+    if (args.staged !== true)
+        return [];
+    try {
+        return createStagedEntityIdStyleDiagnostics(getStagedFiles((command, options) => execSync(command, { ...options, cwd: workspaceRoot })));
+    }
+    catch {
+        // Outside a Git work tree there is no staged creation boundary.
+        return [];
+    }
+}
 // implements REQ-mcp-tool-check
 export function qualityDiagnosticsFromImpact(impactResult) {
     if (impactResult === undefined)

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

@@ -1 +1 @@
-{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../src/public/operations/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,0BAA0B,EAC1B,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB,oEAAoE;AACpE,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAwDpE;;uEAEuE;AACvE,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,mBAAmB,GAC1B,mBAAmB,CAMrB;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAsP3C,CAAC;AAgDF,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,EAClD,YAAY,EAAE,MAAM,GACnB,IAAI,CAIN;AAED,wBAAgB,eAAe,CAC7B,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,SAAS,0BAA0B,EAAE,CAoBvC"}
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../src/public/operations/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,0BAA0B,EAC1B,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB,oEAAoE;AACpE,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAwDpE;;uEAEuE;AACvE,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,mBAAmB,GAC1B,mBAAmB,CAMrB;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAyQ3C,CAAC;AAgDF,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,EAClD,YAAY,EAAE,MAAM,GACnB,IAAI,CAIN;AAED,wBAAgB,eAAe,CAC7B,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,SAAS,0BAA0B,EAAE,CAoBvC"}

package/dist/public/operations/contracts.js

@@ -145,6 +145,21 @@ export const OPERATION_DATA_SCHEMAS = {
         warnings: recordArray,
         migrationWarning: { type: ["string", "null"] },
         logic: recordValue,
+        vocabularyAlignment: objectData({
+            subject: recordValue,
+            redundancyCandidates: recordArray,
+            reviewPlan: recordArray,
+            stamps: recordArray,
+            fallbackUsed: booleanValue,
+            diagnostics: recordArray,
+        }, [
+            "subject",
+            "redundancyCandidates",
+            "reviewPlan",
+            "stamps",
+            "fallbackUsed",
+            "diagnostics",
+        ]),
     }),
     kb_suggest_predicates: objectData({
         text: stringValue,
@@ -226,6 +241,7 @@ export const OPERATION_DATA_SCHEMAS = {
         sourceWrites: recordArray,
         deletionPlan: recordValue,
         supersessionPlan: recordValue,
+        skippedEffects: stringArray,
         status: stringValue,
         effectFailures: recordArray,
         nextActions: recordArray,

package/dist/public/operations/discovery-entities.d.ts

@@ -1,4 +1,4 @@
-import type { PrologPort } from "./runtime-types.js";
+import type { PrologEntityQueryInput, PrologEntityQueryResult, PrologPort } from "./runtime-types.js";
 export type EntityQueryInput = {
     readonly type?: string;
     readonly id?: string;
@@ -7,10 +7,22 @@ export type EntityQueryInput = {
     /** Page size for index-backed queries; bounds each query's output. */
     readonly limit?: number;
     readonly offset?: number;
+    /**
+     * Proof selection only needs the contract. Omit receipt histories so a
+     * campaign does not page every full test entity.
+     */
+    readonly projection?: "proof_contract";
 };
 export declare const VALID_ENTITY_TYPES: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
 export declare function validateEntityType(type?: string): void;
+/**
+ * Proof campaign selection must not materialize every contracted test in a
+ * single Prolog result. The specialized projection excludes receipt histories
+ * and returns one bounded page at a time.
+ */
+export declare const PROOF_CONTRACT_PAGE_SIZE = 100;
 export declare function buildEntityGoal(input: EntityQueryInput): string;
+export declare function loadEntitiesPaged(prolog: Pick<PrologPort, "query">, type: (typeof VALID_ENTITY_TYPES)[number], pageSize?: number): Promise<Record<string, unknown>[]>;
 export declare function loadEntities(prolog: Pick<PrologPort, "query">, input: EntityQueryInput): Promise<Record<string, unknown>[]>;
 export declare function paginateResults<T>(results: readonly T[], limit?: number, offset?: number): T[];
 /**
@@ -20,10 +32,38 @@ export declare function paginateResults<T>(results: readonly T[], limit?: number
  * a byte-size guarantee for arbitrarily large individual entity payloads.
  */
 export declare const SEARCH_CANDIDATE_PAGE_SIZE = 500;
-export declare function loadSearchCandidates(prolog: Pick<PrologPort, "searchEntities">, input: {
+export declare function loadSearchCandidates(prolog: Pick<PrologPort, "searchEntities"> & Partial<Pick<PrologPort, "query">>, input: {
     readonly query: string;
     readonly type?: string;
     readonly maxCandidates?: number;
 }, signal?: AbortSignal): Promise<Record<string, unknown>[]>;
+/**
+ * Projected candidate rows for every entity (optionally of one type), in id
+ * order, bounded by `maxCandidates`. For semantic discovery that has no
+ * lexical token to pre-filter candidates.
+ */
+export declare function listSearchCandidates(prolog: Pick<PrologPort, "query">, input: {
+    readonly type?: string;
+    readonly maxCandidates: number;
+}, signal?: AbortSignal): Promise<Record<string, unknown>[]>;
+/**
+ * Rows per `kb_query_entities` request. Full entities carry receipt
+ * histories, so a caller-sized page (up to 100k rows) is split into bounded
+ * requests and concatenated; the reported count is the total match count.
+ */
+export declare const ENTITY_QUERY_CHUNK_SIZE = 25;
+export declare function queryEntityChunks(readChunk: (input: PrologEntityQueryInput) => Promise<PrologEntityQueryResult>, input: PrologEntityQueryInput): Promise<PrologEntityQueryResult>;
+/** Bounded `kb_query_entities` paging for ports without the engine method. */
+export declare function queryEntitiesViaQuery(prolog: Pick<PrologPort, "query">, input: PrologEntityQueryInput, signal?: AbortSignal): Promise<PrologEntityQueryResult>;
+/** Every entity id, without materializing entity properties. */
+export declare function loadEntityIds(prolog: Pick<PrologPort, "query">): Promise<string[]>;
+/**
+ * Replace projected search candidates with complete entities, one bounded
+ * query per entity. Used only for the final result page when a caller asks
+ * for full entity bodies.
+ */
+export declare function reloadFullEntities<TMatch extends {
+    readonly entity: Record<string, unknown>;
+}>(prolog: Pick<PrologPort, "query">, matches: readonly TMatch[]): Promise<TMatch[]>;
 export declare function dedupeEntities(entities: readonly Record<string, unknown>[]): Record<string, unknown>[];
 //# sourceMappingURL=discovery-entities.d.ts.map