import { randomUUID } from 'node:crypto';

import {

  AgentIdentitySchema,

  CounterpartyBriefSchema,

  canonicalHash,

  createKeyPair,

  DelegationCredentialSchema,

  FeedbackSchema,

  FeedbackDimensionSchema,

  InteractionContractSchema,

  InteractionConclusionSchema,

  InteractionEventSchema,

  ReceiptSchema,

  signNamed,

  signObject,

  TrustEnvelopeSchema,

  verifyNamed,

  verifyObject,

  type AgentIdentity,

  type CounterpartyBrief,

  type DelegationCredential,

  type FactCheckResult,

  type Feedback,

  type InteractionContract,

  type InteractionConclusion,

  type InteractionCompletionReport,

  type InteractionFeedback,

  type InteractionEvent,

  type KeyPair,

  type LiveSessionInsight,

  type PublicAgentCard,

  type Receipt,

  type RiskDecision,

  type TrustEnvelope,

} from '../../protocol/src/index.js';

const REQUIREMENT_STOP_WORDS = new Set([

  'about',

  'agent',

  'available',

  'from',

  'have',

  'into',

  'must',

  'provide',

  'return',

  'should',

  'that',

  'their',

  'this',

  'with',

]);

function normalized(value: string): string {

  return value

    .trim()

    .toLowerCase()

    .replace(/[^a-z0-9]+/g, ' ')

    .trim();

}

function meaningfulTerms(value: string): string[] {

  return [

    ...new Set(

      normalized(value)

        .split(' ')

        .filter((term) => term.length >= 4 && !REQUIREMENT_STOP_WORDS.has(term)),

    ),

  ];

}

function assessDeclaration(

  requirement: string,

  declarations: string[],

): { status: 'match' | 'partial' | 'mismatch' | 'unknown'; reason: string; confidence: number } {

  const normalizedRequirement = normalized(requirement);

  const normalizedDeclarations = declarations.map(normalized);

  if (

    normalizedDeclarations.some(

      (declaration) => declaration === '*' || declaration === normalizedRequirement,

    )

  )

    return {

      status: 'match',

      reason: 'The counterparty explicitly declares this capability.',

      confidence: 0.95,

    };

  const terms = meaningfulTerms(requirement);

  const negative = normalizedDeclarations.find((declaration) =>

    terms.some(

      (term) =>

        declaration.includes(`no ${term}`) ||

        declaration.includes(`not ${term}`) ||

        declaration.includes(`cannot ${term}`),

    ),

  );

  if (negative)

    return {

      status: 'mismatch',

      reason: `The counterparty declares a conflicting limitation: ${negative}`,

      confidence: 0.95,

    };

  if (terms.length) {

    const declarationText = normalizedDeclarations.join(' ');

    const overlap = terms.filter((term) => declarationText.includes(term)).length / terms.length;

    if (overlap >= 0.6)

      return {

        status: 'match',

        reason: 'The counterparty declarations strongly match this requirement.',

        confidence: 0.8,

      };

    if (overlap > 0)

      return {

        status: 'partial',

        reason: 'The counterparty declarations only partially cover this requirement.',

        confidence: 0.65,

      };

  }

  return {

    status: 'unknown',

    reason: 'The published agent card does not establish this requirement.',

    confidence: 0.35,

  };

}

