@restormel/reasoning-core 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog — @restormel/reasoning-core
+
+## 0.1.0 — 2026-06-01
+
+- Initial extraction from SOPHIA Verify pipeline (Phase 3 suite migration).
+- `extractClaims`, `evaluateReasoning`, constitution evaluator + rules.
+- `runVerificationPipeline` with host-injected `ReasoningCoreContext` and optional `runPassOutputs` hook.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adam Boon
+
+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,54 @@
+# @restormel/reasoning-core
+
+Knowledge **Verify** pipeline — claim extraction, reasoning quality evaluation, and epistemic constitution checks. Host apps inject LLM routing and `generateText` via **`ReasoningCoreContext`** (no SOPHIA vertex, DB, or engine imports).
+
+## Install
+
+```bash
+npm install @restormel/reasoning-core @restormel/contracts
+```
+
+Peer: `ai` (Vercel AI SDK) when wiring real models in the host adapter.
+
+## Usage
+
+```ts
+import {
+  runVerificationPipeline,
+  type ReasoningCoreContext,
+} from "@restormel/reasoning-core";
+
+const ctx: ReasoningCoreContext = {
+  generateText: (params) => hostGenerateText(params),
+  resolveExtractionRoute: (opts) => hostResolveExtraction(opts),
+  resolveReasoningRoute: (opts) => hostResolveReasoning(opts),
+  trackTokens: (input, output) => hostTrackTokens(input, output),
+};
+
+const result = await runVerificationPipeline(
+  { text: "Argument to verify…" },
+  {
+    ctx,
+    includePassOutputs: false,
+  }
+);
+```
+
+When `includePassOutputs` is true, pass a host hook (e.g. SOPHIA `runDomainAgnosticReasoning`):
+
+```ts
+await runVerificationPipeline(request, {
+  ctx,
+  runPassOutputs: (inputText, callbacks, opts) =>
+    runDomainAgnosticReasoning(inputText, callbacks, opts),
+});
+```
+
+## Publish
+
+Tag **`platform-v*`** in the restormel-keys monorepo — see [docs/restormel/SUITE-ARCHITECTURE-MIGRATION.md](../../docs/restormel/SUITE-ARCHITECTURE-MIGRATION.md) Phase 3.
+
+## Related
+
+- Types/schemas: `@restormel/contracts/verification`, `@restormel/contracts/constitution`
+- SOPHIA consumer adapter: `src/lib/server/verification/sophiaAdapter.ts` in the sophia repo

package/dist/constitution/evaluator.d.ts

