kibi-cli 0.14.0 → 0.17.0

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

@@ -0,0 +1,200 @@
+// implements REQ-mcp-suggest-predicates
+export const PREDICATE_CATALOG_1 = [
+    {
+        id: "FACT-SCHEMA-STATE",
+        predicate_name: "state",
+        title: "State assertion",
+        description: "A subject has or enters a named state.",
+        argument_names: ["subject", "state"],
+        argument_types: ["entity", "state"],
+        keywords: ["state", "mode", "idle", "active", "draft", "edit"],
+        examples: ["state(editor.annotation, idle)"],
+        tags: ["state", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-TRANSITION",
+        predicate_name: "transition",
+        title: "State transition",
+        description: "A subject transitions between states because of a trigger.",
+        argument_names: ["subject", "from_state", "to_state", "trigger"],
+        argument_types: ["entity", "state", "state", "trigger"],
+        keywords: [
+            "transition",
+            "enter",
+            "leave",
+            "idle",
+            "navigate",
+            "navigates",
+            "cancel",
+            "escape",
+        ],
+        examples: ["transition(editor.annotation, draft, idle, navigation)"],
+        tags: ["state", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-GUARD",
+        predicate_name: "guard",
+        title: "Behavior guard",
+        description: "A condition gates or forbids behavior for a subject.",
+        argument_names: ["subject", "condition", "expected"],
+        argument_types: ["entity", "condition", "boolean"],
+        keywords: ["guard", "unless", "readonly", "scrubbing", "disabled until"],
+        examples: ["guard(editor.annotation, isReadOnly, false)"],
+        tags: ["guard", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-EXCEPTION-RULE",
+        predicate_name: "exception_rule",
+        title: "Exception rule",
+        description: "A required behavior is skipped when a named exception condition holds.",
+        argument_names: ["subject", "behavior", "exception"],
+        argument_types: ["entity", "behavior", "condition"],
+        keywords: ["unless", "except", "except when", "opted out", "exception"],
+        examples: [
+            "exception_rule(notification.service, send_email, user_has_opted_out)",
+        ],
+        tags: ["exception", "conditional"],
+    },
+    {
+        id: "FACT-SCHEMA-MUTUAL-EXCLUSION",
+        predicate_name: "mutual_exclusion",
+        title: "Mutual exclusion",
+        description: "Two modes, states, options, or behaviors cannot be true or active together.",
+        argument_names: ["left", "right"],
+        argument_types: ["entity", "entity"],
+        keywords: ["mutually exclusive", "exclusive", "cannot overlap", "not both"],
+        examples: ["mutual_exclusion(practice_mode, exam_mode)"],
+        tags: ["constraint", "exclusivity"],
+    },
+    {
+        id: "FACT-SCHEMA-DEPENDENCY-RULE",
+        predicate_name: "dependency_rule",
+        title: "Dependency rule",
+        description: "A subject requires a prerequisite before a dependent action or state can proceed.",
+        argument_names: ["subject", "prerequisite", "dependent"],
+        argument_types: ["entity", "condition", "action"],
+        keywords: ["requires", "depends on", "prerequisite", "before"],
+        examples: [
+            "dependency_rule(checkout, payment_authorization, order_submission)",
+        ],
+        tags: ["dependency", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-OWNERSHIP-RULE",
+        predicate_name: "ownership_rule",
+        title: "Ownership rule",
+        description: "A resource or behavior is owned by a service, team, role, or component.",
+        argument_names: ["resource", "owner"],
+        argument_types: ["entity", "owner"],
+        keywords: ["owned by", "owner", "responsible for"],
+        examples: ["ownership_rule(account_settings, profile_service)"],
+        tags: ["ownership", "governance"],
+    },
+    {
+        id: "FACT-SCHEMA-RETRY-POLICY",
+        predicate_name: "retry_policy",
+        title: "Retry policy",
+        description: "A failed subject or action retries up to a bounded attempt count.",
+        argument_names: ["subject", "count", "unit"],
+        argument_types: ["entity", "number", "unit"],
+        keywords: ["retry", "retries", "up to", "attempts", "times"],
+        examples: ["retry_policy(failed_webhook_delivery, 3, times)"],
+        tags: ["retry", "resilience"],
+    },
+    {
+        id: "FACT-SCHEMA-ESCALATION-RULE",
+        predicate_name: "escalation_rule",
+        title: "Escalation rule",
+        description: "A failed or unresolved subject escalates to an owner after a bounded delay.",
+        argument_names: ["subject", "target", "delay", "unit"],
+        argument_types: ["entity", "owner", "number", "unit"],
+        keywords: ["escalate", "escalates", "escalation", "after", "support"],
+        examples: ["escalation_rule(failed_payment_disputes, support, 48, hours)"],
+        tags: ["escalation", "operations"],
+    },
+    {
+        id: "FACT-SCHEMA-AVAILABILITY-SLA",
+        predicate_name: "availability_sla",
+        title: "Availability SLA",
+        description: "A service or API must meet a minimum availability target over a reporting window.",
+        argument_names: ["subject", "threshold", "unit", "window"],
+        argument_types: ["entity", "number", "unit", "duration"],
+        keywords: ["availability", "at least", "percent", "monthly", "sla"],
+        examples: ["availability_sla(checkout_api, 99.9, percent, monthly)"],
+        tags: ["sla", "availability"],
+    },
+    {
+        id: "FACT-SCHEMA-NOTIFICATION-ROUTE",
+        predicate_name: "notification_route",
+        title: "Notification route",
+        description: "A subject notifies a target recipient through a specific channel.",
+        argument_names: ["subject", "recipient", "channel"],
+        argument_types: ["entity", "recipient", "channel"],
+        keywords: ["notify", "notifies", "notification", "by email", "by sms"],
+        examples: ["notification_route(fraud_alerts, risk_operations, email)"],
+        tags: ["notification", "routing"],
+    },
+    {
+        id: "FACT-SCHEMA-IDEMPOTENCY-RULE",
+        predicate_name: "idempotency_rule",
+        title: "Idempotency rule",
+        description: "A request or operation must deduplicate repeated execution by a stable idempotency key.",
+        argument_names: ["subject", "key"],
+        argument_types: ["entity", "key"],
+        keywords: [
+            "idempotent",
+            "idempotency",
+            "idempotency key",
+            "dedupe",
+            "deduplicated",
+            "redundant",
+            "concurrent",
+        ],
+        examples: ["idempotency_rule(payment_capture_requests, idempotency_key)"],
+        tags: ["idempotency", "resilience"],
+    },
+    {
+        id: "FACT-SCHEMA-DATA-RESIDENCY-RULE",
+        predicate_name: "data_residency_rule",
+        title: "Data residency rule",
+        description: "A data set must be stored, processed, or kept within a named region or jurisdiction.",
+        argument_names: ["subject", "region"],
+        argument_types: ["entity", "region"],
+        keywords: ["data residency", "stored in", "region", "jurisdiction"],
+        examples: ["data_residency_rule(eu_customer_data, eu_region)"],
+        tags: ["privacy", "data-residency"],
+    },
+    {
+        id: "FACT-SCHEMA-AUDIT-EVENT-RULE",
+        predicate_name: "audit_event_rule",
+        title: "Audit event rule",
+        description: "An action, change, or security-relevant event must be recorded in an audit log or audit trail.",
+        argument_names: ["subject", "log"],
+        argument_types: ["entity", "log"],
+        keywords: ["audit log", "audit trail", "recorded", "logged", "audited"],
+        examples: ["audit_event_rule(admin_access_changes, audit_log)"],
+        tags: ["audit", "logging", "governance"],
+    },
+    {
+        id: "FACT-SCHEMA-CONSENT-RULE",
+        predicate_name: "consent_rule",
+        title: "Consent rule",
+        description: "An action or processing purpose requires a named consent before it proceeds.",
+        argument_names: ["subject", "consent", "purpose"],
+        argument_types: ["entity", "consent", "purpose"],
+        keywords: ["consent", "requires consent", "before processing"],
+        examples: ["consent_rule(marketing_emails, user_consent, processing)"],
+        tags: ["privacy", "consent"],
+    },
+    {
+        id: "FACT-SCHEMA-LIFECYCLE-RULE",
+        predicate_name: "lifecycle_rule",
+        title: "Lifecycle rule",
+        description: "An entity must be archived, deleted, expired, or lifecycle-transitioned after a duration.",
+        argument_names: ["subject", "action", "duration", "unit"],
+        argument_types: ["entity", "action", "number", "unit"],
+        keywords: ["archive", "archived", "delete", "deleted", "expire", "after"],
+        examples: ["lifecycle_rule(expired_sessions, archived, 30, days)"],
+        tags: ["lifecycle", "retention"],
+    },
+];

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

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

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

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

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

@@ -0,0 +1,197 @@
+// implements REQ-mcp-suggest-predicates
+export const PREDICATE_CATALOG_2 = [
+    {
+        id: "FACT-SCHEMA-CONFLICT-RESOLUTION-RULE",
+        predicate_name: "conflict_resolution_rule",
+        title: "Conflict resolution rule",
+        description: "Concurrent or synchronized updates resolve conflicts with a named strategy.",
+        argument_names: ["subject", "strategy"],
+        argument_types: ["entity", "strategy"],
+        keywords: ["conflict", "conflicts", "latest write wins", "merge"],
+        examples: ["conflict_resolution_rule(profile_updates, latest_write_wins)"],
+        tags: ["sync", "conflict-resolution"],
+    },
+    {
+        id: "FACT-SCHEMA-FALLBACK-RULE",
+        predicate_name: "fallback_rule",
+        title: "Fallback rule",
+        description: "A degraded or unavailable dependency causes a subject to fall back to an alternative behavior.",
+        argument_names: ["condition", "subject", "fallback"],
+        argument_types: ["condition", "entity", "behavior"],
+        keywords: ["fall back", "fallback", "unavailable", "degraded"],
+        examples: [
+            "fallback_rule(payment_provider_is_unavailable, checkout, manual_review)",
+        ],
+        tags: ["fallback", "resilience"],
+    },
+    {
+        id: "FACT-SCHEMA-BATCH-OPERATION-RULE",
+        predicate_name: "batch_operation_rule",
+        title: "Batch operation rule",
+        description: "A bulk operation processes a resource in batches of a bounded size.",
+        argument_names: ["subject", "resource", "batch_size"],
+        argument_types: ["entity", "resource", "number"],
+        keywords: ["batch", "batches", "bulk", "process"],
+        examples: ["batch_operation_rule(invoice_exports, records, 500)"],
+        tags: ["batching", "bulk"],
+    },
+    {
+        id: "FACT-SCHEMA-CONSISTENCY-RULE",
+        predicate_name: "consistency_rule",
+        title: "Consistency rule",
+        description: "An entity reference or value must remain consistent with another existing entity or invariant.",
+        argument_names: ["subject", "target"],
+        argument_types: ["entity", "entity"],
+        keywords: ["reference", "references", "existing", "consistent"],
+        examples: ["consistency_rule(order_items, existing_order)"],
+        tags: ["consistency", "referential-integrity"],
+    },
+    {
+        id: "FACT-SCHEMA-BUILD-CONSTRAINT",
+        predicate_name: "build_constraint",
+        title: "Build constraint",
+        description: "Build-time generation or deployment configuration must satisfy a deterministic property.",
+        argument_names: ["subject", "property", "scope"],
+        argument_types: ["entity", "property", "scope"],
+        keywords: ["build time", "deterministic", "generator", "deployment"],
+        examples: [
+            "build_constraint(share_manifest_generation, deterministic, build_time)",
+        ],
+        tags: ["build", "determinism"],
+    },
+    {
+        id: "FACT-SCHEMA-ENVIRONMENT-SAFETY-RULE",
+        predicate_name: "environment_safety_rule",
+        title: "Environment safety rule",
+        description: "A named action is allowed or forbidden in a deployment environment.",
+        argument_names: ["action", "decision", "environment"],
+        argument_types: ["action", "decision", "environment"],
+        keywords: ["production", "staging", "forbidden", "destructive"],
+        examples: [
+            "environment_safety_rule(destructive_operations, forbidden, production)",
+        ],
+        tags: ["environment", "safety"],
+    },
+    {
+        id: "FACT-SCHEMA-SCHEMA-INVARIANT-RULE",
+        predicate_name: "schema_invariant_rule",
+        title: "Schema invariant rule",
+        description: "A schema field has an invariant such as immutability, type, enum, or value range.",
+        argument_names: ["field", "invariant", "scope"],
+        argument_types: ["field", "invariant", "scope"],
+        keywords: ["immutable", "schema", "field", "enum", "range"],
+        examples: ["schema_invariant_rule(user_email, immutable, after_creation)"],
+        tags: ["schema", "invariant"],
+    },
+    {
+        id: "FACT-SCHEMA-CODING-STANDARD-RULE",
+        predicate_name: "coding_standard_rule",
+        title: "Coding standard rule",
+        description: "Developer-facing code must use or avoid a framework API, pattern, or documentation practice.",
+        argument_names: ["subject", "action", "target"],
+        argument_types: ["entity", "action", "api"],
+        keywords: ["computed", "signals", "must use", "must not use"],
+        examples: ["coding_standard_rule(derived_state, use, computed_signals)"],
+        tags: ["coding-standard", "agent-guidance"],
+    },
+    {
+        id: "FACT-SCHEMA-MIGRATION-BOUNDARY-RULE",
+        predicate_name: "migration_boundary_rule",
+        title: "Migration boundary rule",
+        description: "Legacy data or APIs may only be used for migration or compatibility input.",
+        argument_names: ["subject", "allowed_action", "scope"],
+        argument_types: ["entity", "action", "scope"],
+        keywords: ["legacy", "migration input", "only be read"],
+        examples: [
+            "migration_boundary_rule(legacy_fabricdata, read, migration_input)",
+        ],
+        tags: ["migration", "compatibility"],
+    },
+    {
+        id: "FACT-SCHEMA-ABSENCE-REQUIREMENT",
+        predicate_name: "absence_requirement",
+        title: "Absence requirement",
+        description: "A component, extension, RPC, schema, or feature must be absent, removed, or not exist.",
+        argument_names: ["subject", "state"],
+        argument_types: ["entity", "state"],
+        keywords: ["absent", "removed", "must not exist", "not exist", "no"],
+        examples: ["absence_requirement(pg_graphql_extension, absent)"],
+        tags: ["absence", "security"],
+    },
+    {
+        id: "FACT-SCHEMA-OFFLINE-BEHAVIOR-RULE",
+        predicate_name: "offline_behavior_rule",
+        title: "Offline behavior rule",
+        description: "Synchronization or gameplay behavior remains non-blocking or resilient during offline conditions.",
+        argument_names: ["subject", "behavior", "condition"],
+        argument_types: ["entity", "behavior", "condition"],
+        keywords: ["offline", "non-blocking", "resilient", "synchronization"],
+        examples: [
+            "offline_behavior_rule(cloud_synchronization, non-blocking, offline_conditions)",
+        ],
+        tags: ["offline", "sync"],
+    },
+    {
+        id: "FACT-SCHEMA-RELEASE-GATE-RULE",
+        predicate_name: "release_gate_rule",
+        title: "Release gate rule",
+        description: "A build or release must pass named gates before distribution, review, or deployment.",
+        argument_names: ["subject", "gate", "target"],
+        argument_types: ["entity", "gate", "release_target"],
+        keywords: ["release", "gates", "before", "testflight", "distribution"],
+        examples: [
+            "release_gate_rule(ios_builds, configuration_gates, testflight_distribution)",
+        ],
+        tags: ["release", "gate"],
+    },
+    {
+        id: "FACT-SCHEMA-PLATFORM-CONSISTENCY-RULE",
+        predicate_name: "platform_consistency_rule",
+        title: "Platform consistency rule",
+        description: "A state or entitlement synchronizes across named platforms.",
+        argument_names: ["subject", "platforms"],
+        argument_types: ["entity", "platform_list"],
+        keywords: ["synchronize", "across", "platforms", "ios", "android", "web"],
+        examples: ["platform_consistency_rule(premium_status, ios,android,web)"],
+        tags: ["platform", "consistency"],
+    },
+    {
+        id: "FACT-SCHEMA-PRESERVATION-RULE",
+        predicate_name: "preservation_rule",
+        title: "Preservation rule",
+        description: "Child data or feedback is preserved across deletion or removal of a parent resource.",
+        argument_names: ["subject", "preserved", "condition"],
+        argument_types: ["action", "entity", "condition"],
+        keywords: ["preserve", "preserved", "deletion", "removed"],
+        examples: [
+            "preservation_rule(soft_deletion, annotations, video_is_removed)",
+        ],
+        tags: ["preservation", "deletion"],
+    },
+    {
+        id: "FACT-SCHEMA-ABSTRACTION-BOUNDARY-RULE",
+        predicate_name: "abstraction_boundary_rule",
+        title: "Abstraction boundary rule",
+        description: "Persisted data, APIs, or contracts must stay neutral to a renderer, vendor, runtime, or implementation detail.",
+        argument_names: ["subject", "relation", "contract"],
+        argument_types: ["entity", "relation", "contract"],
+        keywords: ["renderer-neutral", "contract", "runtime snapshots", "vendor"],
+        examples: [
+            "abstraction_boundary_rule(annotation_drawing_data, persisted_as, renderer-neutral_scene_contract)",
+        ],
+        tags: ["architecture", "abstraction"],
+    },
+    {
+        id: "FACT-SCHEMA-SECURITY-CONFIGURATION-RULE",
+        predicate_name: "security_configuration_rule",
+        title: "Security configuration rule",
+        description: "A security-sensitive component must have an explicit configuration value.",
+        argument_names: ["subject", "setting", "value"],
+        argument_types: ["entity", "setting", "value"],
+        keywords: ["explicit", "search_path", "security", "configuration"],
+        examples: [
+            "security_configuration_rule(trigger_functions, search_path, public)",
+        ],
+        tags: ["security", "configuration"],
+    },
+];

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

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

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

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

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"}