@claude-flow/plugin-agent-federation 1.0.2 → 1.0.4

package/dist/application/federation-coordinator.d.ts

@@ -1,211 +0,0 @@
-import { FederationNode, type FederationNodeStateRecord } from '../domain/entities/federation-node.js';
-import { FederationSession } from '../domain/entities/federation-session.js';
-import { type FederationMessageType } from '../domain/entities/federation-envelope.js';
-import { TrustLevel } from '../domain/entities/trust-level.js';
-import { type SuspensionReason } from '../domain/value-objects/federation-node-state.js';
-import { DiscoveryService, type FederationManifest } from '../domain/services/discovery-service.js';
-import { HandshakeService } from '../domain/services/handshake-service.js';
-import { RoutingService, type RoutingResult } from '../domain/services/routing-service.js';
-import { AuditService } from '../domain/services/audit-service.js';
-import { PIIPipelineService } from '../domain/services/pii-pipeline-service.js';
-import { TrustEvaluator, type BootstrapElevationAuditEntry } from './trust-evaluator.js';
-import { PolicyEngine } from './policy-engine.js';
-import { enforceBudget, validateBudget } from '../domain/value-objects/federation-budget.js';
-import type { FederationBreakerService } from './federation-breaker-service.js';
-import type { SpendReporter } from './spend-reporter.js';
-import type { WgMeshService, WgCommand } from '../domain/services/wg-mesh-service.js';
-/**
- * Optional per-call budget controls (ADR-097 Phase 1). All fields are
- * optional; omitted means "no limit on that axis" (the default unbounded
- * budget still has maxHops = 8 to defang recursive delegation loops).
- */
-export interface SendOptions {
-    readonly budget?: {
-        maxTokens?: number;
-        maxUsd?: number;
-    };
-    readonly maxHops?: number;
-    /**
-     * How many hops this message has already traveled (0 on the originator).
-     * Phase 1 enforces at the send side because there is no inbound dispatcher
-     * yet; callers re-forwarding a received message should pass the original
-     * envelope's hopCount here.
-     */
-    readonly hopCount?: number;
-    /** Caller-reported usage from the previous leg, for cumulative checks. */
-    readonly spent?: {
-        tokens?: number;
-        usd?: number;
-    };
-}
-export interface FederationCoordinatorConfig {
-    readonly nodeId: string;
-    readonly publicKey: string;
-    readonly endpoint: string;
-    readonly capabilities: readonly string[];
-    /** Wire protocols this runtime is prepared to advertise and negotiate. */
-    readonly supportedProtocols?: readonly string[];
-    readonly version?: string;
-}
-export interface FederationStatus {
-    readonly nodeId: string;
-    readonly activeSessions: number;
-    readonly knownPeers: number;
-    readonly trustLevels: Record<string, TrustLevel>;
-    readonly healthy: boolean;
-}
-/**
- * Optional integrations (ADR-097 Phase 3 upstream + Phase 2.b breaker
- * wiring). Both are constructor-injected; both default to no-op.
- *
- * - `spendReporter` — invoked by reportSpend() when present; persists
- *   the FederationSpendEvent to whatever backend the integrator wired
- *   (cost-tracker bus, ruflo memory federation-spend namespace, etc.)
- * - `breakerService` — invoked by reportSpend() when present; calls
- *   recordOutcome() so the breaker's in-memory rolling buffer is fed
- *   without requiring the integrator to wire two parallel pipelines
- */
-export interface FederationCoordinatorIntegrations {
-    readonly spendReporter?: SpendReporter;
-    readonly breakerService?: FederationBreakerService;
-    /**
-     * ADR-111 Phase 3 — optional WG mesh service. When present, peer state
-     * transitions (evict/reactivate/breaker-suspend) emit `wg set` commands
-     * to a sink supplied by `wgCommandSink`. No-op for peers without a `wg`
-     * manifest block, so wiring the service is safe even in mixed deployments.
-     */
-    readonly wgMesh?: WgMeshService;
-    /**
-     * Where emitted WG commands go. Defaults to the audit log only. Integrators
-     * can plug in a shell executor here (after operator approval — bringing up
-     * a network interface is destructive). Commands include shell-ready
-     * `wg set <iface> ...` strings; the sink should still validate before exec.
-     */
-    readonly wgCommandSink?: (cmd: WgCommand) => void | Promise<void>;
-}
-export declare class FederationCoordinator {
-    private readonly config;
-    private readonly discovery;
-    private readonly handshake;
-    private readonly routing;
-    private readonly audit;
-    private readonly piiPipeline;
-    private readonly trustEvaluator;
-    private readonly policyEngine;
-    private readonly sessions;
-    private initialized;
-    private readonly spendReporter?;
-    private readonly breakerService?;
-    private readonly wgMesh?;
-    private readonly wgCommandSink?;
-    constructor(config: FederationCoordinatorConfig, discovery: DiscoveryService, handshake: HandshakeService, routing: RoutingService, audit: AuditService, piiPipeline: PIIPipelineService, trustEvaluator: TrustEvaluator, policyEngine: PolicyEngine, integrations?: FederationCoordinatorIntegrations);
-    /**
-     * ADR-111 Phase 3 — emit a WG command for an audited peer transition.
-     * No-op if no wgMesh is configured or the peer lacks a `wg` manifest
-     * block. Commands flow to `wgCommandSink` (if any) and always to the
-     * audit log so reactivation is fully traceable.
-     */
-    private emitWgCommand;
-    initialize(manifest: Omit<FederationManifest, 'signature'>): Promise<void>;
-    shutdown(): Promise<void>;
-    joinPeer(endpoint: string, manifest?: FederationManifest): Promise<FederationSession>;
-    leavePeer(nodeId: string): Promise<void>;
-    sendMessage<T>(targetNodeId: string, messageType: FederationMessageType, payload: T, options?: SendOptions): Promise<RoutingResult>;
-    /**
-     * Re-export the budget primitives so external callers (e.g. follow-up
-     * iterations adding receive-side decrement) can reuse them without
-     * dipping into domain/value-objects directly.
-     */
-    static readonly budget: {
-        validate: typeof validateBudget;
-        enforce: typeof enforceBudget;
-    };
-    broadcastMessage<T>(messageType: FederationMessageType, payload: T): Promise<RoutingResult[]>;
-    handleThreatDetection(nodeId: string): void;
-    handleHmacFailure(nodeId: string): void;
-    getStatus(): FederationStatus;
-    /**
-     * ADR-097 Phase 4: per-peer breaker state snapshot for the doctor
-     * surface and `federation_breaker_status` MCP tool.
-     *
-     * Returns one entry per known peer with the entity's stateRecord —
-     * what state, when it changed, why, and which caller's correlation
-     * key triggered it. Pure read; does not mutate.
-     */
-    getPeerStates(): readonly (FederationNodeStateRecord & {
-        readonly nodeId: string;
-    })[];
-    /**
-     * ADR-111 Phase 6: public read of the discovery peer list. Used by
-     * federation_wg_status MCP tool + WG firewall projection. Returns the
-     * full known-peer set (active + suspended + evicted) — filter via
-     * .isActive / state if you only want the live mesh members.
-     */
-    listPeers(): readonly FederationNode[];
-    /**
-     * Aggregated counts for the doctor surface — `{ active: N, suspended: M,
-     * evicted: K }`. Cheap O(peers) sweep; safe to call from a status line.
-     */
-    getPeerStateCounts(): {
-        readonly active: number;
-        readonly suspended: number;
-        readonly evicted: number;
-    };
-    /**
-     * Operator-initiated evict. Returns true on transition, false if the
-     * peer was already EVICTED or unknown. Logs to audit either way.
-     *
-     * Does NOT remove the peer from the discovery registry — `leavePeer`
-     * is the registry-removal API. Eviction is the breaker layer; the peer
-     * remains queryable so the operator can later reactivate.
-     */
-    evictPeer(nodeId: string, reason?: SuspensionReason, correlationId?: string): Promise<boolean>;
-    /**
-     * ADR-097 Phase 3 upstream: report the actual cost of a federated
-     * call. Federation doesn't own model pricing, so the integrator calls
-     * this after the downstream agent completes.
-     *
-     * Fans out to:
-     *   - spendReporter (if injected) — persists to integrator's backend
-     *   - breakerService.recordOutcome (if injected) — feeds the breaker's
-     *     in-memory rolling buffer for cost/failure-ratio thresholds
-     *
-     * Both are no-ops if the corresponding integration isn't wired, so
-     * callers don't need to branch on configuration. Negative tokens/usd
-     * are clamped to 0 at the breaker layer (anti-credit-inflation); the
-     * spend reporter receives the raw values so backends can audit them.
-     *
-     * Auto-fills `ts` if the caller omits it.
-     */
-    reportSpend(input: {
-        readonly peerId: string;
-        readonly taskId?: string;
-        readonly tokensUsed: number;
-        readonly usdSpent: number;
-        readonly success: boolean;
-        readonly ts?: string;
-    }): Promise<void>;
-    /**
-     * Founder-bootstrap trust elevation (ADR-164 §3.5.4 — operator escape hatch
-     * used in the autopilot Day-1 scenario where a freshly-joined BBS peer
-     * needs TRUSTED before organic minInteractions thresholds can accrue).
-     *
-     * Refuses if the target node is not a registered federation peer (returns
-     * null). On success, writes a `trust_level_changed` audit entry tagged
-     * `bootstrap_elevation` with the operator-supplied reason, and returns
-     * the audit entry so the CLI / caller can print it to stdout.
-     */
-    bootstrapElevatePeer(nodeId: string, newLevel: TrustLevel, reason: string): Promise<BootstrapElevationAuditEntry | null>;
-    /**
-     * Operator-initiated reactivate. Used after an integrator-supplied
-     * health probe confirms a SUSPENDED peer is healthy, OR as an
-     * operator-override escape from EVICTED. Returns true on transition.
-     */
-    reactivatePeer(nodeId: string, correlationId?: string): Promise<boolean>;
-    getSession(sessionId: string): FederationSession | undefined;
-    getActiveSessions(): FederationSession[];
-    private establishSession;
-    private findSessionByNodeId;
-    private ensureInitialized;
-}
-//# sourceMappingURL=federation-coordinator.d.ts.map

