@heybeaux/lattice-adapter-parliament 0.2.1 → 0.3.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { TieredCircuitBreakerConfig, TieredCircuitBreaker, ConsensusReducerConfig, StateContract } from '@heybeaux/lattice-core';
+import { TieredCircuitBreakerConfig, TieredCircuitBreaker, ConsensusReducerConfig, EmbeddingProvider, StateContract, PolicyEvidenceRow, TieredValidationResult } from '@heybeaux/lattice-core';
+export { EmbeddingProvider, PolicyEvidenceRow } from '@heybeaux/lattice-core';
 
 /**
  * @heybeaux/lattice-adapter-parliament
@@ -41,6 +42,8 @@ interface ParliamentConfig {
     modelConfigs?: Record<string, ParliamentModelConfig>;
     /** Default model configuration (applied to all models without specific config) */
     defaultModelConfig?: ParliamentModelConfig;
+    /** Embedding provider for semantic consensus comparison */
+    embeddingProvider?: EmbeddingProvider;
 }
 /**
  * Result from wrapping a Parliament deliberation.
@@ -102,14 +105,18 @@ declare class ParliamentCircuitBreaker {
  *
  * Detects disagreements between model responses, computes agreement
  * ratios, and flags conflicts for the synthesizer to resolve.
+ *
+ * When an embeddingProvider is supplied, the consensus fields
+ * (mainPoint, supportingArguments, conclusion) are compared using
+ * cosine similarity (≥0.85 = agreeing) instead of exact string equality.
  */
 declare class ParliamentReducer {
     private reducer;
-    constructor(config?: ConsensusReducerConfig);
+    constructor(config?: ConsensusReducerConfig, embeddingProvider?: EmbeddingProvider);
     /**
      * Reduce multiple model responses into a consensus.
      */
-    reduce(contracts: StateContract[], traceId?: string): {
+    reduce(contracts: StateContract[], traceId?: string): Promise<{
         consensus: unknown;
         conflicts: Array<{
             field: string;
@@ -122,7 +129,7 @@ declare class ParliamentReducer {
         agreementRatio: number;
         consensusReached: boolean;
         reducedContract: StateContract;
-    };
+    }>;
 }
 /**
  * Run a full Parliament deliberation with Lattice coordination.
@@ -134,5 +141,73 @@ declare class ParliamentReducer {
  * @returns ParliamentDeliberationResult
  */
 declare function runParliamentDeliberation(topic: string, models: ParliamentModel[], modelCalls: Map<string, (prompt: string) => Promise<unknown>>, config?: ParliamentConfig): Promise<ParliamentDeliberationResult>;
+/**
+ * Shape of the `governance` block on a SonderEvent envelope. Surfaces the
+ * L0 evidence row trail produced by the Lattice breaker plus the
+ * `+`-joined list of tiers that actually ran.
+ *
+ * - `tier` is `'+'`-joined and includes only tiers that ran (Spec 1 R8).
+ *   Skipped tiers (e.g. L1/L2/L3 after an L0 fail) MUST NOT appear.
+ * - `evidence` carries the full per-rule audit trail from L0. Empty array
+ *   when no policy was bound; absent only when no validation ran at all.
+ * - `policySet` / `policySetVersion` mirror the bound `PolicyRuleSet`.
+ *   Present iff L0 ran; absent otherwise.
+ */
+interface SonderGovernanceBlock {
+    /** `+`-joined list of tiers that actually ran (e.g. `'L0+L1'`). */
+    tier: string;
+    /** Pass/fail/uncertain — derived from the underlying ValidationResult. */
+    verdict: 'pass' | 'fail';
+    /** L0 evidence rows, in rule-set order. Empty array when L0 didn't run. */
+    evidence: PolicyEvidenceRow[];
+    /** PolicyRuleSet.id when L0 ran. */
+    policySet?: string;
+    /** PolicyRuleSet.version when L0 ran. */
+    policySetVersion?: string;
+    /** Optional reject reason — present when verdict === 'fail'. */
+    reason?: string;
+}
+/**
+ * Build the SonderEvent `governance` block from a Lattice contract +
+ * the breaker's {@link TieredValidationResult}. Pulls L0 evidence /
+ * policy identifiers from `contract.metadata.l0` (when present) and
+ * computes the `+`-joined `tier` string from `validation.tiersRun`.
+ *
+ * Spec 1 R8: `tier` lists only tiers that actually ran. Spec 1 R7:
+ * downstream signers consume this block and apply the sign-refusal rule.
+ */
+declare function buildGovernanceBlock(contract: StateContract, validation: TieredValidationResult): SonderGovernanceBlock;
+/**
+ * Error thrown by {@link assertSonderEventSignable} when a SonderEvent
+ * envelope would violate Spec 1 R7's signing invariant. The `code`
+ * field is a stable machine identifier; the message is human-facing.
+ */
+declare class SignRefusedError extends Error {
+    /**
+     * Stable identifier — currently always `'l0-evidence-missing'`,
+     * reserved for future R7 violations.
+     */
+    readonly code: 'l0-evidence-missing';
+    constructor(
+    /**
+     * Stable identifier — currently always `'l0-evidence-missing'`,
+     * reserved for future R7 violations.
+     */
+    code: 'l0-evidence-missing', message?: string);
+}
+/**
+ * Spec 1 R7 — refuse to sign a SonderEvent whose `governance.tier`
+ * mentions any of `L1`, `L2`, `L3` but whose `governance.evidence` is
+ * empty or absent. Sonder's runtime calls this immediately before the
+ * ed25519 signing step; throwing here aborts the signature.
+ *
+ * Why this matters: without L0 evidence the audit trail cannot prove
+ * the deterministic policy tier ran, so cryptographic provenance over
+ * the validation chain would be a lie. Refusing to sign is the
+ * cheapest enforcement boundary in the system.
+ *
+ * @throws {SignRefusedError} when the envelope violates R7.
+ */
+declare function assertSonderEventSignable(governance: SonderGovernanceBlock): void;
 
-export { ParliamentCircuitBreaker, type ParliamentConfig, type ParliamentDeliberationResult, type ParliamentModel, type ParliamentModelConfig, ParliamentReducer, runParliamentDeliberation, wrapParliamentModel };
+export { ParliamentCircuitBreaker, type ParliamentConfig, type ParliamentDeliberationResult, type ParliamentModel, type ParliamentModelConfig, ParliamentReducer, SignRefusedError, type SonderGovernanceBlock, assertSonderEventSignable, buildGovernanceBlock, runParliamentDeliberation, wrapParliamentModel };

package/dist/index.js

@@ -46,19 +46,21 @@ var ParliamentCircuitBreaker = class {
 };
 var ParliamentReducer = class {
   reducer;
-  constructor(config) {
+  constructor(config, embeddingProvider) {
     this.reducer = new ConsensusReducer({
       conflictStrategy: config?.conflictStrategy ?? "flag-only",
       minAgreementRatio: config?.minAgreementRatio ?? 0.6,
       consensusFields: config?.consensusFields ?? ["mainPoint", "supportingArguments", "conclusion"],
-      includeIndividualOutputs: config?.includeIndividualOutputs ?? true
+      includeIndividualOutputs: config?.includeIndividualOutputs ?? true,
+      embeddingProvider: embeddingProvider ?? config?.embeddingProvider,
+      embeddingThreshold: config?.embeddingThreshold ?? 0.85
     });
   }
   /**
    * Reduce multiple model responses into a consensus.
    */
-  reduce(contracts, traceId) {
-    const result = this.reducer.reduce(contracts);
+  async reduce(contracts, traceId) {
+    const result = await this.reducer.reduce(contracts);
     const reducedContract = this.reducer.createReducedContract(result, contracts, "parliament-reducer", null);
     return {
       consensus: result.output,
@@ -104,8 +106,8 @@ async function runParliamentDeliberation(topic, models, modelCalls, config) {
       });
     }
   }
-  const reducer = new ParliamentReducer(config?.reducer);
-  const reduction = reducer.reduce(modelContracts, traceId);
+  const reducer = new ParliamentReducer(config?.reducer, config?.embeddingProvider);
+  const reduction = await reducer.reduce(modelContracts, traceId);
   if (auditLog) {
     auditLog.append({
       type: "consensus",
@@ -131,9 +133,51 @@ async function runParliamentDeliberation(topic, models, modelCalls, config) {
     traceId
   };
 }
+function buildGovernanceBlock(contract, validation) {
+  const l0 = contract.metadata.l0;
+  const tiersRun = validation.tiersRun ?? [validation.tier];
+  const tier = tiersRun.join("+");
+  const verdict = validation.passed ? "pass" : "fail";
+  const block = {
+    tier,
+    verdict,
+    evidence: l0?.evidence ?? []
+  };
+  if (l0) {
+    block.policySet = l0.ruleSetId;
+    block.policySetVersion = l0.ruleSetVersion;
+  }
+  if (!validation.passed && validation.reason) {
+    block.reason = validation.reason;
+  }
+  return block;
+}
+var SignRefusedError = class extends Error {
+  constructor(code, message) {
+    super(message ?? `Sonder sign refused: ${code}`);
+    this.code = code;
+    this.name = "SignRefusedError";
+  }
+  code;
+};
+function assertSonderEventSignable(governance) {
+  const tiers = governance.tier.split("+");
+  const mentionsLaterTiers = tiers.includes("L1") || tiers.includes("L2") || tiers.includes("L3");
+  const evidence = governance.evidence;
+  const evidenceMissing = !evidence || evidence.length === 0;
+  if (mentionsLaterTiers && evidenceMissing) {
+    throw new SignRefusedError(
+      "l0-evidence-missing",
+      `Sonder sign refused (l0-evidence-missing): governance.tier="${governance.tier}" mentions L1/L2/L3 but governance.evidence is empty`
+    );
+  }
+}
 export {
   ParliamentCircuitBreaker,
   ParliamentReducer,
+  SignRefusedError,
+  assertSonderEventSignable,
+  buildGovernanceBlock,
   runParliamentDeliberation,
   wrapParliamentModel
 };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * @heybeaux/lattice-adapter-parliament\n *\n * Wraps Parliament's multi-model deliberations with Lattice State Contracts,\n * Circuit Breakers, and ConsensusReducer for coordinated, auditable synthesis.\n */\n\nimport {\n  createContract,\n  TieredCircuitBreaker,\n  ConsensusReducer,\n  ComplianceAuditLog,\n  wrapAgent,\n  HandoffFailure,\n  EventEmitter,\n  globalEmitter,\n  redactContract,\n} from '@heybeaux/lattice-core';\nimport type {\n  TieredCircuitBreakerConfig,\n  ConsensusReducerConfig,\n  StateContract,\n} from '@heybeaux/lattice-core';\n\n// ─── Types ────────────────────────────────────────────────\n\n/**\n * A Parliament model participant.\n */\nexport interface ParliamentModel {\n  /** Unique identifier for the model (e.g., 'claude-opus-4-6') */\n  id: string;\n  /** Role in the deliberation (proposer, expander, pragmatist, etc.) */\n  role: string;\n  /** Whether this model is adversarial (skeptic, devils-advocate) */\n  isAdversarial?: boolean;\n}\n\n/**\n * Configuration for wrapping a Parliament model.\n */\nexport interface ParliamentModelConfig {\n  /** Circuit breaker configuration (defaults: L1+L2 for cooperative, L1 for adversarial) */\n  breaker?: TieredCircuitBreakerConfig;\n  /** Whether to redact sensitive data before validation (default: true) */\n  redactForValidation?: boolean;\n  /** Whether to run in shadow mode (validate but don't block) (default: true) */\n  shadowMode?: boolean;\n}\n\n/**\n * Configuration for the Parliament integration.\n */\nexport interface ParliamentConfig {\n  /** Audit log path (optional — if provided, all deliberations are logged) */\n  auditLogPath?: string;\n  /** ConsensusReducer configuration */\n  reducer?: ConsensusReducerConfig;\n  /** Per-model configurations (optional) */\n  modelConfigs?: Record<string, ParliamentModelConfig>;\n  /** Default model configuration (applied to all models without specific config) */\n  defaultModelConfig?: ParliamentModelConfig;\n}\n\n/**\n * Result from wrapping a Parliament deliberation.\n */\nexport interface ParliamentDeliberationResult {\n  /** State Contracts for each model response */\n  modelContracts: StateContract[];\n  /** The consensus/synthesis output */\n  consensus: unknown;\n  /** Conflicts detected between models */\n  conflicts: Array<{\n    field: string;\n    values: Array<{ agentId: string; value: unknown }>;\n    resolution: string;\n  }>;\n  /** Agreement ratio (0-1) */\n  agreementRatio: number;\n  /** Whether consensus was reached */\n  consensusReached: boolean;\n  /** Total deliberation time in milliseconds */\n  totalDurationMs: number;\n  /** Trace ID for the deliberation */\n  traceId: string;\n}\n\n// ─── wrapParliamentModel ──────────────────────────────────\n\n/**\n * Wrap a Parliament model call with Lattice State Contracts and Circuit Breakers.\n *\n * The wrapped model:\n * 1. Executes the original model call\n * 2. Creates a State Contract with the model's response\n * 3. Validates through Circuit Breaker (L1+L2 for cooperative, L1 for adversarial)\n * 4. Returns the State Contract\n *\n * @param model - The Parliament model definition\n * @param modelCall - The model call function: (prompt) => Promise<response>\n * @param config - Configuration for this model\n * @returns A wrapped function that returns StateContract instead of raw response\n */\nexport function wrapParliamentModel(\n  model: ParliamentModel,\n  modelCall: (prompt: string) => Promise<unknown>,\n  config?: ParliamentModelConfig,\n) {\n  const shadowMode = config?.shadowMode ?? true;\n  const breakerConfig = config?.breaker ?? (\n    model.isAdversarial\n      ? { tier: 'L1' as const }\n      : { tier: 'L1+L2' as const, l2Threshold: 0.7 }\n  );\n\n  const wrapped = wrapAgent(\n    async (prompt: string) => modelCall(prompt),\n    {\n      id: model.id,\n      breaker: breakerConfig,\n    },\n  );\n\n  return async (\n    prompt: string,\n    traceId?: string,\n  ): Promise<{ contract: StateContract; passed: boolean }> => {\n    try {\n      const contract = await wrapped(prompt, traceId);\n      return { contract, passed: true };\n    } catch (error) {\n      if (error instanceof HandoffFailure) {\n        // In shadow mode, return the failed contract without blocking\n        if (shadowMode) {\n          return { contract: error.contract, passed: false };\n        }\n        throw error;\n      }\n      throw error;\n    }\n  };\n}\n\n// ─── ParliamentCircuitBreaker ─────────────────────────────\n\n/**\n * A pre-configured circuit breaker for Parliament model responses.\n *\n * Cooperative models use L1+L2 validation.\n * Adversarial models use L1 only (they're supposed to be contrarian).\n */\nexport class ParliamentCircuitBreaker {\n  private breakers: Map<string, TieredCircuitBreaker> = new Map();\n\n  constructor(models: ParliamentModel[], configs?: Record<string, TieredCircuitBreakerConfig>) {\n    for (const model of models) {\n      const config = configs?.[model.id] ?? (\n        model.isAdversarial\n          ? { tier: 'L1' as const }\n          : { tier: 'L1+L2' as const, l2Threshold: 0.7 }\n      );\n      this.breakers.set(model.id, new TieredCircuitBreaker(config));\n    }\n  }\n\n  get(agentId: string): TieredCircuitBreaker | undefined {\n    return this.breakers.get(agentId);\n  }\n}\n\n// ─── ParliamentReducer ────────────────────────────────────\n\n/**\n * A ConsensusReducer configured for Parliament synthesis.\n *\n * Detects disagreements between model responses, computes agreement\n * ratios, and flags conflicts for the synthesizer to resolve.\n */\nexport class ParliamentReducer {\n  private reducer: ConsensusReducer;\n\n  constructor(config?: ConsensusReducerConfig) {\n    this.reducer = new ConsensusReducer({\n      conflictStrategy: config?.conflictStrategy ?? 'flag-only',\n      minAgreementRatio: config?.minAgreementRatio ?? 0.6,\n      consensusFields: config?.consensusFields ?? ['mainPoint', 'supportingArguments', 'conclusion'],\n      includeIndividualOutputs: config?.includeIndividualOutputs ?? true,\n    });\n  }\n\n  /**\n   * Reduce multiple model responses into a consensus.\n   */\n  reduce(\n    contracts: StateContract[],\n    traceId?: string,\n  ): {\n    consensus: unknown;\n    conflicts: Array<{\n      field: string;\n      values: Array<{ agentId: string; value: unknown }>;\n      resolution: string;\n    }>;\n    agreementRatio: number;\n    consensusReached: boolean;\n    reducedContract: StateContract;\n  } {\n    const result = this.reducer.reduce(contracts);\n    const reducedContract = this.reducer.createReducedContract(result, contracts, 'parliament-reducer', null);\n\n    return {\n      consensus: result.output,\n      conflicts: result.conflicts,\n      agreementRatio: result.agreementRatio,\n      consensusReached: result.consensus,\n      reducedContract,\n    };\n  }\n}\n\n// ─── ParliamentDeliberation ───────────────────────────────\n\n/**\n * Run a full Parliament deliberation with Lattice coordination.\n *\n * @param topic - The deliberation topic\n * @param models - Array of Parliament models to run\n * @param modelCalls - Map of model ID to model call function\n * @param config - Parliament configuration\n * @returns ParliamentDeliberationResult\n */\nexport async function runParliamentDeliberation(\n  topic: string,\n  models: ParliamentModel[],\n  modelCalls: Map<string, (prompt: string) => Promise<unknown>>,\n  config?: ParliamentConfig,\n): Promise<ParliamentDeliberationResult> {\n  const start = Date.now();\n  const traceId = createContract({\n    fromAgent: 'parliament-topic',\n    inputs: { topic },\n    outputs: {},\n    budget: { tokensUsed: 0, callsMade: 0, wallClockMs: 0 },\n  }).traceId;\n\n  // Set up audit log if configured\n  let auditLog: ComplianceAuditLog | undefined;\n  if (config?.auditLogPath) {\n    auditLog = new ComplianceAuditLog({ logPath: config.auditLogPath });\n  }\n\n  // Run each model\n  const modelContracts: StateContract[] = [];\n  const modelResults: Array<{ model: ParliamentModel; result: { contract: StateContract; passed: boolean } }> = [];\n\n  for (const model of models) {\n    const modelCall = modelCalls.get(model.id);\n    if (!modelCall) {\n      continue;\n    }\n\n    const modelConfig = config?.modelConfigs?.[model.id] ?? config?.defaultModelConfig;\n    const wrappedModel = wrapParliamentModel(model, modelCall, modelConfig);\n    const result = await wrappedModel(topic, traceId);\n\n    modelContracts.push(result.contract);\n    modelResults.push({ model, result });\n\n    // Log to audit if configured\n    if (auditLog) {\n      auditLog.append({\n        agentId: model.id,\n        modelRole: model.role,\n        isAdversarial: model.isAdversarial ?? false,\n        passed: result.passed,\n        traceId,\n        contractId: result.contract.id,\n      });\n    }\n  }\n\n  // Run consensus reduction\n  const reducer = new ParliamentReducer(config?.reducer);\n  const reduction = reducer.reduce(modelContracts, traceId);\n\n  // Log consensus to audit\n  if (auditLog) {\n    auditLog.append({\n      type: 'consensus',\n      traceId,\n      agreementRatio: reduction.agreementRatio,\n      consensusReached: reduction.consensusReached,\n      conflictCount: reduction.conflicts.length,\n      modelCount: modelContracts.length,\n      validModelCount: modelResults.filter(r => r.result.passed).length,\n    });\n  }\n\n  return {\n    modelContracts,\n    consensus: reduction.consensus,\n    conflicts: reduction.conflicts.map(c => ({\n      field: c.field,\n      values: c.values.map(v => ({ agentId: v.agentId, value: v.value })),\n      resolution: c.resolution,\n    })),\n    agreementRatio: reduction.agreementRatio,\n    consensusReached: reduction.consensusReached,\n    totalDurationMs: Date.now() - start,\n    traceId,\n  };\n}\n\n\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * @heybeaux/lattice-adapter-parliament\n *\n * Wraps Parliament's multi-model deliberations with Lattice State Contracts,\n * Circuit Breakers, and ConsensusReducer for coordinated, auditable synthesis.\n */\n\nimport {\n  createContract,\n  TieredCircuitBreaker,\n  ConsensusReducer,\n  ComplianceAuditLog,\n  wrapAgent,\n  HandoffFailure,\n  EventEmitter,\n  globalEmitter,\n  redactContract,\n} from '@heybeaux/lattice-core';\nimport type {\n  TieredCircuitBreakerConfig,\n  ConsensusReducerConfig,\n  StateContract,\n  EmbeddingProvider,\n  PolicyEvidenceRow,\n  TieredValidationResult,\n  ValidationTier,\n} from '@heybeaux/lattice-core';\n\nexport type { EmbeddingProvider, PolicyEvidenceRow };\n\n// ─── Types ────────────────────────────────────────────────\n\n/**\n * A Parliament model participant.\n */\nexport interface ParliamentModel {\n  /** Unique identifier for the model (e.g., 'claude-opus-4-6') */\n  id: string;\n  /** Role in the deliberation (proposer, expander, pragmatist, etc.) */\n  role: string;\n  /** Whether this model is adversarial (skeptic, devils-advocate) */\n  isAdversarial?: boolean;\n}\n\n/**\n * Configuration for wrapping a Parliament model.\n */\nexport interface ParliamentModelConfig {\n  /** Circuit breaker configuration (defaults: L1+L2 for cooperative, L1 for adversarial) */\n  breaker?: TieredCircuitBreakerConfig;\n  /** Whether to redact sensitive data before validation (default: true) */\n  redactForValidation?: boolean;\n  /** Whether to run in shadow mode (validate but don't block) (default: true) */\n  shadowMode?: boolean;\n}\n\n/**\n * Configuration for the Parliament integration.\n */\nexport interface ParliamentConfig {\n  /** Audit log path (optional — if provided, all deliberations are logged) */\n  auditLogPath?: string;\n  /** ConsensusReducer configuration */\n  reducer?: ConsensusReducerConfig;\n  /** Per-model configurations (optional) */\n  modelConfigs?: Record<string, ParliamentModelConfig>;\n  /** Default model configuration (applied to all models without specific config) */\n  defaultModelConfig?: ParliamentModelConfig;\n  /** Embedding provider for semantic consensus comparison */\n  embeddingProvider?: EmbeddingProvider;\n}\n\n/**\n * Result from wrapping a Parliament deliberation.\n */\nexport interface ParliamentDeliberationResult {\n  /** State Contracts for each model response */\n  modelContracts: StateContract[];\n  /** The consensus/synthesis output */\n  consensus: unknown;\n  /** Conflicts detected between models */\n  conflicts: Array<{\n    field: string;\n    values: Array<{ agentId: string; value: unknown }>;\n    resolution: string;\n  }>;\n  /** Agreement ratio (0-1) */\n  agreementRatio: number;\n  /** Whether consensus was reached */\n  consensusReached: boolean;\n  /** Total deliberation time in milliseconds */\n  totalDurationMs: number;\n  /** Trace ID for the deliberation */\n  traceId: string;\n}\n\n// ─── wrapParliamentModel ──────────────────────────────────\n\n/**\n * Wrap a Parliament model call with Lattice State Contracts and Circuit Breakers.\n *\n * The wrapped model:\n * 1. Executes the original model call\n * 2. Creates a State Contract with the model's response\n * 3. Validates through Circuit Breaker (L1+L2 for cooperative, L1 for adversarial)\n * 4. Returns the State Contract\n *\n * @param model - The Parliament model definition\n * @param modelCall - The model call function: (prompt) => Promise<response>\n * @param config - Configuration for this model\n * @returns A wrapped function that returns StateContract instead of raw response\n */\nexport function wrapParliamentModel(\n  model: ParliamentModel,\n  modelCall: (prompt: string) => Promise<unknown>,\n  config?: ParliamentModelConfig,\n) {\n  const shadowMode = config?.shadowMode ?? true;\n  const breakerConfig = config?.breaker ?? (\n    model.isAdversarial\n      ? { tier: 'L1' as const }\n      : { tier: 'L1+L2' as const, l2Threshold: 0.7 }\n  );\n\n  const wrapped = wrapAgent(\n    async (prompt: string) => modelCall(prompt),\n    {\n      id: model.id,\n      breaker: breakerConfig,\n    },\n  );\n\n  return async (\n    prompt: string,\n    traceId?: string,\n  ): Promise<{ contract: StateContract; passed: boolean }> => {\n    try {\n      const contract = await wrapped(prompt, traceId);\n      return { contract, passed: true };\n    } catch (error) {\n      if (error instanceof HandoffFailure) {\n        // In shadow mode, return the failed contract without blocking\n        if (shadowMode) {\n          return { contract: error.contract, passed: false };\n        }\n        throw error;\n      }\n      throw error;\n    }\n  };\n}\n\n// ─── ParliamentCircuitBreaker ─────────────────────────────\n\n/**\n * A pre-configured circuit breaker for Parliament model responses.\n *\n * Cooperative models use L1+L2 validation.\n * Adversarial models use L1 only (they're supposed to be contrarian).\n */\nexport class ParliamentCircuitBreaker {\n  private breakers: Map<string, TieredCircuitBreaker> = new Map();\n\n  constructor(models: ParliamentModel[], configs?: Record<string, TieredCircuitBreakerConfig>) {\n    for (const model of models) {\n      const config = configs?.[model.id] ?? (\n        model.isAdversarial\n          ? { tier: 'L1' as const }\n          : { tier: 'L1+L2' as const, l2Threshold: 0.7 }\n      );\n      this.breakers.set(model.id, new TieredCircuitBreaker(config));\n    }\n  }\n\n  get(agentId: string): TieredCircuitBreaker | undefined {\n    return this.breakers.get(agentId);\n  }\n}\n\n// ─── ParliamentReducer ────────────────────────────────────\n\n/**\n * A ConsensusReducer configured for Parliament synthesis.\n *\n * Detects disagreements between model responses, computes agreement\n * ratios, and flags conflicts for the synthesizer to resolve.\n *\n * When an embeddingProvider is supplied, the consensus fields\n * (mainPoint, supportingArguments, conclusion) are compared using\n * cosine similarity (≥0.85 = agreeing) instead of exact string equality.\n */\nexport class ParliamentReducer {\n  private reducer: ConsensusReducer;\n\n  constructor(config?: ConsensusReducerConfig, embeddingProvider?: EmbeddingProvider) {\n    this.reducer = new ConsensusReducer({\n      conflictStrategy: config?.conflictStrategy ?? 'flag-only',\n      minAgreementRatio: config?.minAgreementRatio ?? 0.6,\n      consensusFields: config?.consensusFields ?? ['mainPoint', 'supportingArguments', 'conclusion'],\n      includeIndividualOutputs: config?.includeIndividualOutputs ?? true,\n      embeddingProvider: embeddingProvider ?? config?.embeddingProvider,\n      embeddingThreshold: config?.embeddingThreshold ?? 0.85,\n    });\n  }\n\n  /**\n   * Reduce multiple model responses into a consensus.\n   */\n  async reduce(\n    contracts: StateContract[],\n    traceId?: string,\n  ): Promise<{\n    consensus: unknown;\n    conflicts: Array<{\n      field: string;\n      values: Array<{ agentId: string; value: unknown }>;\n      resolution: string;\n    }>;\n    agreementRatio: number;\n    consensusReached: boolean;\n    reducedContract: StateContract;\n  }> {\n    const result = await this.reducer.reduce(contracts);\n    const reducedContract = this.reducer.createReducedContract(result, contracts, 'parliament-reducer', null);\n\n    return {\n      consensus: result.output,\n      conflicts: result.conflicts,\n      agreementRatio: result.agreementRatio,\n      consensusReached: result.consensus,\n      reducedContract,\n    };\n  }\n}\n\n// ─── ParliamentDeliberation ───────────────────────────────\n\n/**\n * Run a full Parliament deliberation with Lattice coordination.\n *\n * @param topic - The deliberation topic\n * @param models - Array of Parliament models to run\n * @param modelCalls - Map of model ID to model call function\n * @param config - Parliament configuration\n * @returns ParliamentDeliberationResult\n */\nexport async function runParliamentDeliberation(\n  topic: string,\n  models: ParliamentModel[],\n  modelCalls: Map<string, (prompt: string) => Promise<unknown>>,\n  config?: ParliamentConfig,\n): Promise<ParliamentDeliberationResult> {\n  const start = Date.now();\n  const traceId = createContract({\n    fromAgent: 'parliament-topic',\n    inputs: { topic },\n    outputs: {},\n    budget: { tokensUsed: 0, callsMade: 0, wallClockMs: 0 },\n  }).traceId;\n\n  // Set up audit log if configured\n  let auditLog: ComplianceAuditLog | undefined;\n  if (config?.auditLogPath) {\n    auditLog = new ComplianceAuditLog({ logPath: config.auditLogPath });\n  }\n\n  // Run each model\n  const modelContracts: StateContract[] = [];\n  const modelResults: Array<{ model: ParliamentModel; result: { contract: StateContract; passed: boolean } }> = [];\n\n  for (const model of models) {\n    const modelCall = modelCalls.get(model.id);\n    if (!modelCall) {\n      continue;\n    }\n\n    const modelConfig = config?.modelConfigs?.[model.id] ?? config?.defaultModelConfig;\n    const wrappedModel = wrapParliamentModel(model, modelCall, modelConfig);\n    const result = await wrappedModel(topic, traceId);\n\n    modelContracts.push(result.contract);\n    modelResults.push({ model, result });\n\n    // Log to audit if configured\n    if (auditLog) {\n      auditLog.append({\n        agentId: model.id,\n        modelRole: model.role,\n        isAdversarial: model.isAdversarial ?? false,\n        passed: result.passed,\n        traceId,\n        contractId: result.contract.id,\n      });\n    }\n  }\n\n  // Run consensus reduction\n  const reducer = new ParliamentReducer(config?.reducer, config?.embeddingProvider);\n  const reduction = await reducer.reduce(modelContracts, traceId);\n\n  // Log consensus to audit\n  if (auditLog) {\n    auditLog.append({\n      type: 'consensus',\n      traceId,\n      agreementRatio: reduction.agreementRatio,\n      consensusReached: reduction.consensusReached,\n      conflictCount: reduction.conflicts.length,\n      modelCount: modelContracts.length,\n      validModelCount: modelResults.filter(r => r.result.passed).length,\n    });\n  }\n\n  return {\n    modelContracts,\n    consensus: reduction.consensus,\n    conflicts: reduction.conflicts.map(c => ({\n      field: c.field,\n      values: c.values.map(v => ({ agentId: v.agentId, value: v.value })),\n      resolution: c.resolution,\n    })),\n    agreementRatio: reduction.agreementRatio,\n    consensusReached: reduction.consensusReached,\n    totalDurationMs: Date.now() - start,\n    traceId,\n  };\n}\n\n// ─── Governance / Sonder envelope ────────────────────────\n\n/**\n * Shape of the `governance` block on a SonderEvent envelope. Surfaces the\n * L0 evidence row trail produced by the Lattice breaker plus the\n * `+`-joined list of tiers that actually ran.\n *\n * - `tier` is `'+'`-joined and includes only tiers that ran (Spec 1 R8).\n *   Skipped tiers (e.g. L1/L2/L3 after an L0 fail) MUST NOT appear.\n * - `evidence` carries the full per-rule audit trail from L0. Empty array\n *   when no policy was bound; absent only when no validation ran at all.\n * - `policySet` / `policySetVersion` mirror the bound `PolicyRuleSet`.\n *   Present iff L0 ran; absent otherwise.\n */\nexport interface SonderGovernanceBlock {\n  /** `+`-joined list of tiers that actually ran (e.g. `'L0+L1'`). */\n  tier: string;\n  /** Pass/fail/uncertain — derived from the underlying ValidationResult. */\n  verdict: 'pass' | 'fail';\n  /** L0 evidence rows, in rule-set order. Empty array when L0 didn't run. */\n  evidence: PolicyEvidenceRow[];\n  /** PolicyRuleSet.id when L0 ran. */\n  policySet?: string;\n  /** PolicyRuleSet.version when L0 ran. */\n  policySetVersion?: string;\n  /** Optional reject reason — present when verdict === 'fail'. */\n  reason?: string;\n}\n\n/**\n * Build the SonderEvent `governance` block from a Lattice contract +\n * the breaker's {@link TieredValidationResult}. Pulls L0 evidence /\n * policy identifiers from `contract.metadata.l0` (when present) and\n * computes the `+`-joined `tier` string from `validation.tiersRun`.\n *\n * Spec 1 R8: `tier` lists only tiers that actually ran. Spec 1 R7:\n * downstream signers consume this block and apply the sign-refusal rule.\n */\nexport function buildGovernanceBlock(\n  contract: StateContract,\n  validation: TieredValidationResult,\n): SonderGovernanceBlock {\n  const l0 = (contract.metadata as {\n    l0?: {\n      ruleSetId: string;\n      ruleSetVersion: string;\n      evidence: PolicyEvidenceRow[];\n    };\n  }).l0;\n\n  const tiersRun: ValidationTier[] = validation.tiersRun ?? [validation.tier];\n  const tier = tiersRun.join('+');\n  const verdict: 'pass' | 'fail' = validation.passed ? 'pass' : 'fail';\n\n  const block: SonderGovernanceBlock = {\n    tier,\n    verdict,\n    evidence: l0?.evidence ?? [],\n  };\n  if (l0) {\n    block.policySet = l0.ruleSetId;\n    block.policySetVersion = l0.ruleSetVersion;\n  }\n  if (!validation.passed && validation.reason) {\n    block.reason = validation.reason;\n  }\n  return block;\n}\n\n/**\n * Error thrown by {@link assertSonderEventSignable} when a SonderEvent\n * envelope would violate Spec 1 R7's signing invariant. The `code`\n * field is a stable machine identifier; the message is human-facing.\n */\nexport class SignRefusedError extends Error {\n  constructor(\n    /**\n     * Stable identifier — currently always `'l0-evidence-missing'`,\n     * reserved for future R7 violations.\n     */\n    public readonly code: 'l0-evidence-missing',\n    message?: string,\n  ) {\n    super(message ?? `Sonder sign refused: ${code}`);\n    this.name = 'SignRefusedError';\n  }\n}\n\n/**\n * Spec 1 R7 — refuse to sign a SonderEvent whose `governance.tier`\n * mentions any of `L1`, `L2`, `L3` but whose `governance.evidence` is\n * empty or absent. Sonder's runtime calls this immediately before the\n * ed25519 signing step; throwing here aborts the signature.\n *\n * Why this matters: without L0 evidence the audit trail cannot prove\n * the deterministic policy tier ran, so cryptographic provenance over\n * the validation chain would be a lie. Refusing to sign is the\n * cheapest enforcement boundary in the system.\n *\n * @throws {SignRefusedError} when the envelope violates R7.\n */\nexport function assertSonderEventSignable(\n  governance: SonderGovernanceBlock,\n): void {\n  const tiers = governance.tier.split('+');\n  const mentionsLaterTiers =\n    tiers.includes('L1') || tiers.includes('L2') || tiers.includes('L3');\n  const evidence = governance.evidence;\n  const evidenceMissing = !evidence || evidence.length === 0;\n\n  if (mentionsLaterTiers && evidenceMissing) {\n    throw new SignRefusedError(\n      'l0-evidence-missing',\n      `Sonder sign refused (l0-evidence-missing): governance.tier=\"${governance.tier}\" mentions L1/L2/L3 but governance.evidence is empty`,\n    );\n  }\n}\n\n\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heybeaux/lattice-adapter-parliament",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Lattice coordination layer for Parliament — wraps multi-model deliberations with State Contracts and Circuit Breakers",
   "type": "module",
   "main": "./dist/index.js",