export function buildCounterpartyBrief(input: {

  interactionId: string;

  contractHash: string;

  contract: InteractionContract;

  recipientAgentId: string;

  subject: PublicAgentCard;

  historyInsights: LiveSessionInsight[];

  relevantSampleSize: number;

  historyConfidence: number;

  generatedAt?: string;

  expiresAt: string;

}): CounterpartyBrief {

  const declarations = [

    input.subject.description,

    ...input.subject.capabilities,

    ...input.subject.limitations,

  ];

  const requirements = [

    {

      requirementId: 'task-category',

      requirement: input.contract.taskCategory,

      kind: 'capability' as const,

    },

    {

      requirementId: 'requested-outcome',

      requirement: input.contract.requestedOutcome,

      kind: 'scope' as const,

    },

    ...input.contract.allowedActions.map((requirement, index) => ({

      requirementId: `allowed-action-${index + 1}`,

      requirement,

      kind: 'capability' as const,

    })),

    ...input.contract.successCriteria.map((requirement, index) => ({

      requirementId: `success-criterion-${index + 1}`,

      requirement,

      kind: 'success_criterion' as const,

    })),

    ...input.contract.evidenceRequirements.map((requirement, index) => ({

      requirementId: `evidence-${index + 1}`,

      requirement,

      kind: 'evidence' as const,

    })),

  ].map((requirement) => ({

    ...requirement,

    ...assessDeclaration(requirement.requirement, declarations),

    sources: ['contract', 'self_declared'] as const,

    evidenceReferences: [input.subject.cardUrl],

  }));

  const requirementReferences = requirements

    .filter((requirement) => requirement.status !== 'match')

    .map((requirement) => requirement.requirementId);

  const insights = input.historyInsights.map((insight) => ({

    ...insight,

    requirementReferences:

      insight.requirementReferences.length > 0

        ? insight.requirementReferences

        : requirementReferences,

  }));

  const needsChallenge =

    input.relevantSampleSize === 0 ||

    requirements.some((requirement) => requirement.status === 'mismatch') ||

    insights.some((insight) => insight.severity === 'high');

  return CounterpartyBriefSchema.parse({

    briefId: randomUUID(),

    interactionId: input.interactionId,

    contractHash: input.contractHash,

    recipientAgentId: input.recipientAgentId,

    subjectAgentId: input.subject.agentId,

    taskCategory: input.contract.taskCategory,

    decision: needsChallenge ? 'CHALLENGE' : 'ALLOW',

    requirements,

    insights,

    relevantSampleSize: input.relevantSampleSize,

    historyConfidence: input.historyConfidence,

    subjectAgentVersion: input.subject.agentVersion,

    recommendedContractChanges: requirements

      .filter((requirement) => requirement.status === 'mismatch')

      .map((requirement) => `Resolve mismatch: ${requirement.requirement}`),

    generatedAt: input.generatedAt ?? new Date().toISOString(),

    expiresAt: input.expiresAt,

  });

}

export function buildInteractionConclusion(input: {

  interaction: { interactionId: string; termsHash: string; contract: InteractionContract };

  reports: InteractionCompletionReport[];

  feedback: InteractionFeedback[];

  conclusionId?: string;

  generatedAt?: string;

}): InteractionConclusion {

  const outcomes = input.reports.map((report) => report.outcome);

  const uniqueOutcomes = new Set(outcomes);

  const outcome =

    outcomes.length === 0

      ? ('cancelled' as const)

      : uniqueOutcomes.size === 1

        ? outcomes[0]!

        : outcomes.includes('failure')

          ? ('failure' as const)

          : ('partial' as const);

  const consensus =

    input.reports.length < 2

      ? ('unilateral' as const)

      : uniqueOutcomes.size === 1

        ? ('bilateral_agreement' as const)

        : outcomes.includes('partial')

          ? ('bilateral_partial_agreement' as const)

          : ('conflicting' as const);

  const statusRank = { met: 0, partially_met: 1, unknown: 2, missed: 3 } as const;

  const criteria = input.interaction.contract.successCriteria.map((criterion) => {

    const assessments = input.reports

      .flatMap((report) => report.criteria)

      .filter((assessment) => assessment.criterion === criterion);

    const selected = assessments.sort(

      (left, right) => statusRank[right.status] - statusRank[left.status],

    )[0];

    return {

      criterion,

      status: selected?.status ?? ('unknown' as const),

      ...(selected?.explanation ? { explanation: selected.explanation } : {}),

      evidenceReferences: [

        ...new Set(assessments.flatMap((assessment) => assessment.evidenceReferences)),

      ],

    };

  });

  const averageRatings = Object.fromEntries(

    FeedbackDimensionSchema.options.flatMap((dimension) => {

      const values = input.feedback

        .map((item) => item.ratings[dimension])

        .filter((value): value is number => typeof value === 'number');

      return values.length

        ? [[dimension, values.reduce((total, value) => total + value, 0) / values.length]]

        : [];

    }),

  );

  return InteractionConclusionSchema.parse({

    conclusionId: input.conclusionId ?? randomUUID(),

    interactionId: input.interaction.interactionId,

    contractHash: input.interaction.termsHash,

    outcome,

    consensus,

    summary: `${input.reports.length} completion report${input.reports.length === 1 ? '' : 's'} and ${input.feedback.length} feedback response${input.feedback.length === 1 ? '' : 's'} were eligible for this conclusion.`,

    criteria,

    reportIds: input.reports.map((report) => report.reportId),

    feedbackIds: input.feedback.map((item) => item.feedbackId),

    averageRatings,

    evidenceReferences: [...new Set(input.reports.flatMap((report) => report.evidenceReferences))],

    generatedAt: input.generatedAt ?? new Date().toISOString(),

  });

}