package/dist/application/inbound-dispatcher.d.ts

@@ -1,113 +0,0 @@
-/**
- * Inbound message dispatcher (ADR-109).
- *
- * The federation plugin's `transport.listen()` accepts inbound bytes
- * but until this module landed, the bytes had no consumer — they sat
- * in the transport's per-address message queue with no one polling.
- *
- * `dispatchInbound()` is what the plugin registers as the
- * transport.onMessage handler. For each received message it:
- *
- *   1. Resolves the sender via `sourceNodeId` in metadata
- *   2. Verifies the peer is in the discovery registry (unknown → reject)
- *   3. Verifies peer is ACTIVE (SUSPENDED/EVICTED → reject defense-in-depth)
- *   4. Audits success or rejection
- *   5. Emits a typed event on the eventBus for the integrator to handle
- *
- * Anti-coupling: dispatcher does NOT actually execute inbound tasks.
- * That's the integrator's job. The dispatcher's contract is "deliver
- * an envelope to the integrator's handler IFF it passes safety gates."
- */
-import type { AgentMessage } from '../transport/midstream-aware-loader.js';
-import type { DiscoveryService } from '../domain/services/discovery-service.js';
-import type { AuditService } from '../domain/services/audit-service.js';
-import type { FederationNode } from '../domain/entities/federation-node.js';
-export declare const FEDERATION_INBOUND_EVENT_PREFIX = "federation:inbound";
-/** Reasons we reject an inbound message — constant strings, no oracle leak. */
-export type InboundRejectionReason = 'PEER_UNKNOWN' | 'PEER_SUSPENDED' | 'PEER_EVICTED' | 'MISSING_METADATA' | 'INVALID_PAYLOAD' | 'INVALID_SIGNATURE' | 'LEGACY_SIGNATURE_TYPE_REJECTED' | 'AUTHORIZATION_DENIED' | 'AUTHORIZATION_ERROR';
-/**
- * Verifier function for inbound envelopes. Given the canonical bytes of
- * the message + the claimed signature + the peer's published public
- * key, returns true iff the signature is valid. Plugin wires this with
- * `@noble/ed25519`; tests inject a mock.
- *
- * Returning `null` means "no signature provided" — handled by the
- * dispatcher as INVALID_SIGNATURE (defense: unsigned messages from
- * known peers are still rejected).
- */
-export type EnvelopeVerifier = (canonicalBytes: string, signatureHex: string | null, peerPublicKeyHex: string) => boolean;
-export declare const JCS_SIGNATURE_PROTOCOL: "ruflo-signature-jcs-v1";
-export type EnvelopeSignatureVersion = 'legacy-v1' | 'jcs-v1';
-export type EnvelopeSignatureMode = 'legacy' | 'prefer-jcs' | 'require-jcs';
-/**
- * Updated peers advertise and negotiate recursively complete JCS signatures
- * without operator configuration. Legacy mode remains explicit for low-risk
- * heartbeat/status interoperability only.
- */
-export declare const DEFAULT_ENVELOPE_SIGNATURE_MODE: EnvelopeSignatureMode;
-export type InboundAuthorizationMode = 'legacy' | 'observe' | 'enforce';
-export declare function isLegacyEnvelopeTypeAllowed(messageType: string): boolean;
-export interface InboundAuthorizationRequest {
-    readonly address: string;
-    readonly sourceNodeId: string;
-    readonly messageType: string;
-    readonly message: AgentMessage;
-    readonly peer: FederationNode;
-    readonly signatureVersion: EnvelopeSignatureVersion;
-    readonly messageSizeBytes: number;
-}
-export interface InboundAuthorizationDecision {
-    readonly allowed: boolean;
-    readonly reason?: string;
-}
-export type InboundAuthorizationEvaluator = (request: InboundAuthorizationRequest) => InboundAuthorizationDecision | Promise<InboundAuthorizationDecision>;
-/** Dispatch dependencies (kept narrow for testability). */
-export interface InboundDispatchDeps {
-    readonly discovery: Pick<DiscoveryService, 'getPeer'>;
-    readonly audit: Pick<AuditService, 'log'>;
-    readonly eventBus: {
-        emit: (event: string, data: unknown) => void;
-    };
-    readonly logger: {
-        debug: (m: string) => void;
-        warn: (m: string) => void;
-    };
-    /**
-     * Optional Ed25519 envelope verifier. When PROVIDED, every accepted
-     * message MUST pass verification — `null` signature or false-returning
-     * verifier rejects the message as INVALID_SIGNATURE.
-     *
-     * When OMITTED, the dispatcher operates in legacy "trust the metadata"
-     * mode (backward compat for tests that inject minimal deps). Production
-     * MUST inject this — see the plugin.ts wiring.
-    */
-    readonly verifyEnvelope?: EnvelopeVerifier;
-    /** Defaults to both versions; enforce-only deployments pass `['jcs-v1']`. */
-    readonly acceptedSignatureVersions?: readonly EnvelopeSignatureVersion[];
-    /** Compatibility mode defaults to legacy; enforce is fail-closed. */
-    readonly authorizationMode?: InboundAuthorizationMode;
-    /** Injected policy decision point. It is always called before event emission. */
-    readonly authorizeInbound?: InboundAuthorizationEvaluator;
-}
-export declare function selectEnvelopeSignatureVersion(mode: EnvelopeSignatureMode, peerProtocols: readonly string[], messageType?: string): EnvelopeSignatureVersion;
-export declare function canonicalizeEnvelopeForVerify(message: AgentMessage, requestedVersion?: EnvelopeSignatureVersion): string;
-/** Outcome reported to the caller (mostly for tests + observability). */
-export type InboundDispatchOutcome = {
-    readonly accepted: true;
-    readonly sourceNodeId: string;
-    readonly messageType: string;
-} | {
-    readonly accepted: false;
-    readonly reason: InboundRejectionReason;
-};
-/**
- * Process one received message. Pure-ish: no side effects beyond audit
- * + event emission, both injected.
- *
- * `address` is the wire-level remote (e.g. `192.168.1.42:54321`).
- * `message.metadata.sourceNodeId` is the cryptographic identity claim.
- * The two MAY differ (e.g. behind NAT) — we trust `sourceNodeId` for
- * peer lookup since it's bound to the Ed25519 keypair.
- */
-export declare function dispatchInbound(address: string, message: AgentMessage, deps: InboundDispatchDeps): Promise<InboundDispatchOutcome>;
-//# sourceMappingURL=inbound-dispatcher.d.ts.map

