@reactive-agents/verification 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tyler Buell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,39 @@
+# @reactive-agents/verification
+
+Output verification for the [Reactive Agents](https://tylerjrbuell.github.io/reactive-agents-ts/) framework.
+
+Reduces hallucinations by measuring semantic entropy (consistency across multiple samples) and decomposing claims into verifiable facts.
+
+## Installation
+
+```bash
+bun add @reactive-agents/verification effect
+```
+
+## Techniques
+
+| Technique | How it works |
+|-----------|-------------|
+| Semantic entropy | Samples the LLM N times; high variance → low confidence |
+| Fact decomposition | Breaks output into atomic claims, checks each independently |
+
+## Usage
+
+```typescript
+import { ReactiveAgents } from "reactive-agents";
+
+const agent = await ReactiveAgents.create()
+  .withName("fact-checker")
+  .withProvider("anthropic")
+  .withVerification()
+  .build();
+
+const result = await agent.run("What year did the Berlin Wall fall?");
+console.log(result.metadata.confidence); // 0.0–1.0
+```
+
+When confidence is below the threshold, the agent can re-sample or escalate to the user depending on the active interaction mode.
+
+## Documentation
+
+Full documentation at [tylerjrbuell.github.io/reactive-agents-ts](https://tylerjrbuell.github.io/reactive-agents-ts/)

package/dist/index.d.ts

@@ -0,0 +1,133 @@
+import { Schema, Effect, Context, Layer } from 'effect';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import * as effect_Layer from 'effect/Layer';
+
+declare const RiskLevel: Schema.Literal<["low", "medium", "high", "critical"]>;
+type RiskLevel = typeof RiskLevel.Type;
+declare const ConfidenceScoreSchema: Schema.Struct<{
+    score: typeof Schema.Number;
+    calibrated: typeof Schema.Boolean;
+    layerScores: Schema.Record$<typeof Schema.String, typeof Schema.Number>;
+}>;
+type ConfidenceScore = typeof ConfidenceScoreSchema.Type;
+declare const ClaimSchema: Schema.Struct<{
+    text: typeof Schema.String;
+    confidence: typeof Schema.Number;
+    source: Schema.optional<typeof Schema.String>;
+}>;
+type Claim = typeof ClaimSchema.Type;
+declare const LayerResultSchema: Schema.Struct<{
+    layerName: typeof Schema.String;
+    score: typeof Schema.Number;
+    passed: typeof Schema.Boolean;
+    details: Schema.optional<typeof Schema.String>;
+    claims: Schema.optional<Schema.Array$<Schema.Struct<{
+        text: typeof Schema.String;
+        confidence: typeof Schema.Number;
+        source: Schema.optional<typeof Schema.String>;
+    }>>>;
+}>;
+type LayerResult = typeof LayerResultSchema.Type;
+declare const VerificationResultSchema: Schema.Struct<{
+    overallScore: typeof Schema.Number;
+    passed: typeof Schema.Boolean;
+    riskLevel: Schema.Literal<["low", "medium", "high", "critical"]>;
+    layerResults: Schema.Array$<Schema.Struct<{
+        layerName: typeof Schema.String;
+        score: typeof Schema.Number;
+        passed: typeof Schema.Boolean;
+        details: Schema.optional<typeof Schema.String>;
+        claims: Schema.optional<Schema.Array$<Schema.Struct<{
+            text: typeof Schema.String;
+            confidence: typeof Schema.Number;
+            source: Schema.optional<typeof Schema.String>;
+        }>>>;
+    }>>;
+    recommendation: Schema.Literal<["accept", "review", "reject"]>;
+    verifiedAt: typeof Schema.DateFromSelf;
+}>;
+type VerificationResult = typeof VerificationResultSchema.Type;
+declare const VerificationConfigSchema: Schema.Struct<{
+    enableSemanticEntropy: typeof Schema.Boolean;
+    enableFactDecomposition: typeof Schema.Boolean;
+    enableMultiSource: typeof Schema.Boolean;
+    enableSelfConsistency: typeof Schema.Boolean;
+    enableNli: typeof Schema.Boolean;
+    passThreshold: typeof Schema.Number;
+    riskThreshold: typeof Schema.Number;
+}>;
+type VerificationConfig = typeof VerificationConfigSchema.Type;
+declare const defaultVerificationConfig: VerificationConfig;
+
+declare const VerificationError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "VerificationError";
+} & Readonly<A>;
+declare class VerificationError extends VerificationError_base<{
+    readonly message: string;
+    readonly layer?: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const CalibrationError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "CalibrationError";
+} & Readonly<A>;
+declare class CalibrationError extends CalibrationError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+
+/**
+ * Semantic Entropy Layer (Tier 1: Heuristic)
+ *
+ * Measures uncertainty by analyzing word diversity and specificity.
+ * Higher entropy = more vague = lower confidence.
+ */
+declare const checkSemanticEntropy: (text: string, _context?: string) => Effect.Effect<LayerResult, never>;
+
+/**
+ * Fact Decomposition Layer (Tier 1: Heuristic)
+ *
+ * Splits response into atomic claims and scores each based on specificity.
+ * Claims with dates, numbers, and proper nouns are more verifiable (higher confidence).
+ */
+declare const checkFactDecomposition: (text: string) => Effect.Effect<LayerResult, never>;
+
+/**
+ * Multi-Source Layer (Tier 1: Placeholder)
+ *
+ * In Tier 2, this cross-references claims against multiple sources.
+ * In Tier 1, returns moderate confidence as a placeholder.
+ */
+declare const checkMultiSource: (_text: string) => Effect.Effect<LayerResult, never>;
+
+/**
+ * Self-Consistency Layer (Tier 1: Heuristic)
+ *
+ * Checks for internal contradictions within the response.
+ * Looks for negation patterns and conflicting statements.
+ */
+declare const checkSelfConsistency: (text: string) => Effect.Effect<LayerResult, never>;
+
+/**
+ * Natural Language Inference Layer (Tier 1: Heuristic)
+ *
+ * Checks if the response logically follows from the input.
+ * Uses keyword overlap and relevance heuristics.
+ */
+declare const checkNli: (response: string, input: string) => Effect.Effect<LayerResult, never>;
+
+declare const VerificationService_base: Context.TagClass<VerificationService, "VerificationService", {
+    /** Verify a response against an input query. */
+    readonly verify: (response: string, input: string) => Effect.Effect<VerificationResult, VerificationError>;
+    /** Get current verification config. */
+    readonly getConfig: () => Effect.Effect<VerificationConfig, never>;
+}>;
+declare class VerificationService extends VerificationService_base {
+}
+declare const VerificationServiceLive: (config: VerificationConfig) => Layer.Layer<VerificationService, never, never>;
+
+declare const createVerificationLayer: (config?: Partial<VerificationConfig>) => effect_Layer.Layer<VerificationService, never, never>;
+
+export { CalibrationError, type Claim, ClaimSchema, type ConfidenceScore, ConfidenceScoreSchema, type LayerResult, LayerResultSchema, RiskLevel, type VerificationConfig, VerificationConfigSchema, VerificationError, type VerificationResult, VerificationResultSchema, VerificationService, VerificationServiceLive, checkFactDecomposition, checkMultiSource, checkNli, checkSelfConsistency, checkSemanticEntropy, createVerificationLayer, defaultVerificationConfig };

package/dist/index.js

@@ -0,0 +1,286 @@
+// src/types.ts
+import { Schema } from "effect";
+var RiskLevel = Schema.Literal("low", "medium", "high", "critical");
+var ConfidenceScoreSchema = Schema.Struct({
+  score: Schema.Number,
+  // 0-1
+  calibrated: Schema.Boolean,
+  layerScores: Schema.Record({ key: Schema.String, value: Schema.Number })
+});
+var ClaimSchema = Schema.Struct({
+  text: Schema.String,
+  confidence: Schema.Number,
+  source: Schema.optional(Schema.String)
+});
+var LayerResultSchema = Schema.Struct({
+  layerName: Schema.String,
+  score: Schema.Number,
+  // 0-1
+  passed: Schema.Boolean,
+  details: Schema.optional(Schema.String),
+  claims: Schema.optional(Schema.Array(ClaimSchema))
+});
+var VerificationResultSchema = Schema.Struct({
+  overallScore: Schema.Number,
+  // 0-1
+  passed: Schema.Boolean,
+  riskLevel: RiskLevel,
+  layerResults: Schema.Array(LayerResultSchema),
+  recommendation: Schema.Literal("accept", "review", "reject"),
+  verifiedAt: Schema.DateFromSelf
+});
+var VerificationConfigSchema = Schema.Struct({
+  enableSemanticEntropy: Schema.Boolean,
+  enableFactDecomposition: Schema.Boolean,
+  enableMultiSource: Schema.Boolean,
+  enableSelfConsistency: Schema.Boolean,
+  enableNli: Schema.Boolean,
+  passThreshold: Schema.Number,
+  // Default: 0.7
+  riskThreshold: Schema.Number
+  // Default: 0.5
+});
+var defaultVerificationConfig = {
+  enableSemanticEntropy: true,
+  enableFactDecomposition: true,
+  enableMultiSource: false,
+  // placeholder in Tier 1
+  enableSelfConsistency: true,
+  enableNli: true,
+  passThreshold: 0.7,
+  riskThreshold: 0.5
+};
+
+// src/errors.ts
+import { Data } from "effect";
+var VerificationError = class extends Data.TaggedError("VerificationError") {
+};
+var CalibrationError = class extends Data.TaggedError("CalibrationError") {
+};
+
+// src/layers/semantic-entropy.ts
+import { Effect } from "effect";
+var checkSemanticEntropy = (text, _context) => Effect.sync(() => {
+  const words = text.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  const unique = new Set(words);
+  const diversity = words.length > 0 ? unique.size / words.length : 0;
+  const hedges = [
+    "might",
+    "could",
+    "perhaps",
+    "possibly",
+    "maybe",
+    "i think",
+    "i believe",
+    "it seems",
+    "probably",
+    "likely",
+    "not sure",
+    "uncertain",
+    "approximately",
+    "roughly"
+  ];
+  const hedgeCount = hedges.filter((h) => text.toLowerCase().includes(h)).length;
+  const hedgePenalty = Math.min(0.3, hedgeCount * 0.1);
+  const lengthBonus = Math.min(0.1, words.length / 100);
+  const score = Math.max(0, Math.min(1, diversity + lengthBonus - hedgePenalty));
+  return {
+    layerName: "semantic-entropy",
+    score,
+    passed: score >= 0.5,
+    details: `Diversity: ${diversity.toFixed(2)}, Hedges: ${hedgeCount}, Score: ${score.toFixed(2)}`
+  };
+});
+
+// src/layers/fact-decomposition.ts
+import { Effect as Effect2 } from "effect";
+var checkFactDecomposition = (text) => Effect2.sync(() => {
+  const sentences = text.split(/[.!?]+/).map((s) => s.trim()).filter((s) => s.length > 10);
+  if (sentences.length === 0) {
+    return {
+      layerName: "fact-decomposition",
+      score: 0.5,
+      passed: true,
+      details: "No verifiable claims found",
+      claims: []
+    };
+  }
+  const claims = sentences.map((sentence) => {
+    let confidence = 0.5;
+    if (/\d+/.test(sentence)) confidence += 0.15;
+    const properNouns = sentence.match(/\b[A-Z][a-z]+\b/g) ?? [];
+    confidence += Math.min(0.15, properNouns.length * 0.05);
+    if (/\d{4}|\b(January|February|March|April|May|June|July|August|September|October|November|December)\b/i.test(sentence)) {
+      confidence += 0.1;
+    }
+    if (/\b(some|many|often|generally|usually)\b/i.test(sentence)) {
+      confidence -= 0.1;
+    }
+    return {
+      text: sentence,
+      confidence: Math.max(0, Math.min(1, confidence))
+    };
+  });
+  const avgConfidence = claims.reduce((sum, c) => sum + c.confidence, 0) / claims.length;
+  return {
+    layerName: "fact-decomposition",
+    score: avgConfidence,
+    passed: avgConfidence >= 0.5,
+    details: `${claims.length} claims, avg confidence: ${avgConfidence.toFixed(2)}`,
+    claims
+  };
+});
+
+// src/layers/multi-source.ts
+import { Effect as Effect3 } from "effect";
+var checkMultiSource = (_text) => Effect3.succeed({
+  layerName: "multi-source",
+  score: 0.6,
+  passed: true,
+  details: "Tier 1 placeholder \u2014 multi-source verification requires Tier 2"
+});
+
+// src/layers/self-consistency.ts
+import { Effect as Effect4 } from "effect";
+var checkSelfConsistency = (text) => Effect4.sync(() => {
+  const sentences = text.split(/[.!?]+/).map((s) => s.trim().toLowerCase()).filter((s) => s.length > 10);
+  if (sentences.length < 2) {
+    return {
+      layerName: "self-consistency",
+      score: 0.8,
+      passed: true,
+      details: "Too few sentences to check consistency"
+    };
+  }
+  let contradictions = 0;
+  const negationPairs = [
+    [/\bis\b/, /\bis not\b/],
+    [/\bcan\b/, /\bcannot\b/],
+    [/\bwill\b/, /\bwill not\b/],
+    [/\btrue\b/, /\bfalse\b/],
+    [/\balways\b/, /\bnever\b/],
+    [/\beveryone\b/, /\bno one\b/]
+  ];
+  for (let i = 0; i < sentences.length; i++) {
+    for (let j = i + 1; j < sentences.length; j++) {
+      for (const [pos, neg] of negationPairs) {
+        if (pos.test(sentences[i]) && neg.test(sentences[j]) || neg.test(sentences[i]) && pos.test(sentences[j])) {
+          const wordsI = new Set(sentences[i].split(/\s+/));
+          const wordsJ = new Set(sentences[j].split(/\s+/));
+          const overlap = [...wordsI].filter((w) => wordsJ.has(w)).length;
+          const similarity = overlap / Math.max(wordsI.size, wordsJ.size);
+          if (similarity > 0.3) contradictions++;
+        }
+      }
+    }
+  }
+  const score = Math.max(0, 1 - contradictions * 0.3);
+  return {
+    layerName: "self-consistency",
+    score,
+    passed: score >= 0.5,
+    details: `${contradictions} potential contradiction(s) found`
+  };
+});
+
+// src/layers/nli.ts
+import { Effect as Effect5 } from "effect";
+var checkNli = (response, input) => Effect5.sync(() => {
+  const inputWords = new Set(
+    input.toLowerCase().split(/\s+/).filter((w) => w.length > 3)
+  );
+  const responseWords = response.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+  if (inputWords.size === 0 || responseWords.length === 0) {
+    return {
+      layerName: "nli",
+      score: 0.5,
+      passed: true,
+      details: "Insufficient text for NLI check"
+    };
+  }
+  const relevantCount = responseWords.filter((w) => inputWords.has(w)).length;
+  const relevance = relevantCount / responseWords.length;
+  const topicScore = Math.min(1, relevance * 3);
+  const offTopicPhrases = [
+    "as an ai",
+    "i cannot",
+    "i'm unable",
+    "i don't have",
+    "i apologize",
+    "sorry, but"
+  ];
+  const offTopicCount = offTopicPhrases.filter(
+    (p) => response.toLowerCase().includes(p)
+  ).length;
+  const offTopicPenalty = offTopicCount * 0.1;
+  const score = Math.max(0, Math.min(1, topicScore - offTopicPenalty + 0.3));
+  return {
+    layerName: "nli",
+    score,
+    passed: score >= 0.5,
+    details: `Relevance: ${relevance.toFixed(2)}, Topic score: ${topicScore.toFixed(2)}, Off-topic penalty: ${offTopicPenalty.toFixed(2)}`
+  };
+});
+
+// src/verification-service.ts
+import { Effect as Effect6, Context, Layer } from "effect";
+var VerificationService = class extends Context.Tag("VerificationService")() {
+};
+var VerificationServiceLive = (config) => Layer.succeed(VerificationService, {
+  verify: (response, input) => Effect6.gen(function* () {
+    const layerResults = [];
+    if (config.enableSemanticEntropy) {
+      layerResults.push(yield* checkSemanticEntropy(response, input));
+    }
+    if (config.enableFactDecomposition) {
+      layerResults.push(yield* checkFactDecomposition(response));
+    }
+    if (config.enableMultiSource) {
+      layerResults.push(yield* checkMultiSource(response));
+    }
+    if (config.enableSelfConsistency) {
+      layerResults.push(yield* checkSelfConsistency(response));
+    }
+    if (config.enableNli) {
+      layerResults.push(yield* checkNli(response, input));
+    }
+    const overallScore = layerResults.length > 0 ? layerResults.reduce((sum, r) => sum + r.score, 0) / layerResults.length : 0.5;
+    const riskLevel = overallScore >= 0.8 ? "low" : overallScore >= 0.6 ? "medium" : overallScore >= 0.4 ? "high" : "critical";
+    const recommendation = overallScore >= config.passThreshold ? "accept" : overallScore >= config.riskThreshold ? "review" : "reject";
+    return {
+      overallScore,
+      passed: overallScore >= config.passThreshold,
+      riskLevel,
+      layerResults: [...layerResults],
+      recommendation,
+      verifiedAt: /* @__PURE__ */ new Date()
+    };
+  }),
+  getConfig: () => Effect6.succeed(config)
+});
+
+// src/runtime.ts
+var createVerificationLayer = (config) => VerificationServiceLive({
+  ...defaultVerificationConfig,
+  ...config
+});
+export {
+  CalibrationError,
+  ClaimSchema,
+  ConfidenceScoreSchema,
+  LayerResultSchema,
+  RiskLevel,
+  VerificationConfigSchema,
+  VerificationError,
+  VerificationResultSchema,
+  VerificationService,
+  VerificationServiceLive,
+  checkFactDecomposition,
+  checkMultiSource,
+  checkNli,
+  checkSelfConsistency,
+  checkSemanticEntropy,
+  createVerificationLayer,
+  defaultVerificationConfig
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/errors.ts","../src/layers/semantic-entropy.ts","../src/layers/fact-decomposition.ts","../src/layers/multi-source.ts","../src/layers/self-consistency.ts","../src/layers/nli.ts","../src/verification-service.ts","../src/runtime.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n// ─── Risk Level ───\n\nexport const RiskLevel = Schema.Literal(\"low\", \"medium\", \"high\", \"critical\");\nexport type RiskLevel = typeof RiskLevel.Type;\n\n// ─── Confidence Score ───\n\nexport const ConfidenceScoreSchema = Schema.Struct({\n  score: Schema.Number, // 0-1\n  calibrated: Schema.Boolean,\n  layerScores: Schema.Record({ key: Schema.String, value: Schema.Number }),\n});\nexport type ConfidenceScore = typeof ConfidenceScoreSchema.Type;\n\n// ─── Claim ───\n\nexport const ClaimSchema = Schema.Struct({\n  text: Schema.String,\n  confidence: Schema.Number,\n  source: Schema.optional(Schema.String),\n});\nexport type Claim = typeof ClaimSchema.Type;\n\n// ─── Verification Layer Result ───\n\nexport const LayerResultSchema = Schema.Struct({\n  layerName: Schema.String,\n  score: Schema.Number, // 0-1\n  passed: Schema.Boolean,\n  details: Schema.optional(Schema.String),\n  claims: Schema.optional(Schema.Array(ClaimSchema)),\n});\nexport type LayerResult = typeof LayerResultSchema.Type;\n\n// ─── Verification Result ───\n\nexport const VerificationResultSchema = Schema.Struct({\n  overallScore: Schema.Number, // 0-1\n  passed: Schema.Boolean,\n  riskLevel: RiskLevel,\n  layerResults: Schema.Array(LayerResultSchema),\n  recommendation: Schema.Literal(\"accept\", \"review\", \"reject\"),\n  verifiedAt: Schema.DateFromSelf,\n});\nexport type VerificationResult = typeof VerificationResultSchema.Type;\n\n// ─── Verification Config ───\n\nexport const VerificationConfigSchema = Schema.Struct({\n  enableSemanticEntropy: Schema.Boolean,\n  enableFactDecomposition: Schema.Boolean,\n  enableMultiSource: Schema.Boolean,\n  enableSelfConsistency: Schema.Boolean,\n  enableNli: Schema.Boolean,\n  passThreshold: Schema.Number, // Default: 0.7\n  riskThreshold: Schema.Number, // Default: 0.5\n});\nexport type VerificationConfig = typeof VerificationConfigSchema.Type;\n\nexport const defaultVerificationConfig: VerificationConfig = {\n  enableSemanticEntropy: true,\n  enableFactDecomposition: true,\n  enableMultiSource: false, // placeholder in Tier 1\n  enableSelfConsistency: true,\n  enableNli: true,\n  passThreshold: 0.7,\n  riskThreshold: 0.5,\n};\n","import { Data } from \"effect\";\n\nexport class VerificationError extends Data.TaggedError(\"VerificationError\")<{\n  readonly message: string;\n  readonly layer?: string;\n  readonly cause?: unknown;\n}> {}\n\nexport class CalibrationError extends Data.TaggedError(\"CalibrationError\")<{\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n","import { Effect } from \"effect\";\nimport type { LayerResult } from \"../types.js\";\n\n/**\n * Semantic Entropy Layer (Tier 1: Heuristic)\n *\n * Measures uncertainty by analyzing word diversity and specificity.\n * Higher entropy = more vague = lower confidence.\n */\nexport const checkSemanticEntropy = (\n  text: string,\n  _context?: string,\n): Effect.Effect<LayerResult, never> =>\n  Effect.sync(() => {\n    const words = text.toLowerCase().split(/\\s+/).filter((w) => w.length > 2);\n    const unique = new Set(words);\n    const diversity = words.length > 0 ? unique.size / words.length : 0;\n\n    // Hedging phrases indicate uncertainty\n    const hedges = [\n      \"might\", \"could\", \"perhaps\", \"possibly\", \"maybe\",\n      \"i think\", \"i believe\", \"it seems\", \"probably\", \"likely\",\n      \"not sure\", \"uncertain\", \"approximately\", \"roughly\",\n    ];\n    const hedgeCount = hedges.filter((h) => text.toLowerCase().includes(h)).length;\n    const hedgePenalty = Math.min(0.3, hedgeCount * 0.1);\n\n    // Very short responses are suspicious\n    const lengthBonus = Math.min(0.1, words.length / 100);\n\n    const score = Math.max(0, Math.min(1, diversity + lengthBonus - hedgePenalty));\n\n    return {\n      layerName: \"semantic-entropy\",\n      score,\n      passed: score >= 0.5,\n      details: `Diversity: ${diversity.toFixed(2)}, Hedges: ${hedgeCount}, Score: ${score.toFixed(2)}`,\n    } satisfies LayerResult;\n  });\n","import { Effect } from \"effect\";\nimport type { LayerResult, Claim } from \"../types.js\";\n\n/**\n * Fact Decomposition Layer (Tier 1: Heuristic)\n *\n * Splits response into atomic claims and scores each based on specificity.\n * Claims with dates, numbers, and proper nouns are more verifiable (higher confidence).\n */\nexport const checkFactDecomposition = (\n  text: string,\n): Effect.Effect<LayerResult, never> =>\n  Effect.sync(() => {\n    // Split into sentences\n    const sentences = text\n      .split(/[.!?]+/)\n      .map((s) => s.trim())\n      .filter((s) => s.length > 10);\n\n    if (sentences.length === 0) {\n      return {\n        layerName: \"fact-decomposition\",\n        score: 0.5,\n        passed: true,\n        details: \"No verifiable claims found\",\n        claims: [],\n      };\n    }\n\n    const claims: Claim[] = sentences.map((sentence) => {\n      let confidence = 0.5; // baseline\n\n      // Numbers increase specificity\n      if (/\\d+/.test(sentence)) confidence += 0.15;\n\n      // Proper nouns (capitalized words) increase specificity\n      const properNouns = sentence.match(/\\b[A-Z][a-z]+\\b/g) ?? [];\n      confidence += Math.min(0.15, properNouns.length * 0.05);\n\n      // Dates increase specificity\n      if (/\\d{4}|\\b(January|February|March|April|May|June|July|August|September|October|November|December)\\b/i.test(sentence)) {\n        confidence += 0.1;\n      }\n\n      // Weasel words decrease confidence\n      if (/\\b(some|many|often|generally|usually)\\b/i.test(sentence)) {\n        confidence -= 0.1;\n      }\n\n      return {\n        text: sentence,\n        confidence: Math.max(0, Math.min(1, confidence)),\n      };\n    });\n\n    const avgConfidence = claims.reduce((sum, c) => sum + c.confidence, 0) / claims.length;\n\n    return {\n      layerName: \"fact-decomposition\",\n      score: avgConfidence,\n      passed: avgConfidence >= 0.5,\n      details: `${claims.length} claims, avg confidence: ${avgConfidence.toFixed(2)}`,\n      claims,\n    } satisfies LayerResult;\n  });\n","import { Effect } from \"effect\";\nimport type { LayerResult } from \"../types.js\";\n\n/**\n * Multi-Source Layer (Tier 1: Placeholder)\n *\n * In Tier 2, this cross-references claims against multiple sources.\n * In Tier 1, returns moderate confidence as a placeholder.\n */\nexport const checkMultiSource = (\n  _text: string,\n): Effect.Effect<LayerResult, never> =>\n  Effect.succeed({\n    layerName: \"multi-source\",\n    score: 0.6,\n    passed: true,\n    details: \"Tier 1 placeholder — multi-source verification requires Tier 2\",\n  });\n","import { Effect } from \"effect\";\nimport type { LayerResult } from \"../types.js\";\n\n/**\n * Self-Consistency Layer (Tier 1: Heuristic)\n *\n * Checks for internal contradictions within the response.\n * Looks for negation patterns and conflicting statements.\n */\nexport const checkSelfConsistency = (\n  text: string,\n): Effect.Effect<LayerResult, never> =>\n  Effect.sync(() => {\n    const sentences = text\n      .split(/[.!?]+/)\n      .map((s) => s.trim().toLowerCase())\n      .filter((s) => s.length > 10);\n\n    if (sentences.length < 2) {\n      return {\n        layerName: \"self-consistency\",\n        score: 0.8,\n        passed: true,\n        details: \"Too few sentences to check consistency\",\n      };\n    }\n\n    let contradictions = 0;\n\n    // Check for direct negation patterns\n    const negationPairs = [\n      [/\\bis\\b/, /\\bis not\\b/],\n      [/\\bcan\\b/, /\\bcannot\\b/],\n      [/\\bwill\\b/, /\\bwill not\\b/],\n      [/\\btrue\\b/, /\\bfalse\\b/],\n      [/\\balways\\b/, /\\bnever\\b/],\n      [/\\beveryone\\b/, /\\bno one\\b/],\n    ] as const;\n\n    for (let i = 0; i < sentences.length; i++) {\n      for (let j = i + 1; j < sentences.length; j++) {\n        for (const [pos, neg] of negationPairs) {\n          if (\n            (pos.test(sentences[i]!) && neg.test(sentences[j]!)) ||\n            (neg.test(sentences[i]!) && pos.test(sentences[j]!))\n          ) {\n            // Check if about same subject (share >50% words)\n            const wordsI = new Set(sentences[i]!.split(/\\s+/));\n            const wordsJ = new Set(sentences[j]!.split(/\\s+/));\n            const overlap = [...wordsI].filter((w) => wordsJ.has(w)).length;\n            const similarity = overlap / Math.max(wordsI.size, wordsJ.size);\n            if (similarity > 0.3) contradictions++;\n          }\n        }\n      }\n    }\n\n    const score = Math.max(0, 1 - contradictions * 0.3);\n\n    return {\n      layerName: \"self-consistency\",\n      score,\n      passed: score >= 0.5,\n      details: `${contradictions} potential contradiction(s) found`,\n    } satisfies LayerResult;\n  });\n","import { Effect } from \"effect\";\nimport type { LayerResult } from \"../types.js\";\n\n/**\n * Natural Language Inference Layer (Tier 1: Heuristic)\n *\n * Checks if the response logically follows from the input.\n * Uses keyword overlap and relevance heuristics.\n */\nexport const checkNli = (\n  response: string,\n  input: string,\n): Effect.Effect<LayerResult, never> =>\n  Effect.sync(() => {\n    const inputWords = new Set(\n      input.toLowerCase().split(/\\s+/).filter((w) => w.length > 3),\n    );\n    const responseWords = response.toLowerCase().split(/\\s+/).filter((w) => w.length > 3);\n\n    if (inputWords.size === 0 || responseWords.length === 0) {\n      return {\n        layerName: \"nli\",\n        score: 0.5,\n        passed: true,\n        details: \"Insufficient text for NLI check\",\n      };\n    }\n\n    // Relevance: what fraction of response words relate to input\n    const relevantCount = responseWords.filter((w) => inputWords.has(w)).length;\n    const relevance = relevantCount / responseWords.length;\n\n    // Topicality: does the response stay on topic?\n    const topicScore = Math.min(1, relevance * 3); // scale up — even 33% overlap is good\n\n    // Off-topic penalty\n    const offTopicPhrases = [\n      \"as an ai\", \"i cannot\", \"i'm unable\", \"i don't have\",\n      \"i apologize\", \"sorry, but\",\n    ];\n    const offTopicCount = offTopicPhrases.filter((p) =>\n      response.toLowerCase().includes(p),\n    ).length;\n    const offTopicPenalty = offTopicCount * 0.1;\n\n    const score = Math.max(0, Math.min(1, topicScore - offTopicPenalty + 0.3));\n\n    return {\n      layerName: \"nli\",\n      score,\n      passed: score >= 0.5,\n      details: `Relevance: ${relevance.toFixed(2)}, Topic score: ${topicScore.toFixed(2)}, Off-topic penalty: ${offTopicPenalty.toFixed(2)}`,\n    } satisfies LayerResult;\n  });\n","import { Effect, Context, Layer } from \"effect\";\nimport type { VerificationResult, VerificationConfig, LayerResult, RiskLevel } from \"./types.js\";\nimport { VerificationError } from \"./errors.js\";\nimport { checkSemanticEntropy } from \"./layers/semantic-entropy.js\";\nimport { checkFactDecomposition } from \"./layers/fact-decomposition.js\";\nimport { checkMultiSource } from \"./layers/multi-source.js\";\nimport { checkSelfConsistency } from \"./layers/self-consistency.js\";\nimport { checkNli } from \"./layers/nli.js\";\n\n// ─── Service Tag ───\n\nexport class VerificationService extends Context.Tag(\"VerificationService\")<\n  VerificationService,\n  {\n    /** Verify a response against an input query. */\n    readonly verify: (\n      response: string,\n      input: string,\n    ) => Effect.Effect<VerificationResult, VerificationError>;\n\n    /** Get current verification config. */\n    readonly getConfig: () => Effect.Effect<VerificationConfig, never>;\n  }\n>() {}\n\n// ─── Live Implementation ───\n\nexport const VerificationServiceLive = (config: VerificationConfig) =>\n  Layer.succeed(VerificationService, {\n    verify: (response, input) =>\n      Effect.gen(function* () {\n        const layerResults: LayerResult[] = [];\n\n        if (config.enableSemanticEntropy) {\n          layerResults.push(yield* checkSemanticEntropy(response, input));\n        }\n\n        if (config.enableFactDecomposition) {\n          layerResults.push(yield* checkFactDecomposition(response));\n        }\n\n        if (config.enableMultiSource) {\n          layerResults.push(yield* checkMultiSource(response));\n        }\n\n        if (config.enableSelfConsistency) {\n          layerResults.push(yield* checkSelfConsistency(response));\n        }\n\n        if (config.enableNli) {\n          layerResults.push(yield* checkNli(response, input));\n        }\n\n        // Weighted average of layer scores\n        const overallScore =\n          layerResults.length > 0\n            ? layerResults.reduce((sum, r) => sum + r.score, 0) / layerResults.length\n            : 0.5;\n\n        const riskLevel: RiskLevel =\n          overallScore >= 0.8 ? \"low\" :\n          overallScore >= 0.6 ? \"medium\" :\n          overallScore >= 0.4 ? \"high\" : \"critical\";\n\n        const recommendation =\n          overallScore >= config.passThreshold ? \"accept\" as const :\n          overallScore >= config.riskThreshold ? \"review\" as const :\n          \"reject\" as const;\n\n        return {\n          overallScore,\n          passed: overallScore >= config.passThreshold,\n          riskLevel,\n          layerResults: [...layerResults],\n          recommendation,\n          verifiedAt: new Date(),\n        } satisfies VerificationResult;\n      }),\n\n    getConfig: () => Effect.succeed(config),\n  });\n","import type { VerificationConfig } from \"./types.js\";\nimport { defaultVerificationConfig } from \"./types.js\";\nimport { VerificationServiceLive } from \"./verification-service.js\";\n\nexport const createVerificationLayer = (config?: Partial<VerificationConfig>) =>\n  VerificationServiceLive({\n    ...defaultVerificationConfig,\n    ...config,\n  });\n"],"mappings":";AAAA,SAAS,cAAc;AAIhB,IAAM,YAAY,OAAO,QAAQ,OAAO,UAAU,QAAQ,UAAU;AAKpE,IAAM,wBAAwB,OAAO,OAAO;AAAA,EACjD,OAAO,OAAO;AAAA;AAAA,EACd,YAAY,OAAO;AAAA,EACnB,aAAa,OAAO,OAAO,EAAE,KAAK,OAAO,QAAQ,OAAO,OAAO,OAAO,CAAC;AACzE,CAAC;AAKM,IAAM,cAAc,OAAO,OAAO;AAAA,EACvC,MAAM,OAAO;AAAA,EACb,YAAY,OAAO;AAAA,EACnB,QAAQ,OAAO,SAAS,OAAO,MAAM;AACvC,CAAC;AAKM,IAAM,oBAAoB,OAAO,OAAO;AAAA,EAC7C,WAAW,OAAO;AAAA,EAClB,OAAO,OAAO;AAAA;AAAA,EACd,QAAQ,OAAO;AAAA,EACf,SAAS,OAAO,SAAS,OAAO,MAAM;AAAA,EACtC,QAAQ,OAAO,SAAS,OAAO,MAAM,WAAW,CAAC;AACnD,CAAC;AAKM,IAAM,2BAA2B,OAAO,OAAO;AAAA,EACpD,cAAc,OAAO;AAAA;AAAA,EACrB,QAAQ,OAAO;AAAA,EACf,WAAW;AAAA,EACX,cAAc,OAAO,MAAM,iBAAiB;AAAA,EAC5C,gBAAgB,OAAO,QAAQ,UAAU,UAAU,QAAQ;AAAA,EAC3D,YAAY,OAAO;AACrB,CAAC;AAKM,IAAM,2BAA2B,OAAO,OAAO;AAAA,EACpD,uBAAuB,OAAO;AAAA,EAC9B,yBAAyB,OAAO;AAAA,EAChC,mBAAmB,OAAO;AAAA,EAC1B,uBAAuB,OAAO;AAAA,EAC9B,WAAW,OAAO;AAAA,EAClB,eAAe,OAAO;AAAA;AAAA,EACtB,eAAe,OAAO;AAAA;AACxB,CAAC;AAGM,IAAM,4BAAgD;AAAA,EAC3D,uBAAuB;AAAA,EACvB,yBAAyB;AAAA,EACzB,mBAAmB;AAAA;AAAA,EACnB,uBAAuB;AAAA,EACvB,WAAW;AAAA,EACX,eAAe;AAAA,EACf,eAAe;AACjB;;;ACrEA,SAAS,YAAY;AAEd,IAAM,oBAAN,cAAgC,KAAK,YAAY,mBAAmB,EAIxE;AAAC;AAEG,IAAM,mBAAN,cAA+B,KAAK,YAAY,kBAAkB,EAGtE;AAAC;;;ACXJ,SAAS,cAAc;AAShB,IAAM,uBAAuB,CAClC,MACA,aAEA,OAAO,KAAK,MAAM;AAChB,QAAM,QAAQ,KAAK,YAAY,EAAE,MAAM,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC;AACxE,QAAM,SAAS,IAAI,IAAI,KAAK;AAC5B,QAAM,YAAY,MAAM,SAAS,IAAI,OAAO,OAAO,MAAM,SAAS;AAGlE,QAAM,SAAS;AAAA,IACb;AAAA,IAAS;AAAA,IAAS;AAAA,IAAW;AAAA,IAAY;AAAA,IACzC;AAAA,IAAW;AAAA,IAAa;AAAA,IAAY;AAAA,IAAY;AAAA,IAChD;AAAA,IAAY;AAAA,IAAa;AAAA,IAAiB;AAAA,EAC5C;AACA,QAAM,aAAa,OAAO,OAAO,CAAC,MAAM,KAAK,YAAY,EAAE,SAAS,CAAC,CAAC,EAAE;AACxE,QAAM,eAAe,KAAK,IAAI,KAAK,aAAa,GAAG;AAGnD,QAAM,cAAc,KAAK,IAAI,KAAK,MAAM,SAAS,GAAG;AAEpD,QAAM,QAAQ,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,YAAY,cAAc,YAAY,CAAC;AAE7E,SAAO;AAAA,IACL,WAAW;AAAA,IACX;AAAA,IACA,QAAQ,SAAS;AAAA,IACjB,SAAS,cAAc,UAAU,QAAQ,CAAC,CAAC,aAAa,UAAU,YAAY,MAAM,QAAQ,CAAC,CAAC;AAAA,EAChG;AACF,CAAC;;;ACtCH,SAAS,UAAAA,eAAc;AAShB,IAAM,yBAAyB,CACpC,SAEAA,QAAO,KAAK,MAAM;AAEhB,QAAM,YAAY,KACf,MAAM,QAAQ,EACd,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,EACnB,OAAO,CAAC,MAAM,EAAE,SAAS,EAAE;AAE9B,MAAI,UAAU,WAAW,GAAG;AAC1B,WAAO;AAAA,MACL,WAAW;AAAA,MACX,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,SAAS;AAAA,MACT,QAAQ,CAAC;AAAA,IACX;AAAA,EACF;AAEA,QAAM,SAAkB,UAAU,IAAI,CAAC,aAAa;AAClD,QAAI,aAAa;AAGjB,QAAI,MAAM,KAAK,QAAQ,EAAG,eAAc;AAGxC,UAAM,cAAc,SAAS,MAAM,kBAAkB,KAAK,CAAC;AAC3D,kBAAc,KAAK,IAAI,MAAM,YAAY,SAAS,IAAI;AAGtD,QAAI,qGAAqG,KAAK,QAAQ,GAAG;AACvH,oBAAc;AAAA,IAChB;AAGA,QAAI,2CAA2C,KAAK,QAAQ,GAAG;AAC7D,oBAAc;AAAA,IAChB;AAEA,WAAO;AAAA,MACL,MAAM;AAAA,MACN,YAAY,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,UAAU,CAAC;AAAA,IACjD;AAAA,EACF,CAAC;AAED,QAAM,gBAAgB,OAAO,OAAO,CAAC,KAAK,MAAM,MAAM,EAAE,YAAY,CAAC,IAAI,OAAO;AAEhF,SAAO;AAAA,IACL,WAAW;AAAA,IACX,OAAO;AAAA,IACP,QAAQ,iBAAiB;AAAA,IACzB,SAAS,GAAG,OAAO,MAAM,4BAA4B,cAAc,QAAQ,CAAC,CAAC;AAAA,IAC7E;AAAA,EACF;AACF,CAAC;;;AChEH,SAAS,UAAAC,eAAc;AAShB,IAAM,mBAAmB,CAC9B,UAEAA,QAAO,QAAQ;AAAA,EACb,WAAW;AAAA,EACX,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,SAAS;AACX,CAAC;;;ACjBH,SAAS,UAAAC,eAAc;AAShB,IAAM,uBAAuB,CAClC,SAEAA,QAAO,KAAK,MAAM;AAChB,QAAM,YAAY,KACf,MAAM,QAAQ,EACd,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,YAAY,CAAC,EACjC,OAAO,CAAC,MAAM,EAAE,SAAS,EAAE;AAE9B,MAAI,UAAU,SAAS,GAAG;AACxB,WAAO;AAAA,MACL,WAAW;AAAA,MACX,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,SAAS;AAAA,IACX;AAAA,EACF;AAEA,MAAI,iBAAiB;AAGrB,QAAM,gBAAgB;AAAA,IACpB,CAAC,UAAU,YAAY;AAAA,IACvB,CAAC,WAAW,YAAY;AAAA,IACxB,CAAC,YAAY,cAAc;AAAA,IAC3B,CAAC,YAAY,WAAW;AAAA,IACxB,CAAC,cAAc,WAAW;AAAA,IAC1B,CAAC,gBAAgB,YAAY;AAAA,EAC/B;AAEA,WAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACzC,aAAS,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AAC7C,iBAAW,CAAC,KAAK,GAAG,KAAK,eAAe;AACtC,YACG,IAAI,KAAK,UAAU,CAAC,CAAE,KAAK,IAAI,KAAK,UAAU,CAAC,CAAE,KACjD,IAAI,KAAK,UAAU,CAAC,CAAE,KAAK,IAAI,KAAK,UAAU,CAAC,CAAE,GAClD;AAEA,gBAAM,SAAS,IAAI,IAAI,UAAU,CAAC,EAAG,MAAM,KAAK,CAAC;AACjD,gBAAM,SAAS,IAAI,IAAI,UAAU,CAAC,EAAG,MAAM,KAAK,CAAC;AACjD,gBAAM,UAAU,CAAC,GAAG,MAAM,EAAE,OAAO,CAAC,MAAM,OAAO,IAAI,CAAC,CAAC,EAAE;AACzD,gBAAM,aAAa,UAAU,KAAK,IAAI,OAAO,MAAM,OAAO,IAAI;AAC9D,cAAI,aAAa,IAAK;AAAA,QACxB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,QAAQ,KAAK,IAAI,GAAG,IAAI,iBAAiB,GAAG;AAElD,SAAO;AAAA,IACL,WAAW;AAAA,IACX;AAAA,IACA,QAAQ,SAAS;AAAA,IACjB,SAAS,GAAG,cAAc;AAAA,EAC5B;AACF,CAAC;;;ACjEH,SAAS,UAAAC,eAAc;AAShB,IAAM,WAAW,CACtB,UACA,UAEAA,QAAO,KAAK,MAAM;AAChB,QAAM,aAAa,IAAI;AAAA,IACrB,MAAM,YAAY,EAAE,MAAM,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC;AAAA,EAC7D;AACA,QAAM,gBAAgB,SAAS,YAAY,EAAE,MAAM,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC;AAEpF,MAAI,WAAW,SAAS,KAAK,cAAc,WAAW,GAAG;AACvD,WAAO;AAAA,MACL,WAAW;AAAA,MACX,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,SAAS;AAAA,IACX;AAAA,EACF;AAGA,QAAM,gBAAgB,cAAc,OAAO,CAAC,MAAM,WAAW,IAAI,CAAC,CAAC,EAAE;AACrE,QAAM,YAAY,gBAAgB,cAAc;AAGhD,QAAM,aAAa,KAAK,IAAI,GAAG,YAAY,CAAC;AAG5C,QAAM,kBAAkB;AAAA,IACtB;AAAA,IAAY;AAAA,IAAY;AAAA,IAAc;AAAA,IACtC;AAAA,IAAe;AAAA,EACjB;AACA,QAAM,gBAAgB,gBAAgB;AAAA,IAAO,CAAC,MAC5C,SAAS,YAAY,EAAE,SAAS,CAAC;AAAA,EACnC,EAAE;AACF,QAAM,kBAAkB,gBAAgB;AAExC,QAAM,QAAQ,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,aAAa,kBAAkB,GAAG,CAAC;AAEzE,SAAO;AAAA,IACL,WAAW;AAAA,IACX;AAAA,IACA,QAAQ,SAAS;AAAA,IACjB,SAAS,cAAc,UAAU,QAAQ,CAAC,CAAC,kBAAkB,WAAW,QAAQ,CAAC,CAAC,wBAAwB,gBAAgB,QAAQ,CAAC,CAAC;AAAA,EACtI;AACF,CAAC;;;ACrDH,SAAS,UAAAC,SAAQ,SAAS,aAAa;AAWhC,IAAM,sBAAN,cAAkC,QAAQ,IAAI,qBAAqB,EAYxE,EAAE;AAAC;AAIE,IAAM,0BAA0B,CAAC,WACtC,MAAM,QAAQ,qBAAqB;AAAA,EACjC,QAAQ,CAAC,UAAU,UACjBC,QAAO,IAAI,aAAa;AACtB,UAAM,eAA8B,CAAC;AAErC,QAAI,OAAO,uBAAuB;AAChC,mBAAa,KAAK,OAAO,qBAAqB,UAAU,KAAK,CAAC;AAAA,IAChE;AAEA,QAAI,OAAO,yBAAyB;AAClC,mBAAa,KAAK,OAAO,uBAAuB,QAAQ,CAAC;AAAA,IAC3D;AAEA,QAAI,OAAO,mBAAmB;AAC5B,mBAAa,KAAK,OAAO,iBAAiB,QAAQ,CAAC;AAAA,IACrD;AAEA,QAAI,OAAO,uBAAuB;AAChC,mBAAa,KAAK,OAAO,qBAAqB,QAAQ,CAAC;AAAA,IACzD;AAEA,QAAI,OAAO,WAAW;AACpB,mBAAa,KAAK,OAAO,SAAS,UAAU,KAAK,CAAC;AAAA,IACpD;AAGA,UAAM,eACJ,aAAa,SAAS,IAClB,aAAa,OAAO,CAAC,KAAK,MAAM,MAAM,EAAE,OAAO,CAAC,IAAI,aAAa,SACjE;AAEN,UAAM,YACJ,gBAAgB,MAAM,QACtB,gBAAgB,MAAM,WACtB,gBAAgB,MAAM,SAAS;AAEjC,UAAM,iBACJ,gBAAgB,OAAO,gBAAgB,WACvC,gBAAgB,OAAO,gBAAgB,WACvC;AAEF,WAAO;AAAA,MACL;AAAA,MACA,QAAQ,gBAAgB,OAAO;AAAA,MAC/B;AAAA,MACA,cAAc,CAAC,GAAG,YAAY;AAAA,MAC9B;AAAA,MACA,YAAY,oBAAI,KAAK;AAAA,IACvB;AAAA,EACF,CAAC;AAAA,EAEH,WAAW,MAAMA,QAAO,QAAQ,MAAM;AACxC,CAAC;;;AC5EI,IAAM,0BAA0B,CAAC,WACtC,wBAAwB;AAAA,EACtB,GAAG;AAAA,EACH,GAAG;AACL,CAAC;","names":["Effect","Effect","Effect","Effect","Effect","Effect"]}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@reactive-agents/verification",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsup --config ../../tsup.config.base.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "test:watch": "bun test --watch"
+  },
+  "dependencies": {
+    "effect": "^3.10.0",
+    "@reactive-agents/core": "0.1.0",
+    "@reactive-agents/llm-provider": "0.1.0",
+    "@reactive-agents/memory": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "bun-types": "latest"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts.git",
+    "directory": "packages/verification"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "description": "Output verification for Reactive Agents — semantic entropy and fact decomposition",
+  "homepage": "https://tylerjrbuell.github.io/reactive-agents-ts/",
+  "bugs": {
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts/issues"
+  }
+}