kibi-cli 0.12.8 → 0.16.1

package/dist/operations/modeling/predicate-catalog-3.js

@@ -0,0 +1,193 @@
+// implements REQ-mcp-suggest-predicates
+export const PREDICATE_CATALOG_3 = [
+    {
+        id: "FACT-SCHEMA-ORDERED-STRATEGY-RULE",
+        predicate_name: "ordered_strategy_rule",
+        title: "Ordered strategy rule",
+        description: "A subject must use strategies in a required priority order.",
+        argument_names: ["subject", "strategy_kind", "ordered_values"],
+        argument_types: ["entity", "strategy_kind", "ordered_list"],
+        keywords: ["priority order", "selector strategies", "fallback order"],
+        examples: [
+            "ordered_strategy_rule(poms, selector_strategies, data-testid,visible,text)",
+        ],
+        tags: ["strategy", "priority"],
+    },
+    {
+        id: "FACT-SCHEMA-REFRESH-POLICY-RULE",
+        predicate_name: "refresh_policy_rule",
+        title: "Refresh policy rule",
+        description: "A subject refreshes a target automatically or by a named policy.",
+        argument_names: ["subject", "target", "policy"],
+        argument_types: ["entity", "target", "policy"],
+        keywords: ["automatically refresh", "manual page reload", "refresh"],
+        examples: ["refresh_policy_rule(dashboard, processing_videos, automatic)"],
+        tags: ["refresh", "ui"],
+    },
+    {
+        id: "FACT-SCHEMA-SCOPED-AUTHORIZATION-RULE",
+        predicate_name: "scoped_authorization_rule",
+        title: "Scoped authorization rule",
+        description: "A scoped actor is allowed or denied an action because of assignment, ownership, or membership.",
+        argument_names: ["actor_scope", "action", "decision"],
+        argument_types: ["actor_scope", "action", "decision"],
+        keywords: ["unassigned", "assigned", "denied", "scoped"],
+        examples: [
+            "scoped_authorization_rule(unassigned_instructors, signed_url_generation, deny)",
+        ],
+        tags: ["authorization", "scope"],
+    },
+    {
+        id: "FACT-SCHEMA-DOCUMENTATION-STANDARD-RULE",
+        predicate_name: "documentation_standard_rule",
+        title: "Documentation standard rule",
+        description: "A subject must be documented in a named documentation artifact.",
+        argument_names: ["subject", "relation", "artifact"],
+        argument_types: ["entity", "relation", "artifact"],
+        keywords: ["documented", "docs", "symbols", "documentation"],
+        examples: [
+            "documentation_standard_rule(code_symbols, documented_in, docs_symbols_yaml)",
+        ],
+        tags: ["documentation", "standard"],
+    },
+    {
+        id: "FACT-SCHEMA-WARMUP-POLICY-RULE",
+        predicate_name: "warmup_policy_rule",
+        title: "Warmup policy rule",
+        description: "A subject must warm up on a named trigger or entry point.",
+        argument_names: ["subject", "trigger"],
+        argument_types: ["entity", "trigger"],
+        keywords: ["warm up", "warmup", "on entry"],
+        examples: ["warmup_policy_rule(editor_video, entry)"],
+        tags: ["warmup", "performance"],
+    },
+    {
+        id: "FACT-SCHEMA-VISUAL-LAYOUT-RULE",
+        predicate_name: "visual_layout_rule",
+        title: "Visual layout rule",
+        description: "A UI subject must remain visually aligned or layout-consistent with a target.",
+        argument_names: ["subject", "relation", "target"],
+        argument_types: ["ui_entity", "relation", "ui_entity"],
+        keywords: ["visually aligned", "layout", "aligned with"],
+        examples: [
+            "visual_layout_rule(processing_video_cards, aligned_with, ready_cards)",
+        ],
+        tags: ["visual", "layout"],
+    },
+    {
+        id: "FACT-SCHEMA-ENFORCEMENT-LOCATION-RULE",
+        predicate_name: "enforcement_location_rule",
+        title: "Enforcement location rule",
+        description: "A constraint or policy must be enforced at a named system layer.",
+        argument_names: ["subject", "location"],
+        argument_types: ["constraint", "system_layer"],
+        keywords: ["enforced at", "database level", "application level"],
+        examples: [
+            "enforcement_location_rule(foreign_key_constraints, database_level)",
+        ],
+        tags: ["enforcement", "architecture"],
+    },
+    {
+        id: "FACT-SCHEMA-RECONCILIATION-RULE",
+        predicate_name: "reconciliation_rule",
+        title: "Reconciliation rule",
+        description: "A trigger reconciles a target and performs a stale-data cleanup action.",
+        argument_names: ["subject", "trigger", "target", "action"],
+        argument_types: ["entity", "trigger", "target", "action"],
+        keywords: ["reconcile", "clear stale", "stale notifications"],
+        examples: [
+            "reconciliation_rule(system, login, analysis_notifications, clear_stale_notifications)",
+        ],
+        tags: ["reconciliation", "cleanup"],
+    },
+    {
+        id: "FACT-SCHEMA-THROTTLE-POLICY-RULE",
+        predicate_name: "throttle_policy_rule",
+        title: "Throttle policy rule",
+        description: "Handlers or operations must be throttled for a named activity class.",
+        argument_names: ["subject", "condition"],
+        argument_types: ["entity", "condition"],
+        keywords: ["throttled", "high-frequency", "event handlers"],
+        examples: [
+            "throttle_policy_rule(event_handlers, high-frequency_operations)",
+        ],
+        tags: ["throttle", "performance"],
+    },
+    {
+        id: "FACT-SCHEMA-HAS-UNSAVED-CHANGES",
+        predicate_name: "has_unsaved_changes",
+        title: "Unsaved change state",
+        description: "A subject has unsaved or dirty local edits.",
+        argument_names: ["subject", "expected"],
+        argument_types: ["entity", "boolean"],
+        keywords: ["unsaved", "dirty", "draft", "edits", "changes"],
+        examples: ["has_unsaved_changes(editor.annotation, true)"],
+        tags: ["state", "persistence"],
+    },
+    {
+        id: "FACT-SCHEMA-COMMIT-ACTION",
+        predicate_name: "commit_action",
+        title: "Commit or save action",
+        description: "A trigger commits, saves, or persists a subject within a scope.",
+        argument_names: ["subject", "trigger", "scope"],
+        argument_types: ["entity", "trigger", "scope"],
+        keywords: [
+            "save",
+            "saves",
+            "saved",
+            "auto-save",
+            "autosave",
+            "commit",
+            "persist",
+            "navigation",
+            "navigates",
+            "draft",
+        ],
+        examples: ["commit_action(editor.annotation, navigation, draft)"],
+        tags: ["persistence", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-DISCARD-ACTION",
+        predicate_name: "discard_action",
+        title: "Discard action",
+        description: "A trigger discards or cancels changes for a subject within a scope.",
+        argument_names: ["subject", "trigger", "scope"],
+        argument_types: ["entity", "trigger", "scope"],
+        keywords: ["discard", "cancel", "escape", "revert", "without save"],
+        examples: ["discard_action(editor.annotation, escape, active_annotation)"],
+        tags: ["persistence", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-ACCESSIBILITY",
+        predicate_name: "accessibility_requirement",
+        title: "Accessibility requirement",
+        description: "A subject must satisfy an accessibility standard or severity target.",
+        argument_names: ["subject", "standard", "severity"],
+        argument_types: ["entity", "standard", "severity"],
+        keywords: ["accessibility", "a11y", "wcag", "keyboard", "screen reader"],
+        examples: ["accessibility_requirement(game.flow, WCAG, high)"],
+        tags: ["accessibility", "quality"],
+    },
+    {
+        id: "FACT-SCHEMA-RETENTION-POLICY",
+        predicate_name: "retention_policy",
+        title: "Retention policy",
+        description: "A subject is retained for a bounded duration.",
+        argument_names: ["subject", "duration", "unit"],
+        argument_types: ["entity", "number", "unit"],
+        keywords: ["retain", "retained", "retention", "days", "months", "years"],
+        examples: ["retention_policy(customer.data, 7, years)"],
+        tags: ["data", "policy"],
+    },
+    {
+        id: "FACT-SCHEMA-RESOURCE-CONSTRAINT",
+        predicate_name: "resource_constraint",
+        title: "Resource constraint",
+        description: "A subject constrains a resource by operator, threshold, and unit.",
+        argument_names: ["subject", "resource", "operator", "threshold", "unit"],
+        argument_types: ["entity", "resource", "operator", "number", "unit"],
+        keywords: ["limit", "maximum", "minimum", "latency", "timeout", "size"],
+        examples: ["resource_constraint(api.search, latency, lte, 200, ms)"],
+        tags: ["performance", "constraint"],
+    },
+];

package/dist/operations/modeling/predicate-catalog-4.d.ts

@@ -0,0 +1,3 @@
+import type { PredicateSchemaCandidate } from "./predicate-types.js";
+export declare const PREDICATE_CATALOG_4: PredicateSchemaCandidate[];
+//# sourceMappingURL=predicate-catalog-4.d.ts.map

package/dist/operations/modeling/predicate-catalog-4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-catalog-4.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-catalog-4.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,eAAO,MAAM,mBAAmB,EAAE,wBAAwB,EAoJzD,CAAC"}

package/dist/operations/modeling/predicate-catalog-4.js

@@ -0,0 +1,149 @@
+// implements REQ-mcp-suggest-predicates
+export const PREDICATE_CATALOG_4 = [
+    {
+        id: "FACT-SCHEMA-FEATURE-GATE",
+        predicate_name: "feature_gate",
+        title: "Feature gate",
+        description: "A subject is controlled by a runtime or configuration gate.",
+        argument_names: ["subject", "gate", "expected"],
+        argument_types: ["entity", "flag", "boolean"],
+        keywords: ["flag", "feature gate", "enabled", "disabled", "kill switch"],
+        examples: ["feature_gate(checkout.v2, checkoutV2Enabled, true)"],
+        tags: ["flag", "runtime"],
+    },
+    {
+        id: "FACT-SCHEMA-EVENT-PUBLISH",
+        predicate_name: "publishes_event",
+        title: "Event publication",
+        description: "A subject publishes a domain or system event.",
+        argument_names: ["subject", "event"],
+        argument_types: ["entity", "event"],
+        keywords: ["publish", "publishes", "emit", "emits", "event"],
+        examples: ["publishes_event(order.checkout, OrderSubmitted)"],
+        tags: ["event", "architecture"],
+    },
+    {
+        id: "FACT-SCHEMA-ACCEPTANCE-RULE",
+        predicate_name: "acceptance_rule",
+        title: "Acceptance rule",
+        description: "A subject has an observable acceptance outcome.",
+        argument_names: ["subject", "outcome"],
+        argument_types: ["entity", "outcome"],
+        keywords: [
+            "acceptance",
+            "observable",
+            "outcome",
+            "must show",
+            "must display",
+        ],
+        examples: ["acceptance_rule(search.results, shows_empty_state)"],
+        tags: ["acceptance", "quality"],
+    },
+    {
+        id: "FACT-SCHEMA-PERMISSION-RULE",
+        predicate_name: "permission_rule",
+        title: "Permission rule",
+        description: "An actor is allowed or denied an action against a resource.",
+        argument_names: ["actor", "action", "resource", "decision"],
+        argument_types: ["actor", "action", "resource", "decision"],
+        keywords: [
+            "may",
+            "can",
+            "allowed",
+            "denied",
+            "forbidden",
+            "must not",
+            "cannot",
+            "can't",
+            "export",
+            "permission",
+        ],
+        examples: ["permission_rule(guest, export, customer_data, deny)"],
+        tags: ["permission", "policy"],
+    },
+    {
+        id: "FACT-SCHEMA-DEFAULT-VALUE",
+        predicate_name: "default_value",
+        title: "Default value",
+        description: "A subject property defaults to a value.",
+        argument_names: ["subject", "property", "value"],
+        argument_types: ["entity", "property", "value"],
+        keywords: ["default", "defaults", "defaulted", "initial", "mode", "tool"],
+        examples: ["default_value(annotation.tool, mode, move)"],
+        tags: ["default", "configuration"],
+    },
+    {
+        id: "FACT-SCHEMA-UNIQUENESS-CONSTRAINT",
+        predicate_name: "uniqueness_constraint",
+        title: "Uniqueness constraint",
+        description: "A subject is unique within one or more scope keys.",
+        argument_names: ["subject", "scope"],
+        argument_types: ["entity", "scope"],
+        keywords: ["unique", "uniqueness", "at most one", "one", "per"],
+        examples: ["uniqueness_constraint(annotation, video,timeKey)"],
+        tags: ["constraint", "identity"],
+    },
+    {
+        id: "FACT-SCHEMA-STATE-MEMBERSHIP",
+        predicate_name: "state_membership",
+        title: "State membership",
+        description: "A state-valued subject has a closed set of allowed states.",
+        argument_names: ["subject", "states"],
+        argument_types: ["entity", "state_list"],
+        keywords: ["terminal states", "states are", "one of", "ready", "anonymous"],
+        examples: ["state_membership(auth.status, ready,anonymous,profile-error)"],
+        tags: ["state", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-TEMPORAL-ORDER",
+        predicate_name: "temporal_order",
+        title: "Temporal order",
+        description: "One event or state must occur before or after another.",
+        argument_names: ["subject", "before_event", "after_event"],
+        argument_types: ["entity", "event", "event"],
+        keywords: ["before", "after", "saved", "completes", "navigation"],
+        examples: ["temporal_order(draft.changes, saved, navigation_completes)"],
+        tags: ["temporal", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-CONDITIONAL-BEHAVIOR",
+        predicate_name: "conditional_behavior",
+        title: "Conditional behavior",
+        description: "A behavior follows when a condition is true.",
+        argument_names: ["subject", "condition", "behavior"],
+        argument_types: ["entity", "condition", "behavior"],
+        keywords: ["if", "during", "becomes", "condition", "provided that"],
+        examples: [
+            "conditional_behavior(card, fails_during_session, becomes_tainted)",
+        ],
+        tags: ["conditional", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-STATE-TRANSITION",
+        predicate_name: "state_transition",
+        title: "State transition",
+        description: "A subject moves from one state to another because of a trigger.",
+        argument_names: ["subject", "from_state", "to_state", "trigger"],
+        argument_types: ["entity", "state", "state", "trigger"],
+        keywords: ["transitions from", "transition from", "from draft", "to idle"],
+        examples: ["state_transition(editor, draft, idle, navigation_completes)"],
+        tags: ["state", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-RATE-LIMIT",
+        predicate_name: "rate_limit",
+        title: "Rate limit",
+        description: "An action is limited to a count within a time window.",
+        argument_names: ["subject", "action", "window", "count"],
+        argument_types: ["entity", "action", "duration", "number"],
+        keywords: [
+            "rate limited",
+            "rate limit",
+            "attempts",
+            "per hour",
+            "per minute",
+        ],
+        examples: ["rate_limit(password_reset.request, attempts, hour, 5)"],
+        tags: ["rate-limit", "security"],
+    },
+];

package/dist/operations/modeling/predicate-catalog.d.ts

@@ -0,0 +1,5 @@
+import type { PredicateSchemaCandidate, PredicateUsageHints } from "./predicate-types.js";
+export declare const DEFAULT_USAGE_HINTS: PredicateUsageHints;
+export declare const USAGE_HINTS_BY_PREDICATE: Record<string, PredicateUsageHints>;
+export declare const BUILT_IN_PREDICATE_SCHEMAS: PredicateSchemaCandidate[];
+//# sourceMappingURL=predicate-catalog.d.ts.map

package/dist/operations/modeling/predicate-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-catalog.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-catalog.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAM9B,eAAO,MAAM,mBAAmB,EAAE,mBAOjC,CAAC;AAGF,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAIxE,CAAC;AAGF,eAAO,MAAM,0BAA0B,EAAE,wBAAwB,EAKhE,CAAC"}

package/dist/operations/modeling/predicate-catalog.js

@@ -0,0 +1,29 @@
+import { PREDICATE_CATALOG_1 } from "./predicate-catalog-1.js";
+import { PREDICATE_CATALOG_2 } from "./predicate-catalog-2.js";
+import { PREDICATE_CATALOG_3 } from "./predicate-catalog-3.js";
+import { PREDICATE_CATALOG_4 } from "./predicate-catalog-4.js";
+import { PREDICATE_USAGE_HINTS_1 } from "./predicate-usage-hints-1.js";
+import { PREDICATE_USAGE_HINTS_2 } from "./predicate-usage-hints-2.js";
+import { PREDICATE_USAGE_HINTS_3 } from "./predicate-usage-hints-3.js";
+// implements REQ-mcp-suggest-predicates
+export const DEFAULT_USAGE_HINTS = {
+    use_when: [
+        "Use when the prose matches this predicate signature and all required arguments can be named explicitly.",
+    ],
+    do_not_use_when: [
+        "Do not use when a stricter scalar property, a more specific predicate, or an ontology-gap observation better preserves the claim.",
+    ],
+};
+// implements REQ-mcp-suggest-predicates
+export const USAGE_HINTS_BY_PREDICATE = {
+    ...PREDICATE_USAGE_HINTS_1,
+    ...PREDICATE_USAGE_HINTS_2,
+    ...PREDICATE_USAGE_HINTS_3,
+};
+// implements REQ-mcp-suggest-predicates
+export const BUILT_IN_PREDICATE_SCHEMAS = [
+    ...PREDICATE_CATALOG_1,
+    ...PREDICATE_CATALOG_2,
+    ...PREDICATE_CATALOG_3,
+    ...PREDICATE_CATALOG_4,
+];

package/dist/operations/modeling/predicate-inference-1.d.ts

@@ -0,0 +1,16 @@
+export declare function inferPermissionRuleArgs(text: string): string[];
+export declare function inferGuardArgs(text: string, subject: string): string[];
+export declare function inferExceptionRuleArgs(text: string, subject: string): string[];
+export declare function inferMutualExclusionArgs(text: string): string[];
+export declare function inferDependencyRuleArgs(text: string): string[];
+export declare function inferOwnershipRuleArgs(text: string): string[];
+export declare function inferRetryPolicyArgs(text: string): string[];
+export declare function inferEscalationRuleArgs(text: string): string[];
+export declare function inferAvailabilitySlaArgs(text: string): string[];
+export declare function inferNotificationRouteArgs(text: string): string[];
+export declare function inferIdempotencyRuleArgs(text: string): string[];
+export declare function inferDataResidencyRuleArgs(text: string): string[];
+export declare function inferAuditEventRuleArgs(text: string): string[];
+export declare function inferConsentRuleArgs(text: string): string[];
+export declare function inferLifecycleRuleArgs(text: string): string[];
+//# sourceMappingURL=predicate-inference-1.d.ts.map

package/dist/operations/modeling/predicate-inference-1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-inference-1.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-inference-1.ts"],"names":[],"mappings":"AAQA,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAsB9D;AAGD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBtE;AAGD,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,EAAE,CAWV;AAGD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ/D;AAGD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS9D;AAGD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ7D;AAGD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS3D;AAGD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAU9D;AAGD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAY/D;AAGD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASjE;AAGD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAmB/D;AAGD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQjE;AAGD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ9D;AAGD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS3D;AAGD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAU7D"}

package/dist/operations/modeling/predicate-inference-1.js

@@ -0,0 +1,161 @@
+import { normalizePredicateToken, normalizeSubjectKey, singularize, slug, } from "./predicate-utils.js";
+// implements REQ-mcp-suggest-predicates
+export function inferPermissionRuleArgs(text) {
+    const prohibition = text.match(/^(?<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);
+    if (prohibition?.groups) {
+        return [
+            singularize(slug(prohibition.groups.actor ?? "actor")),
+            normalizePredicateToken(prohibition.groups.action ?? "action"),
+            normalizePredicateToken(prohibition.groups.resource ?? "resource"),
+            "deny",
+        ];
+    }
+    const permission = text.match(/^(?:only\s+)?(?<actor>[a-z][a-z\s_-]*?)\s+(?:may|can|is\s+allowed\s+to)\s+(?<action>[a-z][a-z_-]*)\s+(?<resource>.+?)(?:\s+when\s+.+)?\.?$/i);
+    return [
+        singularize(slug(permission?.groups?.actor ?? "actor")),
+        normalizePredicateToken(permission?.groups?.action ?? "action"),
+        normalizePredicateToken(permission?.groups?.resource ?? "resource"),
+        "assert",
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferGuardArgs(text, subject) {
+    const disabledUntil = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)?\s*(?:stay|remain)?\s*disabled\s+until\s+(?<condition>.+?)\.?$/i);
+    if (disabledUntil?.groups?.subject && disabledUntil.groups.condition) {
+        return [
+            slug(disabledUntil.groups.subject),
+            normalizePredicateToken(disabledUntil.groups.condition),
+            "disabled",
+        ];
+    }
+    const lower = text.toLowerCase();
+    return [
+        subject,
+        lower.includes("readonly") ? "isReadOnly" : "condition",
+        "true",
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferExceptionRuleArgs(text, subject) {
+    const exception = text.match(/^(?:the\s+)?(?<subject>[a-z][a-z\s_-]*?)\s+(?:must|shall|should)\s+(?<behavior>.+?)\s+unless\s+(?:the\s+)?(?<exception>.+?)\.?$/i);
+    return [
+        exception?.groups?.subject
+            ? normalizeSubjectKey(exception.groups.subject)
+            : subject,
+        normalizePredicateToken(exception?.groups?.behavior ?? "behavior"),
+        normalizePredicateToken(exception?.groups?.exception ?? "exception"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferMutualExclusionArgs(text) {
+    const exclusion = text.match(/^(?<left>.+?)\s+and\s+(?<right>.+?)\s+(?:must|shall|should)\s+be\s+mutually\s+exclusive\.?$/i);
+    return [
+        slug(exclusion?.groups?.left ?? "left"),
+        slug(exclusion?.groups?.right ?? "right"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferDependencyRuleArgs(text) {
+    const dependency = text.match(/^(?<subject>.+?)\s+requires\s+(?<prerequisite>.+?)\s+before\s+(?<dependent>.+?)\.?$/i);
+    return [
+        slug(dependency?.groups?.subject ?? "subject"),
+        normalizePredicateToken(dependency?.groups?.prerequisite ?? "prerequisite"),
+        normalizePredicateToken(dependency?.groups?.dependent ?? "dependent"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferOwnershipRuleArgs(text) {
+    const ownership = text.match(/^(?<resource>.+?)\s+(?:is|are)\s+owned\s+by\s+(?:the\s+)?(?<owner>.+?)\.?$/i);
+    return [
+        slug(ownership?.groups?.resource ?? "resource"),
+        slug(ownership?.groups?.owner ?? "owner"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferRetryPolicyArgs(text) {
+    const retry = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+retry\s+up\s+to\s+(?<count>\d+)\s+(?<unit>times|attempts?)\.?$/i);
+    return [
+        slug(retry?.groups?.subject ?? "subject"),
+        retry?.groups?.count ?? "0",
+        slug(retry?.groups?.unit ?? "times"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferEscalationRuleArgs(text) {
+    const escalation = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+escalate\s+to\s+(?<target>.+?)\s+after\s+(?<delay>\d+)\s+(?<unit>[a-z]+)\.?$/i);
+    return [
+        slug(escalation?.groups?.subject ?? "subject"),
+        slug(escalation?.groups?.target ?? "target"),
+        escalation?.groups?.delay ?? "0",
+        slug(escalation?.groups?.unit ?? "unit"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferAvailabilitySlaArgs(text) {
+    const availability = text.match(/^(?<subject>.+?)\s+availability\s+(?:must|shall|should)\s+be\s+at\s+least\s+(?<threshold>\d+(?:\.\d+)?)\s+(?<unit>percent|%)\s+(?<window>[a-z]+)\.?$/i);
+    return [
+        slug(availability?.groups?.subject ?? "subject"),
+        availability?.groups?.threshold ?? "0",
+        availability?.groups?.unit === "%"
+            ? "percent"
+            : slug(availability?.groups?.unit ?? "percent"),
+        slug(availability?.groups?.window ?? "window"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferNotificationRouteArgs(text) {
+    const notification = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+notify\s+(?<recipient>.+?)\s+by\s+(?<channel>[a-z]+)\.?$/i);
+    return [
+        slug(notification?.groups?.subject ?? "subject"),
+        slug(notification?.groups?.recipient ?? "recipient"),
+        slug(notification?.groups?.channel ?? "channel"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferIdempotencyRuleArgs(text) {
+    const idempotency = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+idempotent\s+by\s+(?<key>.+?)\.?$/i);
+    const deduplicated = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+deduplicated\s+to\s+prevent\s+redundant\s+requests\s+during\s+(?<key>.+?)\.?$/i);
+    return [
+        slug(idempotency?.groups?.subject ??
+            deduplicated?.groups?.subject ??
+            "subject"),
+        slug(idempotency?.groups?.key ??
+            deduplicated?.groups?.key ??
+            "idempotency_key"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferDataResidencyRuleArgs(text) {
+    const residency = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?:stored|processed|kept)\s+in\s+(?:the\s+)?(?<region>.+?\b(?:region|jurisdiction|country|zone|area))\.?$/i);
+    return [
+        slug(residency?.groups?.subject ?? "data"),
+        slug(residency?.groups?.region ?? "region"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferAuditEventRuleArgs(text) {
+    const audit = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?:recorded|logged|audited)\s+in\s+(?:the\s+)?(?<log>audit\s+(?:log|trail))\.?$/i);
+    return [
+        slug(audit?.groups?.subject ?? "subject"),
+        slug(audit?.groups?.log ?? "audit_log"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferConsentRuleArgs(text) {
+    const consent = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+require\s+(?<consent>.+?consent)\s+before\s+(?<purpose>.+?)\.?$/i);
+    return [
+        slug(consent?.groups?.subject ?? "subject"),
+        slug(consent?.groups?.consent ?? "consent"),
+        normalizePredicateToken(consent?.groups?.purpose ?? "purpose"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferLifecycleRuleArgs(text) {
+    const lifecycle = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<action>archived|deleted|expired)\s+after\s+(?<duration>\d+)\s+(?<unit>[a-z]+)\.?$/i);
+    return [
+        slug(lifecycle?.groups?.subject ?? "subject"),
+        slug(lifecycle?.groups?.action ?? "action"),
+        lifecycle?.groups?.duration ?? "0",
+        slug(lifecycle?.groups?.unit ?? "unit"),
+    ];
+}

package/dist/operations/modeling/predicate-inference-2.d.ts

@@ -0,0 +1,19 @@
+export declare function inferConflictResolutionRuleArgs(text: string): string[];
+export declare function inferFallbackRuleArgs(text: string): string[];
+export declare function inferBatchOperationRuleArgs(text: string): string[];
+export declare function inferConsistencyRuleArgs(text: string): string[];
+export declare function inferBuildConstraintArgs(text: string): string[];
+export declare function inferEnvironmentSafetyRuleArgs(text: string): string[];
+export declare function inferSchemaInvariantRuleArgs(text: string): string[];
+export declare function inferCodingStandardRuleArgs(text: string): string[];
+export declare function inferMigrationBoundaryRuleArgs(text: string): string[];
+export declare function inferAbsenceRequirementArgs(text: string): string[];
+export declare function inferOfflineBehaviorRuleArgs(text: string): string[];
+export declare function inferReleaseGateRuleArgs(text: string): string[];
+export declare function inferPlatformConsistencyRuleArgs(text: string): string[];
+export declare function inferPreservationRuleArgs(text: string): string[];
+export declare function inferAbstractionBoundaryRuleArgs(text: string): string[];
+export declare function inferSecurityConfigurationRuleArgs(text: string): string[];
+export declare function inferOrderedStrategyRuleArgs(text: string): string[];
+export declare function inferRefreshPolicyRuleArgs(text: string): string[];
+//# sourceMappingURL=predicate-inference-2.d.ts.map

package/dist/operations/modeling/predicate-inference-2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-inference-2.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-inference-2.ts"],"names":[],"mappings":"AAGA,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQtE;AAGD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS5D;AAGD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASlE;AAGD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ/D;AAGD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS/D;AAGD,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASrE;AAGD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAWnE;AAGD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASlE;AAGD,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASrE;AAGD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAalE;AAGD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASnE;AAGD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS/D;AAGD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAUvE;AAGD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAShE;AAGD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASvE;AAGD,wBAAgB,kCAAkC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASzE;AAGD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAcnE;AAGD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASjE"}