kibi-cli 0.12.8 → 0.16.1

package/dist/operations/modeling/model-requirement.js

@@ -0,0 +1,108 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { buildStrictWriteSet } from "../../public/check-types.js";
+import { getSchemaVersionStatus } from "../../public/schema-version.js";
+import { semanticClaimKey } from "../semantic-advisor/clauses.js";
+import { strictWriteSetToApplyPlan, writeSetPrimaryEntityId, } from "./requirement-applyplan.js";
+import { estimateNormativeSignalConfidence, extractRequirementClaim, } from "./requirement-modeler.js";
+import { normalizeOptionalString, normalizeSourceFiles, } from "./requirement-utils.js";
+export { estimateNormativeSignalConfidence, extractRequirementClaim, strictWriteSetToApplyPlan, writeSetPrimaryEntityId, };
+export async function getWorkspaceMigrationWarning(workspaceRoot) {
+    const configPath = path.join(workspaceRoot, ".kb", "config.json");
+    let rawConfig;
+    try {
+        rawConfig = await readFile(configPath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(rawConfig);
+        return getSchemaVersionStatus(parsed ?? undefined).warning;
+    }
+    catch {
+        return "KB config schemaVersion could not be read and should be checked before applying automated modeling.";
+    }
+}
+export async function handleKbModelRequirement(_prolog, args, workspaceRoot) {
+    const extracted = extractRequirementClaim({
+        ...args,
+        source: normalizeOptionalString(args.source) ??
+            normalizeSourceFiles(args.sourceFiles)[0] ??
+            "mcp://kibi/model-requirement",
+    });
+    const writeSet = buildStrictWriteSet({
+        claim: extracted.claim,
+        statement: extracted.statement,
+    });
+    const claimKey = semanticClaimKey(extracted.statement);
+    const logicClaims = Array.from(new Set([...(args.existingLogicClaims ?? []), claimKey]));
+    const applyPlan = strictWriteSetToApplyPlan(writeSet).map((step) => {
+        const properties = step.properties !== null && typeof step.properties === "object"
+            ? step.properties
+            : {};
+        if (step.type === "fact") {
+            return {
+                ...step,
+                properties: {
+                    ...properties,
+                    claim_key: claimKey,
+                    claim_text: extracted.statement,
+                },
+            };
+        }
+        if (step.type === "req") {
+            return {
+                ...step,
+                properties: { ...properties, logic_claims: logicClaims },
+            };
+        }
+        return step;
+    });
+    const migrationWarning = await getWorkspaceMigrationWarning(workspaceRoot);
+    const warnings = writeSet.isStrict
+        ? []
+        : [
+            {
+                kind: "low_confidence_observation_downgrade",
+                message: `Claim confidence ${writeSet.confidence.toFixed(2)} is below the strict threshold 0.70, so Kibi emitted an observation fact instead of strict subject/property facts.`,
+                nextAction: "If this is normative, provide subjectKey, propertyKey, operator, and value explicitly, then apply the returned strict write-set sequentially.",
+            },
+        ];
+    const strictSummary = writeSet.isStrict
+        ? `Modeled strict requirement into ${applyPlan.length} sequential applyPlan step(s).`
+        : "Modeled a non-blocking observation review artifact; deterministic claim extraction stayed below the strict threshold.";
+    const structuredContent = {
+        statement: extracted.statement,
+        claimKey,
+        logicClaims,
+        source: extracted.source,
+        sourceFiles: extracted.sourceFiles,
+        claim: extracted.claim,
+        writeSet,
+        applyPlan,
+        isStrict: writeSet.isStrict,
+        confidence: writeSet.confidence,
+        extractionMode: extracted.extractionMode,
+        extractionWarnings: extracted.extractionWarnings,
+        warnings,
+        migrationWarning,
+    };
+    return {
+        content: [
+            {
+                type: "text",
+                text: migrationWarning
+                    ? `${strictSummary} Migration warning included.`
+                    : strictSummary,
+            },
+        ],
+        structuredContent,
+        applyPlan,
+        writeSet,
+        migrationWarning,
+    };
+}
+export async function executeModelRequirement(args, context) {
+    return handleKbModelRequirement(context.prolog, args, context.workspaceRoot);
+}

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

@@ -0,0 +1,6 @@
+import type { PredicateSchemaCandidate, PredicateSuggestion, SuggestPredicatesArgs } from "./predicate-types.js";
+export declare function buildSuggestion(schema: PredicateSchemaCandidate, text: string, subject: string, score: number): PredicateSuggestion;
+export declare function buildPredicateApplyPlan(suggestion: PredicateSuggestion, args: SuggestPredicatesArgs): Array<Record<string, unknown>>;
+export declare function buildRelationshipPlan(factId: string | undefined, requirementId: string | undefined, claimText?: string, existingLogicClaims?: readonly string[]): Record<string, unknown> | null;
+export declare function buildGapApplyPlan(text: string, args: SuggestPredicatesArgs): Array<Record<string, unknown>>;
+//# sourceMappingURL=predicate-applyplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-applyplan.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-applyplan.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,sBAAsB,CAAC;AAI9B,wBAAgB,eAAe,CAC7B,MAAM,EAAE,wBAAwB,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,mBAAmB,CAarB;AAGD,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,mBAAmB,EAC/B,IAAI,EAAE,qBAAqB,GAC1B,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAgChC;AAGD,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,SAAS,CAAC,EAAE,MAAM,EAClB,mBAAmB,GAAE,SAAS,MAAM,EAAO,GAC1C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAwBhC;AAGD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,qBAAqB,GAC1B,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAyBhC"}

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

@@ -0,0 +1,104 @@
+import { semanticClaimKey } from "../semantic-advisor/clauses.js";
+import { inferArgs } from "./predicate-inference.js";
+import { schemaForCandidate } from "./predicate-loader.js";
+import { hashId } from "./predicate-utils.js";
+// implements REQ-mcp-suggest-predicates
+export function buildSuggestion(schema, text, subject, score) {
+    const predicateArgs = inferArgs(schema, text, subject);
+    const canonicalKey = `${schema.predicate_name}(${predicateArgs.join(",")})`;
+    return {
+        id: hashId("SUGGEST", [schema.id, canonicalKey, text]),
+        predicate_name: schema.predicate_name,
+        predicate_args: predicateArgs,
+        canonical_key: canonicalKey,
+        polarity: "assert",
+        score,
+        rationale: `Matched ${schema.predicate_name} because the prose overlaps with ${schema.tags.join(", ")} cues.`,
+        schema: schemaForCandidate(schema),
+    };
+}
+// implements REQ-mcp-suggest-predicates
+export function buildPredicateApplyPlan(suggestion, args) {
+    const claimKey = semanticClaimKey(args.text);
+    const factId = hashId("FACT-PRED", [
+        args.requirementId ?? "",
+        args.source ?? "",
+        suggestion.canonical_key,
+    ]);
+    return [
+        {
+            type: "fact",
+            id: factId,
+            properties: {
+                title: `Predicate: ${suggestion.canonical_key}`,
+                status: "active",
+                source: args.source ?? "mcp://kibi/suggest-predicates",
+                text_ref: args.source,
+                tags: [
+                    "lane:ontology",
+                    "predicate-suggestion",
+                    ...suggestion.schema.tags.map((tag) => `predicate:${tag}`),
+                ],
+                fact_kind: "predicate",
+                predicate_name: suggestion.predicate_name,
+                predicate_args: suggestion.predicate_args,
+                canonical_key: suggestion.canonical_key,
+                polarity: suggestion.polarity,
+                claim_key: claimKey,
+                claim_text: args.text.trim(),
+            },
+            relationships: [],
+        },
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function buildRelationshipPlan(factId, requirementId, claimText, existingLogicClaims = []) {
+    if (!factId || !requirementId)
+        return null;
+    const claimKey = claimText ? semanticClaimKey(claimText) : null;
+    const logicClaims = Array.from(new Set([...existingLogicClaims, ...(claimKey === null ? [] : [claimKey])]));
+    return {
+        applyAfter: factId,
+        requiresExistingReq: requirementId,
+        relationship: {
+            type: "requires_predicate",
+            from: requirementId,
+            to: factId,
+        },
+        ...(claimText
+            ? {
+                claimKey,
+                claimText: claimText.trim(),
+                logicClaims,
+            }
+            : {}),
+        instructions: "Apply the predicate fact first, update the requirement with the returned merged logicClaims manifest, then attach this relationship without overwriting other requirement metadata.",
+    };
+}
+// implements REQ-mcp-suggest-predicates
+export function buildGapApplyPlan(text, args) {
+    const claimKey = semanticClaimKey(text);
+    const factId = hashId("FACT-ONTOLOGY-GAP", [
+        args.requirementId ?? "",
+        args.source ?? "",
+        text,
+    ]);
+    return [
+        {
+            type: "fact",
+            id: factId,
+            properties: {
+                title: "Ontology gap: predicate schema needed",
+                status: "active",
+                source: args.source ?? "mcp://kibi/suggest-predicates",
+                text_ref: args.source,
+                tags: ["review:ontology-gap", "needs_schema_extension"],
+                fact_kind: "observation",
+                value_string: text,
+                claim_key: claimKey,
+                claim_text: text,
+            },
+            relationships: [],
+        },
+    ];
+}

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

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

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

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

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