package/dist/application/policy-engine.d.ts

@@ -1,41 +0,0 @@
-import { TrustLevel } from '../domain/entities/trust-level.js';
-import { type PIIAction, type PIIDetection, type PIIPolicyConfig } from '../domain/services/pii-pipeline-service.js';
-import { type FederationMessageType } from '../domain/entities/federation-envelope.js';
-export type FederationClaimType = 'federation:discover' | 'federation:connect' | 'federation:read' | 'federation:write' | 'federation:admin' | 'federation:memory' | 'federation:spawn';
-export interface SecurityPolicy {
-    readonly maxMessageSizeBytes: number;
-    readonly maxMessagesPerMinute: number;
-    readonly allowedMessageTypes: readonly FederationMessageType[];
-    readonly requirePiiScan: boolean;
-    readonly requireAiDefenceScan: boolean;
-    readonly minTrustLevelForWrite: TrustLevel;
-    readonly minTrustLevelForMemory: TrustLevel;
-    readonly minTrustLevelForSpawn: TrustLevel;
-}
-export interface PolicyEvaluationResult {
-    readonly allowed: boolean;
-    readonly reason: string;
-    readonly requiredClaims: readonly FederationClaimType[];
-    readonly trustLevelSufficient: boolean;
-    readonly piiAction?: PIIAction;
-}
-export interface PolicyEngineDeps {
-    checkClaim: (claim: FederationClaimType) => boolean;
-}
-export declare class PolicyEngine {
-    private readonly deps;
-    private readonly securityPolicy;
-    private readonly piiPolicy;
-    private readonly rateLimitCounters;
-    constructor(deps: PolicyEngineDeps, securityPolicy?: Partial<SecurityPolicy>, piiPolicy?: PIIPolicyConfig);
-    evaluateMessage(messageType: FederationMessageType, trustLevel: TrustLevel, messageSizeBytes: number, sourceNodeId: string): PolicyEvaluationResult;
-    evaluatePiiDetection(detection: PIIDetection, trustLevel: TrustLevel): PIIAction;
-    evaluateTrustChange(currentLevel: TrustLevel, proposedLevel: TrustLevel): {
-        allowed: boolean;
-        requiresHumanApproval: boolean;
-        reason: string;
-    };
-    private checkRateLimit;
-    private getOperationForMessageType;
-}
-//# sourceMappingURL=policy-engine.d.ts.map

