kibi-cli 0.12.8 → 0.16.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-score-1.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-score-1.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,wBAAwB,EAChC,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,IAAI,CA6Lf"}

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

@@ -0,0 +1,121 @@
+// implements REQ-mcp-suggest-predicates
+export function scoreExactPredicates1(schema, text) {
+    if (schema.predicate_name === "guard") {
+        if (/^.+?\s+(?:must|shall|should)?\s*(?:stay|remain)?\s*disabled\s+until\s+.+?\.?$/i.test(text)) {
+            return 0.98;
+        }
+    }
+    if (schema.predicate_name === "conditional_behavior") {
+        if (/^if\s+(?:(?:a|an|the)\s+)?[a-z][a-z_-]*\s+.+?,\s*(?:it|they|the\s+[a-z][a-z\s_-]*?)\s+.+?\.?$/i.test(text)) {
+            return 0.98;
+        }
+        if (/^when\s+.+?,\s*(?:the\s+)?.+?\s+(?:must|shall|should)\s+.+?\.?$/i.test(text)) {
+            return 0.36;
+        }
+        return 0;
+    }
+    if (schema.predicate_name === "exception_rule") {
+        if (!/^(?:the\s+)?[a-z][a-z\s_-]*?\s+(?:must|shall|should)\s+.+?\s+unless\s+(?:the\s+)?.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "mutual_exclusion") {
+        if (!/^.+?\s+and\s+.+?\s+(?:must|shall|should)\s+be\s+mutually\s+exclusive\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "dependency_rule") {
+        if (!/^.+?\s+requires\s+.+?\s+before\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "ownership_rule") {
+        if (!/^.+?\s+(?:is|are)\s+owned\s+by\s+(?:the\s+)?.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "retry_policy") {
+        if (!/^.+?\s+(?:must|shall|should)\s+retry\s+up\s+to\s+\d+\s+(?:times|attempts?)\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "escalation_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+escalate\s+to\s+.+?\s+after\s+\d+\s+[a-z]+\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "availability_sla") {
+        if (!/^.+?\s+availability\s+(?:must|shall|should)\s+be\s+at\s+least\s+\d+(?:\.\d+)?\s+(?:percent|%)\s+[a-z]+\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "notification_route") {
+        if (!/^.+?\s+(?:must|shall|should)\s+notify\s+.+?\s+by\s+[a-z]+\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "idempotency_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+idempotent\s+by\s+.+?\.?$/i.test(text) &&
+            !/^.+?\s+(?:must|shall|should)\s+be\s+deduplicated\s+to\s+prevent\s+redundant\s+requests\s+during\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "data_residency_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+(?:stored|processed|kept)\s+in\s+(?:the\s+)?.+?\b(?:region|jurisdiction|country|zone|area)\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "audit_event_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+(?:recorded|logged|audited)\s+in\s+(?:the\s+)?audit\s+(?:log|trail)\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "consent_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+require\s+.+?consent\s+before\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "lifecycle_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+(?:archived|deleted|expired)\s+after\s+\d+\s+[a-z]+\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "conflict_resolution_rule") {
+        if (!/^when\s+.+?\s+conflicts?,\s+(?:the\s+)?.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "fallback_rule") {
+        if (!/^if\s+.+?,\s+.+?\s+(?:must|shall|should)\s+fall\s+back\s+to\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "batch_operation_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+process\s+.+?\s+in\s+batches\s+of\s+\d+\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "consistency_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+reference\s+an?\s+existing\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    return null;
+}

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

@@ -0,0 +1,3 @@
+import type { PredicateSchemaCandidate } from "./predicate-types.js";
+export declare function scoreExactPredicates2(schema: PredicateSchemaCandidate, text: string): number | null;
+//# sourceMappingURL=predicate-score-2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-score-2.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-score-2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,wBAAwB,EAChC,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,IAAI,CAgMf"}

package/dist/operations/modeling/predicate-score-2.js

@@ -0,0 +1,122 @@
+// implements REQ-mcp-suggest-predicates
+export function scoreExactPredicates2(schema, text) {
+    if (schema.predicate_name === "build_constraint") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+deterministic\s+at\s+build\s+time\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "environment_safety_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+(?:forbidden|read-only|allowed)\s+in\s+(?:production|staging|development)\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "schema_invariant_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+immutable\s+after\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "coding_standard_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+(?:use|avoid)\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        if (!/\b(?:api|apis|code|component|computed|framework|hook|pattern|signal|schema|type)\b/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "migration_boundary_rule") {
+        if (!/^.+?\s+may\s+only\s+be\s+read\s+as\s+migration\s+input(?:\s+by\s+.+?)?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "absence_requirement") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+(?:absent|removed)\.?$/i.test(text) &&
+            !/^no\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "offline_behavior_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+(?:non-blocking|resilient)\s+during\s+offline\s+conditions\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "release_gate_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+pass\s+.+?\s+before\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        if (!/\b(?:app store|build|deployment|distribution|release|testflight)\b/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "platform_consistency_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+synchronize\s+across\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "preservation_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+preserve\s+.+?\s+when\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "abstraction_boundary_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+persisted\s+as\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        if (!/\b(?:neutral|contract|renderer|runtime|vendor)\b/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "security_configuration_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+have\s+explicit\s+[A-Za-z0-9_.-]+\s+[A-Za-z0-9_.-]+\.?$/i.test(text)) {
+            return 0;
+        }
+        if (!/\b(?:database|deployment|function|rpc|search_path|security|trigger)\b/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "ordered_strategy_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+use\s+.+?\s+in\s+priority\s+order\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "refresh_policy_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+automatically\s+refresh\s+.+?\s+without\s+requiring\s+manual\s+page\s+reload\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "scoped_authorization_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+denied\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        if (!/\b(?:assigned|unassigned|owner|member|scoped)\b/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "documentation_standard_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+documented\s+in\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "warmup_policy_rule") {
+        if (!/^(?:the\s+)?.+?\s+(?:must|shall|should)\s+warm\s+up\s+on\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    return null;
+}

package/dist/operations/modeling/predicate-score-3.d.ts

@@ -0,0 +1,3 @@
+import type { PredicateSchemaCandidate } from "./predicate-types.js";
+export declare function scoreExactPredicates3(schema: PredicateSchemaCandidate, text: string): number | null;
+//# sourceMappingURL=predicate-score-3.d.ts.map

package/dist/operations/modeling/predicate-score-3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-score-3.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-score-3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,wBAAwB,EAChC,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,IAAI,CA8Ef"}

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

@@ -0,0 +1,54 @@
+// implements REQ-mcp-suggest-predicates
+export function scoreExactPredicates3(schema, text) {
+    if (schema.predicate_name === "visual_layout_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+remain\s+visually\s+aligned\s+with\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "enforcement_location_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+enforced\s+at\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "reconciliation_rule") {
+        if (!/^on\s+.+?,\s*.+?\s+(?:must|shall|should)\s+reconcile\s+.+?\s+and\s+clear\s+stale\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "throttle_policy_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+throttled\s+for\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "temporal_order") {
+        if (/^(?:the\s+)?.+?\s+initializes\s+after\s+(?:the\s+)?.+?\s+is\s+ready\.?$/i.test(text)) {
+            return 0.98;
+        }
+    }
+    if (schema.predicate_name === "state_transition") {
+        if (!/^when\s+.+?,\s*(?:the\s+)?[a-z][a-z\s_-]*?\s+transitions?\s+from\s+[a-z][a-z0-9_-]*\s+to\s+[a-z][a-z0-9_-]*\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "state_transition" ||
+        schema.predicate_name === "conditional_behavior") {
+        return 0.98;
+    }
+    if (schema.predicate_name === "commit_action") {
+        if (/\b(?:auto-save|autosave|commit|persist)\b/i.test(text)) {
+            return 0.98;
+        }
+        if (/\b(?:save|saves)\b/i.test(text) &&
+            !/\bwithout\s+save\b/i.test(text) &&
+            !/\bsaved\s+before\b/i.test(text)) {
+            return 0.98;
+        }
+        return 0;
+    }
+    return null;
+}

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

@@ -0,0 +1,61 @@
+export type PredicatePolarity = "assert" | "deny";
+export interface PredicateUsageHints {
+    use_when: string[];
+    do_not_use_when: string[];
+}
+export interface PredicateSchemaCandidate {
+    id: string;
+    predicate_name: string;
+    title: string;
+    description: string;
+    argument_names: string[];
+    argument_types: string[];
+    keywords: string[];
+    examples: string[];
+    tags: string[];
+    usage_hints?: PredicateUsageHints;
+}
+export type SuggestPredicatesArgs = Readonly<Record<string, unknown>> & {
+    readonly text: string;
+    readonly requirementId?: string;
+    readonly source?: string;
+    readonly subjectHint?: string;
+    readonly maxCandidates?: number;
+    readonly minScore?: number;
+    readonly includeExistingSchemas?: boolean;
+    /** Existing requirement claim manifest. Relationship guidance merges this list. */
+    readonly existingLogicClaims?: readonly string[];
+};
+export interface PredicateSuggestion {
+    id: string;
+    predicate_name: string;
+    predicate_args: string[];
+    canonical_key: string;
+    polarity: PredicatePolarity;
+    score: number;
+    rationale: string;
+    schema: Omit<PredicateSchemaCandidate, "keywords"> & {
+        usage_hints: PredicateUsageHints;
+    };
+}
+export interface SuggestPredicatesResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent: {
+        text: string;
+        claimKey: string;
+        logicClaims: string[];
+        source: string | null;
+        requirementId: string | null;
+        subject: string;
+        candidates: PredicateSuggestion[];
+        recommendedAction: "apply_requires_predicate" | "record_ontology_gap";
+        applyPlan: Array<Record<string, unknown>>;
+        relationshipPlan: Record<string, unknown> | null;
+        warnings: string[];
+    };
+    applyPlan: Array<Record<string, unknown>>;
+}
+//# sourceMappingURL=predicate-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-types.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-types.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,MAAM,CAAC;AAGlD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAGD,MAAM,WAAW,wBAAwB;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,WAAW,CAAC,EAAE,mBAAmB,CAAC;CACnC;AAGD,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,mFAAmF;IACnF,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClD,CAAC;AAGF,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,IAAI,CAAC,wBAAwB,EAAE,UAAU,CAAC,GAAG;QACnD,WAAW,EAAE,mBAAmB,CAAC;KAClC,CAAC;CACH;AAGD,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,iBAAiB,EAAE;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;QAC7B,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,mBAAmB,EAAE,CAAC;QAClC,iBAAiB,EAAE,0BAA0B,GAAG,qBAAqB,CAAC;QACtE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QAC1C,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;QACjD,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;IACF,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC3C"}

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

@@ -0,0 +1 @@
+export {};

package/dist/operations/modeling/predicate-usage-hints-1.d.ts

@@ -0,0 +1,3 @@
+import type { PredicateUsageHints } from "./predicate-types.js";
+export declare const PREDICATE_USAGE_HINTS_1: Record<string, PredicateUsageHints>;
+//# sourceMappingURL=predicate-usage-hints-1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-usage-hints-1.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-usage-hints-1.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAGhE,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAiNvE,CAAC"}

package/dist/operations/modeling/predicate-usage-hints-1.js

@@ -0,0 +1,211 @@
+// implements REQ-mcp-suggest-predicates
+export const PREDICATE_USAGE_HINTS_1 = {
+    state: {
+        use_when: [
+            "Use for one subject being in, entering, or requiring one named state.",
+        ],
+        do_not_use_when: [
+            "Do not use for allowed state sets or explicit state-to-state movement; use state_membership or state_transition instead.",
+        ],
+    },
+    transition: {
+        use_when: [
+            "Use for workflow prose where a subject moves between states because of a trigger.",
+        ],
+        do_not_use_when: [
+            "Do not use for one current state, allowed terminal states, or non-state conditional behavior.",
+        ],
+    },
+    guard: {
+        use_when: [
+            "Use when a boolean condition gates whether behavior is active or permitted.",
+        ],
+        do_not_use_when: [
+            "Do not use for explicit unless/except exceptions, actor authorization, feature flags, or scalar thresholds.",
+        ],
+    },
+    exception_rule: {
+        use_when: [
+            "Use for unless/except clauses where a normally required behavior is skipped under a named exception.",
+        ],
+        do_not_use_when: [
+            "Do not use for generic boolean guards without an exception clause, actor permissions, or feature flags.",
+        ],
+    },
+    mutual_exclusion: {
+        use_when: [
+            "Use when two modes, states, options, or behaviors cannot be true or active together.",
+        ],
+        do_not_use_when: [
+            "Do not use for uniqueness per scope, allowed state sets, or ordinary permission denials.",
+        ],
+    },
+    dependency_rule: {
+        use_when: [
+            "Use when one action, state, or resource requires another prerequisite before it can proceed.",
+        ],
+        do_not_use_when: [
+            "Do not use for temporal ordering without a required prerequisite, ownership, or feature gates.",
+        ],
+    },
+    ownership_rule: {
+        use_when: [
+            "Use when a resource, domain area, or behavior is owned by a service, team, role, or component.",
+        ],
+        do_not_use_when: [
+            "Do not use for permission to access a resource or event publication.",
+        ],
+    },
+    retry_policy: {
+        use_when: [
+            "Use when a failed action must be retried a bounded number of times or attempts.",
+        ],
+        do_not_use_when: [
+            "Do not use for rate limits, backoff timing without retries, or escalation after a delay.",
+        ],
+    },
+    escalation_rule: {
+        use_when: [
+            "Use when an unresolved or failed condition is escalated to an owner, role, queue, or service after a delay.",
+        ],
+        do_not_use_when: [
+            "Do not use for ownership assignments, retry counts, or simple notification routing.",
+        ],
+    },
+    availability_sla: {
+        use_when: [
+            "Use when an API, service, or system has a minimum availability target over a reporting window.",
+        ],
+        do_not_use_when: [
+            "Do not use for latency thresholds, retention durations, or generic resource constraints.",
+        ],
+    },
+    notification_route: {
+        use_when: [
+            "Use when a subject must notify a recipient, team, or role through a specific channel.",
+        ],
+        do_not_use_when: [
+            "Do not use for event publication, ownership assignment, or escalation after a delay.",
+        ],
+    },
+    idempotency_rule: {
+        use_when: [
+            "Use when repeated, redundant, or concurrent requests or operations must be safely deduplicated by an idempotency key or equivalent identity.",
+        ],
+        do_not_use_when: [
+            "Do not use for general uniqueness constraints, retry counts, or rate limits; choose the more specific predicate instead.",
+        ],
+    },
+    data_residency_rule: {
+        use_when: [
+            "Use when data must be stored, processed, or kept within a named region or jurisdiction.",
+        ],
+        do_not_use_when: [
+            "Do not use for retention durations, access permissions, or notification routing.",
+        ],
+    },
+    audit_event_rule: {
+        use_when: [
+            "Use when an action, change, or security-relevant event must be recorded in an audit log or audit trail.",
+        ],
+        do_not_use_when: [
+            "Do not use for user-facing notifications, event publication, or generic dirty-change state.",
+        ],
+    },
+    consent_rule: {
+        use_when: [
+            "Use when an action or data-processing purpose requires explicit user consent before it proceeds.",
+        ],
+        do_not_use_when: [
+            "Do not use for data residency, permission denials, or retention durations.",
+        ],
+    },
+    lifecycle_rule: {
+        use_when: [
+            "Use when an entity must be archived, deleted, expired, or otherwise lifecycle-transitioned after a duration.",
+        ],
+        do_not_use_when: [
+            "Do not use for passive retention duration requirements; use retention_policy when data is simply kept for a period.",
+        ],
+    },
+    conflict_resolution_rule: {
+        use_when: [
+            "Use when synchronization or concurrent updates require a named conflict-resolution strategy.",
+        ],
+        do_not_use_when: [
+            "Do not use for ordinary state transitions, dependency ordering, or fallback behavior.",
+        ],
+    },
+    fallback_rule: {
+        use_when: [
+            "Use when a degraded or unavailable dependency causes a subject to fall back to a named alternative behavior.",
+        ],
+        do_not_use_when: [
+            "Do not use for escalation after a delay, notification routing, or retry policies.",
+        ],
+    },
+    batch_operation_rule: {
+        use_when: [
+            "Use when a bulk operation must process a resource in batches of a specific size.",
+        ],
+        do_not_use_when: [
+            "Do not use for rate limits, retry counts, or general resource thresholds.",
+        ],
+    },
+    consistency_rule: {
+        use_when: [
+            "Use when one entity must reference, match, or remain consistent with another existing entity or invariant.",
+        ],
+        do_not_use_when: [
+            "Do not use for ownership, permission checks, or prerequisite workflow dependencies.",
+        ],
+    },
+    build_constraint: {
+        use_when: [
+            "Use when build-time generation or deployment configuration must satisfy a deterministic property.",
+        ],
+        do_not_use_when: [
+            "Do not use for runtime feature gates or ordinary resource thresholds.",
+        ],
+    },
+    environment_safety_rule: {
+        use_when: [
+            "Use when an action is allowed or forbidden in a named environment such as production or staging.",
+        ],
+        do_not_use_when: [
+            "Do not use for actor permissions that are independent of deployment environment.",
+        ],
+    },
+    schema_invariant_rule: {
+        use_when: [
+            "Use when a schema field has an invariant such as immutability, type, enum, or value-range constraints.",
+        ],
+        do_not_use_when: [
+            "Do not use for cross-entity references; use consistency_rule for referential integrity.",
+        ],
+    },
+    coding_standard_rule: {
+        use_when: [
+            "Use when developer-facing code must use or avoid a framework API, pattern, or documentation practice.",
+        ],
+        do_not_use_when: [
+            "Do not use for user-facing product behavior or role-based access control.",
+        ],
+    },
+    migration_boundary_rule: {
+        use_when: [
+            "Use when legacy data or APIs may only be used for migration or compatibility input.",
+        ],
+        do_not_use_when: [
+            "Do not use for general lifecycle archive/delete timing rules.",
+        ],
+    },
+    absence_requirement: {
+        use_when: [
+            "Use when a component, extension, RPC, schema, or feature must be absent, removed, or not exist.",
+        ],
+        do_not_use_when: [
+            "Do not use for denied user actions; use permission_rule for actor/action/resource denials.",
+        ],
+    },
+};

package/dist/operations/modeling/predicate-usage-hints-2.d.ts

@@ -0,0 +1,3 @@
+import type { PredicateUsageHints } from "./predicate-types.js";
+export declare const PREDICATE_USAGE_HINTS_2: Record<string, PredicateUsageHints>;
+//# sourceMappingURL=predicate-usage-hints-2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-usage-hints-2.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-usage-hints-2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAGhE,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CA+MvE,CAAC"}