@@ -0,0 +1,30 @@
+import type { ConstitutionalCheck, RuleEvaluation } from "@restormel/contracts/constitution";
+import type { ExtractedClaim, ExtractedRelation } from "@restormel/contracts/verification";
+import type { ReasoningCoreContext } from "../context.js";
+export interface ConstitutionEvaluationTelemetry {
+    constitution_input_tokens: number;
+    constitution_output_tokens: number;
+    constitution_llm_called: boolean;
+    constitution_llm_failed: boolean;
+    constitution_rule_violations: string[];
+    constitution_provider?: string;
+    constitution_model?: string;
+    constitution_route_reason?: string | null;
+}
+export interface ConstitutionEvaluationResult {
+    check: ConstitutionalCheck;
+    telemetry: ConstitutionEvaluationTelemetry;
+}
+export declare function checkEvidenceRequirement(claims: ExtractedClaim[], relations: ExtractedRelation[]): RuleEvaluation;
+export declare function checkContradictionAwareness(claims: ExtractedClaim[], relations: ExtractedRelation[]): RuleEvaluation;
+export declare function checkScopeDiscipline(claims: ExtractedClaim[], relations: ExtractedRelation[]): RuleEvaluation;
+export declare function checkCorrelationVsCausation(claims: ExtractedClaim[], relations: ExtractedRelation[]): RuleEvaluation;
+export declare function checkNormativeBridge(claims: ExtractedClaim[], relations: ExtractedRelation[]): RuleEvaluation;
+export declare function checkSourceDiversity(claims: ExtractedClaim[], relations: ExtractedRelation[]): RuleEvaluation;
+export declare function evaluateConstitution(claims: ExtractedClaim[], relations: ExtractedRelation[], originalText: string, ctx: ReasoningCoreContext, options?: {
+    providerApiKeys?: unknown;
+}): Promise<ConstitutionalCheck>;
+export declare function evaluateConstitutionWithTelemetry(claims: ExtractedClaim[], relations: ExtractedRelation[], originalText: string, ctx: ReasoningCoreContext, options?: {
+    providerApiKeys?: unknown;
+}): Promise<ConstitutionEvaluationResult>;
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/constitution/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../src/constitution/evaluator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAa,mBAAmB,EAAoB,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAE1H,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC3F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AA2C1D,MAAM,WAAW,+BAA+B;IAC9C,yBAAyB,EAAE,MAAM,CAAC;IAClC,0BAA0B,EAAE,MAAM,CAAC;IACnC,uBAAuB,EAAE,OAAO,CAAC;IACjC,uBAAuB,EAAE,OAAO,CAAC;IACjC,4BAA4B,EAAE,MAAM,EAAE,CAAC;IACvC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,yBAAyB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3C;AAED,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,mBAAmB,CAAC;IAC3B,SAAS,EAAE,+BAA+B,CAAC;CAC5C;AAgRD,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,cAAc,EAAE,EACxB,SAAS,EAAE,iBAAiB,EAAE,GAC7B,cAAc,CAkChB;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,cAAc,EAAE,EACxB,SAAS,EAAE,iBAAiB,EAAE,GAC7B,cAAc,CAuDhB;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,cAAc,EAAE,EACxB,SAAS,EAAE,iBAAiB,EAAE,GAC7B,cAAc,CAuDhB;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,cAAc,EAAE,EACxB,SAAS,EAAE,iBAAiB,EAAE,GAC7B,cAAc,CAgEhB;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,cAAc,EAAE,EACxB,SAAS,EAAE,iBAAiB,EAAE,GAC7B,cAAc,CAkFhB;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,cAAc,EAAE,EACxB,SAAS,EAAE,iBAAiB,EAAE,GAC7B,cAAc,CA0DhB;AAED,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,cAAc,EAAE,EACxB,SAAS,EAAE,iBAAiB,EAAE,EAC9B,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,oBAAoB,EACzB,OAAO,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GACtC,OAAO,CAAC,mBAAmB,CAAC,CAG9B;AAED,wBAAsB,iCAAiC,CACrD,MAAM,EAAE,cAAc,EAAE,EACxB,SAAS,EAAE,iBAAiB,EAAE,EAC9B,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,oBAAoB,EACzB,OAAO,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GACtC,OAAO,CAAC,4BAA4B,CAAC,CA4BvC"}

package/dist/constitution/evaluator.js

