kibi-cli 0.14.0 → 0.17.0

package/dist/operations/semantic-advisor/predicate-rules-product-tail.d.ts

@@ -0,0 +1,48 @@
+export declare const PRODUCT_TAIL_PREDICATE_RULES: readonly [{
+    readonly pattern: RegExp;
+    readonly name: "throttle_policy_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Throttle-policy prose defines throttling behavior under high-frequency conditions and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "temporal_order";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Initializes-after prose defines temporal readiness ordering and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "state_transition";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "State transitions have source state, target state, and trigger; model them as predicate facts.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "permission_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Prohibitions are negative permission rules and should preserve deny polarity.";
+    readonly polarity: "deny";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "uniqueness_constraint";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Per-scope uniqueness is relational and should be modeled as a predicate rather than a generic count.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "default_value";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Defaults are relational product behavior and should be explicit ontology predicates.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "state_membership";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "State sets are relational workflow constraints and should be queryable as predicate facts.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "rate_limit";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Rate limits are bounded action-window constraints and now map to the production rate_limit predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "permission_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Actor/action/resource permission prose is better represented as an ontology predicate than a scalar property.";
+}];
+//# sourceMappingURL=predicate-rules-product-tail.d.ts.map

package/dist/operations/semantic-advisor/predicate-rules-product-tail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-rules-product-tail.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/predicate-rules-product-tail.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsHI,CAAC"}

package/dist/operations/semantic-advisor/predicate-rules-product-tail.js

@@ -0,0 +1,102 @@
+import { normalizeKey, normalizePredicateToken, normalizeSubjectKey, singularize, } from "./predicate-rule.js";
+export const PRODUCT_TAIL_PREDICATE_RULES = [
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+throttled\s+for\s+(?<condition>.+?)\.?$/i,
+        name: "throttle_policy_rule",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizePredicateToken(g.condition ?? ""),
+        ],
+        rationale: "Throttle-policy prose defines throttling behavior under high-frequency conditions and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?:the\s+)?(?<subject>.+?)\s+initializes\s+after\s+(?:the\s+)?(?<ready>.+?)\s+is\s+ready\.?$/i,
+        name: "temporal_order",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            `${normalizeKey(g.ready ?? "")}_ready`,
+            "initializes",
+        ],
+        rationale: "Initializes-after prose defines temporal readiness ordering and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^when\s+(?<trigger>.+?),\s*(?:the\s+)?(?<subject>[a-z][a-z\s_-]*?)\s+transitions?\s+from\s+(?<from>[a-z][a-z0-9_-]*)\s+to\s+(?<to>[a-z][a-z0-9_-]*)\.?$/i,
+        name: "state_transition",
+        args: (g) => [
+            normalizeSubjectKey(g.subject ?? ""),
+            normalizePredicateToken(g.from ?? ""),
+            normalizePredicateToken(g.to ?? ""),
+            normalizePredicateToken(g.trigger ?? ""),
+        ],
+        rationale: "State transitions have source state, target state, and trigger; model them as predicate facts.",
+    },
+    {
+        pattern: /^(?<actor>[a-z][a-z\s_-]*?)\s+(?:must\s+not|cannot|can't|is\s+forbidden\s+to)\s+(?<action>[a-z][a-z_-]*)\s+(?<resource>.+?)\.?$/i,
+        name: "permission_rule",
+        args: (g) => [
+            singularize(normalizeKey(g.actor ?? "")),
+            normalizePredicateToken(g.action ?? ""),
+            normalizePredicateToken(g.resource ?? ""),
+            "deny",
+        ],
+        rationale: "Prohibitions are negative permission rules and should preserve deny polarity.",
+        polarity: "deny",
+    },
+    {
+        pattern: /^(?:there\s+)?(?:must|shall|should)\s+be\s+at\s+most\s+one\s+(?<subject>[a-z][a-z\s_-]*?)\s+per\s+(?<scope>.+?)\.?$/i,
+        name: "uniqueness_constraint",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            (g.scope ?? "")
+                .split(/\s+per\s+/i)
+                .map(normalizePredicateToken)
+                .join(","),
+        ],
+        rationale: "Per-scope uniqueness is relational and should be modeled as a predicate rather than a generic count.",
+    },
+    {
+        pattern: /^(?:the\s+)?(?<subject>[a-z][a-z\s_-]*?)\s+defaults?\s+to\s+(?<value>[a-z][a-z0-9\s_-]*?)(?:\s+(?<property>mode|state|status))?\.?$/i,
+        name: "default_value",
+        args: (g) => [
+            normalizeSubjectKey(g.subject ?? ""),
+            normalizeKey(g.property ?? "value"),
+            normalizeKey(g.value ?? ""),
+        ],
+        rationale: "Defaults are relational product behavior and should be explicit ontology predicates.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:terminal\s+)?states\s+are\s+(?<states>.+?)\.?$/i,
+        name: "state_membership",
+        args: (g) => [
+            normalizeSubjectKey(g.subject ?? ""),
+            (g.states ?? "")
+                .split(/,|\band\b|\bor\b/i)
+                .map((value) => normalizePredicateToken(value.trim()))
+                .filter(Boolean)
+                .join(","),
+        ],
+        rationale: "State sets are relational workflow constraints and should be queryable as predicate facts.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+rate\s+limited\s+to\s+(?<count>\d+)\s+(?<action>[a-z][a-z\s_-]*?)\s+per\s+(?<window>[a-z]+)\.?$/i,
+        name: "rate_limit",
+        args: (g) => [
+            `${normalizeKey(g.subject ?? "").replace(/_requests?$/, "")}.request`,
+            normalizePredicateToken(g.action ?? ""),
+            normalizePredicateToken(g.window ?? ""),
+            g.count ?? "",
+        ],
+        rationale: "Rate limits are bounded action-window constraints and now map to the production rate_limit predicate.",
+    },
+    {
+        pattern: /^only\s+(?<actor>[a-z][a-z\s_-]*?)\s+can\s+(?<action>[a-z][a-z_-]*)\s+(?<resource>.+?)(?:\s+when\s+.+)?\.?$/i,
+        name: "permission_rule",
+        args: (g) => [
+            singularize(normalizeKey(g.actor ?? "")),
+            normalizeKey(g.action ?? ""),
+            normalizeKey(g.resource ?? ""),
+            "assert",
+        ],
+        rationale: "Actor/action/resource permission prose is better represented as an ontology predicate than a scalar property.",
+    },
+];