package/dist/application/spend-reporter.d.ts

@@ -1,150 +0,0 @@
-/**
- * Federation spend-reporting interface (ADR-097 Phase 3 upstream).
- *
- * The federation layer doesn't own model pricing — it can't know how much
- * a downstream agent's work cost until the integrator tells it. So the
- * coordinator exposes a `reportSpend()` method that callers invoke after
- * their downstream completes, and that method fans out to:
- *
- *   1. The injected SpendReporter (if any) — typically wires to the
- *      cost-tracker bus / `federation-spend` memory namespace
- *   2. The injected FederationBreakerService (if any) — its in-memory
- *      buffer becomes a transparent cache when the cost-tracker
- *      subscriber lands
- *
- * Both deps are constructor-optional. A coordinator with neither still
- * accepts reportSpend() calls (silent no-op) so callers don't need to
- * branch on which integrations are wired.
- *
- * Event shape matches the consumer contract pinned by
- * plugins/ruflo-cost-tracker/scripts/federation.mjs:
- *
- *   { peerId, taskId, tokensUsed, usdSpent, ts }
- *
- * Storage layout (consumer convention): namespace `federation-spend`,
- * key `fed-spend-<peerId>-<ts>`. The interface is storage-agnostic; the
- * default in-memory reporter included here is for tests + a reference
- * implementation. Production integrators write a thin adapter that
- * persists to ruflo memory / Redis / Datadog / their accounting system.
- */
-/** A single per-send cost report from the integrator. */
-export interface FederationSpendEvent {
-    /** Peer this cost was incurred against. */
-    readonly peerId: string;
-    /** Optional task correlation key — not all callers will have one. */
-    readonly taskId?: string;
-    /** Tokens consumed (input + output). Negative values clamped to 0 by sink. */
-    readonly tokensUsed: number;
-    /** USD spent. Negative values clamped to 0 by sink. */
-    readonly usdSpent: number;
-    /** ISO 8601 timestamp. Caller-supplied for testability; auto-filled if omitted by reportSpend. */
-    readonly ts: string;
-    /** Whether the underlying send succeeded (drives breaker failure-ratio). */
-    readonly success: boolean;
-}
-/**
- * Strategy interface the coordinator calls when reportSpend() fires.
- * Integrators implement this to push the event to whatever backend they
- * want — cost-tracker bus, Datadog, accounting DB, etc.
- *
- * Implementations must be tolerant: dropping or persisting later is
- * acceptable, but throwing here will surface to the integrator's caller.
- * Buffer and retry inside the implementation.
- */
-export interface SpendReporter {
-    reportSpend(event: FederationSpendEvent): Promise<void>;
-}
-/**
- * In-memory reporter for tests + a reference implementation. Production
- * code should wire a real SpendReporter that persists to durable storage.
- *
- * Buffer is unbounded — fine for tests, NOT fine for long-running
- * production. The cost-tracker consumer reads from durable storage, not
- * from this buffer.
- */
-export declare class InMemorySpendReporter implements SpendReporter {
-    private readonly buffer;
-    reportSpend(event: FederationSpendEvent): Promise<void>;
-    /** Snapshot of all reported events (test inspection). */
-    getEvents(): readonly FederationSpendEvent[];
-    /** Drop everything (test cleanup). */
-    clear(): void;
-}
-/**
- * Minimal memory-backend interface (ADR-110). The integrator wires this
- * to whatever store satisfies their durability/consistency needs:
- * ruflo memory, Redis, DynamoDB, file-backed JSON, etc. The federation
- * plugin doesn't import any specific memory client — pluggable by
- * design.
- */
-export interface MemoryStore {
-    /** Persist a value under (namespace, key). Optional TTL in seconds. */
-    store(args: {
-        namespace: string;
-        key: string;
-        value: string;
-        ttl?: number;
-    }): Promise<void>;
-}
-/** Configuration for `MemorySpendReporter`. See ADR-110. */
-export interface MemorySpendReporterConfig {
-    /** Memory store impl. Required. */
-    readonly memoryStore: MemoryStore;
-    /** Namespace per the cost-tracker consumer contract. Default: `federation-spend`. */
-    readonly namespace?: string;
-    /** Optional TTL in seconds. Default: 7 days. Cost-tracker rolling windows are 1h/24h/7d, so anything older is irrelevant. */
-    readonly ttlSeconds?: number;
-}
-/** Default namespace per cost-tracker's `plugins/ruflo-cost-tracker/scripts/federation.mjs`. */
-export declare const DEFAULT_FEDERATION_SPEND_NAMESPACE = "federation-spend";
-/** Default TTL: 7 days, matching cost-tracker's longest rolling window. */
-export declare const DEFAULT_FEDERATION_SPEND_TTL_SECONDS: number;
-/**
- * Production reporter (ADR-110) that satisfies the cost-tracker
- * consumer contract: writes to namespace `federation-spend`, key
- * `fed-spend-<peerId>-<ts>`. The consumer
- * (`plugins/ruflo-cost-tracker/scripts/federation.mjs`) `memory list`s
- * the namespace, retrieves each key, and aggregates into rolling
- * windows.
- *
- * Storage-agnostic: the integrator injects a `MemoryStore`
- * implementation. Common wirings:
- *
- *   // ruflo memory MCP
- *   new MemorySpendReporter({
- *     memoryStore: {
- *       store: async (a) => mcpClient.call('memory_store', a),
- *     },
- *   });
- *
- *   // ruflo memory CLI shell-out
- *   new MemorySpendReporter({
- *     memoryStore: {
- *       store: async ({namespace, key, value, ttl}) => {
- *         await execFile('npx', ['ruflo', 'memory', 'store',
- *           '--namespace', namespace, '--key', key, '--value', value]);
- *       },
- *     },
- *   });
- *
- * Errors from the memory backend BUBBLE UP — the reporter does not
- * retry/swallow. Wrap with the integrator's preferred retry strategy
- * if needed.
- *
- * Negative `tokensUsed` / `usdSpent` are persisted as-is. Clamping is
- * the breaker's responsibility (see federation-breaker-service.ts);
- * the audit/spend log is an honest mirror of what the integrator
- * reported.
- */
-export declare class MemorySpendReporter implements SpendReporter {
-    private readonly memoryStore;
-    private readonly namespace;
-    private readonly ttlSeconds;
-    constructor(config: MemorySpendReporterConfig);
-    reportSpend(event: FederationSpendEvent): Promise<void>;
-    /** Read configured namespace (for the doctor/debug surface). */
-    getNamespace(): string;
-    /** Read configured TTL in seconds. */
-    getTtlSeconds(): number;
-}
-//# sourceMappingURL=spend-reporter.d.ts.map

