kibi-cli 0.14.0 → 0.17.0

package/dist/prolog.d.ts

@@ -13,7 +13,10 @@ export declare class PrologProcess {
     private swiplPath;
     private timeout;
     private outputBuffer;
+    private outputBufferBytes;
+    private outputOverflowed;
     private errorBuffer;
+    private errorBufferBytes;
     private cache;
     private interactiveQueryTail;
     private terminationPromise;
@@ -32,6 +35,8 @@ export declare class PrologProcess {
     private execOneShot;
     private normalizeGoal;
     private clearQueryBuffers;
+    private appendOutputChunk;
+    private appendErrorChunk;
     private isProcessUsable;
     private extractBindings;
     private translateError;

package/dist/prolog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prolog.d.ts","sourceRoot":"","sources":["../src/prolog.ts"],"names":[],"mappings":"AA4BA,wBAAgB,eAAe,IAAI,MAAM,CAsCxC;AACD,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,KAAK,CAAuC;IACpD,OAAO,CAAC,oBAAoB,CAAoC;IAChE,OAAO,CAAC,kBAAkB,CAA8B;IACxD,OAAO,CAAC,cAAc,CACyC;IAC/D,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,aAAa,CAA6B;gBAEtC,OAAO,GAAE,aAAkB;IAKjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAuCd,YAAY;IA2CpB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAyK1D,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,kBAAkB;YAIZ,YAAY;IA2C1B,OAAO,CAAC,WAAW;IAsGnB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,eAAe;IAkBvB,OAAO,CAAC,cAAc;IA6DtB,SAAS,IAAI,OAAO;IAMpB,MAAM,IAAI,MAAM;IAIV,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CAwCjC"}
+{"version":3,"file":"prolog.d.ts","sourceRoot":"","sources":["../src/prolog.ts"],"names":[],"mappings":"AAgCA,wBAAgB,eAAe,IAAI,MAAM,CAsCxC;AACD,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,KAAK,CAAuC;IACpD,OAAO,CAAC,oBAAoB,CAAoC;IAChE,OAAO,CAAC,kBAAkB,CAA8B;IACxD,OAAO,CAAC,cAAc,CACyC;IAC/D,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,aAAa,CAA6B;gBAEtC,OAAO,GAAE,aAAkB;IAKjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAuCd,YAAY;IAyCpB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAsL1D,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,kBAAkB;YAIZ,YAAY;IA2C1B,OAAO,CAAC,WAAW;IA+GnB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,gBAAgB;IAcxB,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,eAAe;IAkBvB,OAAO,CAAC,cAAc;IA6DtB,SAAS,IAAI,OAAO;IAMpB,MAAM,IAAI,MAAM;IAIV,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CAwCjC"}

package/dist/prolog.js

@@ -22,6 +22,9 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { getKbPlPathOverride, isPrologDebugEnabled } from "./env.js";
 const importMetaDir = path.dirname(fileURLToPath(import.meta.url));
+const 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);
 export function resolveKbPlPath() {
     // implements REQ-009
@@ -64,7 +67,10 @@ export class PrologProcess {
     swiplPath;
     timeout;
     outputBuffer = "";
+    outputBufferBytes = 0;
+    outputOverflowed = false;
     errorBuffer = "";
+    errorBufferBytes = 0;
     cache = new Map();
     interactiveQueryTail = Promise.resolve();
     terminationPromise = null;
@@ -90,10 +96,10 @@ export class PrologProcess {
             throw new Error("Failed to spawn Prolog process");
         }
         this.process.stdout.on("data", (chunk) => {
-            this.outputBuffer += chunk.toString();
+            this.appendOutputChunk(chunk);
         });
         this.process.stderr.on("data", (chunk) => {
-            this.errorBuffer += chunk.toString();
+            this.appendErrorChunk(chunk);
         });
         this.process.stdin.write("true.\n");
         if (!this.onProcessExit) {
@@ -118,8 +124,7 @@ export class PrologProcess {
                 throw new Error(`Failed to load kb module: ${this.translateError(this.errorBuffer)}`);
             }
             if (this.outputBuffer.includes("true.")) {
-                this.outputBuffer = "";
-                this.errorBuffer = "";
+                this.clearQueryBuffers();
                 return;
             }
             // brief pause
@@ -130,8 +135,7 @@ export class PrologProcess {
         if (this.errorBuffer.includes("ERROR")) {
             throw new Error(`Failed to load kb module: ${this.translateError(this.errorBuffer)}`);
         }
-        this.outputBuffer = "";
-        this.errorBuffer = "";
+        this.clearQueryBuffers();
     }
     // implements REQ-core-prolog-process-management
     async query(goal) {
@@ -146,10 +150,15 @@ export class PrologProcess {
         }
         if (this.useOneShotMode) {
             const oneShotResult = await this.queryOneShot(goal);
-            if (!cacheable && oneShotResult.success) {
+            // Compound goals are read-after-write sensitive, so keep them out of the
+            // cache to mirror the interactive path and let later reads observe
+            // same-session writes (e.g. kb_status freshness after a file lands).
+            const isBatchGoal = isSingleGoal && /^\s*\(/.test(this.normalizeGoal(goal));
+            const shouldCache = cacheable && !isBatchGoal;
+            if (!shouldCache && oneShotResult.success) {
                 this.invalidateCache();
             }
-            if (cacheable && oneShotResult.success) {
+            if (shouldCache && oneShotResult.success) {
                 this.cache.set(goalKey, oneShotResult);
             }
             return oneShotResult;
@@ -172,7 +181,7 @@ export class PrologProcess {
             if (debug) {
                 console.error(`[prolog debug] start query: ${normalizedGoal}`);
             }
-            this.process?.stdin?.write(`${wrappedGoal}.\n`);
+            this.process?.stdin?.write(`${wrappedGoal}.\nwriteln('${INTERACTIVE_QUERY_FRAME_END}').\n`);
             return new Promise((resolve, reject) => {
                 let settled = false;
                 const timeoutId = setTimeout(() => {
@@ -193,6 +202,28 @@ export class PrologProcess {
                     if (settled) {
                         return;
                     }
+                    if (this.outputOverflowed) {
+                        clearTimeout(timeoutId);
+                        settled = true;
+                        void this.terminate().finally(() => {
+                            resolve({
+                                success: false,
+                                bindings: {},
+                                error: PROLOG_OUTPUT_OVERFLOW_ERROR,
+                            });
+                        });
+                        return;
+                    }
+                    if (!this.isProcessUsable()) {
+                        clearTimeout(timeoutId);
+                        settled = true;
+                        resolve({
+                            success: false,
+                            bindings: {},
+                            error: "Query interrupted because the Prolog process terminated",
+                        });
+                        return;
+                    }
                     if (this.errorBuffer.length > 0 &&
                         this.errorBuffer.includes("ERROR")) {
                         clearTimeout(timeoutId);
@@ -207,14 +238,22 @@ export class PrologProcess {
                         });
                         return;
                     }
-                    if (this.outputBuffer.includes("true.") ||
-                        this.outputBuffer.match(/^[A-Z_][A-Za-z0-9_]*\s*=\s*.+\./m) ||
-                        this.outputBuffer.match(/\]\s*$/m)) {
+                    const frameEnd = this.outputBuffer.indexOf(INTERACTIVE_QUERY_FRAME_END);
+                    if (frameEnd >= 0) {
                         clearTimeout(timeoutId);
                         settled = true;
+                        const framedOutput = this.outputBuffer.slice(0, frameEnd).trimEnd();
+                        if (/(?:^|\n)(?:false|fail)\.\s*$/.test(framedOutput)) {
+                            resolve({
+                                success: false,
+                                bindings: {},
+                                error: "Query failed",
+                            });
+                            return;
+                        }
                         const result = {
                             success: true,
-                            bindings: this.extractBindings(this.outputBuffer),
+                            bindings: this.extractBindings(framedOutput),
                         };
                         // Treat any batch/compound goal as non-cacheable to preserve
                         // read-after-write consistency. A batch goal is produced when
@@ -234,25 +273,6 @@ export class PrologProcess {
                         resolve(result);
                         return;
                     }
-                    if (this.outputBuffer.includes("false.") ||
-                        this.outputBuffer.includes("fail.")) {
-                        clearTimeout(timeoutId);
-                        settled = true;
-                        if (debug) {
-                            console.error(`[prolog debug] query failed (false): ${normalizedGoal}`);
-                        }
-                        // Check errorBuffer first — Prolog catch/3 writes ERROR to stderr
-                        // then fail to stdout. If stderr has the real error, surface it.
-                        const errorMessage = this.errorBuffer.length > 0 && this.errorBuffer.includes("ERROR")
-                            ? this.translateError(this.errorBuffer)
-                            : "Query failed";
-                        resolve({
-                            success: false,
-                            bindings: {},
-                            error: errorMessage,
-                        });
-                        return;
-                    }
                     setTimeout(checkResult, 50);
                 };
                 checkResult();
@@ -369,6 +389,7 @@ export class PrologProcess {
         const result = spawnSync(this.swiplPath, ["-q", "-g", prologGoal, "-t", "halt"], {
             encoding: "utf8",
             timeout: this.timeout,
+            maxBuffer: PROLOG_OUTPUT_MAX_BUFFER_BYTES,
             env: {
                 ...process.env,
                 KIBI_GOAL: combinedGoal,
@@ -382,6 +403,13 @@ export class PrologProcess {
                 result.error.message.includes("ETIMEDOUT"))) {
             throw new Error(`Query timeout after ${this.timeout / 1000}s`);
         }
+        if (result.error?.message.includes("ENOBUFS")) {
+            return {
+                success: false,
+                bindings: {},
+                error: PROLOG_OUTPUT_OVERFLOW_ERROR,
+            };
+        }
         const stdout = result.stdout ?? "";
         const stderr = result.stderr ?? "";
         if (stderr.includes("ERROR")) {
@@ -419,7 +447,36 @@ export class PrologProcess {
     }
     clearQueryBuffers() {
         this.outputBuffer = "";
+        this.outputBufferBytes = 0;
+        this.outputOverflowed = false;
         this.errorBuffer = "";
+        this.errorBufferBytes = 0;
+    }
+    appendOutputChunk(chunk) {
+        if (this.outputOverflowed)
+            return;
+        const remaining = PROLOG_OUTPUT_MAX_BUFFER_BYTES - this.outputBufferBytes;
+        if (chunk.byteLength > remaining) {
+            this.outputBuffer += chunk.subarray(0, remaining).toString();
+            this.outputBufferBytes = PROLOG_OUTPUT_MAX_BUFFER_BYTES;
+            this.outputOverflowed = true;
+            return;
+        }
+        this.outputBuffer += chunk.toString();
+        this.outputBufferBytes += chunk.byteLength;
+    }
+    appendErrorChunk(chunk) {
+        if (this.outputOverflowed)
+            return;
+        const remaining = PROLOG_OUTPUT_MAX_BUFFER_BYTES - this.errorBufferBytes;
+        if (chunk.byteLength > remaining) {
+            this.errorBuffer += chunk.subarray(0, remaining).toString();
+            this.errorBufferBytes = PROLOG_OUTPUT_MAX_BUFFER_BYTES;
+            this.outputOverflowed = true;
+            return;
+        }
+        this.errorBuffer += chunk.toString();
+        this.errorBufferBytes += chunk.byteLength;
     }
     // implements REQ-009
     isProcessUsable() {

package/dist/public/impact/diagnostics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../src/public/impact/diagnostics.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAWrF,OAAO,KAAK,EACV,iBAAiB,EACjB,gCAAgC,EAChC,mCAAmC,EACpC,MAAM,YAAY,CAAC;AAoFpB,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,mCAAmC,GAC3C,oBAAoB,EAAE,CA+CxB;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,gCAAgC,GACxC,oBAAoB,EAAE,CAsBxB;AAED,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,SAAS,oBAAoB,EAAE,GAC3C,OAAO,CAET;AAED,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,SAAS,iBAAiB,EAAE,GACxC,OAAO,CAIT"}
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../src/public/impact/diagnostics.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAWrF,OAAO,KAAK,EACV,iBAAiB,EACjB,gCAAgC,EAChC,mCAAmC,EACpC,MAAM,YAAY,CAAC;AA2FpB,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,mCAAmC,GAC3C,oBAAoB,EAAE,CA+CxB;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,gCAAgC,GACxC,oBAAoB,EAAE,CAsBxB;AAED,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,SAAS,oBAAoB,EAAE,GAC3C,OAAO,CAET;AAED,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,SAAS,iBAAiB,EAAE,GACxC,OAAO,CAIT"}

package/dist/public/impact/diagnostics.js

@@ -38,8 +38,12 @@ function readSourceSymbols(sourceFile, sourceContentByFile, workspaceRoot) {
     });
 }
 function getGranularSymbolsForSourceFile(sourceFile, options) {
-    return (options.symbolsByFile.get(sourceFile) ??
-        readSourceSymbols(sourceFile, options.sourceContentByFile, options.workspaceRoot ?? process.cwd()));
+    const sourceSymbols = readSourceSymbols(sourceFile, options.sourceContentByFile, options.workspaceRoot ?? process.cwd());
+    const changedSymbols = options.symbolsByFile.get(sourceFile);
+    return {
+        candidateSymbols: changedSymbols ?? sourceSymbols,
+        sourceSymbols: sourceSymbols.length > 0 ? sourceSymbols : (changedSymbols ?? []),
+    };
 }
 function formatRelationshipTargets(symbol) {
     const targets = [
@@ -69,8 +73,8 @@ export function createSymbolGranularityDiagnostics(options) {
             continue;
         if (hasValidGranularityReason(result))
             continue;
-        const granularSymbols = getGranularSymbolsForSourceFile(result.sourceFile, options);
-        const narrowerSymbols = granularSymbols.filter((symbol) => isNarrowerSymbol(result.entity.title, symbol, granularSymbols));
+        const { candidateSymbols, sourceSymbols } = getGranularSymbolsForSourceFile(result.sourceFile, options);
+        const narrowerSymbols = candidateSymbols.filter((symbol) => isNarrowerSymbol(result.entity.title, symbol, sourceSymbols));
         if (narrowerSymbols.length === 0)
             continue;
         const behavioralNames = getBehavioralSymbolNames(narrowerSymbols);

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

@@ -1,7 +1,7 @@
 import type { PrologProcess } from "../../prolog.js";
 import type { QualityDiagnostic } from "./types.js";
 type FullKbQualityDiagnosticsOptions = {
-    readonly prolog: PrologProcess;
+    readonly prolog: Pick<PrologProcess, "query">;
     readonly hardViolationEntityIds?: ReadonlySet<string>;
     readonly maxDiagnostics?: number;
 };

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":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AASrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAqBpD,KAAK,+BAA+B,GAAG;IACrC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AA+IF,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAmBvC"}
+{"version":3,"file":"full-kb-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/full-kb-quality.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AASrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAqBpD,KAAK,+BAA+B,GAAG;IACrC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAC9C,QAAQ,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AA0KF,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAmBvC"}

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

@@ -63,6 +63,9 @@ function toExtractedEntity(entity) {
     const textRef = optionalStringField(entity, "text_ref");
     if (textRef !== undefined)
         extracted.text_ref = textRef;
+    const logicClaims = optionalStringArrayField(entity, "logic_claims");
+    if (logicClaims !== undefined)
+        extracted.logic_claims = logicClaims;
     const granularityReason = optionalStringField(entity, "granularity_reason");
     if (granularityReason !== undefined) {
         extracted.granularity_reason = granularityReason;
@@ -95,9 +98,39 @@ function toExtractedEntity(entity) {
     if (factKind === "subject" ||
         factKind === "property_value" ||
         factKind === "observation" ||
-        factKind === "meta") {
+        factKind === "meta" ||
+        factKind === "predicate_schema" ||
+        factKind === "predicate") {
         extracted.fact_kind = factKind;
     }
+    const claimKey = optionalStringField(entity, "claim_key");
+    if (claimKey !== undefined)
+        extracted.claim_key = claimKey;
+    const claimText = optionalStringField(entity, "claim_text");
+    if (claimText !== undefined)
+        extracted.claim_text = claimText;
+    const predicateName = optionalStringField(entity, "predicate_name");
+    if (predicateName !== undefined)
+        extracted.predicate_name = predicateName;
+    const predicateNamespace = optionalStringField(entity, "predicate_namespace");
+    if (predicateNamespace !== undefined) {
+        extracted.predicate_namespace = predicateNamespace;
+    }
+    const predicateArity = optionalNumberField(entity, "predicate_arity");
+    if (predicateArity !== undefined)
+        extracted.predicate_arity = predicateArity;
+    for (const field of [
+        "argument_names",
+        "argument_types",
+        "argument_descriptions",
+        "aliases",
+        "examples",
+        "predicate_args",
+    ]) {
+        const values = optionalStringArrayField(entity, field);
+        if (values !== undefined)
+            extracted[field] = values;
+    }
     return extracted;
 }
 function sourceFileFor(entity) {

package/dist/public/impact/requirement-quality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requirement-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/requirement-quality.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AACrF,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,YAAY,CAAC;AA+QvE,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,oCAAoC,GAC5C,oBAAoB,EAAE,CAMxB"}
+{"version":3,"file":"requirement-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/requirement-quality.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AACrF,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,YAAY,CAAC;AA2PvE,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,oCAAoC,GAC5C,oBAAoB,EAAE,CAMxB"}

package/dist/public/impact/requirement-quality.js

@@ -21,16 +21,6 @@ const BROAD_REQUIREMENT_THRESHOLDS = {
     tests: 8,
     dependentRequirements: 5,
 };
-const NORMATIVE_INDICATOR_PATTERNS = [
-    ["must", /\bmust\b/i],
-    ["only", /\bonly\b/i],
-    ["never", /\bnever\b/i],
-    ["limit", /\blimits?\b/i],
-    ["minimum", /\bminimum\b/i],
-    ["maximum", /\bmaximum\b/i],
-    ["at least", /\bat\s+least\b/i],
-    ["at most", /\bat\s+most\b/i],
-];
 function isRequirement(result) {
     return result.entity.type === "req";
 }
@@ -172,24 +162,18 @@ function strictRelationshipTypes(result) {
         .filter((relationship) => STRICT_RELATIONSHIP_TYPES.has(relationship.type))
         .map((relationship) => relationship.type));
 }
-function matchedNormativeIndicators(text) {
-    return NORMATIVE_INDICATOR_PATTERNS.filter((entry) => entry[1].test(text)).map((entry) => entry[0]);
-}
-function createStrictFactModelingDiagnostics(options) {
+function createLogicalCoverageDiagnostics(options) {
     return options.manifestResults.flatMap((result) => {
         if (!isCurrentRequirement(result))
             return [];
         if (options.hardViolationEntityIds?.has(result.entity.id))
             return [];
         const relationshipTypes = strictRelationshipTypes(result);
-        if (relationshipTypes.length > 0)
-            return [];
-        const indicators = matchedNormativeIndicators(result.entity.title);
-        if (indicators.length === 0)
+        if ((result.entity.logic_claims?.length ?? 0) > 0)
             return [];
         return [
             {
-                id: "strict_fact_modeling_review",
+                id: "logical_coverage_review",
                 severity: "review",
                 blocking: false,
                 category: "fact",
@@ -197,10 +181,9 @@ function createStrictFactModelingDiagnostics(options) {
                 source: result.entity.source,
                 files: [result.entity.source],
                 docs: ["docs/modeling-cheatsheet.md", "docs/error-reference.md"],
-                message: `Requirement ${result.entity.id} contains normative prose but has no strict fact or predicate relationship.`,
-                suggestion: "Use kb_model_requirement for strict property facts, or kb_suggest_predicates when the claim fits a predicate schema.",
+                message: `Current requirement ${result.entity.id} has no atomic logic_claims manifest, so prose and existing fact links cannot prove complete logical coverage.`,
+                suggestion: "Call kb_semantic_advisor with the complete requirement prose and atomic clauses, ground each returned claim key through kb_model_requirement or kb_suggest_predicates, and persist all keys in logic_claims.",
                 evidence: {
-                    matchedIndicators: indicators,
                     strictRelationshipTypes: relationshipTypes,
                 },
             },
@@ -211,6 +194,6 @@ export function createRequirementQualityDiagnostics(options) {
     return [
         ...createBroadRequirementDiagnostics(options.manifestResults),
         ...createRequirementStatusDiagnostics(options.manifestResults),
-        ...createStrictFactModelingDiagnostics(options),
+        ...createLogicalCoverageDiagnostics(options),
     ];
 }