package/dist/operations/semantic-advisor/predicate-rules-product.d.ts

@@ -0,0 +1,71 @@
+export declare const PRODUCT_PREDICATE_RULES: readonly [{
+    readonly pattern: RegExp;
+    readonly name: "release_gate_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Release-gate prose defines required gates before distribution or deployment and should be queryable as a predicate.";
+    readonly accepts: (statement: string) => boolean;
+}, {
+    readonly pattern: RegExp;
+    readonly name: "platform_consistency_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Platform consistency prose defines synchronization across platforms and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "preservation_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Preservation prose defines data preserved across deletion/removal boundaries and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "abstraction_boundary_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Abstraction-boundary prose defines renderer/vendor-neutral persistence or contract constraints and should be queryable as a predicate.";
+    readonly accepts: (statement: string) => boolean;
+}, {
+    readonly pattern: RegExp;
+    readonly name: "security_configuration_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Security-configuration prose defines explicit infrastructure or database settings and should be queryable as a predicate.";
+    readonly accepts: (statement: string) => boolean;
+}, {
+    readonly pattern: RegExp;
+    readonly name: "ordered_strategy_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Ordered-strategy prose defines a required priority order and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "refresh_policy_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Refresh-policy prose defines automatic refresh behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "scoped_authorization_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Scoped-authorization prose defines assignment/ownership-qualified authorization and should be queryable as a predicate.";
+    readonly accepts: (statement: string) => boolean;
+}, {
+    readonly pattern: RegExp;
+    readonly name: "documentation_standard_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Documentation-standard prose defines required documentation artifacts and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "warmup_policy_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Warmup-policy prose defines a required warmup trigger and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "visual_layout_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Visual-layout prose defines UI alignment requirements and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "enforcement_location_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Enforcement-location prose defines the layer where a constraint is enforced and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "reconciliation_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Reconciliation prose defines trigger-based cleanup of stale records and should be queryable as a predicate.";
+}];
+//# sourceMappingURL=predicate-rules-product.d.ts.map

