@plures/praxis 1.2.41 → 1.4.0

package/dist/node/index.js

@@ -1,3 +1,7 @@
+import {
+  auditCompleteness,
+  formatReport
+} from "./chunk-2IUFZBH3.js";
 import {
   AcknowledgeContractGap,
   BehaviorLedger,
@@ -21,12 +25,13 @@ import {
   formatValidationReportJSON,
   formatValidationReportSARIF,
   validateContracts
-} from "./chunk-PTH6MD6P.js";
+} from "./chunk-FWOXU4MM.js";
+import "./chunk-7CSWBDFL.js";
 import {
   defineContract,
   getContract,
   isContract
-} from "./chunk-WZ6B3LZ6.js";
+} from "./chunk-PGVSB6NR.js";
 import {
   InMemoryPraxisDB,
   PluresDBPraxisAdapter,
@@ -50,10 +55,14 @@ import {
 import {
   ReactiveLogicEngine,
   createReactiveEngine
-} from "./chunk-32YFEEML.js";
+} from "./chunk-7M3HV4XR.js";
 import {
-  PraxisRegistry
-} from "./chunk-R2PSBPKQ.js";
+  LogicEngine,
+  PRAXIS_PROTOCOL_VERSION,
+  RuleResult,
+  createPraxisEngine,
+  fact
+} from "./chunk-KMJWAFZV.js";
 import {
   TerminalAdapter,
   createMockExecutor,
@@ -76,10 +85,8 @@ import {
   validateSchema
 } from "./chunk-UATVJBNV.js";
 import {
-  LogicEngine,
-  PRAXIS_PROTOCOL_VERSION,
-  createPraxisEngine
-} from "./chunk-BBP2F7TT.js";
+  PraxisRegistry
+} from "./chunk-TEMFJOIH.js";
 import "./chunk-QGM4M3NI.js";
 
 // src/core/reactive-engine.ts