@@ -0,0 +1,444 @@
+import { z } from "zod";
+import { ConstitutionalCheckSchema, RuleEvaluationSchema } from "@restormel/contracts/constitution";
+import { buildConstitutionEvalUserPrompt, CONSTITUTION_EVAL_SYSTEM_PROMPT, } from "../prompts/constitution-eval.js";
+import { EPISTEMIC_RULES } from "./rules.js";
+const RULE_INDEX = new Map(EPISTEMIC_RULES.map((rule) => [rule.id, rule]));
+const LLM_RULE_IDS = new Set([
+    'proportional_evidence',
+    'alternative_hypotheses',
+    'assumption_transparency',
+    'uncertainty_signalling'
+]);
+const ACKNOWLEDGEMENT_RELATIONS = new Set(['qualifies', 'refines']);
+const CAUSAL_MECHANISM_TYPES = new Set(['causal', 'explanatory']);
+const DESCRIPTIVE_TYPES = new Set(['empirical', 'causal', 'predictive', 'explanatory']);
+const SCOPE_RANK = {
+    narrow: 0,
+    moderate: 1,
+    broad: 2,
+    universal: 3
+};
+const LlmRuleEvaluationSchema = z.object({
+    rule_id: z.string().min(1),
+    status: z.enum(['satisfied', 'violated', 'uncertain', 'not_applicable']),
+    affected_claim_ids: z.array(z.string()).default([]),
+    rationale: z.string().min(1),
+    remediation: z.string().min(1).optional()
+});
+function getRule(ruleId) {
+    const rule = RULE_INDEX.get(ruleId);
+    if (!rule) {
+        throw new Error(`Unknown epistemic rule: ${ruleId}`);
+    }
+    return rule;
+}
+function createEvaluation(rule, status, affectedClaimIds, rationale, remediation) {
+    return RuleEvaluationSchema.parse({
+        rule_id: rule.id,
+        rule_name: rule.name,
+        status,
+        severity: rule.severity,
+        affected_claim_ids: [...new Set(affectedClaimIds)],
+        rationale,
+        remediation
+    });
+}
+function claimsById(claims) {
+    return new Map(claims.map((claim) => [claim.id, claim]));
+}
+function incomingSupporters(claimId, relations, byId) {
+    return relations
+        .filter((relation) => relation.relation_type === 'supports' && relation.to_claim_id === claimId)
+        .map((relation) => byId.get(relation.from_claim_id))
+        .filter((claim) => Boolean(claim));
+}
+function hasCitation(claim) {
+    if (claim.source_span?.trim())
+        return true;
+    return typeof claim.source_span_start === 'number' && typeof claim.source_span_end === 'number';
+}
+function sourceKey(claim) {
+    if (claim.source_span?.trim()) {
+        return `span:${claim.source_span.trim().toLowerCase()}`;
+    }
+    if (typeof claim.source_span_start === 'number' && typeof claim.source_span_end === 'number') {
+        return `offset:${claim.source_span_start}-${claim.source_span_end}`;
+    }
+    return 'unknown';
+}
+function extractJsonArray(text) {
+    const trimmed = text.trim();
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        return trimmed;
+    }
+    const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+    if (fencedMatch) {
+        return fencedMatch[1].trim();
+    }
+    const firstBracket = trimmed.indexOf('[');
+    const lastBracket = trimmed.lastIndexOf(']');
+    if (firstBracket !== -1 && lastBracket !== -1 && lastBracket > firstBracket) {
+        return trimmed.slice(firstBracket, lastBracket + 1);
+    }
+    throw new Error('Could not find JSON array in LLM response');
+}
+function parseLlmEvaluations(text) {
+    const raw = JSON.parse(extractJsonArray(text));
+    return z.array(LlmRuleEvaluationSchema).parse(raw);
+}
+function fallbackLlmEvaluations(rules, reason) {
+    return rules.map((rule) => createEvaluation(rule, 'uncertain', [], `LLM constitutional evaluation unavailable: ${reason}`));
+}
+function finalizeEvaluations(allEvaluations) {
+    const ordered = EPISTEMIC_RULES.map((rule) => {
+        return (allEvaluations.find((evaluation) => evaluation.rule_id === rule.id) ??
+            createEvaluation(rule, 'uncertain', [], 'Rule evaluation missing from constitution pipeline.'));
+    });
+    const satisfied = ordered.filter((evaluation) => evaluation.status === 'satisfied');
+    const violated = ordered.filter((evaluation) => evaluation.status === 'violated');
+    const uncertain = ordered.filter((evaluation) => evaluation.status === 'uncertain');
+    const notApplicable = ordered.filter((evaluation) => evaluation.status === 'not_applicable');
+    const criticalViolations = violated.filter((evaluation) => evaluation.severity === 'critical').length;
+    const warningViolations = violated.filter((evaluation) => evaluation.severity === 'warning').length;
+    const overallCompliance = criticalViolations > 0 ? 'fail' : warningViolations > 1 ? 'partial' : 'pass';
+    return ConstitutionalCheckSchema.parse({
+        rules_evaluated: ordered.length,
+        satisfied,
+        violated,
+        uncertain,
+        not_applicable: notApplicable,
+        overall_compliance: overallCompliance
+    });
+}
+function isRuleApplicable(rule, claimType) {
+    return rule.applies_to.includes(claimType);
+}
+function buildDependencyGraph(relations) {
+    const graph = new Map();
+    for (const relation of relations) {
+        if (relation.relation_type !== 'depends_on')
+            continue;
+        const current = graph.get(relation.from_claim_id) ?? [];
+        current.push(relation.to_claim_id);
+        graph.set(relation.from_claim_id, current);
+    }
+    return graph;
+}
+function collectDependencies(rootClaimId, graph) {
+    const visited = new Set([rootClaimId]);
+    const collected = new Set();
+    const queue = [...(graph.get(rootClaimId) ?? [])];
+    while (queue.length > 0) {
+        const next = queue.shift();
+        if (!next)
+            continue;
+        if (visited.has(next))
+            continue;
+        visited.add(next);
+        collected.add(next);
+        const children = graph.get(next);
+        if (!children) {
+            continue;
+        }
+        for (const child of children) {
+            if (!visited.has(child)) {
+                queue.push(child);
+            }
+        }
+    }
+    return [...collected];
+}
+function collectRule2Heuristics(claims, relations) {
+    const rule = getRule('proportional_evidence');
+    const byId = claimsById(claims);
+    return claims
+        .filter((claim) => isRuleApplicable(rule, claim.claim_type))
+        .filter((claim) => claim.scope === 'broad' || claim.scope === 'universal')
+        .filter((claim) => incomingSupporters(claim.id, relations, byId).length < 2)
+        .map((claim) => claim.id);
+}
+async function evaluateLlmRules(claims, relations, originalText, ctx, options) {
+    const llmRules = EPISTEMIC_RULES.filter((rule) => LLM_RULE_IDS.has(rule.id));
+    if (llmRules.length === 0) {
+        return {
+            evaluations: [],
+            inputTokens: 0,
+            outputTokens: 0,
+            llmCalled: false,
+            llmFailed: false
+        };
+    }
+    const heuristics = {
+        proportional_evidence_low_support_claim_ids: collectRule2Heuristics(claims, relations)
+    };
+    const prompt = buildConstitutionEvalUserPrompt(claims, relations, llmRules, originalText, heuristics);
+    const route = await ctx.resolveReasoningRoute({
+        depthMode: "standard",
+        providerApiKeys: options?.providerApiKeys,
+        failureMode: "error",
+    });
+    try {
+        const result = await ctx.generateText({
+            model: route.model,
+            system: CONSTITUTION_EVAL_SYSTEM_PROMPT,
+            prompt,
+            maxOutputTokens: 1400,
+        });
+        ctx.trackTokens?.(result.usage?.inputTokens ?? 0, result.usage?.outputTokens ?? 0);
+        const parsed = parseLlmEvaluations(result.text);
+        const byRuleId = new Map(parsed.map((evaluation) => [evaluation.rule_id, evaluation]));
+        const evaluations = llmRules.map((rule) => {
+            const raw = byRuleId.get(rule.id);
+            if (!raw) {
+                return createEvaluation(rule, 'uncertain', [], 'LLM response omitted this rule from the batch output.');
+            }
+            return createEvaluation(rule, raw.status, raw.affected_claim_ids, raw.rationale, raw.status === 'violated'
+                ? (raw.remediation ?? `Revise claims to satisfy ${rule.name.toLowerCase()}.`)
+                : undefined);
+        });
+        return {
+            evaluations,
+            inputTokens: result.usage?.inputTokens ?? 0,
+            outputTokens: result.usage?.outputTokens ?? 0,
+            llmCalled: true,
+            llmFailed: false,
+            provider: route.provider,
+            modelId: route.modelId,
+            routeReason: route.resolvedExplanation ?? null
+        };
+    }
+    catch (error) {
+        return {
+            evaluations: fallbackLlmEvaluations(llmRules, error instanceof Error ? error.message : String(error)),
+            inputTokens: 0,
+            outputTokens: 0,
+            llmCalled: true,
+            llmFailed: true,
+            provider: route.provider,
+            modelId: route.modelId,
+            routeReason: route.resolvedExplanation ?? null
+        };
+    }
+}
+export function checkEvidenceRequirement(claims, relations) {
+    const rule = getRule('evidence_requirement');
+    const byId = claimsById(claims);
+    const applicableClaims = claims.filter((claim) => isRuleApplicable(rule, claim.claim_type));
+    if (applicableClaims.length === 0) {
+        return createEvaluation(rule, 'not_applicable', [], 'No empirical, causal, or predictive claims were extracted.');
+    }
+    const unsupported = applicableClaims
+        .filter((claim) => incomingSupporters(claim.id, relations, byId).length === 0 && !hasCitation(claim))
+        .map((claim) => claim.id);
+    if (unsupported.length > 0) {
+        return createEvaluation(rule, 'violated', unsupported, 'Some factual claims have neither supporting relations nor citation evidence.', 'Add supporting evidence relations or explicit citation passages for each flagged claim.');
+    }
+    return createEvaluation(rule, 'satisfied', applicableClaims.map((claim) => claim.id), 'All factual claims include support relations or citation evidence.');
+}
+export function checkContradictionAwareness(claims, relations) {
+    const rule = getRule('contradiction_awareness');
+    const byId = claimsById(claims);
+    const contradictions = relations.filter((relation) => {
+        if (relation.relation_type !== 'contradicts')
+            return false;
+        const from = byId.get(relation.from_claim_id);
+        const to = byId.get(relation.to_claim_id);
+        if (!from || !to)
+            return false;
+        return isRuleApplicable(rule, from.claim_type) || isRuleApplicable(rule, to.claim_type);
+    });
+    if (contradictions.length === 0) {
+        return createEvaluation(rule, 'not_applicable', [], 'No contradiction relations were extracted for applicable claim types.');
+    }
+    const unaddressed = contradictions.filter((contradiction) => {
+        return !relations.some((relation) => {
+            if (!ACKNOWLEDGEMENT_RELATIONS.has(relation.relation_type))
+                return false;
+            const sameDirection = relation.from_claim_id === contradiction.from_claim_id &&
+                relation.to_claim_id === contradiction.to_claim_id;
+            const reverseDirection = relation.from_claim_id === contradiction.to_claim_id &&
+                relation.to_claim_id === contradiction.from_claim_id;
+            return sameDirection || reverseDirection;
+        });
+    });
+    if (unaddressed.length > 0) {
+        const affected = unaddressed.flatMap((relation) => [relation.from_claim_id, relation.to_claim_id]);
+        return createEvaluation(rule, 'violated', affected, 'Contradiction relations exist but are not reconciled or qualified in the argument graph.', 'Explicitly address contradictory claims by qualifying, refining, or resolving the tension.');
+    }
+    return createEvaluation(rule, 'satisfied', contradictions.flatMap((relation) => [relation.from_claim_id, relation.to_claim_id]), 'Detected contradictions are explicitly acknowledged through qualifying/refining links.');
+}
+export function checkScopeDiscipline(claims, relations) {
+    const rule = getRule('scope_discipline');
+    const byId = claimsById(claims);
+    const applicableClaims = claims.filter((claim) => isRuleApplicable(rule, claim.claim_type));
+    if (applicableClaims.length === 0) {
+        return createEvaluation(rule, 'not_applicable', [], 'No empirical, causal, or predictive claims were extracted.');
+    }
+    const exceededScope = [];
+    const insufficientSupport = [];
+    for (const claim of applicableClaims) {
+        const supporters = incomingSupporters(claim.id, relations, byId);
+        if (supporters.length === 0) {
+            insufficientSupport.push(claim.id);
+            continue;
+        }
+        const maxSupportScope = Math.max(...supporters.map((supporter) => SCOPE_RANK[supporter.scope]));
+        if (SCOPE_RANK[claim.scope] > maxSupportScope) {
+            exceededScope.push(claim.id);
+        }
+    }
+    if (exceededScope.length > 0) {
+        return createEvaluation(rule, 'violated', exceededScope, 'At least one claim has broader scope than its supporting evidence.', 'Narrow the scope of flagged claims or add broader evidence before making universal statements.');
+    }
+    if (insufficientSupport.length > 0) {
+        return createEvaluation(rule, 'uncertain', insufficientSupport, 'Some claims lack enough support to determine whether scope is disciplined.');
+    }
+    return createEvaluation(rule, 'satisfied', applicableClaims.map((claim) => claim.id), 'Claim scope is consistent with the scope of supporting evidence.');
+}
+export function checkCorrelationVsCausation(claims, relations) {
+    const rule = getRule('correlation_vs_causation');
+    const byId = claimsById(claims);
+    const causalClaims = claims.filter((claim) => isRuleApplicable(rule, claim.claim_type));
+    if (causalClaims.length === 0) {
+        return createEvaluation(rule, 'not_applicable', [], 'No causal claims were extracted.');
+    }
+    const violated = [];
+    const insufficient = [];
+    for (const claim of causalClaims) {
+        const supporters = incomingSupporters(claim.id, relations, byId);
+        if (supporters.length === 0) {
+            insufficient.push(claim.id);
+            continue;
+        }
+        const allSupportersEmpirical = supporters.every((supporter) => supporter.claim_type === 'empirical');
+        const hasMechanismSupport = relations.some((relation) => {
+            if (relation.to_claim_id !== claim.id)
+                return false;
+            if (relation.relation_type === 'contradicts')
+                return false;
+            const source = byId.get(relation.from_claim_id);
+            if (!source)
+                return false;
+            return CAUSAL_MECHANISM_TYPES.has(source.claim_type);
+        });
+        if (allSupportersEmpirical && !hasMechanismSupport) {
+            violated.push(claim.id);
+        }
+    }
+    if (violated.length > 0) {
+        return createEvaluation(rule, 'violated', violated, 'Some causal claims are supported only by correlational evidence without mechanism claims.', 'Add causal mechanism claims or weaken causal wording to reflect correlational support.');
+    }
+    if (insufficient.length > 0) {
+        return createEvaluation(rule, 'uncertain', insufficient, 'Some causal claims lack enough structured support to assess correlation-vs-causation risk.');
+    }
+    return createEvaluation(rule, 'satisfied', causalClaims.map((claim) => claim.id), 'Causal claims include mechanism-level support or non-correlational evidence.');
+}
+export function checkNormativeBridge(claims, relations) {
+    const rule = getRule('normative_bridge_requirement');
+    const byId = claimsById(claims);
+    const dependencyGraph = buildDependencyGraph(relations);
+    const normativeClaims = claims.filter((claim) => isRuleApplicable(rule, claim.claim_type));
+    if (normativeClaims.length === 0) {
+        return createEvaluation(rule, 'not_applicable', [], 'No normative claims were extracted.');
+    }
+    const violated = [];
+    const uncertain = [];
+    for (const claim of normativeClaims) {
+        const directDependencies = dependencyGraph.get(claim.id) ?? [];
+        if (directDependencies.length === 0) {
+            uncertain.push(claim.id);
+            continue;
+        }
+        const dependencyIds = collectDependencies(claim.id, dependencyGraph);
+        const hasMissingNodes = dependencyIds.some((dependencyId) => !byId.has(dependencyId));
+        const dependencyClaims = dependencyIds
+            .map((dependencyId) => byId.get(dependencyId))
+            .filter((c) => Boolean(c));
+        if (dependencyClaims.length === 0 || hasMissingNodes) {
+            uncertain.push(claim.id);
+            continue;
+        }
+        const hasNormativePremise = dependencyClaims.some((dependencyClaim) => dependencyClaim.claim_type === 'normative');
+        if (hasNormativePremise) {
+            continue;
+        }
+        const onlyDescriptive = dependencyClaims.every((dependencyClaim) => DESCRIPTIVE_TYPES.has(dependencyClaim.claim_type));
+        const hasEmpiricalOrCausal = dependencyClaims.some((dependencyClaim) => dependencyClaim.claim_type === 'empirical' || dependencyClaim.claim_type === 'causal');
+        if (onlyDescriptive && hasEmpiricalOrCausal) {
+            violated.push(claim.id);
+        }
+        else {
+            uncertain.push(claim.id);
+        }
+    }
+    if (violated.length > 0) {
+        return createEvaluation(rule, 'violated', violated, 'Normative conclusions rely on descriptive premises without an explicit normative bridge.', 'Add at least one explicit normative premise linking descriptive evidence to the normative conclusion.');
+    }
+    if (uncertain.length > 0) {
+        return createEvaluation(rule, 'uncertain', uncertain, 'Some normative claims do not expose enough dependency structure to verify a normative bridge.');
+    }
+    return createEvaluation(rule, 'satisfied', normativeClaims.map((claim) => claim.id), 'Normative claims include explicit normative premises in their dependency chains.');
+}
+export function checkSourceDiversity(claims, relations) {
+    const rule = getRule('source_diversity');
+    const byId = claimsById(claims);
+    const targetClaims = claims.filter((claim) => {
+        if (!isRuleApplicable(rule, claim.claim_type))
+            return false;
+        return claim.scope === 'broad' || claim.scope === 'universal';
+    });
+    if (targetClaims.length === 0) {
+        return createEvaluation(rule, 'not_applicable', [], 'No broad or universal empirical/causal/predictive claims were extracted.');
+    }
+    const singleSourceClaims = [];
+    const uncertainClaims = [];
+    for (const claim of targetClaims) {
+        const supporters = incomingSupporters(claim.id, relations, byId);
+        if (supporters.length === 0) {
+            uncertainClaims.push(claim.id);
+            continue;
+        }
+        const uniqueSources = new Set(supporters.map((supporter) => sourceKey(supporter)));
+        if (uniqueSources.size <= 1) {
+            singleSourceClaims.push(claim.id);
+        }
+    }
+    if (singleSourceClaims.length > 0) {
+        return createEvaluation(rule, 'violated', singleSourceClaims, 'Broad claims are supported by only one identifiable source stream.', 'Add independent supporting evidence from multiple distinct sources.');
+    }
+    if (uncertainClaims.length > 0) {
+        return createEvaluation(rule, 'uncertain', uncertainClaims, 'Some broad claims have no support links, so source diversity cannot be measured.');
+    }
+    return createEvaluation(rule, 'satisfied', targetClaims.map((claim) => claim.id), 'Broad claims are supported by multiple distinct source streams.');
+}
+export async function evaluateConstitution(claims, relations, originalText, ctx, options) {
+    const result = await evaluateConstitutionWithTelemetry(claims, relations, originalText, ctx, options);
+    return result.check;
+}
+export async function evaluateConstitutionWithTelemetry(claims, relations, originalText, ctx, options) {
+    const deterministicEvaluations = [
+        checkEvidenceRequirement(claims, relations),
+        checkContradictionAwareness(claims, relations),
+        checkScopeDiscipline(claims, relations),
+        checkCorrelationVsCausation(claims, relations),
+        checkNormativeBridge(claims, relations),
+        checkSourceDiversity(claims, relations)
+    ];
+    const llmBatchResult = await evaluateLlmRules(claims, relations, originalText, ctx, options);
+    const allEvaluations = [...deterministicEvaluations, ...llmBatchResult.evaluations];
+    const check = finalizeEvaluations(allEvaluations);
+    const constitutionRuleViolations = check.violated.map((evaluation) => evaluation.rule_id);
+    return {
+        check,
+        telemetry: {
+            constitution_input_tokens: llmBatchResult.inputTokens,
+            constitution_output_tokens: llmBatchResult.outputTokens,
+            constitution_llm_called: llmBatchResult.llmCalled,
+            constitution_llm_failed: llmBatchResult.llmFailed,
+            constitution_rule_violations: constitutionRuleViolations,
+            constitution_provider: llmBatchResult.provider,
+            constitution_model: llmBatchResult.modelId,
+            constitution_route_reason: llmBatchResult.routeReason ?? null
+        }
+    };
+}