export interface AuditStore {

  append(kind: string, id: string, value: unknown): void;

  list(kind: string): unknown[];

}

export class MemoryAuditStore implements AuditStore {

  private rows: { kind: string; id: string; value: unknown }[] = [];

  append(kind: string, id: string, value: unknown): void {

    const old = this.rows.find((row) => row.kind === kind && row.id === id);

    if (old && canonicalHash(old.value) !== canonicalHash(value))

      throw new Error(`Conflicting duplicate ${kind}:${id}`);

    if (!old) this.rows.push({ kind, id, value: structuredClone(value) });

  }

  list(kind: string): unknown[] {

    return this.rows.filter((row) => row.kind === kind).map((row) => structuredClone(row.value));

  }

}

export function createIdentity(input: {

  agentId: string;

  operatorRef: string;

  version?: string;

  capabilities: string[];

  assurance?: AgentIdentity['assurance'];

  parentAgentId?: string;

  rootControllerId?: string;

}): { identity: AgentIdentity; keyPair: KeyPair } {

  const keyPair = createKeyPair(`${input.agentId}#1`);

  const identity: Record<string, unknown> = {

    protocolVersion: '0.1',

    agentId: input.agentId,

    publicKey: keyPair.publicKey,

    keyId: keyPair.keyId,

    operatorRef: input.operatorRef,

    assurance: input.assurance ?? 'pseudonymous',

    agentVersion: input.version ?? '1.0.0',

    capabilities: input.capabilities,

    supportedProtocols: ['A2A/1.0', 'OpenClasp/0.1'],

    ...(input.parentAgentId ? { parentAgentId: input.parentAgentId } : {}),

    rootControllerId: input.rootControllerId ?? input.agentId,

    revoked: false,

    provenance: 'cryptographically_verified',

    createdAt: new Date().toISOString(),

  };

  return { identity: AgentIdentitySchema.parse(signObject(identity, keyPair)), keyPair };

}

export type PolicyContext = {

  envelope: TrustEnvelope;

  action: string;

  dataClasses?: string[];

  humanApproved?: boolean;

};

export type Conflict = {

  conflictId: string;

  interactionId: string;

  issue: string;

  positions: Record<string, string>;

  evidence: string[];

  contractClauses: string[];

  missingInformation: string[];

  possibleResolutions: string[];

  permissions: Record<string, boolean>;

  status: 'pending_consent' | 'open' | 'resolved';

  resolution?: string;

};

type ProfileAggregate = {

  agentId: string;

  agentVersion: string;

  taskCategory: string;

  sampleSize: number;

  updatedAt: string;

  completion: number;

  acceptance: number;

  specification: number;

  deadline: number;

  communication: number;

  evidence: number;

  scope: number;

  disputes: number;

};