package/dist/application/trust-evaluator.d.ts

@@ -1,74 +0,0 @@
-import { TrustLevel } from '../domain/entities/trust-level.js';
-import { FederationNode } from '../domain/entities/federation-node.js';
-import { type SessionMetrics } from '../domain/entities/federation-session.js';
-export interface TrustScoreComponents {
-    readonly successRate: number;
-    readonly uptime: number;
-    readonly threatPenalty: number;
-    readonly dataIntegrityScore: number;
-}
-export interface TrustTransitionResult {
-    readonly previousLevel: TrustLevel;
-    readonly newLevel: TrustLevel;
-    readonly score: number;
-    readonly components: TrustScoreComponents;
-    readonly reason: string;
-    readonly requiresHumanApproval: boolean;
-}
-export type ImmediateDowngradeReason = 'repeated-threat-detection' | 'hmac-verification-failure' | 'session-hijack-attempt';
-export interface TrustEvaluatorDeps {
-    onTrustChange?: (nodeId: string, result: TrustTransitionResult) => void;
-}
-/**
- * Audit record emitted by `bootstrapElevate`. Captures the bypass intent,
- * the operator-supplied reason, and the before/after trust levels so that
- * downstream audit consumers can flag bootstrap elevations distinctly from
- * organic trust transitions. See ADR-164 §3.5.4.
- */
-export interface BootstrapElevationAuditEntry {
-    readonly tag: 'bootstrap_elevation';
-    readonly nodeId: string;
-    readonly previousLevel: TrustLevel;
-    readonly newLevel: TrustLevel;
-    readonly reason: string;
-    readonly timestamp: string;
-    readonly operatorBypass: true;
-}
-export interface ThreatWindow {
-    readonly detections: Date[];
-    readonly windowMs: number;
-    readonly threshold: number;
-}
-export declare class TrustEvaluator {
-    private readonly deps;
-    private readonly threatWindows;
-    constructor(deps?: TrustEvaluatorDeps);
-    computeScore(metrics: SessionMetrics, uptimeRatio: number): {
-        score: number;
-        components: TrustScoreComponents;
-    };
-    evaluateTransition(node: FederationNode, metrics: SessionMetrics, uptimeRatio: number, hasInstitutionalAttestation?: boolean): TrustTransitionResult | null;
-    downgrade(node: FederationNode, reason: ImmediateDowngradeReason): TrustTransitionResult;
-    /**
-     * Founder-bootstrap trust elevation (ADR-164 §3.5.4).
-     *
-     * Bypasses the organic trust-accrual thresholds (minInteractions: 500 for
-     * 2→3, etc.) so a freshly-joined BBS peer can be hand-promoted to
-     * TRUSTED on Day 1, before its interaction count has accrued. This is an
-     * operator escape hatch — every invocation MUST be recorded as a special
-     * `bootstrap_elevation` audit entry so it is distinguishable from organic
-     * upgrades. `reason` MUST be a non-empty operator-supplied string.
-     *
-     * The caller is responsible for refusing to invoke this method when the
-     * target node is not a registered federation peer; this function trusts
-     * its inputs and only performs the elevation + audit construction.
-     *
-     * @returns audit entry tagged `bootstrap_elevation` ready to be persisted.
-     */
-    bootstrapElevate(node: FederationNode, newLevel: TrustLevel, reason: string): BootstrapElevationAuditEntry;
-    recordThreatDetection(nodeId: string): boolean;
-    private checkUpgrade;
-    private checkDowngrade;
-    private computeThreatPenalty;
-}
-//# sourceMappingURL=trust-evaluator.d.ts.map