package/dist/operations/semantic-advisor/predicate-rules-product.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-rules-product.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/predicate-rules-product.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqKS,CAAC"}

package/dist/operations/semantic-advisor/predicate-rules-product.js

@@ -0,0 +1,133 @@
+import { commaList, normalizeKey, normalizePredicateToken, } from "./predicate-rule.js";
+export const PRODUCT_PREDICATE_RULES = [
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+pass\s+(?<gate>.+?)\s+before\s+(?<target>.+?)\.?$/i,
+        name: "release_gate_rule",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizePredicateToken(g.gate ?? "gate"),
+            normalizeKey(g.target ?? ""),
+        ],
+        rationale: "Release-gate prose defines required gates before distribution or deployment and should be queryable as a predicate.",
+        accepts: (statement) => /\b(?:app store|build|deployment|distribution|release|testflight)\b/i.test(statement),
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+synchronize\s+across\s+(?<platforms>.+?)\.?$/i,
+        name: "platform_consistency_rule",
+        args: (g) => [normalizeKey(g.subject ?? ""), commaList(g.platforms ?? "")],
+        rationale: "Platform consistency prose defines synchronization across platforms and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+preserve\s+(?<preserved>.+?)\s+when\s+(?:the\s+)?(?<condition>.+?)\.?$/i,
+        name: "preservation_rule",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizeKey(g.preserved ?? "preserved"),
+            normalizePredicateToken(g.condition ?? ""),
+        ],
+        rationale: "Preservation prose defines data preserved across deletion/removal boundaries and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+persisted\s+as\s+(?<contract>.+?)\.?$/i,
+        name: "abstraction_boundary_rule",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            "persisted_as",
+            normalizePredicateToken(g.contract ?? ""),
+        ],
+        rationale: "Abstraction-boundary prose defines renderer/vendor-neutral persistence or contract constraints and should be queryable as a predicate.",
+        accepts: (statement) => /\b(?:neutral|contract|renderer|runtime|vendor)\b/i.test(statement),
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+have\s+explicit\s+(?<setting>[A-Za-z0-9_.-]+)\s+(?<value>[A-Za-z0-9_.-]+)\.?$/i,
+        name: "security_configuration_rule",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizeKey(g.setting ?? ""),
+            normalizeKey(g.value ?? ""),
+        ],
+        rationale: "Security-configuration prose defines explicit infrastructure or database settings and should be queryable as a predicate.",
+        accepts: (statement) => /\b(?:database|deployment|function|rpc|search_path|security|trigger)\b/i.test(statement),
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+use\s+(?<kind>.+?)\s+in\s+priority\s+order\s+(?<values>.+?)\.?$/i,
+        name: "ordered_strategy_rule",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizeKey(g.kind ?? "strategy"),
+            (g.values ?? "")
+                .split(/,|>/)
+                .map(normalizePredicateToken)
+                .filter(Boolean)
+                .join(","),
+        ],
+        rationale: "Ordered-strategy prose defines a required priority order and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+automatically\s+refresh\s+(?<target>.+?)\s+without\s+requiring\s+manual\s+page\s+reload\.?$/i,
+        name: "refresh_policy_rule",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizeKey(g.target ?? ""),
+            "automatic",
+        ],
+        rationale: "Refresh-policy prose defines automatic refresh behavior and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?<actor>.+?)\s+(?:must|shall|should)\s+be\s+denied\s+(?<action>.+?)\.?$/i,
+        name: "scoped_authorization_rule",
+        args: (g) => [
+            normalizeKey(g.actor ?? ""),
+            normalizeKey(g.action ?? ""),
+            "deny",
+        ],
+        rationale: "Scoped-authorization prose defines assignment/ownership-qualified authorization and should be queryable as a predicate.",
+        accepts: (statement) => /\b(?:assigned|unassigned|owner|member|scoped)\b/i.test(statement),
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+documented\s+in\s+(?<artifact>.+?)\.?$/i,
+        name: "documentation_standard_rule",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            "documented_in",
+            normalizeKey(g.artifact ?? ""),
+        ],
+        rationale: "Documentation-standard prose defines required documentation artifacts and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?:the\s+)?(?<subject>.+?)\s+(?:must|shall|should)\s+warm\s+up\s+on\s+(?<trigger>.+?)\.?$/i,
+        name: "warmup_policy_rule",
+        args: (g) => [normalizeKey(g.subject ?? ""), normalizeKey(g.trigger ?? "")],
+        rationale: "Warmup-policy prose defines a required warmup trigger and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+remain\s+visually\s+aligned\s+with\s+(?<target>.+?)\.?$/i,
+        name: "visual_layout_rule",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            "aligned_with",
+            normalizeKey(g.target ?? ""),
+        ],
+        rationale: "Visual-layout prose defines UI alignment requirements and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+enforced\s+at\s+(?<location>.+?)\.?$/i,
+        name: "enforcement_location_rule",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizeKey(g.location ?? ""),
+        ],
+        rationale: "Enforcement-location prose defines the layer where a constraint is enforced and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^on\s+(?<trigger>.+?),\s*(?<subject>.+?)\s+(?:must|shall|should)\s+reconcile\s+(?<target>.+?)\s+and\s+(?<action>clear\s+stale\s+.+?)\.?$/i,
+        name: "reconciliation_rule",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizeKey(g.trigger ?? "trigger"),
+            normalizeKey(g.target ?? ""),
+            normalizeKey(g.action ?? "action"),
+        ],
+        rationale: "Reconciliation prose defines trigger-based cleanup of stale records and should be queryable as a predicate.",
+    },
+];