export class TrustEngine {

  readonly agents = new Map<string, AgentIdentity>();

  readonly delegations = new Map<string, DelegationCredential>();

  readonly contracts = new Map<string, InteractionContract>();

  readonly events = new Map<string, InteractionEvent>();

  readonly receipts = new Map<string, Receipt>();

  readonly conflicts = new Map<string, Conflict>();

  readonly feedback = new Map<string, Feedback>();

  readonly profiles = new Map<string, ProfileAggregate>();

  readonly contributionConsent = new Map<

    string,

    { enabled: boolean; grantedAt: string; revokedAt?: string }

  >();

  private readonly nonces = new Set<string>();

  constructor(readonly store: AuditStore = new MemoryAuditStore()) {

    for (const value of store.list('agent') as AgentIdentity[])

      this.agents.set(value.agentId, value);

    for (const value of store.list('delegation') as DelegationCredential[])

      this.delegations.set(value.delegationId, value);

    for (const value of store.list('contract') as InteractionContract[])

      this.contracts.set(value.interactionId, value);

    for (const value of store.list('event') as InteractionEvent[])

      this.events.set(value.eventId, value);

    for (const value of store.list('receipt') as Receipt[])

      this.receipts.set(value.receiptId, value);

    for (const value of store.list('feedback') as Feedback[])

      this.feedback.set(value.feedbackId, value);

    for (const value of store.list('profile') as ProfileAggregate[])

      this.profiles.set(`${value.agentId}|${value.agentVersion}|${value.taskCategory}`, value);

    for (const value of store.list('conflict') as Conflict[])

      this.conflicts.set(value.conflictId, value);

    for (const value of store.list('consent') as {

      agentId: string;

      enabled: boolean;

      grantedAt: string;

      revokedAt?: string;

    }[])

      this.contributionConsent.set(value.agentId, value);

    for (const value of store.list('revocation') as {

      agentId?: string;

      delegationId?: string;

    }[]) {

      if (value.agentId && this.agents.has(value.agentId))

        this.agents.set(value.agentId, { ...this.agents.get(value.agentId)!, revoked: true });

      if (value.delegationId && this.delegations.has(value.delegationId))

        this.delegations.set(value.delegationId, {

          ...this.delegations.get(value.delegationId)!,

          revoked: true,

        });

    }

  }

  registerAgent(identity: AgentIdentity): AgentIdentity {

    const parsed = AgentIdentitySchema.parse(identity);

    if (!verifyObject(parsed as unknown as Record<string, unknown>, parsed.publicKey))

      throw new Error('Invalid identity signature');

    if (parsed.parentAgentId && parsed.rootControllerId === parsed.agentId)

      throw new Error('Child cannot remove root-controller reference');

    this.agents.set(parsed.agentId, parsed);

    this.store.append('agent', parsed.agentId, parsed);

    return parsed;

  }

  revokeAgent(agentId: string): void {

    const identity = this.requireAgent(agentId);

    const revoked = { ...identity, revoked: true };

    this.agents.set(agentId, revoked);

    this.store.append('revocation', `agent:${agentId}`, { agentId, at: new Date().toISOString() });

  }

  createDelegation(

    parentId: string,

    childId: string,

    capabilities: string[],

    expiresAt: string,

    parentKey: KeyPair,

  ): DelegationCredential {

    const parent = this.requireAgent(parentId);

    const child = this.requireAgent(childId);

    if (parent.revoked) throw new Error('Parent agent is revoked');

    if (child.parentAgentId !== parentId || child.rootControllerId !== parent.rootControllerId)

      throw new Error('Invalid child lineage');

    if (capabilities.some((capability) => !parent.capabilities.includes(capability)))

      throw new Error('Delegation exceeds parent authority');

    const raw = {

      protocolVersion: '0.1' as const,

      delegationId: randomUUID(),

      parentAgentId: parentId,

      childAgentId: childId,

      rootControllerId: parent.rootControllerId,

      capabilities,

      issuedAt: new Date().toISOString(),

      expiresAt,

      revoked: false,

    };

    const credential = DelegationCredentialSchema.parse(signObject(raw, parentKey));

    this.delegations.set(credential.delegationId, credential);

    this.store.append('delegation', credential.delegationId, credential);

    return credential;

  }

