kibi-cli 0.17.0 → 0.19.0

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

@@ -1,4 +1,7 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
 import { parseEntityFromList, parseListOfLists, parseTriples, } from "../../prolog/codec.js";
+import { analyzeTelemetryAcceptance, createTelemetryAcceptanceDiagnostics, parseTelemetryUsageLog, } from "../telemetry-acceptance.js";
 import { createCoverageDepthQualityDiagnostics } from "./coverage-depth-quality.js";
 import { createRequirementQualityDiagnostics } from "./requirement-quality.js";
 import { createSymbolQualityDiagnostics } from "./symbol-quality.js";
@@ -63,6 +66,9 @@ function toExtractedEntity(entity) {
     const textRef = optionalStringField(entity, "text_ref");
     if (textRef !== undefined)
         extracted.text_ref = textRef;
+    const semanticText = optionalStringField(entity, "semantic_text");
+    if (semanticText !== undefined)
+        extracted.semantic_text = semanticText;
     const logicClaims = optionalStringArrayField(entity, "logic_claims");
     if (logicClaims !== undefined)
         extracted.logic_claims = logicClaims;
@@ -171,10 +177,56 @@ function capDiagnostics(diagnostics, maxDiagnostics) {
         ? diagnostics.slice(0, maxDiagnostics)
         : diagnostics;
 }
+function telemetryReadDiagnostic(message) {
+    return {
+        id: "telemetry_evidence_unreadable",
+        severity: "review",
+        blocking: false,
+        category: "telemetry",
+        source: ".kb/usage.log",
+        message,
+        suggestion: "Repair or regenerate .kb/usage.log through Kibi diagnostic mode, then rerun kibi usage-metrics --require-acceptance and an unfiltered kb_check.",
+    };
+}
+async function collectTelemetryDiagnostics(workspaceRoot, now) {
+    if (workspaceRoot === undefined)
+        return [];
+    const usageLogPath = path.join(workspaceRoot, ".kb", "usage.log");
+    let contents;
+    try {
+        contents = await readFile(usageLogPath, "utf8");
+    }
+    catch (error) {
+        if (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return [];
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return [
+            telemetryReadDiagnostic(`Telemetry acceptance evidence is unreadable: ${message}`),
+        ];
+    }
+    try {
+        const report = analyzeTelemetryAcceptance(parseTelemetryUsageLog(contents), now);
+        return createTelemetryAcceptanceDiagnostics(report);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return [
+            telemetryReadDiagnostic(`Telemetry acceptance evidence is malformed: ${message}`),
+        ];
+    }
+}
 export async function collectFullKbQualityDiagnostics(options) {
-    const manifestResults = await loadKbExtractionResults(options.prolog);
+    const [manifestResults, telemetryDiagnostics] = await Promise.all([
+        loadKbExtractionResults(options.prolog),
+        collectTelemetryDiagnostics(options.workspaceRoot, options.now ?? new Date()),
+    ]);
     const coverageDepthDiagnostics = createCoverageDepthQualityDiagnostics(manifestResults);
     const diagnostics = [
+        ...telemetryDiagnostics,
         ...createRequirementQualityDiagnostics({
             manifestResults,
             ...(options.hardViolationEntityIds !== undefined

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

@@ -3,5 +3,7 @@ export { collectFullKbQualityDiagnostics } from "./impact/full-kb-quality.js";
 export { createSemanticReviewDiagnostics, createSymbolGranularityDiagnostics, hasBlockingImpactDiagnostics, hasBlockingQualityDiagnostics, } from "./impact/diagnostics.js";
 export { createRequirementQualityDiagnostics } from "./impact/requirement-quality.js";
 export { createSymbolQualityDiagnostics } from "./impact/symbol-quality.js";
+export { DEFAULT_TELEMETRY_ACCEPTANCE_POLICY, TELEMETRY_ACCEPTANCE_VERSION, analyzeTelemetryAcceptance, createTelemetryAcceptanceDiagnostics, parseTelemetryUsageLog, } from "./telemetry-acceptance.js";
 export type { ChangedFileImpactOptions, ChangedFileImpactResult, ImpactExtractedSymbol, ImpactLinkedEntity, QualityDiagnostic, QualityDiagnosticSeverity, RequirementQualityDiagnosticsOptions, SemanticReviewDiagnosticsOptions, SymbolGranularityDiagnosticsOptions, SymbolQualityDiagnosticsOptions, } from "./impact/types.js";
+export type { TelemetryAcceptanceMetric, TelemetryAcceptancePolicy, TelemetryAcceptanceReport, TelemetryAcceptanceStatus, TelemetryMetricId, TelemetryMetricStatus, TelemetryUsageEvent, } from "./telemetry-acceptance.js";
 //# sourceMappingURL=impact-diagnostics.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"impact-diagnostics.d.ts","sourceRoot":"","sources":["../../src/public/impact-diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AAC9E,OAAO,EACL,+BAA+B,EAC/B,kCAAkC,EAClC,4BAA4B,EAC5B,6BAA6B,GAC9B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,mCAAmC,EAAE,MAAM,iCAAiC,CAAC;AACtF,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAC5E,YAAY,EACV,wBAAwB,EACxB,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,yBAAyB,EACzB,oCAAoC,EACpC,gCAAgC,EAChC,mCAAmC,EACnC,+BAA+B,GAChC,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"impact-diagnostics.d.ts","sourceRoot":"","sources":["../../src/public/impact-diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AAC9E,OAAO,EACL,+BAA+B,EAC/B,kCAAkC,EAClC,4BAA4B,EAC5B,6BAA6B,GAC9B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,mCAAmC,EAAE,MAAM,iCAAiC,CAAC;AACtF,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,EACL,mCAAmC,EACnC,4BAA4B,EAC5B,0BAA0B,EAC1B,oCAAoC,EACpC,sBAAsB,GACvB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,wBAAwB,EACxB,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,yBAAyB,EACzB,oCAAoC,EACpC,gCAAgC,EAChC,mCAAmC,EACnC,+BAA+B,GAChC,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,iBAAiB,EACjB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,2BAA2B,CAAC"}

package/dist/public/impact-diagnostics.js

@@ -3,3 +3,4 @@ export { collectFullKbQualityDiagnostics } from "./impact/full-kb-quality.js";
 export { createSemanticReviewDiagnostics, createSymbolGranularityDiagnostics, hasBlockingImpactDiagnostics, hasBlockingQualityDiagnostics, } from "./impact/diagnostics.js";
 export { createRequirementQualityDiagnostics } from "./impact/requirement-quality.js";
 export { createSymbolQualityDiagnostics } from "./impact/symbol-quality.js";
+export { DEFAULT_TELEMETRY_ACCEPTANCE_POLICY, TELEMETRY_ACCEPTANCE_VERSION, analyzeTelemetryAcceptance, createTelemetryAcceptanceDiagnostics, parseTelemetryUsageLog, } from "./telemetry-acceptance.js";

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

@@ -139,7 +139,7 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_status";
     readonly cliName: "status";
-    readonly description: "Report current branch, snapshot, and freshness metadata for the attached KB. Read-only status inspection with no mutation side effects.";
+    readonly description: "Report current branch, KB snapshot and freshness metadata, plus the deterministic workspace snapshot used to validate execution receipts. Read-only status inspection with no mutation side effects.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {};
@@ -195,7 +195,7 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_coverage";
     readonly cliName: "coverage";
-    readonly description: "Generate curated coverage reports for requirements, symbols, or grouped types. Read-only reporting with no mutation side effects.";
+    readonly description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Requirement reports include a deterministic, dependency-ordered, read-only repair plan; optional legacy migration previews reconstruct authored proposition inventories and rank exact schema candidates without producing executable writes. Paginated plans identify incomplete scope. Requirement rows keep coverageStatus separate from proofStatus and require fresh snapshot-bound E2E receipts before proof. No mutation side effects.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -226,6 +226,38 @@ export declare const OPERATION_CATALOG: readonly [{
                 readonly type: "integer";
                 readonly default: 0;
             };
+            readonly includeMigrationPreview: {
+                readonly type: "boolean";
+                readonly default: false;
+                readonly description: "Opt in to a deterministic, read-only kibi.legacy-migration-plan.v1 preview for ready semantic-inventory repair batches.";
+            };
+            readonly migrationLimit: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 10;
+                readonly default: 1;
+                readonly description: "Maximum requirement migration batches to preview. Defaults to one review batch.";
+            };
+            readonly migrationOffset: {
+                readonly type: "integer";
+                readonly minimum: 0;
+                readonly default: 0;
+                readonly description: "Zero-based offset into ready semantic-inventory batches.";
+            };
+            readonly migrationPredicateLimit: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 20;
+                readonly default: 5;
+                readonly description: "Maximum exact predicate-schema candidates retained per assertive proposition.";
+            };
+            readonly migrationPredicateMinScore: {
+                readonly type: "number";
+                readonly minimum: 0;
+                readonly maximum: 1;
+                readonly default: 0.35;
+                readonly description: "Minimum deterministic predicate-schema rank score retained in migration previews.";
+            };
         };
     };
     readonly requiresProlog: true;
@@ -438,7 +470,7 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_suggest_predicates";
     readonly cliName: "suggest-predicates";
-    readonly description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Read-only guidance returns ranked candidates, a safe predicate-fact applyPlan, a separate requires_predicate relationshipPlan when a requirement ID is supplied, or an explicit ontology-gap observation when no predicate fits.";
+    readonly description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Read-only guidance returns ranked candidates, an applicable predicate-fact plan only when every ordered argument is bound, a separate requires_predicate relationship plan when a requirement ID is supplied, or an explicit ontology-gap observation when no predicate fits.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["text"];
@@ -478,6 +510,24 @@ export declare const OPERATION_CATALOG: readonly [{
                 readonly default: true;
                 readonly description: "Whether to include existing KB fact_kind=predicate_schema facts alongside Kibi's built-in predicate catalog. Default: true.";
             };
+            readonly schemaId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly description: "Optional exact reviewed predicate schema ID. When supplied, Kibi selects that schema instead of lexical rank order and fails closed if it is unavailable.";
+            };
+            readonly argumentBindings: {
+                readonly type: "object";
+                readonly additionalProperties: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly description: "Optional exact predicate argument values keyed by a candidate schema's argument_names. Required before applying a candidate whose binding_status is incomplete; Kibi never substitutes guessed values for unbound arguments.";
+            };
+            readonly polarityHint: {
+                readonly type: "string";
+                readonly enum: readonly ["assert", "deny"];
+                readonly description: "Optional reviewed polarity override for claims whose surface negation does not express predicate denial. Use only after reviewing the selected schema and full claim scope.";
+            };
             readonly existingLogicClaims: {
                 readonly type: "array";
                 readonly items: {
@@ -662,6 +712,10 @@ export declare const OPERATION_CATALOG: readonly [{
                         readonly type: "string";
                         readonly description: "Optional text anchor/reference. Example: 'requirements.md#L40'.";
                     };
+                    readonly semantic_text: {
+                        readonly type: "string";
+                        readonly description: "Requirement-only authored prose used for semantic inventory hashes and UTF-8 spans. Keep text_ref available for independent document or code evidence.";
+                    };
                     readonly logic_claims: {
                         readonly type: "array";
                         readonly minItems: 1;
@@ -672,6 +726,30 @@ export declare const OPERATION_CATALOG: readonly [{
                         };
                         readonly description: "Requirement-only manifest of every atomic normative claim key returned by kb_semantic_advisor. A requirement is logic-complete only when every key is grounded by a linked property_value or predicate fact with the same claim_key.";
                     };
+                    readonly semantic_clauses: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly description: "Optional complete atomic decomposition used by kb_semantic_advisor and proposition-complete ingestion. Preserve it when automatic sentence splitting needs a reviewed override.";
+                    };
+                    readonly semantic_inventory_version: {
+                        readonly type: "string";
+                        readonly const: "kibi.semantic-inventory.v1";
+                        readonly description: "Requirement-only proposition ledger contract version returned by kb_semantic_advisor.";
+                    };
+                    readonly semantic_source_field: {
+                        readonly type: "string";
+                        readonly enum: readonly ["semantic_text", "text_ref", "title"];
+                        readonly description: "Requirement field whose exact UTF-8 bytes anchor semantic_inventory spans.";
+                    };
+                    readonly semantic_source_hash: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                        readonly description: "SHA-256 of the exact semantic source text returned in the advisor inventory contract.";
+                    };
                     readonly sourceFile: {
                         readonly type: "string";
                         readonly description: "Optional code source file for symbol entities. Example: 'src/auth/login.ts'.";
@@ -696,6 +774,66 @@ export declare const OPERATION_CATALOG: readonly [{
                         readonly enum: readonly ["internal", "consumer"];
                         readonly description: "Optional typed verification perspective for test entities. Example: 'consumer'.";
                     };
+                    readonly verification_receipts: {
+                        readonly type: "array";
+                        readonly maxItems: 50;
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["version", "receipt_id", "test_id", "runner", "command", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest"];
+                            readonly properties: {
+                                readonly version: {
+                                    readonly type: "string";
+                                    readonly const: "kibi.verification-receipt.v1";
+                                };
+                                readonly receipt_id: {
+                                    readonly type: "string";
+                                    readonly pattern: "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
+                                };
+                                readonly test_id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly runner: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly command: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly scope: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["unit", "integration", "end_to_end"];
+                                };
+                                readonly outcome: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped"];
+                                };
+                                readonly code_snapshot: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-f0-9]{64}$";
+                                };
+                                readonly environment_hash: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-f0-9]{64}$";
+                                };
+                                readonly started_at: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly finished_at: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly artifact_digest: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-f0-9]{64}$";
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                        readonly description: "Append-only test execution evidence. Proof accepts only the newest valid passed receipt bound to the current code snapshot and within the seven-day freshness window.";
+                    };
                     readonly fact_kind: {
                         readonly type: "string";
                         readonly enum: readonly ["subject", "property_value", "observation", "meta", "predicate_schema", "predicate", "rule_schema", "rule"];
@@ -856,7 +994,14 @@ export declare const OPERATION_CATALOG: readonly [{
                         readonly minimum: 0;
                     };
                 };
-                readonly allOf: readonly [Record<string, unknown>];
+                readonly allOf: readonly [Record<string, unknown>, {
+                    readonly if: {
+                        readonly required: readonly ["verification_receipts"];
+                    };
+                    readonly then: {
+                        readonly required: readonly ["verification_scope"];
+                    };
+                }];
                 readonly required: readonly ["title", "status"];
             };
             readonly relationships: {
@@ -910,7 +1055,7 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_check";
     readonly cliName: "check";
-    readonly description: "Run KB validation rules and return violations. Use before or after mutations, and after meaningful source edits with impact options to surface symbol granularity and semantic-review diagnostics. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration; omit rules for final full validation plus full-KB qualityDiagnostics review.";
+    readonly description: "Run KB validation rules and return violations. Use before or after mutations, and after meaningful source edits with impact options to surface symbol granularity and semantic-review diagnostics. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration; omit rules for final full validation plus full-KB qualityDiagnostics review, including telemetry acceptance when .kb/usage.log exists.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -920,7 +1065,7 @@ export declare const OPERATION_CATALOG: readonly [{
                     readonly type: "string";
                     readonly enum: readonly ["must-priority-coverage", "symbol-coverage", "symbol-traceability", "no-dangling-refs", "no-cycles", "required-fields", "deprecated-adr-no-successor", "domain-contradictions", "strict-fact-shape", "strict-req-fact-pairing", "predicate-verifiability", "logic-coverage", "rule-safety", "rule-verifiability", "semantic-completeness", "query-plan-safety"];
                 };
-                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan; 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, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; 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":"AAoBA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE/D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBe,CAAC;AAO9C,wBAAgB,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,CAM1D;AAGD,wBAAgB,SAAS,IAAI,SAAS,aAAa,EAAE,CAEpD"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/public/operations/catalog.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE/D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBe,CAAC;AAO9C,wBAAgB,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,CAM1D;AAGD,wBAAgB,SAAS,IAAI,SAAS,aAAa,EAAE,CAEpD"}

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,EACjB,gBAAgB,EAEjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,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,gBAAgB,GACjB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,6CAA6C,CAAC,EAAE,OAAO,CAAC;CAClE,CAAC;AAcF,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CA4GxC"}
+{"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,EACjB,gBAAgB,EAEjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,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,gBAAgB,GACjB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,6CAA6C,CAAC,EAAE,OAAO,CAAC;CAClE,CAAC;AAcF,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAgHxC"}

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

@@ -37,6 +37,8 @@ export async function executeCheck(args, context, options = {}) {
                     ? impactQualityDiagnostics
                     : await collectFullKbQualityDiagnostics({
                         prolog,
+                        workspaceRoot,
+                        now: context.clock(),
                         ...maxDiagnosticsOption,
                     });
             return {
@@ -83,6 +85,8 @@ export async function executeCheck(args, context, options = {}) {
                 : await collectFullKbQualityDiagnostics({
                     prolog,
                     hardViolationEntityIds: new Set(violations.map((v) => v.entityId)),
+                    workspaceRoot,
+                    now: context.clock(),
                     ...maxDiagnosticsOption,
                 });
         return {

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

@@ -1 +1 @@
-{"version":3,"file":"discovery-entities.d.ts","sourceRoot":"","sources":["../../../src/public/operations/discovery-entities.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,kBAAkB,gFASrB,CAAC;AAGX,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAMtD;AAGD,wBAAgB,eAAe,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CA+B/D;AAGD,wBAAsB,YAAY,CAChC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,EACjC,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CA0BpC;AAGD,wBAAgB,eAAe,CAAC,CAAC,EAC/B,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,KAAK,SAAM,EACX,MAAM,SAAI,GACT,CAAC,EAAE,CAEL;AAGD,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAC3C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAQ3B"}
+{"version":3,"file":"discovery-entities.d.ts","sourceRoot":"","sources":["../../../src/public/operations/discovery-entities.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,kBAAkB,gFASrB,CAAC;AAGX,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAMtD;AAGD,wBAAgB,eAAe,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAgC/D;AAGD,wBAAsB,YAAY,CAChC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,EACjC,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CA0BpC;AAGD,wBAAgB,eAAe,CAAC,CAAC,EAC/B,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,KAAK,SAAM,EACX,MAAM,SAAI,GACT,CAAC,EAAE,CAEL;AAGD,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAC3C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAQ3B"}

package/dist/public/operations/discovery-entities.js

@@ -36,11 +36,12 @@ export function buildEntityGoal(input) {
         return `findall(['${safeId}',Type,Props], kb_entity('${safeId}', Type, Props), Results)`;
     }
     if (tags && tags.length > 0) {
+        const tagTerms = tags.map((tag) => `'${escapeAtomContent(tag)}'`).join(",");
         if (type) {
             const safeType = escapeAtomContent(type);
-            return `findall([Id,'${safeType}',Props], kb_entity(Id, '${safeType}', Props), Results)`;
+            return `findall([Id,'${safeType}',Props], (member(Tag, [${tagTerms}]), kb_entities_by_tag(Tag, TagIds), member(Id, TagIds), kb_entity(Id, '${safeType}', Props)), Results)`;
         }
-        return "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)";
+        return `findall([Id,Type,Props], (member(Tag, [${tagTerms}]), kb_entities_by_tag(Tag, TagIds), member(Id, TagIds), kb_entity(Id, Type, Props)), Results)`;
     }
     if (type) {
         const safeType = escapeAtomContent(type);

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

@@ -32,6 +32,12 @@ export type StatusPayload = {
     readonly syncState: string;
     readonly kbPath?: string;
     readonly lastSyncSource?: string;
+    readonly verificationSnapshot?: string;
+    readonly verificationSnapshotAvailable?: boolean;
+    readonly verificationSnapshotDirty?: boolean;
+    readonly verificationSnapshotFileCount?: number;
+    readonly verificationSnapshotVersion?: string;
+    readonly verificationSnapshotError?: string;
 };
 export declare function executeQuery(input: QueryInput, context: OperationContext): Promise<OperationResult<QueryPayload>>;
 export declare function executeSearch(input: SearchInput, context: OperationContext): Promise<OperationResult<SearchPayload>>;

package/dist/public/operations/discovery-executors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery-executors.d.ts","sourceRoot":"","sources":["../../../src/public/operations/discovery-executors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAO3D,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;AAE1D,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AAqBF,wBAAsB,YAAY,CAChC,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CA+BxC;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CAsCzC;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CAyBzC"}
+{"version":3,"file":"discovery-executors.d.ts","sourceRoot":"","sources":["../../../src/public/operations/discovery-executors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAO3D,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;AAE1D,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,6BAA6B,CAAC,EAAE,OAAO,CAAC;IACjD,QAAQ,CAAC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IAC7C,QAAQ,CAAC,6BAA6B,CAAC,EAAE,MAAM,CAAC;IAChD,QAAQ,CAAC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IAC9C,QAAQ,CAAC,yBAAyB,CAAC,EAAE,MAAM,CAAC;CAC7C,CAAC;AAqBF,wBAAsB,YAAY,CAChC,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CA6DxC;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CAiDzC;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CAwCzC"}

package/dist/public/operations/discovery-executors.js

@@ -1,6 +1,7 @@
 import { rankEntities } from "../../search-ranking.js";
 import { loadEntities, paginateResults, validateEntityType, } from "./discovery-entities.js";
 import { runOperationJsonQuery } from "./prolog-json.js";
+import { readWorkspaceSnapshot } from "./workspace-snapshot.js";
 function requireProlog(context) {
     if (!context.prolog) {
         throw new Error("Discovery operation requires a Prolog context");
@@ -21,6 +22,32 @@ export async function executeQuery(input, context) {
     // implements REQ-kibi-operation-interface-parity
     const { type, id, tags, sourceFile, limit = 100, offset = 0 } = input;
     try {
+        const prolog = requireProlog(context);
+        const indexedPage = prolog.queryEntities
+            ? await prolog.queryEntities({
+                ...(type !== undefined ? { type } : {}),
+                ...(id !== undefined ? { id } : {}),
+                ...(tags !== undefined ? { tags } : {}),
+                ...(sourceFile !== undefined ? { sourceFile } : {}),
+                limit,
+                offset,
+            })
+            : null;
+        if (indexedPage !== null) {
+            const paginated = indexedPage.entities;
+            const text = indexedPage.count === 0
+                ? `No entities found${type ? ` of type '${type}'` : ""}.`
+                : `Found ${indexedPage.count} entities${type ? ` of type '${type}'` : ""}. Showing ${paginated.length} (offset ${offset}, limit ${limit}): ${paginated
+                    .map((entity) => {
+                    const entityId = String(entity.id ?? "").replace(/^file:\/\/.*\//, "");
+                    return `${entityId} (${String(entity.title ?? "")}, status=${String(entity.status ?? "")})`;
+                })
+                    .join(", ")}`;
+            return {
+                content: [{ type: "text", text }],
+                structuredContent: { entities: paginated, count: indexedPage.count },
+            };
+        }
         const entities = await loadEntities(requireProlog(context), {
             ...(type !== undefined ? { type } : {}),
             ...(id !== undefined ? { id } : {}),
@@ -55,9 +82,20 @@ export async function executeSearch(input, context) {
     }
     validateEntityType(type);
     try {
-        const entities = await loadEntities(requireProlog(context), {
-            ...(type !== undefined ? { type } : {}),
-        });
+        const prolog = requireProlog(context);
+        const indexedCandidates = prolog.searchEntities
+            ? await prolog.searchEntities({
+                query: trimmedQuery,
+                ...(type !== undefined ? { type } : {}),
+                limit: 100_000,
+                offset: 0,
+            })
+            : null;
+        const entities = indexedCandidates
+            ? [...indexedCandidates.entities]
+            : await loadEntities(prolog, {
+                ...(type !== undefined ? { type } : {}),
+            });
         const matches = await rankEntities(entities, trimmedQuery, context.workspaceRoot);
         const paginated = paginateResults(matches, limit, offset);
         const text = matches.length === 0
@@ -84,14 +122,29 @@ export async function executeStatus(_input, context) {
         if (!isStatusPayload(payload)) {
             throw new Error("Status execution query returned an invalid payload");
         }
+        const snapshotEvidence = await readWorkspaceSnapshot(context);
+        const enrichedPayload = {
+            ...payload,
+            verificationSnapshot: snapshotEvidence.available
+                ? snapshotEvidence.snapshot.hash
+                : "unknown",
+            verificationSnapshotAvailable: snapshotEvidence.available,
+            ...(snapshotEvidence.available
+                ? {
+                    verificationSnapshotDirty: snapshotEvidence.snapshot.dirty,
+                    verificationSnapshotFileCount: snapshotEvidence.snapshot.fileCount,
+                    verificationSnapshotVersion: snapshotEvidence.snapshot.version,
+                }
+                : { verificationSnapshotError: snapshotEvidence.error }),
+        };
         return {
             content: [
                 {
                     type: "text",
-                    text: `Branch ${payload.branch} is ${payload.syncState} (snapshot ${payload.snapshotId}, dirty=${payload.dirty})`,
+                    text: `Branch ${payload.branch} is ${payload.syncState} (snapshot ${payload.snapshotId}, dirty=${payload.dirty}, verificationSnapshot=${enrichedPayload.verificationSnapshot})`,
                 },
             ],
-            structuredContent: payload,
+            structuredContent: enrichedPayload,
         };
     }
     catch (error) {

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

@@ -4,6 +4,8 @@ export * from "./discovery-entities.js";
 export * from "./discovery-executors.js";
 export * from "./runtime-types.js";
 export * from "./node-ports.js";
+export * from "./repair-plan.js";
+export * from "./legacy-migration-plan.js";
 export * from "./specs/autopilot.js";
 export * from "./specs/check.js";
 export * from "./specs/discovery.js";
@@ -14,6 +16,8 @@ export * from "./specs/semantic.js";
 export * from "./specs/skills.js";
 export * from "./specs/sparql.js";
 export * from "./types.js";
+export * from "../telemetry-acceptance.js";
+export * from "../telemetry-remediation.js";
 export * from "../../operations/autopilot/generate.js";
 export * from "../../operations/autopilot/presentation.js";
 export type * from "../../operations/autopilot/types.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/public/operations/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,wCAAwC,CAAC;AACvD,cAAc,4CAA4C,CAAC;AAC3D,mBAAmB,qCAAqC,CAAC;AACzD,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/public/operations/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wCAAwC,CAAC;AACvD,cAAc,4CAA4C,CAAC;AAC3D,mBAAmB,qCAAqC,CAAC;AACzD,cAAc,mBAAmB,CAAC"}

package/dist/public/operations/index.js

@@ -4,6 +4,8 @@ export * from "./discovery-entities.js";
 export * from "./discovery-executors.js";
 export * from "./runtime-types.js";
 export * from "./node-ports.js";
+export * from "./repair-plan.js";
+export * from "./legacy-migration-plan.js";
 export * from "./specs/autopilot.js";
 export * from "./specs/check.js";
 export * from "./specs/discovery.js";
@@ -14,6 +16,8 @@ export * from "./specs/semantic.js";
 export * from "./specs/skills.js";
 export * from "./specs/sparql.js";
 export * from "./types.js";
+export * from "../telemetry-acceptance.js";
+export * from "../telemetry-remediation.js";
 export * from "../../operations/autopilot/generate.js";
 export * from "../../operations/autopilot/presentation.js";
 export * from "../../logic/ir.js";