package/dist/bin.d.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-/**
- * Standalone CLI shim for @claude-flow/plugin-agent-federation.
- * Maps `ruflo-federation <subcommand> [args]` -> CLICommandDefinition handlers.
- *
- * Auth/config via .env (loaded from CWD or any parent):
- *   FEDERATION_NODE_NAME      - this node's identity (default: hostname)
- *   FEDERATION_BIND_HOST      - bind address (default: 127.0.0.1, ADR-166 Phase 3d)
- *   FEDERATION_BIND_PORT      - bind port (default: 8443)
- *   FEDERATION_TRUST_LEVEL    - default trust tier (default: untrusted)
- */
-export {};
-//# sourceMappingURL=bin.d.ts.map

package/dist/cli-commands.d.ts

@@ -1,7 +0,0 @@
-import type { CLICommandDefinition, PluginContext } from '@claude-flow/shared/src/plugin-interface.js';
-import type { FederationCoordinator } from './application/federation-coordinator.js';
-type CoordinatorGetter = () => FederationCoordinator | null;
-type ContextGetter = () => PluginContext | null;
-export declare function createCliCommands(getCoordinator: CoordinatorGetter, getContext: ContextGetter): CLICommandDefinition[];
-export {};
-//# sourceMappingURL=cli-commands.d.ts.map