  verifyDelegation(delegationId: string, capability?: string, at = new Date()): boolean {

    const delegation = this.delegations.get(delegationId);

    if (!delegation || delegation.revoked || new Date(delegation.expiresAt) <= at) return false;

    const parent = this.agents.get(delegation.parentAgentId);

    const child = this.agents.get(delegation.childAgentId);

    if (!parent || !child || parent.revoked || child.revoked) return false;

    if (

      child.rootControllerId !== delegation.rootControllerId ||

      child.parentAgentId !== parent.agentId

    )

      return false;

    if (capability && !delegation.capabilities.includes(capability)) return false;

    if (delegation.capabilities.some((item) => !parent.capabilities.includes(item))) return false;

    return verifyObject(delegation as unknown as Record<string, unknown>, parent.publicKey);

  }

  revokeDelegation(delegationId: string): void {

    const item = this.delegations.get(delegationId);

    if (!item) throw new Error('Delegation not found');

    this.delegations.set(delegationId, { ...item, revoked: true });

    this.store.append('revocation', `delegation:${delegationId}`, {

      delegationId,

      at: new Date().toISOString(),

    });

  }

  saveContract(contract: InteractionContract): InteractionContract {

    const parsed = InteractionContractSchema.parse(contract);

    if (parsed.parties.some((party) => !(party in parsed.signatures)))

      throw new Error('Contract requires every party signature');

    for (const party of Object.keys(parsed.signatures)) {

      const agent = this.requireAgent(party);

      if (!verifyNamed(parsed as unknown as Record<string, unknown>, party, agent.publicKey))

        throw new Error(`Invalid contract signature: ${party}`);

    }

    this.contracts.set(parsed.interactionId, parsed);

    this.store.append('contract', parsed.interactionId, parsed);

    return parsed;

  }

  assess(context: PolicyContext): RiskDecision {

    const envelope = TrustEnvelopeSchema.parse(context.envelope);

    const responder = this.agents.get(envelope.respondingAgentId);

    const requester = this.agents.get(envelope.requestingAgentId);

    const contract = this.contracts.get(envelope.interactionId);

    const hardFailures: string[] = [];

    if (

      !requester ||

      requester.revoked ||

      !verifyObject(envelope as unknown as Record<string, unknown>, requester.publicKey)

    )

      hardFailures.push('invalid_requester_signature');

    if (!responder || responder.revoked) hardFailures.push('invalid_or_revoked_responder');

    if (new Date(envelope.expiresAt) <= new Date()) hardFailures.push('expired_envelope');

    if (this.nonces.has(envelope.nonce)) hardFailures.push('replay_attempt');

    if (

      envelope.delegationId &&

      !this.verifyDelegation(envelope.delegationId, envelope.requestedCapability)

    )

      hardFailures.push('invalid_delegation');

    if (!contract || canonicalHash({ ...contract, signatures: {} }) !== envelope.contractHash)

      hardFailures.push('contract_mismatch');

    if (

      contract &&

      (!contract.allowedActions.includes(context.action) ||

        contract.prohibitedActions.includes(context.action))

    )

      hardFailures.push('action_outside_contract');

    if (

      contract &&

      (context.dataClasses ?? []).some((item) => contract.prohibitedData.includes(item))

    )

      hardFailures.push('prohibited_data');

    if (

      contract &&

      contract.humanApprovalRequirements.includes(context.action) &&

      !context.humanApproved

    )

      hardFailures.push('missing_human_approval');

    if (!hardFailures.includes('replay_attempt')) this.nonces.add(envelope.nonce);

    if (hardFailures.length)

      return this.decision('DENY', envelope.taskCategory, 1, hardFailures, [], []);

    const risk = this.getRisk(

      envelope.respondingAgentId,

      responder?.agentVersion ?? envelope.agentVersion,

      envelope.taskCategory,

    );

    return risk;

  }