@@ -739,37 +746,37 @@ var PraxisDBStore = class {
    * @param fact The fact to store
    * @returns Promise that resolves when the fact is stored
    */
-  async storeFact(fact) {
-    const constraintResult = await this.checkConstraints([fact]);
+  async storeFact(fact2) {
+    const constraintResult = await this.checkConstraints([fact2]);
     if (!constraintResult.valid) {
       throw new Error(`Constraint violation: ${constraintResult.errors.join(", ")}`);
     }
     let before;
     if (this.chronicle) {
-      const payload = fact.payload;
+      const payload = fact2.payload;
       const id = payload?.id;
       if (id) {
-        before = await this.getFact(fact.tag, id);
+        before = await this.getFact(fact2.tag, id);
       }
     }
-    await this.persistFact(fact);
+    await this.persistFact(fact2);
     if (this.chronicle) {
-      const payload = fact.payload;
+      const payload = fact2.payload;
       const id = payload?.id ?? "";
       const span = ChronicleContext.current;
       try {
         await this.chronicle.record({
-          path: getFactPath(fact.tag, id),
+          path: getFactPath(fact2.tag, id),
           before,
-          after: fact,
+          after: fact2,
           cause: span?.spanId,
           context: span?.contextId,
-          metadata: { factTag: fact.tag, operation: "storeFact" }
+          metadata: { factTag: fact2.tag, operation: "storeFact" }
         });
       } catch {
       }
     }
-    await this.triggerRules([fact]);
+    await this.triggerRules([fact2]);
   }
   /**
    * Store multiple facts in PluresDB
@@ -781,28 +788,28 @@ var PraxisDBStore = class {
     if (!constraintResult.valid) {
       throw new Error(`Constraint violation: ${constraintResult.errors.join(", ")}`);
     }
-    for (const fact of facts) {
+    for (const fact2 of facts) {
       let before;
       if (this.chronicle) {
-        const payload = fact.payload;
+        const payload = fact2.payload;
         const id = payload?.id;
         if (id) {
-          before = await this.getFact(fact.tag, id);
+          before = await this.getFact(fact2.tag, id);
         }
       }
-      await this.persistFact(fact);
+      await this.persistFact(fact2);
       if (this.chronicle) {
-        const payload = fact.payload;
+        const payload = fact2.payload;
         const id = payload?.id ?? "";
         const span = ChronicleContext.current;
         try {
           await this.chronicle.record({
-            path: getFactPath(fact.tag, id),
+            path: getFactPath(fact2.tag, id),
             before,
-            after: fact,
+            after: fact2,
             cause: span?.spanId,
             context: span?.contextId,
-            metadata: { factTag: fact.tag, operation: "storeFacts" }
+            metadata: { factTag: fact2.tag, operation: "storeFacts" }
           });
         } catch {
         }
@@ -814,11 +821,11 @@ var PraxisDBStore = class {
    * Internal method to persist a fact without constraint checking
    * Used by both storeFact and derived fact storage
    */
-  async persistFact(fact) {
-    const payload = fact.payload;
+  async persistFact(fact2) {
+    const payload = fact2.payload;
     const id = payload?.id ?? generateId();
-    const path = getFactPath(fact.tag, id);
-    await this.db.set(path, fact);
+    const path = getFactPath(fact2.tag, id);
+    await this.db.set(path, fact2);
   }
   /**
    * Get a fact by tag and id
@@ -955,8 +962,8 @@ var PraxisDBStore = class {
     if (watchers) {
       watchers.add(callback);
     }
-    const unsubscribe = this.db.watch(path, (fact) => {
-      callback([fact]);
+    const unsubscribe = this.db.watch(path, (fact2) => {
+      callback([fact2]);
     });
     this.subscriptions.push(unsubscribe);
     return () => {
@@ -1014,13 +1021,18 @@ var PraxisDBStore = class {
     const state = {
       context: this.context,
       facts: [],
+      events,
       meta: {}
     };
     const derivedFacts = [];
     for (const rule of rules) {
       try {
-        const facts = rule.impl(state, events);
-        derivedFacts.push(...facts);
+        const result = rule.impl(state, events);
+        if (Array.isArray(result)) {
+          derivedFacts.push(...result);
+        } else if (result && "kind" in result && result.kind === "emit") {
+          derivedFacts.push(...result.facts);
+        }
       } catch (error) {
         this.onRuleError(rule.id, error);
       }
@@ -1028,19 +1040,19 @@ var PraxisDBStore = class {
     if (derivedFacts.length > 0) {
       const constraintResult = await this.checkConstraints(derivedFacts);
       if (constraintResult.valid) {
-        for (const fact of derivedFacts) {
-          await this.persistFact(fact);
+        for (const fact2 of derivedFacts) {
+          await this.persistFact(fact2);
           if (this.chronicle) {
-            const payload = fact.payload;
+            const payload = fact2.payload;
             const id = payload?.id ?? "";
             const span = ChronicleContext.current;
             try {
               await this.chronicle.record({
-                path: getFactPath(fact.tag, id),
-                after: fact,
+                path: getFactPath(fact2.tag, id),
+                after: fact2,
                 cause: span?.spanId,
                 context: span?.contextId,
-                metadata: { factTag: fact.tag, operation: "derivedFact" }
+                metadata: { factTag: fact2.tag, operation: "derivedFact" }
               });
             } catch {
             }
@@ -1479,7 +1491,7 @@ async function createUnumAdapter(config) {
       type: "event"
     });
   }
-  async function broadcastFact(channelId, fact) {
+  async function broadcastFact(channelId, fact2) {
     const channel = channels.get(channelId);
     if (!channel) {
       throw new Error(`Not joined to channel ${channelId}`);
@@ -1487,7 +1499,7 @@ async function createUnumAdapter(config) {
     await channel.publish({
       id: generateId2(),
       sender: currentIdentity || { id: "anonymous", createdAt: Date.now() },
-      content: fact,
+      content: fact2,
       type: "fact"
     });
   }
@@ -1768,7 +1780,7 @@ function generateTauriConfig(config) {
 
 // src/integrations/unified.ts
 async function createUnifiedApp(config) {
-  const { createPraxisEngine: createPraxisEngine2 } = await import("./engine-7CXQV6RC.js");
+  const { createPraxisEngine: createPraxisEngine2 } = await import("./engine-FEN5IYZ5.js");
   const { createInMemoryDB: createInMemoryDB2 } = await import("./adapter-75ISSMWD.js");
   const db = config.db || createInMemoryDB2();
   const pluresdb = createPluresDBAdapter({
@@ -1897,6 +1909,1290 @@ async function attachAllIntegrations(engine, registry, options = {}) {
     }
   };
 }
+
+// src/core/ui-rules.ts
+var loadingGateRule = {
+  id: "ui/loading-gate",
+  description: "Signals when the app is in a loading state",
+  eventTypes: ["ui.state-change", "app.init"],
+  impl: (state) => {
+    const ctx = state.context;
+    if (ctx.loading) {
+      return RuleResult.emit([fact("ui.loading-gate", { active: true })]);
+    }
+    return RuleResult.retract(["ui.loading-gate"], "Not loading");
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Emits ui.loading-gate when context.loading is true, retracts when false",
+    examples: [
+      { given: "loading is true", when: "ui state changes", then: "ui.loading-gate emitted" },
+      { given: "loading is false", when: "ui state changes", then: "ui.loading-gate retracted" }
+    ],
+    invariants: ["Loading gate must reflect context.loading exactly"]
+  }
+};
+var errorDisplayRule = {
+  id: "ui/error-display",
+  description: "Signals when an error should be displayed to the user",
+  eventTypes: ["ui.state-change", "app.error"],
+  impl: (state) => {
+    const ctx = state.context;
+    if (ctx.error) {
+      return RuleResult.emit([fact("ui.error-display", { message: ctx.error, severity: "error" })]);
+    }
+    return RuleResult.retract(["ui.error-display"], "Error cleared");
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Emits ui.error-display when context.error is non-null, retracts when cleared",
+    examples: [
+      { given: "error is set", when: "ui state changes", then: "ui.error-display emitted with message" },
+      { given: "error is null", when: "ui state changes", then: "ui.error-display retracted" }
+    ],
+    invariants: ["Error display must clear when error is null"]
+  }
+};
+var offlineIndicatorRule = {
+  id: "ui/offline-indicator",
+  description: "Signals when the app is offline",
+  eventTypes: ["ui.state-change", "network.change"],
+  impl: (state) => {
+    if (state.context.offline) {
+      return RuleResult.emit([fact("ui.offline", { message: "You are offline. Changes will sync when reconnected." })]);
+    }
+    return RuleResult.retract(["ui.offline"], "Back online");
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Emits ui.offline when context.offline is true, retracts when back online",
+    examples: [
+      { given: "offline is true", when: "network changes", then: "ui.offline emitted" },
+      { given: "offline is false", when: "network changes", then: "ui.offline retracted" }
+    ],
+    invariants: ["Offline indicator must match actual connectivity"]
+  }
+};
+var dirtyGuardRule = {
+  id: "ui/dirty-guard",
+  description: "Warns when there are unsaved changes",
+  eventTypes: ["ui.state-change", "navigation.request"],
+  impl: (state) => {
+    if (state.context.dirty) {
+      return RuleResult.emit([fact("ui.unsaved-warning", {
+        message: "You have unsaved changes",
+        blocking: true
+      })]);
+    }
+    return RuleResult.retract(["ui.unsaved-warning"], "No unsaved changes");
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Emits ui.unsaved-warning when context.dirty is true, retracts when saved",
+    examples: [
+      { given: "dirty is true", when: "ui state changes", then: "ui.unsaved-warning emitted with blocking=true" },
+      { given: "dirty is false", when: "ui state changes", then: "ui.unsaved-warning retracted" }
+    ],
+    invariants: ["Dirty guard must clear after save"]
+  }
+};
+var initGateRule = {
+  id: "ui/init-gate",
+  description: "Signals whether the app has completed initialization",
+  eventTypes: ["ui.state-change", "app.init"],
+  impl: (state) => {
+    if (!state.context.initialized) {
+      return RuleResult.emit([fact("ui.init-pending", {
+        message: "App is initializing..."
+      })]);
+    }
+    return RuleResult.retract(["ui.init-pending"], "App initialized");
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Emits ui.init-pending until context.initialized is true",
+    examples: [
+      { given: "initialized is false", when: "app starts", then: "ui.init-pending emitted" },
+      { given: "initialized is true", when: "init completes", then: "ui.init-pending retracted" }
+    ],
+    invariants: ["Init gate must clear exactly once, when initialization completes"]
+  }
+};
+var viewportRule = {
+  id: "ui/viewport-class",
+  description: "Classifies viewport size for responsive layout decisions",
+  eventTypes: ["ui.state-change", "ui.resize"],
+  impl: (state) => {
+    const vp = state.context.viewport;
+    if (!vp) return RuleResult.skip("No viewport data");
+    return RuleResult.emit([fact("ui.viewport-class", {
+      viewport: vp,
+      compact: vp === "mobile",
+      showSidebar: vp !== "mobile"
+    })]);
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Classifies viewport into responsive layout hints",
+    examples: [
+      { given: "viewport is mobile", when: "resize event", then: "compact=true, showSidebar=false" },
+      { given: "viewport is desktop", when: "resize event", then: "compact=false, showSidebar=true" }
+    ],
+    invariants: ["Viewport class must update on every resize event"]
+  }
+};
+var noInteractionWhileLoadingConstraint = {
+  id: "ui/no-interaction-while-loading",
+  description: "Prevents data mutations while a load operation is in progress",
+  impl: (state) => {
+    if (state.context.loading) {
+      return "Cannot perform action while data is loading";
+    }
+    return true;
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Fails when context.loading is true",
+    examples: [
+      { given: "loading is true", when: "action attempted", then: "violation" },
+      { given: "loading is false", when: "action attempted", then: "pass" }
+    ],
+    invariants: ["Must always fail during loading"]
+  }
+};
+var mustBeInitializedConstraint = {
+  id: "ui/must-be-initialized",
+  description: "Requires app initialization before user interactions",
+  impl: (state) => {
+    if (!state.context.initialized) {
+      return "App must be initialized before performing this action";
+    }
+    return true;
+  },
+  contract: {
+    ruleId: "RULE_ID_PLACEHOLDER",
+    behavior: "Fails when context.initialized is false",
+    examples: [
+      { given: "initialized is false", when: "action attempted", then: "violation" },
+      { given: "initialized is true", when: "action attempted", then: "pass" }
+    ],
+    invariants: ["Must always fail before init completes"]
+  }
+};
+var uiModule = {
+  rules: [
+    loadingGateRule,
+    errorDisplayRule,
+    offlineIndicatorRule,
+    dirtyGuardRule,
+    initGateRule,
+    viewportRule
+  ],
+  constraints: [
+    noInteractionWhileLoadingConstraint,
+    mustBeInitializedConstraint
+  ],
+  meta: {
+    name: "praxis-ui",
+    version: "1.0.0",
+    description: "Predefined UI rules and constraints \u2014 separate from business logic"
+  }
+};
+function createUIModule(options) {
+  const allRules = uiModule.rules;
+  const allConstraints = uiModule.constraints;
+  const selectedRules = options.rules ? allRules.filter((r) => options.rules.includes(r.id)) : allRules;
+  const selectedConstraints = options.constraints ? allConstraints.filter((c) => options.constraints.includes(c.id)) : allConstraints;
+  return {
+    rules: [...selectedRules, ...options.extraRules ?? []],
+    constraints: [...selectedConstraints, ...options.extraConstraints ?? []],
+    meta: { ...uiModule.meta, customized: true }
+  };
+}
+function uiStateChanged(changes) {
+  return { tag: "ui.state-change", payload: changes ?? {} };
+}
+function navigationRequest(to) {
+  return { tag: "navigation.request", payload: { to } };
+}
+function resizeEvent(width, height) {
+  return { tag: "ui.resize", payload: { width, height } };
+}
+
+// src/expectations/expectations.ts
+var Expectation = class {
+  name;
+  _conditions = [];
+  constructor(name) {
+    this.name = name;
+  }
+  /**
+   * Declare that this behavior should ONLY occur when a condition is true.
+   * If the condition is false, the behavior should NOT occur.
+   */
+  onlyWhen(condition) {
+    this._conditions.push({ description: condition, type: "onlyWhen" });
+    return this;
+  }
+  /**
+   * Declare that this behavior should NEVER occur under a given condition.
+   */
+  never(condition) {
+    this._conditions.push({ description: condition, type: "never" });
+    return this;
+  }
+  /**
+   * Declare that this behavior should ALWAYS have a certain property.
+   */
+  always(condition) {
+    this._conditions.push({ description: condition, type: "always" });
+    return this;
+  }
+  /** Get all declared conditions. */
+  get conditions() {
+    return this._conditions;
+  }
+};
+var ExpectationSet = class {
+  name;
+  description;
+  _expectations = [];
+  constructor(options) {
+    this.name = options.name;
+    this.description = options.description ?? "";
+  }
+  /** Add an expectation to the set. */
+  add(expectation) {
+    this._expectations.push(expectation);
+    return this;
+  }
+  /** Get all expectations in this set. */
+  get expectations() {
+    return this._expectations;
+  }
+  /** Number of expectations. */
+  get size() {
+    return this._expectations.length;
+  }
+};
+function expectBehavior(name) {
+  return new Expectation(name);
+}
+function verify(registry, expectations) {
+  const rules = registry.getAllRules();
+  const constraints = registry.getAllConstraints();
+  const ruleIds = registry.getRuleIds();
+  const constraintIds = registry.getConstraintIds();
+  const allDescriptors = [...rules, ...constraints];
+  const expectationResults = [];
+  for (const exp of expectations.expectations) {
+    const result = verifyExpectation(exp, allDescriptors, ruleIds, constraintIds);
+    expectationResults.push(result);
+  }
+  const satisfied = expectationResults.filter((r) => r.status === "satisfied").length;
+  const violated = expectationResults.filter((r) => r.status === "violated").length;
+  const partial = expectationResults.filter((r) => r.status === "partial").length;
+  const allEdgeCases = expectationResults.flatMap((r) => r.edgeCases);
+  const allMitigations = expectationResults.flatMap((r) => r.mitigations);
+  return {
+    setName: expectations.name,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    status: violated > 0 ? "violated" : partial > 0 ? "partial" : "satisfied",
+    expectations: expectationResults,
+    summary: {
+      total: expectationResults.length,
+      satisfied,
+      violated,
+      partial
+    },
+    allEdgeCases,
+    allMitigations
+  };
+}
+function verifyExpectation(expectation, descriptors, ruleIds, _constraintIds) {
+  const conditionResults = [];
+  const edgeCases = [];
+  const mitigations = [];
+  const related = findRelatedDescriptors(expectation.name, descriptors);
+  for (const condition of expectation.conditions) {
+    const result = verifyCondition(condition, expectation.name, related, ruleIds);
+    conditionResults.push(result);
+    if (result.status === "unverifiable") {
+      edgeCases.push(`Cannot verify "${condition.description}" for "${expectation.name}" \u2014 no covering rule/contract found`);
+      mitigations.push(`Add a rule or constraint that explicitly covers: ${condition.description}`);
+    } else if (result.status === "violated") {
+      edgeCases.push(`"${expectation.name}" may fire incorrectly: ${condition.description}`);
+      mitigations.push(`Review rule logic for "${expectation.name}" regarding: ${condition.description}`);
+    }
+  }
+  const satisfiedCount = conditionResults.filter((r) => r.status === "satisfied").length;
+  const violatedCount = conditionResults.filter((r) => r.status === "violated").length;
+  const total = conditionResults.length;
+  let status;
+  if (total === 0) {
+    status = "satisfied";
+  } else if (violatedCount > 0) {
+    status = "violated";
+  } else if (satisfiedCount === total) {
+    status = "satisfied";
+  } else {
+    status = "partial";
+  }
+  return {
+    name: expectation.name,
+    status,
+    conditions: conditionResults,
+    edgeCases,
+    mitigations
+  };
+}
+function textOverlaps(a, b) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "shall",
+    "can",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "when",
+    "that",
+    "this",
+    "it",
+    "its",
+    "and",
+    "or",
+    "but",
+    "not",
+    "no",
+    "if",
+    "then",
+    "than",
+    "so",
+    "up",
+    "out",
+    "about",
+    "just",
+    "must"
+  ]);
+  const wordsA = a.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+  const wordsB = b.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+  if (wordsA.length === 0 || wordsB.length === 0) return false;
+  const matches = wordsA.filter(
+    (wa) => wordsB.some((wb) => wa.startsWith(wb.slice(0, 4)) || wb.startsWith(wa.slice(0, 4)))
+  );
+  const minWords = Math.min(wordsA.length, wordsB.length);
+  return matches.length >= Math.max(1, Math.ceil(minWords * 0.5));
+}
+function verifyCondition(condition, expectationName, relatedDescriptors, _ruleIds) {
+  if (relatedDescriptors.length === 0) {
+    return {
+      condition,
+      status: "unverifiable",
+      explanation: `No rules or constraints found related to "${expectationName}"`,
+      relatedRules: []
+    };
+  }
+  const relatedIds = relatedDescriptors.map((d) => d.id);
+  const condLower = condition.description.toLowerCase();
+  const matches = (target) => target.toLowerCase().includes(condLower) || condLower.includes(target.toLowerCase()) || textOverlaps(condLower, target);
+  switch (condition.type) {
+    case "onlyWhen": {
+      const coveringRule = relatedDescriptors.find(
+        (d) => d.contract?.examples.some(
+          (ex) => matches(ex.given) || matches(ex.when)
+        ) || d.contract?.invariants.some((inv) => matches(inv))
+      );
+      if (coveringRule) {
+        return {
+          condition,
+          status: "satisfied",
+          explanation: `Rule "${coveringRule.id}" contract covers precondition: ${condition.description}`,
+          relatedRules: relatedIds
+        };
+      }
+      const descMatch = relatedDescriptors.find((d) => matches(d.description));
+      if (descMatch) {
+        return {
+          condition,
+          status: "satisfied",
+          explanation: `Rule "${descMatch.id}" description addresses: ${condition.description}`,
+          relatedRules: relatedIds
+        };
+      }
+      return {
+        condition,
+        status: "unverifiable",
+        explanation: `No rule contract explicitly covers the precondition: ${condition.description}`,
+        relatedRules: relatedIds
+      };
+    }
+    case "never": {
+      const preventingDescriptor = relatedDescriptors.find(
+        (d) => d.contract?.invariants.some((inv) => matches(inv)) || d.contract?.examples.some(
+          (ex) => (matches(ex.given) || matches(ex.when)) && (ex.then.toLowerCase().includes("retract") || ex.then.toLowerCase().includes("fail") || ex.then.toLowerCase().includes("violation") || ex.then.toLowerCase().includes("skip") || ex.then.toLowerCase().includes("block") || ex.then.toLowerCase().includes("no "))
+        ) || d.contract?.behavior.toLowerCase().includes("block") || d.contract?.behavior.toLowerCase().includes("prevent")
+      );
+      if (preventingDescriptor) {
+        return {
+          condition,
+          status: "satisfied",
+          explanation: `Constraint/rule "${preventingDescriptor.id}" prevents: ${condition.description}`,
+          relatedRules: relatedIds
+        };
+      }
+      return {
+        condition,
+        status: "unverifiable",
+        explanation: `No rule or constraint explicitly prevents: ${condition.description}`,
+        relatedRules: relatedIds
+      };
+    }
+    case "always": {
+      const guaranteeing = relatedDescriptors.find(
+        (d) => d.contract?.invariants.some((inv) => matches(inv)) || d.contract?.behavior && matches(d.contract.behavior)
+      );
+      if (guaranteeing) {
+        return {
+          condition,
+          status: "satisfied",
+          explanation: `Rule "${guaranteeing.id}" guarantees: ${condition.description}`,
+          relatedRules: relatedIds
+        };
+      }
+      const exampleMatch = relatedDescriptors.find(
+        (d) => d.contract?.examples.some((ex) => matches(ex.then))
+      );
+      if (exampleMatch) {
+        return {
+          condition,
+          status: "satisfied",
+          explanation: `Rule "${exampleMatch.id}" example demonstrates: ${condition.description}`,
+          relatedRules: relatedIds
+        };
+      }
+      return {
+        condition,
+        status: "unverifiable",
+        explanation: `No rule contract guarantees: ${condition.description}`,
+        relatedRules: relatedIds
+      };
+    }
+  }
+}
+function findRelatedDescriptors(expectationName, descriptors) {
+  const nameLower = expectationName.toLowerCase();
+  const nameParts = nameLower.split(/[-_./\s]+/);
+  return descriptors.filter((d) => {
+    const idLower = d.id.toLowerCase();
+    const descLower = d.description.toLowerCase();
+    const behaviorLower = d.contract?.behavior?.toLowerCase() ?? "";
+    if (idLower.includes(nameLower) || nameLower.includes(idLower)) return true;
+    if (descLower.includes(nameLower)) return true;
+    if (behaviorLower.includes(nameLower)) return true;
+    const minParts = Math.min(2, nameParts.length);
+    const matchingParts = nameParts.filter(
+      (part) => part.length > 2 && (idLower.includes(part) || descLower.includes(part) || behaviorLower.includes(part))
+    );
+    if (matchingParts.length >= minParts) return true;
+    if (d.eventTypes) {
+      const eventStr = Array.isArray(d.eventTypes) ? d.eventTypes.join(" ") : d.eventTypes;
+      if (eventStr.toLowerCase().includes(nameLower)) return true;
+    }
+    return false;
+  });
+}
+function formatVerificationReport(report) {
+  const lines = [];
+  const icon = report.status === "satisfied" ? "\u2705" : report.status === "partial" ? "\u{1F7E1}" : "\u{1F534}";
+  lines.push(`${icon} Expectations: ${report.setName} \u2014 ${report.status.toUpperCase()}`);
+  lines.push(`   ${report.summary.satisfied}/${report.summary.total} satisfied, ${report.summary.violated} violated, ${report.summary.partial} partial`);
+  lines.push("");
+  for (const exp of report.expectations) {
+    const expIcon = exp.status === "satisfied" ? "\u2705" : exp.status === "partial" ? "\u{1F7E1}" : "\u{1F534}";
+    lines.push(`${expIcon} ${exp.name}`);
+    for (const cond of exp.conditions) {
+      const condIcon = cond.status === "satisfied" ? "  \u2713" : cond.status === "violated" ? "  \u2717" : "  ?";
+      lines.push(`${condIcon} [${cond.condition.type}] ${cond.condition.description}`);
+      lines.push(`      ${cond.explanation}`);
+    }
+    if (exp.edgeCases.length > 0) {
+      lines.push("  Edge cases:");
+      for (const ec of exp.edgeCases) {
+        lines.push(`    \u26A0\uFE0F ${ec}`);
+      }
+    }
+    lines.push("");
+  }
+  if (report.allMitigations.length > 0) {
+    lines.push("Suggested mitigations:");
+    for (const m of report.allMitigations) {
+      lines.push(`  \u{1F4A1} ${m}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/factory/factory.ts
+var SANITIZE_PATTERNS = {
+  "sql-injection": /('|"|;|--|\/\*|\*\/|xp_|exec\s|union\s+select|drop\s+table|insert\s+into|delete\s+from)/i,
+  "xss": /(<script|javascript:|on\w+\s*=|<iframe|<object|<embed|<img[^>]+onerror)/i,
+  "path-traversal": /(\.\.[/\\]|~\/|\/etc\/|\/proc\/)/i,
+  "command-injection": /([;&|`$]|\$\(|>\s*\/)/i
+};
+function inputRules(config = {}) {
+  const {
+    sanitize = [],
+    maxLength = 0,
+    required = false,
+    fieldName = "input"
+  } = config;
+  const rules = [];
+  const constraints = [];
+  if (sanitize.length > 0) {
+    rules.push({
+      id: `factory/input.sanitize-${fieldName}`,
+      description: `Validates ${fieldName} against ${sanitize.join(", ")} patterns`,
+      eventTypes: [`${fieldName}.submit`, `${fieldName}.change`],
+      contract: {
+        ruleId: `factory/input.sanitize-${fieldName}`,
+        behavior: `Checks ${fieldName} for dangerous patterns: ${sanitize.join(", ")}`,
+        examples: [
+          { given: `${fieldName} contains safe text`, when: "input submitted", then: "input.valid emitted" },
+          { given: `${fieldName} contains <script> tag`, when: "input submitted", then: "input.violation emitted" }
+        ],
+        invariants: [
+          `Dangerous ${fieldName} patterns must never pass validation`,
+          "All violations must include the violation type"
+        ]
+      },
+      impl: (state, events) => {
+        const inputEvent = events.find(
+          (e) => e.tag === `${fieldName}.submit` || e.tag === `${fieldName}.change`
+        );
+        if (!inputEvent) return RuleResult.skip("No input event");
+        const value = inputEvent.payload?.value ?? state.context.input?.value ?? "";
+        const violations = [];
+        for (const type of sanitize) {
+          const pattern = SANITIZE_PATTERNS[type];
+          if (pattern && pattern.test(value)) {
+            violations.push(type);
+          }
+        }
+        if (violations.length > 0) {
+          return RuleResult.emit([
+            fact(`${fieldName}.violation`, {
+              field: fieldName,
+              violations,
+              message: `Input failed sanitization: ${violations.join(", ")}`
+            })
+          ]);
+        }
+        return RuleResult.emit([
+          fact(`${fieldName}.valid`, { field: fieldName, sanitized: true })
+        ]);
+      }
+    });
+  }
+  if (maxLength > 0) {
+    constraints.push({
+      id: `factory/input.max-length-${fieldName}`,
+      description: `${fieldName} must not exceed ${maxLength} characters`,
+      contract: {
+        ruleId: `factory/input.max-length-${fieldName}`,
+        behavior: `Enforces max length of ${maxLength} for ${fieldName}`,
+        examples: [
+          { given: `${fieldName} is 10 chars`, when: `maxLength is ${maxLength}`, then: maxLength >= 10 ? "passes" : "violation" }
+        ],
+        invariants: [`${fieldName} length must never exceed ${maxLength}`]
+      },
+      impl: (state) => {
+        const value = state.context.input?.value ?? "";
+        if (value.length > maxLength) {
+          return `${fieldName} exceeds maximum length of ${maxLength} (got ${value.length})`;
+        }
+        return true;
+      }
+    });
+  }
+  if (required) {
+    constraints.push({
+      id: `factory/input.required-${fieldName}`,
+      description: `${fieldName} is required and must not be empty`,
+      contract: {
+        ruleId: `factory/input.required-${fieldName}`,
+        behavior: `Enforces that ${fieldName} is non-empty`,
+        examples: [
+          { given: `${fieldName} is "hello"`, when: "checked", then: "passes" },
+          { given: `${fieldName} is empty`, when: "checked", then: "violation" }
+        ],
+        invariants: [`${fieldName} must never be empty when required`]
+      },
+      impl: (state) => {
+        const value = state.context.input?.value ?? "";
+        if (value.trim().length === 0) {
+          return `${fieldName} is required but empty`;
+        }
+        return true;
+      }
+    });
+  }
+  return { rules, constraints };
+}
+function toastRules(config = {}) {
+  const {
+    requireDiff = false,
+    autoDismissMs = 0,
+    deduplicate = false
+  } = config;
+  const rules = [];
+  const constraints = [];
+  rules.push({
+    id: "factory/toast.show",
+    description: "Emits toast notification with content and config",
+    eventTypes: ["toast.request"],
+    contract: {
+      ruleId: "factory/toast.show",
+      behavior: "Shows toast when requested, respecting diff requirement and auto-dismiss",
+      examples: [
+        { given: "toast requested with message", when: "toast.request fires", then: "toast.show emitted" },
+        ...requireDiff ? [{ given: "no diff present", when: "toast.request fires", then: "toast skipped" }] : []
+      ],
+      invariants: [
+        "Toast message must be non-empty",
+        ...requireDiff ? ["Toast must not appear when diff is empty"] : []
+      ]
+    },
+    impl: (state, events) => {
+      const toastEvent = events.find((e) => e.tag === "toast.request");
+      if (!toastEvent) return RuleResult.skip("No toast request");
+      const payload = toastEvent.payload;
+      const message = payload.message ?? "";
+      if (!message) return RuleResult.skip("Empty toast message");
+      if (requireDiff) {
+        const diff = state.context.diff;
+        if (!diff || Object.keys(diff).length === 0) {
+          return RuleResult.skip("No diff \u2014 toast suppressed");
+        }
+      }
+      return RuleResult.emit([
+        fact("toast.show", {
+          message,
+          type: payload.type ?? "info",
+          autoDismissMs: autoDismissMs > 0 ? autoDismissMs : void 0,
+          timestamp: Date.now()
+        })
+      ]);
+    }
+  });
+  if (deduplicate) {
+    constraints.push({
+      id: "factory/toast.no-duplicates",
+      description: "Prevents duplicate toast messages",
+      contract: {
+        ruleId: "factory/toast.no-duplicates",
+        behavior: "Rejects toast if identical message is already showing",
+        examples: [
+          { given: "same toast already visible", when: "duplicate toast requested", then: "violation" }
+        ],
+        invariants: ["No two toasts may have the same message simultaneously"]
+      },
+      impl: (state) => {
+        const toasts = state.context.toasts ?? [];
+        const messages = toasts.map((t) => t.message);
+        const uniqueMessages = new Set(messages);
+        if (uniqueMessages.size < messages.length) {
+          return "Duplicate toast detected";
+        }
+        return true;
+      }
+    });
+  }
+  return { rules, constraints };
+}
+function formRules(config = {}) {
+  const {
+    validateOnBlur = false,
+    submitGate = false,
+    formName = "form"
+  } = config;
+  const rules = [];
+  const constraints = [];
+  if (validateOnBlur) {
+    rules.push({
+      id: `factory/${formName}.validate-on-blur`,
+      description: `Triggers field validation when a ${formName} field loses focus`,
+      eventTypes: [`${formName}.blur`],
+      contract: {
+        ruleId: `factory/${formName}.validate-on-blur`,
+        behavior: `Validates the blurred field and emits validation result`,
+        examples: [
+          { given: `${formName} field has value`, when: "field loses focus", then: "validation result emitted" }
+        ],
+        invariants: ["Validation must run for every blur event on a registered field"]
+      },
+      impl: (_state, events) => {
+        const blurEvent = events.find((e) => e.tag === `${formName}.blur`);
+        if (!blurEvent) return RuleResult.skip("No blur event");
+        const payload = blurEvent.payload;
+        const field = payload.field ?? "unknown";
+        const value = payload.value;
+        const valid = value !== null && value !== void 0 && value !== "";
+        return RuleResult.emit([
+          fact(`${formName}.field-validated`, {
+            field,
+            valid,
+            error: valid ? null : `${field} is required`
+          })
+        ]);
+      }
+    });
+  }
+  if (submitGate) {
+    constraints.push({
+      id: `factory/${formName}.submit-gate`,
+      description: `Prevents ${formName} submission when validation has not passed`,
+      contract: {
+        ruleId: `factory/${formName}.submit-gate`,
+        behavior: `Blocks form submission until all fields are valid`,
+        examples: [
+          { given: `${formName} is invalid`, when: "submit attempted", then: "violation \u2014 submission blocked" },
+          { given: `${formName} is valid`, when: "submit attempted", then: "passes" }
+        ],
+        invariants: ["Form must not submit while any field has errors"]
+      },
+      impl: (state) => {
+        const form = state.context.form;
+        if (!form) return true;
+        if (form.submitting && !form.valid) {
+          return `${formName} cannot submit: validation has not passed`;
+        }
+        return true;
+      }
+    });
+  }
+  rules.push({
+    id: `factory/${formName}.dirty-tracking`,
+    description: `Tracks whether ${formName} has unsaved changes`,
+    eventTypes: [`${formName}.change`, `${formName}.reset`],
+    contract: {
+      ruleId: `factory/${formName}.dirty-tracking`,
+      behavior: "Emits dirty state when form fields change, clears on reset",
+      examples: [
+        { given: "field value changed", when: "form.change fires", then: "form.dirty emitted" },
+        { given: "form reset", when: "form.reset fires", then: "form.dirty retracted" }
+      ],
+      invariants: ["Dirty state must reflect actual field changes"]
+    },
+    impl: (_state, events) => {
+      const resetEvent = events.find((e) => e.tag === `${formName}.reset`);
+      if (resetEvent) {
+        return RuleResult.retract([`${formName}.dirty`], "Form reset");
+      }
+      const changeEvent = events.find((e) => e.tag === `${formName}.change`);
+      if (changeEvent) {
+        return RuleResult.emit([
+          fact(`${formName}.dirty`, { dirty: true })
+        ]);
+      }
+      return RuleResult.skip("No form event");
+    }
+  });
+  return { rules, constraints };
+}
+function navigationRules(config = {}) {
+  const {
+    dirtyGuard = false,
+    authRequired = false
+  } = config;
+  const rules = [];
+  const constraints = [];
+  rules.push({
+    id: "factory/navigation.handle",
+    description: "Processes navigation requests and emits navigation facts",
+    eventTypes: ["navigation.request"],
+    contract: {
+      ruleId: "factory/navigation.handle",
+      behavior: "Emits navigation.allowed or navigation.blocked based on guards",
+      examples: [
+        { given: "no guards active", when: "navigation requested", then: "navigation.allowed emitted" },
+        ...dirtyGuard ? [{ given: "form is dirty", when: "navigation requested", then: "navigation.blocked emitted" }] : [],
+        ...authRequired ? [{ given: "user not authenticated", when: "navigation requested", then: "navigation.blocked emitted" }] : []
+      ],
+      invariants: [
+        "Every navigation request must result in either allowed or blocked",
+        ...dirtyGuard ? ["Navigation must be blocked when dirty data exists"] : [],
+        ...authRequired ? ["Navigation must be blocked when not authenticated"] : []
+      ]
+    },
+    impl: (state, events) => {
+      const navEvent = events.find((e) => e.tag === "navigation.request");
+      if (!navEvent) return RuleResult.skip("No navigation request");
+      const target = navEvent.payload?.target ?? "/";
+      const reasons = [];
+      if (dirtyGuard && state.context.dirty) {
+        reasons.push("Unsaved changes will be lost");
+      }
+      if (authRequired && !state.context.authenticated) {
+        reasons.push("Authentication required");
+      }
+      if (reasons.length > 0) {
+        return RuleResult.emit([
+          fact("navigation.blocked", { target, reasons })
+        ]);
+      }
+      return RuleResult.emit([
+        fact("navigation.allowed", { target })
+      ]);
+    }
+  });
+  if (dirtyGuard) {
+    constraints.push({
+      id: "factory/navigation.dirty-guard",
+      description: "Prevents silent navigation when unsaved changes exist",
+      contract: {
+        ruleId: "factory/navigation.dirty-guard",
+        behavior: "Blocks navigation when dirty state is true",
+        examples: [
+          { given: "dirty is true", when: "navigation attempted", then: "violation" },
+          { given: "dirty is false", when: "navigation attempted", then: "passes" }
+        ],
+        invariants: ["Must never silently lose unsaved changes"]
+      },
+      impl: (state) => {
+        if (state.context.dirty && state.facts.some((f) => f.tag === "navigation.allowed")) {
+          return "Navigation allowed while dirty \u2014 unsaved changes may be lost";
+        }
+        return true;
+      }
+    });
+  }
+  return { rules, constraints };
+}
+function dataRules(config = {}) {
+  const {
+    optimisticUpdate = false,
+    rollbackOnError = false,
+    cacheInvalidation = false,
+    entityName = "data"
+  } = config;
+  const rules = [];
+  const constraints = [];
+  if (optimisticUpdate) {
+    rules.push({
+      id: `factory/${entityName}.optimistic-update`,
+      description: `Applies optimistic update for ${entityName} while request is pending`,
+      eventTypes: [`${entityName}.mutate`],
+      contract: {
+        ruleId: `factory/${entityName}.optimistic-update`,
+        behavior: `Immediately emits updated ${entityName} state before server confirmation`,
+        examples: [
+          { given: `${entityName} mutation requested`, when: "mutate event fires", then: "optimistic state emitted" }
+        ],
+        invariants: [
+          "Optimistic state must store original for rollback",
+          "Optimistic update must be distinguishable from confirmed state"
+        ]
+      },
+      impl: (_state, events) => {
+        const mutateEvent = events.find((e) => e.tag === `${entityName}.mutate`);
+        if (!mutateEvent) return RuleResult.skip("No mutation event");
+        const payload = mutateEvent.payload;
+        return RuleResult.emit([
+          fact(`${entityName}.optimistic`, {
+            id: payload.id,
+            data: payload.data,
+            pending: true,
+            timestamp: Date.now()
+          })
+        ]);
+      }
+    });
+  }
+  if (rollbackOnError) {
+    rules.push({
+      id: `factory/${entityName}.rollback`,
+      description: `Rolls back optimistic ${entityName} update on error`,
+      eventTypes: [`${entityName}.error`],
+      contract: {
+        ruleId: `factory/${entityName}.rollback`,
+        behavior: `Reverts to original ${entityName} state when mutation fails`,
+        examples: [
+          { given: "optimistic update was applied", when: "server returns error", then: "rollback emitted, optimistic retracted" }
+        ],
+        invariants: [
+          "Rollback must restore original state exactly",
+          "Optimistic facts must be retracted on rollback"
+        ]
+      },
+      impl: (_state, events) => {
+        const errorEvent = events.find((e) => e.tag === `${entityName}.error`);
+        if (!errorEvent) return RuleResult.skip("No error event");
+        const payload = errorEvent.payload;
+        const result = RuleResult.emit([
+          fact(`${entityName}.rollback`, {
+            id: payload.id,
+            error: payload.error,
+            timestamp: Date.now()
+          })
+        ]);
+        return result;
+      }
+    });
+  }
+  if (cacheInvalidation) {
+    rules.push({
+      id: `factory/${entityName}.cache-invalidate`,
+      description: `Invalidates ${entityName} cache when data changes are confirmed`,
+      eventTypes: [`${entityName}.confirmed`, `${entityName}.deleted`],
+      contract: {
+        ruleId: `factory/${entityName}.cache-invalidate`,
+        behavior: `Emits cache invalidation signal when ${entityName} is confirmed or deleted`,
+        examples: [
+          { given: `${entityName} mutation confirmed`, when: "confirmed event fires", then: "cache.invalidate emitted" }
+        ],
+        invariants: ["Stale cache entries must be invalidated after confirmed mutations"]
+      },
+      impl: (_state, events) => {
+        const confirmEvent = events.find(
+          (e) => e.tag === `${entityName}.confirmed` || e.tag === `${entityName}.deleted`
+        );
+        if (!confirmEvent) return RuleResult.skip("No confirmation event");
+        const payload = confirmEvent.payload;
+        return RuleResult.emit([
+          fact(`${entityName}.cache-invalidate`, {
+            id: payload.id,
+            timestamp: Date.now()
+          })
+        ]);
+      }
+    });
+  }
+  constraints.push({
+    id: `factory/${entityName}.integrity`,
+    description: `Ensures ${entityName} state integrity \u2014 no orphaned optimistic updates`,
+    contract: {
+      ruleId: `factory/${entityName}.integrity`,
+      behavior: "Detects orphaned optimistic updates without pending confirmation",
+      examples: [
+        { given: "optimistic update exists without pending request", when: "checked", then: "violation" }
+      ],
+      invariants: [`Every optimistic ${entityName} update must have a corresponding pending request`]
+    },
+    impl: (state) => {
+      const pending = state.context.pending ?? {};
+      const optimisticFacts = state.facts.filter((f) => f.tag === `${entityName}.optimistic`);
+      for (const optFact of optimisticFacts) {
+        const id = optFact.payload?.id;
+        if (id && !pending[id]) {
+          return `Orphaned optimistic update for ${entityName} id=${id} \u2014 no pending request`;
+        }
+      }
+      return true;
+    }
+  });
+  return { rules, constraints };
+}
+
+// src/project/project.ts
+function defineGate(name, config) {
+  const { expects, onSatisfied, onViolation } = config;
+  const rule = {
+    id: `gate/${name}`,
+    description: `Feature gate: ${name} \u2014 requires: ${expects.join(", ")}`,
+    eventTypes: ["gate.check", `gate.${name}.check`],
+    contract: {
+      ruleId: `gate/${name}`,
+      behavior: `Opens gate "${name}" when all expectations are met: ${expects.join(", ")}`,
+      examples: [
+        {
+          given: `all expectations satisfied: ${expects.join(", ")}`,
+          when: "gate checked",
+          then: `gate.${name}.open emitted${onSatisfied ? ` \u2192 ${onSatisfied}` : ""}`
+        },
+        {
+          given: "one or more expectations unsatisfied",
+          when: "gate checked",
+          then: `gate.${name}.blocked emitted${onViolation ? ` \u2192 ${onViolation}` : ""}`
+        }
+      ],
+      invariants: [
+        `Gate "${name}" must never open with unsatisfied expectations`,
+        "Gate status must reflect current expectation state exactly"
+      ]
+    },
+    impl: (state, events) => {
+      const gateEvent = events.find(
+        (e) => e.tag === "gate.check" || e.tag === `gate.${name}.check`
+      );
+      if (!gateEvent) return RuleResult.skip("No gate check event");
+      const expectationState = state.context.expectations ?? {};
+      const satisfied = [];
+      const unsatisfied = [];
+      for (const exp of expects) {
+        if (expectationState[exp]) {
+          satisfied.push(exp);
+        } else {
+          unsatisfied.push(exp);
+        }
+      }
+      const status = unsatisfied.length === 0 ? "open" : "blocked";
+      const gateState = {
+        name,
+        status,
+        satisfied,
+        unsatisfied,
+        lastChanged: Date.now()
+      };
+      const facts = [fact(`gate.${name}.status`, gateState)];
+      if (status === "open" && onSatisfied) {
+        facts.push(fact(`gate.${name}.action`, { action: onSatisfied }));
+      } else if (status === "blocked" && onViolation) {
+        facts.push(fact(`gate.${name}.action`, { action: onViolation }));
+      }
+      return RuleResult.emit(facts);
+    }
+  };
+  const constraint = {
+    id: `gate/${name}/integrity`,
+    description: `Ensures gate "${name}" status matches expectation reality`,
+    contract: {
+      ruleId: `gate/${name}/integrity`,
+      behavior: `Validates that gate "${name}" is not open when expectations are unmet`,
+      examples: [
+        {
+          given: `gate ${name} is open but expectations unmet`,
+          when: "constraint checked",
+          then: "violation"
+        }
+      ],
+      invariants: [`Gate "${name}" must never report open when expectations are unsatisfied`]
+    },
+    impl: (state) => {
+      const gateState = state.context.gates?.[name];
+      if (!gateState) return true;
+      if (gateState.status === "open" && gateState.unsatisfied.length > 0) {
+        return `Gate "${name}" is open but has unsatisfied expectations: ${gateState.unsatisfied.join(", ")}`;
+      }
+      return true;
+    }
+  };
+  return { rules: [rule], constraints: [constraint] };
+}
+function semverContract(config) {
+  const { sources, invariants } = config;
+  const rule = {
+    id: "project/semver-check",
+    description: `Checks version consistency across: ${sources.join(", ")}`,
+    eventTypes: ["project.version-check"],
+    contract: {
+      ruleId: "project/semver-check",
+      behavior: `Verifies version consistency across ${sources.length} sources`,
+      examples: [
+        {
+          given: "all sources have version 1.2.3",
+          when: "version check runs",
+          then: "semver.consistent emitted"
+        },
+        {
+          given: "package.json has 1.2.3 but README has 1.2.2",
+          when: "version check runs",
+          then: "semver.inconsistent emitted with diff"
+        }
+      ],
+      invariants: invariants.length > 0 ? invariants : ["All version sources must report the same semver string"]
+    },
+    impl: (_state, events) => {
+      const checkEvent = events.find((e) => e.tag === "project.version-check");
+      if (!checkEvent) return RuleResult.skip("No version check event");
+      const versions = checkEvent.payload?.versions ?? {};
+      const versionValues = Object.values(versions);
+      const unique = new Set(versionValues);
+      if (unique.size <= 1) {
+        return RuleResult.emit([
+          fact("semver.consistent", {
+            version: versionValues[0] ?? "unknown",
+            sources: Object.keys(versions)
+          })
+        ]);
+      }
+      const report = {
+        consistent: false,
+        versions,
+        violations: [`Version mismatch: ${JSON.stringify(versions)}`]
+      };
+      return RuleResult.emit([fact("semver.inconsistent", report)]);
+    }
+  };
+  return { rules: [rule], constraints: [] };
+}
+function commitFromState(diff) {
+  const parts = [];
+  const bodyParts = [];
+  const totalAdded = diff.rulesAdded.length + diff.contractsAdded.length + diff.expectationsAdded.length;
+  const totalRemoved = diff.rulesRemoved.length + diff.contractsRemoved.length + diff.expectationsRemoved.length;
+  const totalModified = diff.rulesModified.length;
+  const hasGateChanges = diff.gateChanges.length > 0;
+  if (totalAdded > 0 && totalRemoved === 0 && totalModified === 0) {
+    if (diff.rulesAdded.length > 0) {
+      const scope = inferScope(diff.rulesAdded);
+      parts.push(`feat(${scope}): add ${formatIds(diff.rulesAdded)}`);
+    } else if (diff.contractsAdded.length > 0) {
+      parts.push(`feat(contracts): add contracts for ${formatIds(diff.contractsAdded)}`);
+    } else {
+      parts.push(`feat(expectations): add ${formatIds(diff.expectationsAdded)}`);
+    }
+  } else if (totalRemoved > 0 && totalAdded === 0) {
+    if (diff.rulesRemoved.length > 0) {
+      const scope = inferScope(diff.rulesRemoved);
+      parts.push(`refactor(${scope}): remove ${formatIds(diff.rulesRemoved)}`);
+    } else {
+      parts.push(`refactor: remove ${totalRemoved} item(s)`);
+    }
+  } else if (totalModified > 0) {
+    const scope = inferScope(diff.rulesModified);
+    parts.push(`refactor(${scope}): update ${formatIds(diff.rulesModified)}`);
+  } else if (hasGateChanges) {
+    const gateNames = diff.gateChanges.map((g) => g.gate);
+    parts.push(`chore(gates): ${formatIds(gateNames)} state changed`);
+  } else {
+    parts.push("chore: behavioral state update");
+  }
+  if (diff.rulesAdded.length > 0) bodyParts.push(`Rules added: ${diff.rulesAdded.join(", ")}`);
+  if (diff.rulesRemoved.length > 0) bodyParts.push(`Rules removed: ${diff.rulesRemoved.join(", ")}`);
+  if (diff.rulesModified.length > 0) bodyParts.push(`Rules modified: ${diff.rulesModified.join(", ")}`);
+  if (diff.contractsAdded.length > 0) bodyParts.push(`Contracts added: ${diff.contractsAdded.join(", ")}`);
+  if (diff.contractsRemoved.length > 0) bodyParts.push(`Contracts removed: ${diff.contractsRemoved.join(", ")}`);
+  if (diff.expectationsAdded.length > 0) bodyParts.push(`Expectations added: ${diff.expectationsAdded.join(", ")}`);
+  if (diff.expectationsRemoved.length > 0) bodyParts.push(`Expectations removed: ${diff.expectationsRemoved.join(", ")}`);
+  for (const gc of diff.gateChanges) {
+    bodyParts.push(`Gate "${gc.gate}": ${gc.from} \u2192 ${gc.to}`);
+  }
+  const subject = parts[0] || "chore: update";
+  return bodyParts.length > 0 ? `${subject}
+
+${bodyParts.join("\n")}` : subject;
+}
+function inferScope(ids) {
+  if (ids.length === 0) return "rules";
+  const prefixes = ids.map((id) => {
+    const slash = id.indexOf("/");
+    return slash > 0 ? id.slice(0, slash) : id;
+  });
+  const unique = new Set(prefixes);
+  return unique.size === 1 ? prefixes[0] : "rules";
+}
+function formatIds(ids) {
+  if (ids.length <= 3) return ids.join(", ");
+  return `${ids.slice(0, 2).join(", ")} (+${ids.length - 2} more)`;
+}
+function branchRules(config) {
+  const { naming, mergeConditions } = config;
+  const namePattern = naming.replace("{name}", "(.+)").replace("{issue}", "(\\d+)");
+  const nameRegex = new RegExp(`^${namePattern}$`);
+  const rule = {
+    id: "project/branch-check",
+    description: `Validates branch naming (${naming}) and merge conditions`,
+    eventTypes: ["project.branch-check"],
+    contract: {
+      ruleId: "project/branch-check",
+      behavior: `Ensures branch follows "${naming}" pattern and merge conditions are met`,
+      examples: [
+        {
+          given: `branch named "${naming.replace("{name}", "my-feature")}"`,
+          when: "branch checked",
+          then: "branch.valid emitted"
+        },
+        {
+          given: 'branch named "random-name"',
+          when: "branch checked",
+          then: "branch.invalid emitted"
+        }
+      ],
+      invariants: [
+        `Branch names must follow pattern: ${naming}`,
+        `Merge requires: ${mergeConditions.join(", ")}`
+      ]
+    },
+    impl: (_state, events) => {
+      const checkEvent = events.find((e) => e.tag === "project.branch-check");
+      if (!checkEvent) return RuleResult.skip("No branch check event");
+      const payload = checkEvent.payload;
+      const branch = payload.branch ?? "";
+      const conditions = payload.conditions ?? {};
+      const validName = nameRegex.test(branch);
+      const unmetConditions = mergeConditions.filter((c) => !conditions[c]);
+      if (validName && unmetConditions.length === 0) {
+        return RuleResult.emit([
+          fact("branch.valid", { branch, mergeReady: true })
+        ]);
+      }
+      const reasons = [];
+      if (!validName) reasons.push(`Branch name "${branch}" doesn't match pattern "${naming}"`);
+      if (unmetConditions.length > 0) reasons.push(`Unmet merge conditions: ${unmetConditions.join(", ")}`);
+      return RuleResult.emit([
+        fact("branch.invalid", { branch, reasons, mergeReady: false })
+      ]);
+    }
+  };
+  return { rules: [rule], constraints: [] };
+}
+function lintGate(config = {}) {
+  const expects = ["lint-passes", ...config.additionalExpects ?? []];
+  return defineGate("lint", {
+    expects,
+    onSatisfied: "lint-passed",
+    onViolation: "lint-failed"
+  });
+}
+function formatGate(config = {}) {
+  const expects = ["format-passes", ...config.additionalExpects ?? []];
+  return defineGate("format", {
+    expects,
+    onSatisfied: "format-passed",
+    onViolation: "format-failed"
+  });
+}
+function expectationGate(config = {}) {
+  const expects = ["expectations-verified", ...config.additionalExpects ?? []];
+  return defineGate("expectations", {
+    expects,
+    onSatisfied: "expectations-passed",
+    onViolation: "expectations-failed"
+  });
+}
 export {
   AcknowledgeContractGap,
   ActorManager,
@@ -1908,6 +3204,8 @@ export {
   ContractMissing,
   ContractUpdated,
   ContractValidated,
+  Expectation,
+  ExpectationSet,
   ReactiveLogicEngine2 as FrameworkAgnosticReactiveEngine,
   InMemoryPraxisDB,
   LogicEngine,
@@ -1921,6 +3219,7 @@ export {
   PraxisSchemaRegistry,
   ReactiveLogicEngine,
   RegistryIntrospector,
+  RuleResult,
   StateDocsGenerator,
   TerminalAdapter,
   ValidateContracts,
@@ -1928,9 +3227,12 @@ export {
   attachTauriToEngine,
   attachToEngine,
   attachUnumToEngine,
+  auditCompleteness,
+  branchRules,
   canvasToMermaid,
   canvasToSchema,
   canvasToYaml,
+  commitFromState,
   createBehaviorLedger,
   createCanvasEditor,
   createChronicle,
@@ -1953,21 +3255,33 @@ export {
   createTauriPraxisAdapter,
   createTerminalAdapter,
   createTimerActor,
+  createUIModule,
   createUnifiedApp,
   createUnumAdapter,
+  dataRules,
   defineConstraint,
   defineContract,
   defineEvent,
   defineFact,
+  defineGate,
   defineModule,
   defineRule,
+  dirtyGuardRule,
+  errorDisplayRule,
+  expectBehavior,
+  expectationGate,
+  fact,
   filterEvents,
   filterFacts,
   findEvent,
   findFact,
+  formRules,
+  formatGate,
+  formatReport,
   formatValidationReport,
   formatValidationReportJSON,
   formatValidationReportSARIF,
+  formatVerificationReport,
   generateDocs,
   generateId,
   generateTauriConfig,
@@ -1975,16 +3289,32 @@ export {
   getEventPath,
   getFactPath,
   getSchemaPath,
+  initGateRule,
+  inputRules,
   isContract,
+  lintGate,
   loadSchema,
   loadSchemaFromFile,
   loadSchemaFromJson,
   loadSchemaFromYaml,
+  loadingGateRule,
+  mustBeInitializedConstraint,
+  navigationRequest,
+  navigationRules,
+  noInteractionWhileLoadingConstraint,
+  offlineIndicatorRule,
   registerSchema,
+  resizeEvent,
   runTerminalCommand,
   schemaToCanvas,
+  semverContract,
+  toastRules,
+  uiModule,
+  uiStateChanged,
   validateContracts,
   validateForGeneration,
   validateSchema,
-  validateWithGuardian
+  validateWithGuardian,
+  verify,
+  viewportRule
 };