package/dist/domain/entities/federation-envelope.d.ts

@@ -1,45 +0,0 @@
-export type FederationMessageType = 'task-assignment' | 'memory-query' | 'memory-response' | 'context-share' | 'status-broadcast' | 'trust-change' | 'topology-change' | 'agent-spawn' | 'heartbeat' | 'challenge' | 'challenge-response' | 'handshake-init' | 'handshake-accept' | 'handshake-reject' | 'session-terminate' | 'claim-event' | 'agent-handoff';
-export type PIIScanAction = 'pass' | 'redact' | 'hash' | 'block';
-export interface PIIScanResult {
-    readonly scanned: boolean;
-    readonly piiFound: boolean;
-    readonly detections: readonly PIIScanDetection[];
-    readonly actionsApplied: readonly PIIScanAction[];
-    readonly scanDurationMs: number;
-}
-export interface PIIScanDetection {
-    readonly type: string;
-    readonly action: PIIScanAction;
-    readonly confidence: number;
-}
-export interface FederationEnvelopeProps<T = unknown> {
-    readonly envelopeId: string;
-    readonly sourceNodeId: string;
-    readonly targetNodeId: string;
-    readonly sessionId: string;
-    readonly messageType: FederationMessageType;
-    readonly payload: T;
-    readonly timestamp: Date;
-    readonly nonce: string;
-    readonly hmacSignature: string;
-    readonly piiScanResult: PIIScanResult;
-}
-export declare class FederationEnvelope<T = unknown> {
-    readonly envelopeId: string;
-    readonly sourceNodeId: string;
-    readonly targetNodeId: string;
-    readonly sessionId: string;
-    readonly messageType: FederationMessageType;
-    readonly payload: T;
-    readonly timestamp: Date;
-    readonly nonce: string;
-    readonly hmacSignature: string;
-    readonly piiScanResult: PIIScanResult;
-    constructor(props: FederationEnvelopeProps<T>);
-    isExpired(maxAgeMs: number): boolean;
-    toJSON(): Record<string, unknown>;
-    toSignablePayload(): string;
-    static emptyScanResult(): PIIScanResult;
-}
-export declare const CONSENSUS_REQUIRED_TYPES: ReadonlySet<FederationMessageType>;
-//# sourceMappingURL=federation-envelope.d.ts.map