  recordEvent(event: InteractionEvent): InteractionEvent {

    const parsed = InteractionEventSchema.parse(event);

    const agent = this.requireAgent(parsed.agentId);

    if (!verifyObject(parsed as unknown as Record<string, unknown>, agent.publicKey))

      throw new Error('Invalid event signature');

    if (canonicalHash(parsed.payload) !== parsed.payloadHash)

      throw new Error('Event payload hash mismatch');

    const existing = this.events.get(parsed.eventId);

    if (existing && canonicalHash(existing) !== canonicalHash(parsed))

      throw new Error('Conflicting duplicate event');

    this.events.set(parsed.eventId, parsed);

    this.store.append('event', parsed.eventId, parsed);

    return parsed;

  }

  createConflict(

    input: Omit<Conflict, 'conflictId' | 'status' | 'permissions'> & { participants: string[] },

  ): Conflict {

    const permissions = Object.fromEntries(input.participants.map((id) => [id, false]));

    const conflict: Conflict = {

      ...input,

      conflictId: randomUUID(),

      permissions,

      status: 'pending_consent',

    };

    delete (conflict as any).participants;

    this.conflicts.set(conflict.conflictId, conflict);

    this.store.append('conflict', `${conflict.conflictId}:created`, conflict);

    return conflict;

  }

  permitMediation(conflictId: string, agentId: string): Conflict {

    const conflict = this.requireConflict(conflictId);

    if (!(agentId in conflict.permissions)) throw new Error('Agent is not a conflict participant');

    conflict.permissions[agentId] = true;

    if (Object.values(conflict.permissions).every(Boolean)) conflict.status = 'open';

    this.store.append('conflict', `${conflict.conflictId}:permit:${agentId}`, conflict);

    return conflict;

  }

  resolveConflict(conflictId: string, resolution: string): Conflict {

    const conflict = this.requireConflict(conflictId);

    if (conflict.status !== 'open') throw new Error('Mutual mediation consent required');

    conflict.status = 'resolved';

    conflict.resolution = resolution;

    this.store.append('conflict', `${conflict.conflictId}:resolved`, conflict);

    return conflict;

  }

  submitReceipt(receipt: Receipt): Receipt {

    const parsed = this.verifyReceipt(receipt);

    this.receipts.set(parsed.receiptId, parsed);

    this.store.append('receipt', parsed.receiptId, parsed);

    return parsed;

  }

  verifyReceipt(receipt: Receipt): Receipt {

    const parsed = ReceiptSchema.parse(receipt);

    const required = parsed.unilateral

      ? Object.keys(parsed.signatures).slice(0, 1)

      : parsed.participants;

    if (

      !required.length ||

      required.some((party) => {

        const agent = this.agents.get(party);

        return (

          !agent ||

          !verifyNamed(parsed as unknown as Record<string, unknown>, party, agent.publicKey)

        );

      })

    )

      throw new Error('Receipt signature verification failed');

    return parsed;

  }

  submitFeedback(item: Feedback): { revealed: boolean } {

    const parsed = FeedbackSchema.parse(item);

    const receipt = this.receipts.get(parsed.receiptId);

    const reviewer = this.agents.get(parsed.reviewerAgentId);

    if (

      !receipt ||

      !reviewer ||

      !receipt.participants.includes(parsed.reviewerAgentId) ||

      !receipt.participants.includes(parsed.subjectAgentId)

    )

      throw new Error('Feedback requires a valid participant receipt');

    if (!verifyObject(parsed as unknown as Record<string, unknown>, reviewer.publicKey))

      throw new Error('Invalid feedback signature');

    this.feedback.set(parsed.feedbackId, parsed);

    this.store.append('feedback', parsed.feedbackId, parsed);

    const related = [...this.feedback.values()].filter(

      (value) => value.receiptId === parsed.receiptId,

    );

    const revealed =

      receipt.unilateral ||

      new Set(related.map((value) => value.reviewerAgentId)).size >= receipt.participants.length;

    if (revealed) for (const feedback of related) this.applyFeedback(feedback, receipt);

    return { revealed };

  }