package/dist/constitution/rules.d.ts

@@ -0,0 +1,3 @@
+import type { ConstitutionRule } from "@restormel/contracts/constitution";
+export declare const EPISTEMIC_RULES: ConstitutionRule[];
+//# sourceMappingURL=rules.d.ts.map

package/dist/constitution/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../src/constitution/rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAYrF,eAAO,MAAM,eAAe,EAAE,gBAAgB,EAwF7C,CAAC"}

package/dist/constitution/rules.js

@@ -0,0 +1,91 @@
+const ALL_CLAIM_TYPES = [
+    'empirical',
+    'causal',
+    'explanatory',
+    'normative',
+    'predictive',
+    'definitional',
+    'procedural'
+];
+export const EPISTEMIC_RULES = [
+    {
+        id: 'evidence_requirement',
+        name: 'Evidence Requirement',
+        description: 'A factual or empirical claim must have at least one supporting evidence passage or citation.',
+        applies_to: ['empirical', 'causal', 'predictive'],
+        severity: 'critical',
+        deterministic_check: true
+    },
+    {
+        id: 'proportional_evidence',
+        name: 'Proportional Evidence',
+        description: 'The strength of a claim must be proportional to the quality and amount of evidence.',
+        applies_to: ['empirical', 'causal', 'predictive'],
+        severity: 'warning',
+        deterministic_check: true
+    },
+    {
+        id: 'contradiction_awareness',
+        name: 'Contradiction Awareness',
+        description: 'Reasoning must acknowledge credible contradicting evidence when present.',
+        applies_to: ['empirical', 'causal', 'explanatory', 'normative'],
+        severity: 'critical',
+        deterministic_check: true
+    },
+    {
+        id: 'alternative_hypotheses',
+        name: 'Alternative Hypotheses',
+        description: 'Causal or explanatory claims should consider plausible alternative explanations.',
+        applies_to: ['causal', 'explanatory'],
+        severity: 'warning',
+        deterministic_check: false
+    },
+    {
+        id: 'scope_discipline',
+        name: 'Scope Discipline',
+        description: 'Claims must not exceed the scope of their evidence.',
+        applies_to: ['empirical', 'causal', 'predictive'],
+        severity: 'critical',
+        deterministic_check: true
+    },
+    {
+        id: 'assumption_transparency',
+        name: 'Assumption Transparency',
+        description: 'Key hidden assumptions should be surfaced when they materially affect the conclusion.',
+        applies_to: ALL_CLAIM_TYPES,
+        severity: 'warning',
+        deterministic_check: false
+    },
+    {
+        id: 'correlation_vs_causation',
+        name: 'Correlation vs Causation',
+        description: 'Correlational evidence must not be presented as decisive causal proof.',
+        applies_to: ['causal'],
+        severity: 'critical',
+        deterministic_check: true
+    },
+    {
+        id: 'uncertainty_signalling',
+        name: 'Uncertainty Signalling',
+        description: 'Weak or mixed evidence should be reflected in the synthesis tone.',
+        applies_to: ALL_CLAIM_TYPES,
+        severity: 'warning',
+        deterministic_check: false
+    },
+    {
+        id: 'normative_bridge_requirement',
+        name: 'Normative Bridge Requirement',
+        description: 'Normative conclusions must not follow directly from descriptive facts alone.',
+        applies_to: ['normative'],
+        severity: 'critical',
+        deterministic_check: true
+    },
+    {
+        id: 'source_diversity',
+        name: 'Source Diversity',
+        description: 'Verification should not rely on a single source when broader support is needed.',
+        applies_to: ['empirical', 'causal', 'predictive'],
+        severity: 'info',
+        deterministic_check: true
+    }
+];