package/dist/operations/semantic-advisor/prose-coverage-evaluator.d.ts

@@ -0,0 +1,29 @@
+import type { SemanticModelingSuggestion } from "./types.js";
+export interface ProseCoverageExpectation {
+    readonly kind: SemanticModelingSuggestion["kind"];
+    readonly predicate_name?: string;
+    readonly property_key?: string;
+    readonly operator?: string;
+}
+export interface ProseCoverageCase {
+    readonly id: string;
+    readonly source?: string;
+    readonly text: string;
+    readonly expected: ProseCoverageExpectation;
+}
+export interface ProseCoverageFailure {
+    readonly id: string;
+    readonly text: string;
+    readonly reason: string;
+}
+export interface ProseCoverageResult {
+    readonly coverage: number;
+    readonly summary: {
+        readonly total: number;
+        readonly passed: number;
+        readonly failed: number;
+    };
+    readonly failures: readonly ProseCoverageFailure[];
+}
+export declare function evaluateProseCoverageCorpus(cases: readonly ProseCoverageCase[]): ProseCoverageResult;
+//# sourceMappingURL=prose-coverage-evaluator.d.ts.map

package/dist/operations/semantic-advisor/prose-coverage-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prose-coverage-evaluator.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/prose-coverage-evaluator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAE7D,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,0BAA0B,CAAC,MAAM,CAAC,CAAC;IAClD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAC;CAC7C;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE;QAChB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,QAAQ,CAAC,QAAQ,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACpD;AAuED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,SAAS,iBAAiB,EAAE,GAClC,mBAAmB,CAQrB"}

package/dist/operations/semantic-advisor/prose-coverage-evaluator.js