  getRisk(agentId: string, version: string, taskCategory: string): RiskDecision {

    const current = this.profiles.get(`${agentId}|${version}|${taskCategory}`);

    const otherVersions = [...this.profiles.values()].filter(

      (p) => p.agentId === agentId && p.taskCategory === taskCategory,

    );

    if (!current) {

      const continuity = otherVersions.length

        ? Math.min(

            0.2,

            Math.max(

              ...otherVersions.map((profile) => profile.sampleSize / (profile.sampleSize + 5)),

            ) * 0.25,

          )

        : 0;

      return this.decision(

        'CHALLENGE',

        taskCategory,

        continuity,

        ['limited_verified_history'],

        ['Agent version has limited task-specific evidence'],

        ['request_evidence'],

      );

    }

    const ageDays = Math.max(0, (Date.now() - Date.parse(current.updatedAt)) / 86_400_000);

    const freshness = Math.exp(-ageDays / 180);

    const quality =

      (current.completion +

        current.acceptance +

        current.specification +

        current.deadline +

        current.communication +

        current.evidence +

        current.scope +

        (1 - current.disputes)) /

      8;

    const confidence = Math.min(0.95, (current.sampleSize / (current.sampleSize + 5)) * freshness);

    const decision = quality >= 0.7 && confidence >= 0.25 ? 'ALLOW' : 'CHALLENGE';

    return {

      decision,

      confidence,

      taskCategory,

      sampleSize: current.sampleSize,

      dimensions: {

        completionReliability: current.completion,

        outputAcceptance: current.acceptance,

        contractAdherence: (current.specification + current.scope) / 2,

        deadlineReliability: current.deadline,

        communicationQuality: current.communication,

        evidenceQuality: current.evidence,

        disputeRate: current.disputes,

      },

      reasons: [`contextual_quality=${quality.toFixed(2)}`],

      warnings: confidence < 0.5 ? ['Limited sample size'] : [],

      dataFreshness: { behaviouralProfile: current.updatedAt },

      requiredChallenges: decision === 'CHALLENGE' ? ['request_evidence'] : [],

    };

  }

  setContributionConsent(agentId: string, enabled: boolean): void {

    this.requireAgent(agentId);

    const previous = this.contributionConsent.get(agentId);

    this.contributionConsent.set(

      agentId,

      enabled

        ? { enabled: true, grantedAt: new Date().toISOString() }

        : {

            enabled: false,

            grantedAt: previous?.grantedAt ?? new Date().toISOString(),

            revokedAt: new Date().toISOString(),

          },

    );

    this.store.append('consent', `${agentId}:${Date.now()}`, {

      agentId,

      ...this.contributionConsent.get(agentId),

    });

  }

  networkContribution(event: InteractionEvent): Record<string, unknown> | null {

    if (!this.contributionConsent.get(event.agentId)?.enabled || event.visibility === 'local_only')

      return null;

    return {

      eventId: event.eventId,

      interactionId: event.interactionId,

      eventType: event.eventType,

      agentId: event.agentId,

      agentVersion: event.agentVersion,

      timestamp: event.timestamp,

      visibility: event.visibility,

      provenance: event.provenance,

      payloadHash: event.payloadHash,

      evidenceRefs: event.evidenceRefs ?? [],

      signature: event.signature,

    };

  }

