kibi-cli 0.14.0 → 0.16.1

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,18 @@
+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 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;AAWD,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"}

package/dist/operations/semantic-advisor/shared.js

@@ -0,0 +1,209 @@
+import { createHash } from "node:crypto";
+import { semanticClaimKey } from "./clauses.js";
+// implements REQ-mcp-semantic-advisor-preflight
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function stringValue(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function canonicalize(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalize).join(",")}]`;
+    if (isRecord(value)) {
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonicalize(value[key])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function payloadHash(payload) {
+    const stable = Object.fromEntries(Object.entries(payload).filter(([key]) => !key.startsWith("_")));
+    return createHash("sha256").update(canonicalize(stable)).digest("hex");
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function shortHash(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function propertiesOf(payload) {
+    return isRecord(payload.properties) ? payload.properties : {};
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function statementOf(payload) {
+    const properties = propertiesOf(payload);
+    return stringValue(properties.text_ref) || stringValue(properties.title);
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function sourceOf(payload) {
+    return (stringValue(propertiesOf(payload).source) || "mcp://kibi/semantic-advisor");
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function normalizeKey(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/['’]/g, "")
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function normalizePredicateToken(value) {
+    return value
+        .trim()
+        .replace(/\b(?:a|an|the)\b\s*/gi, "")
+        .replace(/['’]/g, "")
+        .replace(/\s+/g, "_")
+        .replace(/[^A-Za-z0-9_-]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function singularize(value) {
+    if (["status", "results"].includes(value))
+        return value;
+    return value.endsWith("s") && value.length > 3 ? value.slice(0, -1) : value;
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function normalizeSubjectKey(value) {
+    return normalizeKey(value).split("_").map(singularize).join(".");
+}
+function relationship(from, to, type) {
+    return { type, from, to };
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function strictSuggestion(payload, evidence, claim, rationale, confidence = 0.9) {
+    const claimText = statementOf(payload);
+    const reqId = stringValue(payload.id) || `REQ-SEMANTIC-${shortHash(claim.subject_key)}`;
+    const subjectId = `FACT-SUBJECT-${shortHash(claim.subject_key)}`;
+    const propertyId = `FACT-PROP-${shortHash(`${claim.subject_key}.${claim.property_key}.${claim.operator}.${canonicalize(claim)}`)}`;
+    const source = sourceOf(payload);
+    const value = claim.value_string ??
+        claim.value_int ??
+        claim.value_number ??
+        claim.value_bool;
+    const propertyFields = {
+        ...(claim.value_string !== undefined
+            ? { value_string: claim.value_string }
+            : {}),
+        ...(claim.value_int !== undefined ? { value_int: claim.value_int } : {}),
+        ...(claim.value_number !== undefined
+            ? { value_number: claim.value_number }
+            : {}),
+        ...(claim.value_bool !== undefined ? { value_bool: claim.value_bool } : {}),
+        ...(claim.unit ? { unit: claim.unit } : {}),
+    };
+    return {
+        kind: "strict_property",
+        claim_key: semanticClaimKey(claimText),
+        claim_text: claimText,
+        confidence,
+        evidence,
+        rationale,
+        suggested_next_tool: "kb_model_requirement",
+        claim,
+        rejected_alternatives: ["predicate", "observation_review"],
+        applyPlan: [
+            {
+                type: "fact",
+                id: subjectId,
+                properties: {
+                    title: `${claim.subject_key} subject`,
+                    status: "active",
+                    source,
+                    fact_kind: "subject",
+                    subject_key: claim.subject_key,
+                    canonical_key: claim.subject_key,
+                    tags: ["lane:strict", "semantic-advisor-suggestion"],
+                },
+                relationships: [],
+            },
+            {
+                type: "fact",
+                id: propertyId,
+                properties: {
+                    title: `${claim.subject_key} ${claim.property_key}`,
+                    status: "active",
+                    source,
+                    fact_kind: "property_value",
+                    subject_key: claim.subject_key,
+                    property_key: claim.property_key,
+                    operator: claim.operator,
+                    value_type: claim.value_type,
+                    ...propertyFields,
+                    canonical_key: `${claim.subject_key}.${claim.property_key}.${claim.operator}.${value}`,
+                    tags: ["lane:strict", "semantic-advisor-suggestion"],
+                },
+                relationships: [],
+            },
+            {
+                type: "req",
+                id: reqId,
+                properties: {
+                    title: stringValue(propertiesOf(payload).title) ||
+                        "Semantic advisor requirement suggestion",
+                    status: "open",
+                    source,
+                    text_ref: statementOf(payload),
+                    tags: ["semantic-advisor-suggestion"],
+                },
+                relationships: [
+                    relationship(reqId, subjectId, "constrains"),
+                    relationship(reqId, propertyId, "requires_property"),
+                ],
+            },
+        ],
+    };
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function predicateSuggestion(payload, evidence, name, args, rationale, polarity = "assert") {
+    const claimText = statementOf(payload);
+    const canonicalKey = `${name}(${args.join(",")})`;
+    const predicate = {
+        predicate_name: name,
+        predicate_args: args,
+        canonical_key: canonicalKey,
+        polarity,
+    };
+    const factId = `FACT-PRED-${shortHash(canonicalKey)}`;
+    const reqId = stringValue(payload.id);
+    return {
+        kind: "predicate",
+        claim_key: semanticClaimKey(claimText),
+        claim_text: claimText,
+        confidence: 0.84,
+        evidence,
+        rationale,
+        suggested_next_tool: "kb_suggest_predicates",
+        predicate,
+        rejected_alternatives: ["strict_property"],
+        applyPlan: [
+            {
+                type: "fact",
+                id: factId,
+                properties: {
+                    title: `${name} suggestion`,
+                    status: "active",
+                    source: sourceOf(payload),
+                    fact_kind: "predicate",
+                    predicate_name: name,
+                    predicate_args: args,
+                    canonical_key: canonicalKey,
+                    polarity,
+                    tags: ["lane:ontology", "semantic-advisor-suggestion"],
+                },
+                relationships: [],
+            },
+        ],
+        relationshipPlan: reqId
+            ? {
+                applyAfter: factId,
+                requiresExistingReq: reqId,
+                relationship: relationship(reqId, factId, "requires_predicate"),
+            }
+            : null,
+    };
+}

package/dist/operations/semantic-advisor/strict-count-rules.d.ts

@@ -0,0 +1,4 @@
+import { type Payload } from "./shared.js";
+import type { SemanticModelingSuggestion } from "./types.js";
+export declare function detectCountStrictSuggestion(payload: Payload, statement: string): SemanticModelingSuggestion | null;
+//# sourceMappingURL=strict-count-rules.d.ts.map

package/dist/operations/semantic-advisor/strict-count-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict-count-rules.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/strict-count-rules.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAuB7D,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,GAChB,0BAA0B,GAAG,IAAI,CA4DnC"}

package/dist/operations/semantic-advisor/strict-count-rules.js

@@ -0,0 +1,62 @@
+import { normalizeKey, normalizeSubjectKey, singularize, strictSuggestion, } from "./shared.js";
+const NUMBER_WORDS = new Map([
+    ["zero", 0],
+    ["one", 1],
+    ["two", 2],
+    ["three", 3],
+    ["four", 4],
+    ["five", 5],
+    ["six", 6],
+    ["seven", 7],
+    ["eight", 8],
+    ["nine", 9],
+    ["ten", 10],
+]);
+function numberToken(value) {
+    return /^\d+$/.test(value)
+        ? Number(value)
+        : (NUMBER_WORDS.get(value.toLowerCase()) ?? null);
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function detectCountStrictSuggestion(payload, statement) {
+    const cardinality = statement.match(/\b(?<operator>at\s+most|at\s+least|exactly|no\s+more\s+than|up\s+to)\s+(?<value>\d+|zero|one|two|three|four|five|six|seven|eight|nine|ten)\s+(?<resource>[a-z][a-z\s_-]*?)\.?$/i);
+    if (cardinality?.groups?.operator &&
+        cardinality.groups.value &&
+        cardinality.groups.resource) {
+        const value = numberToken(cardinality.groups.value);
+        if (value !== null) {
+            const normalized = normalizeKey(cardinality.groups.resource);
+            const tail = singularize(normalized.split("_").at(-1) ?? normalized);
+            const operator = /at\s+least/i.test(cardinality.groups.operator)
+                ? "gte"
+                : /exactly/i.test(cardinality.groups.operator)
+                    ? "eq"
+                    : "lte";
+            return strictSuggestion(payload, `${cardinality.groups.operator} ${cardinality.groups.value}`, {
+                subject_key: tail === "session" ? "user.session" : normalized.replace(/_/g, "."),
+                property_key: normalized.includes("active_session")
+                    ? "active_count"
+                    : "count",
+                operator,
+                value_type: "int",
+                value_int: value,
+            }, "Bounded cardinality is a strict numeric property and should be modeled explicitly.", 0.9);
+        }
+    }
+    const capped = statement.match(/^(?<subject>.+?)\s+cap(?:s|ped)?\s+at\s+(?:(?<property>[a-z][a-z\s_-]*?)\s+)?(?<value>\d+|zero|one|two|three|four|five|six|seven|eight|nine|ten)\.?$/i);
+    if (capped?.groups?.subject && capped.groups.value) {
+        const value = numberToken(capped.groups.value);
+        if (value !== null) {
+            return strictSuggestion(payload, `cap at ${capped.groups.value}`, {
+                subject_key: normalizeSubjectKey(capped.groups.subject),
+                property_key: capped.groups.property
+                    ? `${normalizeKey(capped.groups.property)}_cap`
+                    : "count",
+                operator: "lte",
+                value_type: "int",
+                value_int: value,
+            }, "Cap-at prose is an upper-bound strict property and should be modeled explicitly.", 0.9);
+        }
+    }
+    return null;
+}

package/dist/operations/semantic-advisor/strict-rules.d.ts

@@ -0,0 +1,4 @@
+import { type Payload } from "./shared.js";
+import type { SemanticModelingSuggestion } from "./types.js";
+export declare function detectStrictSuggestion(payload: Payload, statement: string): SemanticModelingSuggestion | null;
+//# sourceMappingURL=strict-rules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strict-rules.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/strict-rules.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGb,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EACV,0BAA0B,EAE3B,MAAM,YAAY,CAAC;AAcpB,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,GAChB,0BAA0B,GAAG,IAAI,CA8KnC"}