@private.me/xcontinuity 2.1.0

package/README.md

@@ -0,0 +1,601 @@
+# @private.me/xcontinuity
+
+[![License: Proprietary](https://img.shields.io/badge/License-Proprietary-red.svg)](./LICENSE.md)
+[![Version: v2.1.0](https://img.shields.io/badge/version-2.1.0-blue.svg)](./CHANGELOG.md)
+
+Cryptographic state continuity for AI agents — Reverse-XorIDA with trust substrate, provenance, and enforcement.
+
+## Features
+
+- **Reverse-XorIDA** — incremental state updates at O(delta) cost exploiting GF(2) linearity
+- **XorIDA threshold sharing** — k-of-n split for fault-tolerant state persistence
+- **TLV serialization** — compact binary state encoding with SHA-256 integrity
+- **SessionManager** — lifecycle controller (active/suspended/closed) combining all layers
+- **Chronicle** — ordered state history with contradiction detection
+- **Runtime memory** — ephemeral in-process key-value store with LRU eviction
+- **Session memory** — XorIDA-persisted state layer with incremental updates
+- **Trust substrate** (v2.0.0) — provenance, trust tiers, adjudication, ratification
+- **Mission & enforcement** (v2.0.0) — human-anchored goals with constraint checking
+- **7 algebraic extensions** (v2.0.0) — undo, branching, squashing, blind updates, share refresh, blind equality, network-coded sync
+- **TTL decay** (v2.0.0) — ratified entries auto-downgrade after configurable maxAge
+- **Event hooks** (v2.0.0) — reactive onChange, onContradiction, onTierChange, onEscalation
+- **Cascade / sub-agent architecture** (v2.1.0) — parent-child session hierarchies with trust delegation
+- **SubAgentCoordinator** (v2.1.0) — lifecycle management for spawning, merging, and shutting down sub-agents
+- **2 internal dependencies** — @private.me/shared + @private.me/crypto (no third-party npm packages)
+
+## Installation
+
+```bash
+npm install @private.me/xcontinuity
+```
+
+## Dependencies
+
+**Runtime Dependencies:**
+- **@private.me/shared** — Result<T,E> error handling primitives
+- **@private.me/crypto** — XorIDA threshold sharing, HMAC, padding, UUID
+
+**Platform Dependencies:**
+- **Web Crypto API** — crypto.subtle with Ed25519 support (Node.js 16.9+ and modern browsers)
+
+## Quick Start
+
+```typescript
+import { SessionManager, MemoryStateStore } from '@private.me/xcontinuity';
+
+// Create session with in-memory store
+const store = new MemoryStateStore();
+const session = SessionManager.create({ agentId: 'agent-001', store });
+
+// Build up state
+session.updateState({ model: 'gpt-4', temperature: 0.7 });
+session.updateState({ conversationCount: 42 });
+
+// Snapshot (XorIDA split + persist)
+const snap = await session.snapshot('after-training');
+if (!snap.ok) throw new Error(snap.error.message);
+
+// Later: restore from snapshot
+const restored = await session.restore(snap.value.stateId);
+if (restored.ok) {
+  console.log(restored.value);
+  // { model: 'gpt-4', temperature: 0.7, conversationCount: 42 }
+}
+
+session.close();
+```
+
+### Quick Start: Trust-Aware Session
+
+```typescript
+import {
+  SessionManager, MemoryStateStore, TrustStore,
+  MissionAuthority, MissionGuard, EnforcementLoop,
+  generateSigningKeyPair, publicKeyToAuthorRef,
+} from '@private.me/xcontinuity';
+
+// Set up trust substrate
+const trustStore = new TrustStore({ defaultMaxAge: 7 * 24 * 60 * 60 * 1000 }); // 7-day TTL
+const authority = new MissionAuthority();
+const guard = new MissionGuard(authority);
+const enforcement = new EnforcementLoop(guard, { escalationThreshold: 3 });
+
+// Create trust-aware session
+const store = new MemoryStateStore();
+const session = SessionManager.create({
+  agentId: 'agent-001',
+  store,
+  trustStore,
+  missionGuard: guard,
+  enforcementLoop: enforcement,
+});
+
+// Subscribe to trust events
+trustStore.on('contradiction', (event) => {
+  console.log(`Contradiction on key "${event.key}"`);
+});
+
+trustStore.on('tierChange', (event) => {
+  console.log(`${event.key}: ${event.oldTier} → ${event.newTier} (${event.reason})`);
+});
+
+// Writes now flow through trust substrate
+session.updateState({ temperature: 0.8 });
+```
+
+## API Reference
+
+### SessionManager
+
+```typescript
+import { SessionManager, MemoryStateStore } from '@private.me/xcontinuity';
+
+const store = new MemoryStateStore();
+const session = SessionManager.create({ agentId: 'agent-1', store });
+
+session.updateState({ key: 'value' });          // Merge patch
+session.setState({ newKey: 'newValue' });        // Replace entire state
+const snap = await session.snapshot('desc');      // Persist as XorIDA shares
+const state = await session.restore(snap.value.stateId);
+await session.suspend();                          // Auto-snapshot + suspend
+const resumed = await session.resume();           // Restore latest + resume
+session.close();                                  // Terminal
+
+// Trust substrate accessors (v2.0.0)
+session.getTrustStore();          // TrustStore | undefined
+session.getMissionGuard();        // MissionGuard | undefined
+session.getEnforcementLoop();     // EnforcementLoop | undefined
+```
+
+### Provenance (Ed25519 Signing)
+
+```typescript
+import {
+  generateSigningKeyPair, signEntry, verifyEntry,
+  publicKeyToAuthorRef, canonicalEntryBytes,
+  hashProvenance, verifyChainLink,
+} from '@private.me/xcontinuity';
+
+const keyPair = await generateSigningKeyPair();
+const authorRef = await publicKeyToAuthorRef(keyPair.publicKey);
+
+// Sign an entry
+const signed = await signEntry('temperature', 0.7, keyPair.privateKey, keyPair.publicKey);
+if (signed.ok) {
+  const provenance = signed.value; // { author, timestamp, signature }
+
+  // Verify signature
+  const valid = await verifyEntry('temperature', 0.7, provenance, keyPair.publicKey);
+  console.log(valid.value); // true
+}
+```
+
+### Trust Tiers
+
+```typescript
+import {
+  baselineTier, effectiveTier, applyDecay, isDecayed,
+  applyContradictionDowngrade, compareTiers, isMoreTrusted,
+} from '@private.me/xcontinuity';
+
+// Assign tier based on provenance
+baselineTier(provenance, true);   // 'ratified' (signed + verified)
+baselineTier(provenance, false);  // 'quarantined' (signed but invalid)
+baselineTier(undefined, false);   // 'inherited' (no provenance)
+
+// Contradiction downgrade
+applyContradictionDowngrade('ratified', 1);   // 'inherited'
+applyContradictionDowngrade('inherited', 1);  // 'quarantined'
+
+// TTL decay
+isDecayed(entry, Date.now()); // true if past maxAge
+applyDecay(entry);            // 'inherited' if decayed, else original tier
+effectiveTier(entry);         // decay + contradictions combined
+```
+
+### TrustStore (Ratification)
+
+```typescript
+import { TrustStore, generateSigningKeyPair } from '@private.me/xcontinuity';
+
+const store = new TrustStore({ defaultMaxAge: 30 * 24 * 60 * 60 * 1000 });
+
+// Write (inherits trust tier from provenance)
+store.write('fact', 'The sky is blue');
+
+// Ratify (sign, promoting to 'ratified')
+const keys = await generateSigningKeyPair();
+await store.ratify('fact', keys.privateKey, keys.publicKey);
+
+// Read with effective tier (applies decay + contradictions)
+const entry = store.read('fact');
+
+// Read only if trusted enough
+const trusted = store.readAtTier('fact', 'ratified');
+
+// Hypothesis (sandbox for speculative writes)
+const hyp = store.hypothesisMode();
+hyp.write('speculative', 'maybe true');
+hyp.commit();   // merge into main store
+// or: hyp.discard();  // abandon changes
+
+// Event hooks
+store.on('change', (e) => console.log(e.key, e.newEntry));
+store.on('contradiction', (e) => console.log(e.key));
+store.on('tierChange', (e) => console.log(e.oldTier, '→', e.newTier));
+store.removeAllListeners();
+```
+
+### Adjudicator (Conflict Resolution)
+
+```typescript
+import { PolicyAdjudicator, ConsensusAdjudicator } from '@private.me/xcontinuity';
+
+// Policy: highest tier → newest timestamp → lowest author DID
+const policy = new PolicyAdjudicator();
+const result = policy.resolve('key', [entryA, entryB]);
+if (result.ok) console.log(result.value.winner, result.value.reason);
+
+// Consensus: multi-agent with quorum
+const consensus = new ConsensusAdjudicator(viewProvider);
+const async_result = await consensus.resolveAsync('key', [entryA]);
+```
+
+### Mission & Enforcement
+
+```typescript
+import {
+  MissionAuthority, MissionGuard, EnforcementLoop,
+  AlignmentAdjudicator, PolicyAdjudicator,
+} from '@private.me/xcontinuity';
+
+// Set up mission authority
+const authority = new MissionAuthority();
+authority.loadTrustedMission({
+  missionId: 'm-1',
+  goal: 'Analyze customer data without PII exposure',
+  authority: authorRef,
+  signature: new Uint8Array(64),
+  issuedAt: Date.now(),
+  scopes: ['read:*', 'write:analysis'],
+});
+
+// Guard with constraints
+const guard = new MissionGuard(authority);
+guard.addConstraint({
+  constraintId: 'no-pii',
+  description: 'Block writes containing PII',
+  evaluate: (action) => ({ allowed: !containsPII(action.value) }),
+});
+
+// Enforcement loop
+const enforcement = new EnforcementLoop(guard, { escalationThreshold: 3 });
+const check = enforcement.check({ author: 'agent-1', type: 'write', key: 'output', value: data });
+// check.value.decision: 'allow' | 'reject' | 'rewrite' | 'escalate'
+
+// Alignment adjudicator (wraps any adjudicator with mission checks)
+const aligned = new AlignmentAdjudicator(new PolicyAdjudicator(), guard);
+```
+
+### Cascade / Sub-Agent Architecture (v2.1.0)
+
+```typescript
+import {
+  CascadeSession, SubAgentCoordinator,
+  SessionManager, TrustStore, MemoryStateStore,
+} from '@private.me/xcontinuity';
+
+// Create root cascade session
+const rootStore = new MemoryStateStore();
+const trustStore = new TrustStore();
+const rootSession = SessionManager.create({ agentId: 'orchestrator', store: rootStore, trustStore });
+const root = new CascadeSession(rootSession, trustStore);
+
+// Write shared context
+trustStore.write('shared-context', 'market analysis data');
+
+// Spawn a child with inherited trust
+const childResult = root.spawnChild('analyst-agent', new MemoryStateStore(), {
+  propagation: 'inherit',    // inherit parent trust entries
+  maxChildTier: 'inherited', // cap child tier at inherited
+  maxDepth: 3,               // max 3 levels of nesting
+  escalateToParent: true,    // child violations propagate up
+});
+
+if (childResult.ok) {
+  const child = childResult.value;
+  // Child automatically has parent's trust entries (at inherited tier)
+  child.getTrustStore().write('analysis-result', 'positive outlook');
+
+  // Merge child state back into parent
+  const childId = child.getSession().session.sessionId;
+  root.mergeChild(childId);
+  // root.getTrustStore() now has 'analysis-result'
+}
+
+// SubAgentCoordinator for managing multiple sub-agents
+const coord = new SubAgentCoordinator(root, { maxAgents: 5, autoMerge: true });
+
+const worker1 = coord.spawn('worker-1', new MemoryStateStore());
+const worker2 = coord.spawn('worker-2', new MemoryStateStore());
+
+// Complete and auto-merge
+if (worker1.ok) coord.complete(worker1.value.getSession().session.sessionId);
+
+// Shutdown all
+coord.shutdown();
+```
+
+### Memory Layers
+
+```typescript
+import { RuntimeMemory, SessionMemory, MemoryStateStore } from '@private.me/xcontinuity';
+
+// Ephemeral in-process memory with LRU eviction
+const runtime = new RuntimeMemory({ maxEntries: 1000 });
+runtime.set('key', 'value');
+const val = runtime.get('key');
+
+// Session-persisted memory backed by XorIDA shares
+const store = new MemoryStateStore();
+const sessionMem = new SessionMemory(store);
+await sessionMem.save({ counter: 42 });
+const restored = await sessionMem.load();
+```
+
+### Error Handling
+
+```typescript
+import { ok, err, continuityError, ERROR_DETAILS } from '@private.me/xcontinuity';
+
+// Result<T, E> pattern — all fallible functions return Result
+const success = ok({ data: 'value' });
+const failure = err(continuityError('SESSION_CLOSED'));
+
+if (!success.ok) {
+  console.log(success.error.code); // error code
+}
+
+// Error details lookup
+const details = ERROR_DETAILS['HMAC_FAILURE'];
+console.log(details); // { family: 'Split', description: 'HMAC verification failed' }
+```
+
+### Hypothesis Mode (Speculative Writes)
+
+```typescript
+import { TrustStore, Hypothesis } from '@private.me/xcontinuity';
+
+const store = new TrustStore();
+store.write('fact', 'known value');
+
+// Hypothesis: sandbox for speculative writes
+const hyp = store.hypothesisMode();
+hyp.write('speculative', 'maybe true');
+hyp.write('fact', 'override attempt');
+
+// Inspect without affecting main store
+const specVal = hyp.read('speculative'); // { value: 'maybe true', ... }
+
+// Commit merges into main store
+hyp.commit();
+// Or: hyp.discard() to abandon changes
+```
+
+### Reverse-XorIDA Extensions (v2.0.0)
+
+```typescript
+import {
+  undoDelta, branchState, squashDeltas,
+  blindUpdateShare, refreshShares,
+  blindEqual, networkCodeShares, networkDecodeShare,
+} from '@private.me/xcontinuity';
+
+// Undo: XOR is self-inverse
+undoDelta(currentShares, deltaShares, prevStateId, hmacKey, hmacSig);
+
+// Branch: independent copy of split state
+const branch = branchState(splitState, 'branch-1');
+
+// Squash: combine sequential deltas
+const squashed = squashDeltas([delta1, delta2, delta3]);
+
+// Blind update: update share without seeing plaintext
+blindUpdateShare(share, deltaData, newId, hmacKey, hmacSig);
+
+// Refresh: re-randomize shares preserving plaintext
+const refreshed = await refreshShares(splitState);
+
+// Blind equality: compare states without decryption
+const equal = blindEqual(stateA, stateB);
+
+// Network coding: combine shares for bandwidth efficiency
+const coded = networkCodeShares([share1, share2]);
+const decoded = networkDecodeShare(coded.value, share1);
+```
+
+### State Serialization
+
+```typescript
+import { serializeState, deserializeState, statesEqual } from '@private.me/xcontinuity';
+
+const snapResult = await serializeState({ counter: 42 }, metadata);
+const desResult = await deserializeState(snapResult.value);
+const equal = statesEqual({ a: 1 }, { a: 1 }); // true
+```
+
+### Chronicle (with Contradiction Detection)
+
+```typescript
+import { Chronicle, detectContradiction } from '@private.me/xcontinuity';
+
+const chronicle = new Chronicle();
+
+// Append with contradiction check
+const contradictions = chronicle.appendWithContradictionCheck(
+  entry, 'temperature', 0.8, 0.7 // old value was 0.7, new is 0.8
+);
+if (contradictions.length > 0) {
+  console.log('Contradictions:', contradictions);
+}
+
+// Query
+const results = chronicle.query({ tags: ['checkpoint'], limit: 10 });
+const forKey = chronicle.getContradictionsForKey('temperature');
+```
+
+### Constants
+
+```typescript
+import {
+  VERSION, DEFAULT_SPLIT_CONFIG, DEFAULT_MAX_AGE,
+  DEFAULT_ENFORCEMENT_CONFIG, TRUST_TIER_RANK,
+} from '@private.me/xcontinuity';
+
+console.log(VERSION);                    // '2.1.0'
+console.log(DEFAULT_SPLIT_CONFIG);       // { n: 3, k: 2 }
+console.log(DEFAULT_MAX_AGE);            // 2592000000 (30 days ms)
+console.log(DEFAULT_ENFORCEMENT_CONFIG); // { escalationThreshold: 3 }
+console.log(TRUST_TIER_RANK);            // { ratified: 3, inherited: 2, quarantined: 1 }
+```
+
+## Reverse-XorIDA
+
+The novel contribution: exploiting `split(A XOR B) = split(A) XOR split(B)` over GF(2).
+
+When updating state, instead of re-splitting the entire state:
+1. Compute `delta = oldPadded XOR newPadded`
+2. Split only the delta: `deltaShares = split(delta)`
+3. XOR each old share with the delta share: `newShares[i] = oldShares[i] XOR deltaShares[i]`
+
+Cost: O(delta) instead of O(state). HMAC is recomputed fresh for integrity.
+
+## Trust Substrate (v2.0.0)
+
+Six-layer architecture for trust-annotated state management:
+
+```
+┌─────────────────────────────────────┐
+│ SubAgentCoordinator (v2.1.0)        │  Multi-agent lifecycle
+├─────────────────────────────────────┤
+│ CascadeSession (v2.1.0)            │  Parent-child trust delegation
+├─────────────────────────────────────┤
+│   SessionManager (Public API)       │  Optional trust integration
+├─────────────────────────────────────┤
+│ Mission + Enforcement               │  Human-anchored goals
+├─────────────────────────────────────┤
+│ TrustStore (Ratification)           │  Write/ratify/restore + events
+├─────────────────────────────────────┤
+│ Adjudicator                         │  Policy or consensus resolution
+├─────────────────────────────────────┤
+│ Trust Tiers + Chronicle             │  Tier management + history
+├─────────────────────────────────────┤
+│ Provenance (Ed25519)                │  Signed entries + chain links
+└─────────────────────────────────────┘
+```
+
+### State Store
+
+```typescript
+import { MemoryStateStore, splitState, reconstructState, serializeState } from '@private.me/xcontinuity';
+
+// In-memory store (async interface for future backends)
+const store = new MemoryStateStore();
+
+// Manual split/reconstruct cycle
+const metadata = { agentId: 'a1', sessionId: 's1', sequenceNumber: 0, createdAt: Date.now(), tags: [] };
+const serialized = await serializeState({ model: 'gpt-4', temp: 0.7 }, metadata);
+if (serialized.ok) {
+  const split = await splitState(serialized.value, { k: 2, n: 3 });
+  if (split.ok) {
+    // Reconstruct from any 2-of-3 shares
+    const restored = await reconstructState([split.value.shares[0], split.value.shares[2]]);
+  }
+}
+```
+
+### TLV Constants
+
+```typescript
+import { CONTINUITY_TLV, VALUE_TYPE } from '@private.me/xcontinuity';
+
+// TLV type tags for binary serialization
+console.log(CONTINUITY_TLV); // { STATE_ENTRY: 0x01, CHECKSUM: 0x02, ... }
+console.log(VALUE_TYPE);      // { STRING: 0x01, NUMBER: 0x02, BOOLEAN: 0x03, ... }
+```
+
+## Session Lifecycle
+
+```
+create() → active → snapshot()/restore() → suspend() → resume() → close()
+```
+
+- **active** — accepting state updates and snapshots
+- **suspended** — state persisted, no updates allowed
+- **closed** — terminal, no further operations
+
+## Error Reference
+
+All fallible functions return `Result<T, ContinuityError>` with structured error codes.
+
+| Error Code | Family | Description |
+|---|---|---|
+| `SERIALIZE_FAILED` | Serialization | State serialization failed |
+| `DESERIALIZE_FAILED` | Serialization | TLV data corrupt or unsupported |
+| `CHECKSUM_MISMATCH` | Serialization | SHA-256 verification failed |
+| `SPLIT_FAILED` | Split | XorIDA threshold split failed |
+| `RECONSTRUCT_FAILED` | Split | Share reconstruction failed |
+| `HMAC_FAILURE` | Split | HMAC verification failed |
+| `INSUFFICIENT_SHARES` | Split | Not enough shares for threshold |
+| `SESSION_CLOSED` | Session | Operation on closed session |
+| `SESSION_SUSPENDED` | Session | Operation on suspended session |
+| `NO_SNAPSHOTS` | Session | No snapshots to restore |
+| `SNAPSHOT_NOT_FOUND` | Session | State ID not in store |
+| `INVALID_SIGNATURE` | Provenance | Ed25519 verification failed |
+| `MISSING_AUTHOR` | Provenance | No author in provenance record |
+| `HASH_CHAIN_BREAK` | Provenance | Parent hash chain gap |
+| `CONTRADICTION_DETECTED` | Trust | Incompatible value for same key |
+| `TRUST_DECAY_EXPIRED` | Trust | Entry past maxAge TTL |
+| `CONSENSUS_FAILED` | Adjudicator | Multi-agent consensus failed |
+| `QUORUM_NOT_MET` | Adjudicator | Insufficient views for quorum |
+| `CONSTRAINT_VIOLATION` | Mission | Action violates hard constraint |
+| `AUTHORITY_EXPIRED` | Mission | Mission signature expired |
+| `SCOPE_EXCEEDED` | Mission | Action outside mission scope |
+| `ACTION_REJECTED` | Enforcement | Action rejected by enforcement |
+| `ESCALATION_TRIGGERED` | Enforcement | Repeated violations, human review |
+
+## Export Control Notice
+
+This package uses cryptographic algorithms (XorIDA threshold sharing, HMAC-SHA256, SHA-256, Ed25519) implemented via the Web Crypto API. Export, re-export, and transfer of cryptographic software may be subject to regulation under the Export Administration Regulations (EAR) and the International Traffic in Arms Regulations (ITAR). Users are responsible for compliance with all applicable export control laws.
+
+## Security
+
+See [SECURITY.md](./SECURITY.md) for vulnerability reporting and security architecture.
+
+## Purchasing
+
+Subscribe via the platform:
+
+```bash
+curl -X POST https://private.me/aci/purchase \
+  -H 'Content-Type: application/json' \
+  -d '{"product":"xcontinuity","tier":"pro"}'
+```
+
+**Response (success):**
+```json
+{ "checkoutUrl": "https://checkout.stripe.com/..." }
+```
+
+**Response (error — RFC 7807):**
+```json
+{
+  "type": "https://private.me/errors/invalid-tier",
+  "title": "Invalid tier",
+  "status": 400,
+  "detail": "Tier must be one of: free, pro"
+}
+```
+
+| Tier | Operations | Price |
+|------|-----------|-------|
+| Free | 100K/month | No credit card required |
+| Pro  | Unlimited  | See [pricing](../../docs/pricing-reference.md) |
+
+## Pricing
+
+**Free Tier:** 100K operations/month with full platform access
+**Pro Tier:** Unlimited operations with SLA and priority support
+
+See [pricing details](https://private.me/subscribe?product=xcontinuity) or [internal reference](../../docs/pricing-reference.md).
+
+[Subscribe to xcontinuity](https://private.me/subscribe?product=xcontinuity)
+
+## Legal
+
+- **Terms of Service**: https://private.me/terms
+- **Privacy Policy**: https://private.me/privacy
+
+## License
+
+Proprietary — Copyright © 2024-2026 Standard Clouds, Inc. (Private.Me) All rights reserved.

package/dist/adjudicator.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @private.me/xcontinuity — Adjudicator (Conflict Resolution)
+ *
+ * Resolves conflicts when multiple entries exist for the same key.
+ *
+ * Two implementations:
+ *   PolicyAdjudicator — deterministic local resolution (default)
+ *   ConsensusAdjudicator — multi-agent IXorIDA-backed resolution
+ *
+ * Deterministic tiebreaker (total ordering):
+ *   1. Highest trust tier
+ *   2. Newest timestamp
+ *   3. Lexicographically lowest author DID
+ *
+ * This guarantees two agents merging the same conflicting entries
+ * always pick the same winner — convergent merge without human input.
+ */
+import type { Result } from '@private.me/shared';
+import type { MemoryEntry, AdjudicatorResult, AgentView } from './types.js';
+import type { ContinuityError } from './errors.js';
+/** Interface for conflict resolution strategies. */
+export interface Adjudicator {
+    /**
+     * Resolve a conflict between candidate entries for the same key.
+     *
+     * @param key - The contested key
+     * @param candidates - Competing entries for this key
+     * @returns The winning entry with reason
+     */
+    resolve(key: string, candidates: readonly MemoryEntry[]): Result<AdjudicatorResult, ContinuityError>;
+}
+/**
+ * Interface for gathering views from multiple agents (used by ConsensusAdjudicator).
+ */
+export interface ViewProvider {
+    /**
+     * Gather views from participating agents for a contested key.
+     *
+     * @param key - The key being contested
+     * @returns Views from each participating agent
+     */
+    gatherViews(key: string): Promise<readonly AgentView[]>;
+}
+/**
+ * Policy-based adjudicator (default).
+ *
+ * Deterministic resolution using total ordering:
+ *   1. Highest effective trust tier (with decay applied)
+ *   2. Newest timestamp (higher = more recent)
+ *   3. Lexicographically lowest author DID (deterministic tiebreaker)
+ */
+export declare class PolicyAdjudicator implements Adjudicator {
+    resolve(key: string, candidates: readonly MemoryEntry[]): Result<AdjudicatorResult, ContinuityError>;
+}
+/**
+ * Consensus-based adjudicator for multi-agent scenarios.
+ *
+ * Gathers views from participating agents via ViewProvider,
+ * then applies majority voting with policy fallback.
+ * Requires a quorum (> 50% of views must agree).
+ */
+export declare class ConsensusAdjudicator implements Adjudicator {
+    private readonly viewProvider;
+    private readonly policyFallback;
+    constructor(viewProvider: ViewProvider);
+    resolve(key: string, candidates: readonly MemoryEntry[]): Result<AdjudicatorResult, ContinuityError>;
+    /**
+     * Async resolution with full multi-agent consensus.
+     *
+     * @param key - The contested key
+     * @param candidates - Local candidates
+     * @returns Consensus-resolved winner
+     */
+    resolveAsync(key: string, candidates: readonly MemoryEntry[]): Promise<Result<AdjudicatorResult, ContinuityError>>;
+}