  private applyFeedback(feedback: Feedback, receipt: Receipt): void {

    const taskCategory = this.contracts.get(feedback.interactionId)?.taskCategory ?? 'unknown';

    const version = receipt.agentVersions[feedback.subjectAgentId] ?? 'unknown';

    const key = `${feedback.subjectAgentId}|${version}|${taskCategory}`;

    const previous = this.profiles.get(key);

    const n = previous?.sampleSize ?? 0;

    const next = (old: number | undefined, value: number) => ((old ?? 0) * n + value) / (n + 1);

    const profile = {

      agentId: feedback.subjectAgentId,

      agentVersion: version,

      taskCategory,

      sampleSize: n + 1,

      updatedAt: new Date().toISOString(),

      completion: next(previous?.completion, Number(feedback.taskCompleted)),

      acceptance: next(previous?.acceptance, Number(feedback.outputAccepted)),

      specification: next(previous?.specification, Number(feedback.specificationMatched)),

      deadline: next(previous?.deadline, Number(feedback.deadlineMet)),

      communication: next(previous?.communication, feedback.communicationQuality),

      evidence: next(previous?.evidence, Number(feedback.evidenceProvided)),

      scope: next(previous?.scope, Number(feedback.scopeRespected)),

      disputes: next(previous?.disputes, Number(feedback.disputeRaised)),

    };

    this.profiles.set(key, profile);

    this.store.append('profile', `${key}:${profile.sampleSize}`, profile);

  }

  private decision(

    decision: RiskDecision['decision'],

    taskCategory: string,

    confidence: number,

    reasons: string[],

    warnings: string[],

    challenges: string[],

  ): RiskDecision {

    return {

      decision,

      confidence,

      taskCategory,

      sampleSize: 0,

      dimensions: {},

      reasons,

      warnings,

      dataFreshness: {},

      requiredChallenges: challenges,

    };

  }

  private requireAgent(id: string): AgentIdentity {

    const value = this.agents.get(id);

    if (!value) throw new Error(`Agent not found: ${id}`);

    return value;

  }

  private requireConflict(id: string): Conflict {

    const value = this.conflicts.get(id);

    if (!value) throw new Error('Conflict not found');

    return value;

  }

}

export interface FactCheckProvider {

  check(claim: string, permission?: boolean): Promise<FactCheckResult>;

}

export class FixtureFactCheckProvider implements FactCheckProvider {

  constructor(

    private fixtures: Record<

      string,

      { status: FactCheckResult['status']; evidence: string[] }

    > = {},

  ) {}

  async check(claim: string, permission = true): Promise<FactCheckResult> {

    if (!permission)

      return result(

        claim,

        'objective',

        'insufficient_permission',

        1,

        [],

        'Grant evidence-source permission',

      );

    if (/\b(i think|i prefer|best|beautiful)\b/i.test(claim))

      return result(claim, 'subjective', 'not_fact_checkable', 1, [], 'Treat as an opinion');

    if (/\b(will|might|forecast|predict)\b/i.test(claim))

      return result(

        claim,

        'prediction',

        'not_fact_checkable',

        0.9,

        [],

        'Track as a prediction, not a fact',

      );

    const fixture = this.fixtures[claim];

    if (!fixture)

      return result(claim, 'objective', 'unverified', 0, [], 'Request authoritative evidence');

    return result(

      claim,

      'objective',

      fixture.status,

      0.95,

      fixture.evidence,

      fixture.status === 'contradicted' ? 'Challenge the claim with cited evidence' : 'Continue',

    );

  }

}

function result(

  claim: string,

  claimType: FactCheckResult['claimType'],

  status: FactCheckResult['status'],

  confidence: number,

  evidence: string[],

  action: string,

): FactCheckResult {

  return {

    claim,

    claimType,

    status,

    confidence,

    evidenceReferences: evidence,

    sourceAuthority: evidence.length ? 'authoritative_fixture' : 'none',

    sourceFreshness: new Date().toISOString(),

    contradictingEvidence: status === 'contradicted' ? evidence : [],

    suggestedNextAction: action,

  };

}

export { signNamed, signObject };