@@ -0,0 +1,54 @@
+import { analyzeSemanticAdvisorInput } from "./analyze-prose.js";
+function failure(testCase, reason) {
+    return { id: testCase.id, text: testCase.text, reason };
+}
+function evaluateCase(testCase) {
+    const result = analyzeSemanticAdvisorInput({
+        payload: {
+            type: "req",
+            id: `REQ-CORPUS-${testCase.id}`,
+            properties: {
+                title: testCase.id,
+                status: "open",
+                source: "mcp://kibi/prose-coverage-corpus",
+                text_ref: testCase.text,
+            },
+        },
+    });
+    const suggestion = result.receipt.suggestions[0];
+    if (!suggestion)
+        return [failure(testCase, "No semantic advisor suggestion was produced")];
+    if (suggestion.kind !== testCase.expected.kind)
+        return [
+            failure(testCase, `Expected ${testCase.expected.kind} but received ${suggestion.kind}`),
+        ];
+    if (suggestion.kind === "predicate" &&
+        testCase.expected.predicate_name &&
+        suggestion.predicate.predicate_name !== testCase.expected.predicate_name) {
+        return [
+            failure(testCase, `Expected predicate ${testCase.expected.predicate_name} but received ${suggestion.predicate.predicate_name}`),
+        ];
+    }
+    if (suggestion.kind === "strict_property") {
+        if (testCase.expected.property_key &&
+            suggestion.claim.property_key !== testCase.expected.property_key)
+            return [
+                failure(testCase, `Expected property ${testCase.expected.property_key} but received ${suggestion.claim.property_key}`),
+            ];
+        if (testCase.expected.operator &&
+            suggestion.claim.operator !== testCase.expected.operator)
+            return [
+                failure(testCase, `Expected operator ${testCase.expected.operator} but received ${suggestion.claim.operator}`),
+            ];
+    }
+    return [];
+}
+export function evaluateProseCoverageCorpus(cases) {
+    const failures = cases.flatMap(evaluateCase);
+    const passed = cases.length - failures.length;
+    return {
+        coverage: cases.length === 0 ? 1 : passed / cases.length,
+        summary: { total: cases.length, passed, failed: failures.length },
+        failures,
+    };
+}

package/dist/operations/semantic-advisor/shared.d.ts

@@ -0,0 +1,19 @@
+import type { SemanticModelingSuggestion, SemanticStrictPropertyClaim } from "./types.js";
+export type Payload = Readonly<Record<string, unknown>>;
+export type MatchGroups = Readonly<Record<string, string | undefined>>;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function stringValue(value: unknown): string;
+export declare function canonicalize(value: unknown): string;
+export declare function payloadHash(payload: Payload): string;
+export declare function shortHash(value: string): string;
+export declare function propertiesOf(payload: Payload): Record<string, unknown>;
+export declare function statementOf(payload: Payload): string;
+export declare function sourceOf(payload: Payload): string;
+export declare function normalizeKey(value: string): string;
+export declare function normalizePredicateToken(value: string): string;
+export declare function singularize(value: string): string;
+export declare function normalizeSubjectKey(value: string): string;
+export declare function relationship(from: string, to: string, type: string): Record<string, unknown>;
+export declare function strictSuggestion(payload: Payload, evidence: string, claim: SemanticStrictPropertyClaim, rationale: string, confidence?: number): SemanticModelingSuggestion;
+export declare function predicateSuggestion(payload: Payload, evidence: string, name: string, args: readonly string[], rationale: string, polarity?: "assert" | "deny"): SemanticModelingSuggestion;
+//# sourceMappingURL=shared.d.ts.map

package/dist/operations/semantic-advisor/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/shared.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,0BAA0B,EAE1B,2BAA2B,EAC5B,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AACxD,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;AAGvE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAElD;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CASnD;AAGD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAKpD;AAGD,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAGD,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEtE;AAGD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAGpD;AAGD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAIjD;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOlD;AAGD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ7D;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjD;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzB;AAGD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,2BAA2B,EAClC,SAAS,EAAE,MAAM,EACjB,UAAU,SAAM,GACf,0BAA0B,CAqF5B;AAGD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,QAAQ,GAAG,MAAiB,GACrC,0BAA0B,CA+C5B"}