@claude-flow/cli 3.66.1 → 3.67.0

package/node_modules/@claude-flow/plugin-agent-federation/dist/application/spend-reporter.d.ts

@@ -0,0 +1,150 @@
+/**
+ * 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/node_modules/@claude-flow/plugin-agent-federation/dist/application/trust-evaluator.d.ts

@@ -0,0 +1,74 @@
+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/node_modules/@claude-flow/plugin-agent-federation/dist/bin.d.ts

@@ -0,0 +1,13 @@
+#!/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/node_modules/@claude-flow/plugin-agent-federation/dist/cli-commands.d.ts

@@ -0,0 +1,7 @@
+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/node_modules/@claude-flow/plugin-agent-federation/dist/domain/entities/federation-envelope.d.ts

@@ -0,0 +1,45 @@
+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

package/node_modules/@claude-flow/plugin-agent-federation/dist/domain/entities/federation-node.d.ts

@@ -0,0 +1,104 @@
+import { TrustLevel } from './trust-level.js';
+import { FederationNodeState, SuspensionReason, TransitionReason } from '../value-objects/federation-node-state.js';
+export interface FederationNodeCapabilities {
+    readonly agentTypes: readonly string[];
+    readonly maxConcurrentSessions: number;
+    readonly supportedProtocols: readonly string[];
+    readonly complianceModes: readonly string[];
+}
+export interface FederationNodeMetadata {
+    readonly organizationId?: string;
+    readonly region?: string;
+    readonly version?: string;
+    readonly [key: string]: unknown;
+}
+/** Last-transition record kept on the entity for the audit trail. */
+export interface FederationNodeStateRecord {
+    readonly state: FederationNodeState;
+    readonly changedAt: Date;
+    readonly reason?: SuspensionReason;
+    readonly correlationId?: string;
+}
+export interface FederationNodeProps {
+    readonly nodeId: string;
+    readonly publicKey: string;
+    readonly endpoint: string;
+    readonly capabilities: FederationNodeCapabilities;
+    readonly trustLevel: TrustLevel;
+    readonly trustScore: number;
+    readonly lastSeen: Date;
+    readonly metadata: FederationNodeMetadata;
+    /** Phase 2: peer state. Defaults to ACTIVE if unset. */
+    readonly state?: FederationNodeState;
+    /** Phase 2: when the current state was entered. Defaults to now. */
+    readonly stateChangedAt?: Date;
+    /** Phase 2: why we entered the current non-ACTIVE state. */
+    readonly stateReason?: SuspensionReason;
+    /** Phase 2: caller correlation key for the last transition. */
+    readonly stateCorrelationId?: string;
+}
+export declare class FederationNode {
+    readonly nodeId: string;
+    readonly publicKey: string;
+    readonly endpoint: string;
+    readonly capabilities: FederationNodeCapabilities;
+    private _trustLevel;
+    private _trustScore;
+    private _lastSeen;
+    private readonly _metadata;
+    private _state;
+    private _stateChangedAt;
+    private _stateReason?;
+    private _stateCorrelationId?;
+    constructor(props: FederationNodeProps);
+    get trustLevel(): TrustLevel;
+    get trustScore(): number;
+    get lastSeen(): Date;
+    get metadata(): FederationNodeMetadata;
+    /** Current peer state (ADR-097 Phase 2). */
+    get state(): FederationNodeState;
+    /** When the current state was entered. */
+    get stateChangedAt(): Date;
+    /** Last-transition record for the audit trail. */
+    get stateRecord(): FederationNodeStateRecord;
+    /** Convenience predicate: is this peer accepting outbound sends? */
+    get isActive(): boolean;
+    /** Convenience predicate: is this peer terminally evicted? */
+    get isEvicted(): boolean;
+    updateTrustLevel(level: TrustLevel): void;
+    updateTrustScore(score: number): void;
+    markSeen(): void;
+    isStale(maxAgeMs: number): boolean;
+    /**
+     * Transition this peer to SUSPENDED. Legal from ACTIVE only — calling
+     * from SUSPENDED or EVICTED returns false (the entity is already at or
+     * past the breaker threshold, so a duplicate trip is a no-op).
+     *
+     * Returns true if the state changed, false if the call was rejected
+     * (illegal transition). The breaker treats false as "already handled."
+     */
+    suspend(reason: TransitionReason, now?: Date): boolean;
+    /**
+     * Transition this peer to EVICTED. Legal from ACTIVE or SUSPENDED.
+     * EVICTED is terminal under normal flow — only `reactivate` (operator-
+     * initiated) can move the peer back to ACTIVE.
+     */
+    evict(reason: TransitionReason, now?: Date): boolean;
+    /**
+     * Transition back to ACTIVE. Legal from SUSPENDED (after cooldown +
+     * probe success — the breaker is responsible for those checks; this
+     * entity does not gate on time) or from EVICTED (operator override).
+     *
+     * `correlationId` lets the caller record *why* they're reactivating
+     * (probe ID, operator ticket, etc.) for the audit trail.
+     */
+    reactivate(correlationId?: string, now?: Date): boolean;
+    private _transition;
+    toProps(): FederationNodeProps;
+    static create(props: Omit<FederationNodeProps, 'trustLevel' | 'trustScore' | 'lastSeen'> & {
+        trustLevel?: TrustLevel;
+        trustScore?: number;
+        lastSeen?: Date;
+    }): FederationNode;
+}
+//# sourceMappingURL=federation-node.d.ts.map

package/node_modules/@claude-flow/plugin-agent-federation/dist/domain/entities/federation-session.d.ts

@@ -0,0 +1,55 @@
+import { TrustLevel } from './trust-level.js';
+export interface SessionMetrics {
+    messagesSent: number;
+    messagesReceived: number;
+    piiRedactions: number;
+    threatDetections: number;
+    hmacFailures: number;
+    totalInteractions: number;
+}
+export interface FederationSessionProps {
+    readonly sessionId: string;
+    readonly localNodeId: string;
+    readonly remoteNodeId: string;
+    readonly trustLevel: TrustLevel;
+    readonly negotiatedCapabilities: readonly string[];
+    readonly createdAt: Date;
+    readonly expiresAt: Date;
+    readonly heartbeatInterval: number;
+    readonly sessionToken: string;
+    readonly metrics: SessionMetrics;
+}
+export declare class FederationSession {
+    readonly sessionId: string;
+    readonly localNodeId: string;
+    readonly remoteNodeId: string;
+    readonly negotiatedCapabilities: readonly string[];
+    readonly createdAt: Date;
+    readonly heartbeatInterval: number;
+    readonly sessionToken: string;
+    private _trustLevel;
+    private _expiresAt;
+    private _lastHeartbeat;
+    private _metrics;
+    private _active;
+    constructor(props: FederationSessionProps);
+    get trustLevel(): TrustLevel;
+    get expiresAt(): Date;
+    get lastHeartbeat(): Date;
+    get metrics(): Readonly<SessionMetrics>;
+    get active(): boolean;
+    isExpired(): boolean;
+    isHeartbeatOverdue(): boolean;
+    recordHeartbeat(): void;
+    renew(newExpiresAt: Date): void;
+    updateTrustLevel(level: TrustLevel): void;
+    recordMessageSent(): void;
+    recordMessageReceived(): void;
+    recordPiiRedaction(): void;
+    recordThreatDetection(): void;
+    recordHmacFailure(): void;
+    terminate(): void;
+    toProps(): FederationSessionProps;
+    static createMetrics(): SessionMetrics;
+}
+//# sourceMappingURL=federation-session.d.ts.map

package/node_modules/@claude-flow/plugin-agent-federation/dist/domain/entities/trust-level.d.ts

@@ -0,0 +1,17 @@
+export declare enum TrustLevel {
+    UNTRUSTED = 0,
+    VERIFIED = 1,
+    ATTESTED = 2,
+    TRUSTED = 3,
+    PRIVILEGED = 4
+}
+export interface TrustTransitionThreshold {
+    upgradeScore: number;
+    downgradeScore: number;
+    minInteractions: number;
+}
+export declare const TRUST_TRANSITION_THRESHOLDS: Record<string, TrustTransitionThreshold>;
+export declare const CAPABILITY_GATES: Record<TrustLevel, readonly string[]>;
+export declare function isOperationAllowed(trustLevel: TrustLevel, operation: string): boolean;
+export declare function getTrustLevelLabel(level: TrustLevel): string;
+//# sourceMappingURL=trust-level.d.ts.map

package/node_modules/@claude-flow/plugin-agent-federation/dist/domain/services/audit-service.d.ts

@@ -0,0 +1,69 @@
+export type FederationAuditEventType = 'peer_discovered' | 'peer_manifest_published' | 'handshake_initiated' | 'handshake_completed' | 'handshake_failed' | 'handshake_rejected' | 'session_created' | 'session_renewed' | 'session_expired' | 'session_terminated' | 'message_sent' | 'message_received' | 'message_rejected' | 'message_timeout' | 'pii_detected' | 'pii_stripped' | 'pii_blocked' | 'threat_detected' | 'threat_blocked' | 'threat_learned' | 'claim_checked' | 'claim_denied' | 'trust_level_changed' | 'consensus_proposed' | 'consensus_voted' | 'consensus_reached' | 'consensus_failed';
+export type AuditSeverity = 'info' | 'warn' | 'error' | 'critical';
+export type AuditCategory = 'discovery' | 'handshake' | 'message' | 'pii' | 'security' | 'consensus';
+export type ComplianceMode = 'hipaa' | 'soc2' | 'gdpr' | 'none';
+export interface FederationAuditEvent {
+    readonly eventId: string;
+    readonly timestamp: string;
+    readonly nodeId: string;
+    readonly sessionId?: string;
+    readonly eventType: FederationAuditEventType;
+    readonly severity: AuditSeverity;
+    readonly category: AuditCategory;
+    readonly sourceNodeId?: string;
+    readonly targetNodeId?: string;
+    readonly agentId?: string;
+    readonly trustLevel?: number;
+    readonly piiDetected?: boolean;
+    readonly piiTypesFound?: string[];
+    readonly piiAction?: string;
+    readonly threatDetected?: boolean;
+    readonly threatTypes?: string[];
+    readonly claimsChecked?: string[];
+    readonly claimsResult?: 'granted' | 'denied';
+    readonly latencyMs?: number;
+    readonly messageSizeBytes?: number;
+    readonly complianceMode?: ComplianceMode;
+    readonly dataResidency?: string;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface AuditQuery {
+    readonly eventType?: FederationAuditEventType;
+    readonly severity?: AuditSeverity;
+    readonly category?: AuditCategory;
+    readonly nodeId?: string;
+    readonly sessionId?: string;
+    readonly since?: Date;
+    readonly until?: Date;
+    readonly limit?: number;
+    readonly offset?: number;
+}
+export type AuditExportFormat = 'json' | 'csv' | 'ndjson';
+export interface AuditServiceDeps {
+    generateEventId: () => string;
+    getLocalNodeId: () => string;
+    persistEvent: (event: FederationAuditEvent) => Promise<void>;
+    queryEvents: (query: AuditQuery) => Promise<FederationAuditEvent[]>;
+    onAuditEvent?: (event: FederationAuditEvent) => void;
+}
+export interface AuditServiceConfig {
+    readonly complianceMode: ComplianceMode;
+    readonly dataResidency?: string;
+    readonly retentionDays: number;
+    readonly batchSize: number;
+}
+export declare class AuditService {
+    private readonly deps;
+    private readonly config;
+    private readonly buffer;
+    constructor(deps: AuditServiceDeps, config?: Partial<AuditServiceConfig>);
+    log(eventType: FederationAuditEventType, details?: Partial<Omit<FederationAuditEvent, 'eventId' | 'timestamp' | 'nodeId' | 'eventType' | 'severity' | 'category' | 'complianceMode'>>): Promise<FederationAuditEvent>;
+    query(query: AuditQuery): Promise<FederationAuditEvent[]>;
+    export(query: AuditQuery, format: AuditExportFormat): Promise<string>;
+    flush(): Promise<void>;
+    getBufferSize(): number;
+    private buildEvent;
+    private applyHipaaCompliance;
+    private toCsv;
+}
+//# sourceMappingURL=audit-service.d.ts.map

package/node_modules/@claude-flow/plugin-agent-federation/dist/domain/services/discovery-service.d.ts

@@ -0,0 +1,76 @@
+import { FederationNode } from '../entities/federation-node.js';
+import type { WgManifestSection } from '../value-objects/wg-config.js';
+export type DiscoveryMechanism = 'static' | 'dns-sd' | 'ipfs-registry' | 'a2a-card';
+export interface FederationManifest {
+    readonly nodeId: string;
+    readonly publicKey: string;
+    readonly endpoint: string;
+    readonly capabilities: {
+        readonly agentTypes: readonly string[];
+        readonly maxConcurrentSessions: number;
+        readonly supportedProtocols: readonly string[];
+        readonly complianceModes: readonly string[];
+    };
+    readonly version: string;
+    readonly signature: string;
+    readonly timestamp: string;
+    /**
+     * ADR-111 — optional WG mesh identity. Present only when the publishing
+     * node has opted into the in-tree WG layer (`config.wgMesh: true`).
+     * The Ed25519 manifest signature covers this block too — peers verifying
+     * the manifest also verify the WG-key binding.
+     */
+    readonly wg?: WgManifestSection;
+}
+export interface DiscoveryServiceDeps {
+    signManifest: (manifest: Omit<FederationManifest, 'signature'>) => Promise<string>;
+    verifyManifest: (manifest: FederationManifest) => Promise<boolean>;
+    /**
+     * The Ed25519 key the operator pinned for a node id (hex). A manifest is signed with the key
+     * it carries, so on its own it only proves the sender holds that key; it earns VERIFIED trust
+     * only when the carried key is the pinned one.
+     */
+    pinnedKeyFor?: (nodeId: string) => string | undefined;
+    onPeerDiscovered?: (node: FederationNode) => void;
+}
+export interface DiscoveryConfig {
+    readonly staticPeers: readonly string[];
+    readonly enableDnsSd: boolean;
+    readonly enableIpfsRegistry: boolean;
+    readonly ipfsRegistryCid?: string;
+    readonly discoveryIntervalMs: number;
+    readonly staleThresholdMs: number;
+}
+export declare class DiscoveryService {
+    private readonly deps;
+    private readonly config;
+    private readonly knownPeers;
+    private localManifest;
+    private discoveryTimer;
+    constructor(deps: DiscoveryServiceDeps, config?: Partial<DiscoveryConfig>);
+    publishManifest(manifest: Omit<FederationManifest, 'signature'>): Promise<FederationManifest>;
+    getLocalManifest(): FederationManifest | null;
+    discoverPeers(): Promise<FederationNode[]>;
+    /** Whether the manifest carries the key the operator pinned for its node id. */
+    isPinned(manifest: Pick<FederationManifest, 'nodeId' | 'publicKey'>): boolean;
+    addStaticPeer(endpoint: string, manifest?: FederationManifest): Promise<FederationNode>;
+    /**
+     * Register an externally-discovered peer (e.g. mapped from an A2A Agent
+     * Card via `fromAgentCard`). Unlike `addStaticPeer` this takes a fully
+     * constructed node — the caller owns validation of the external format —
+     * and the node keeps whatever trust level it was constructed with
+     * (A2A-card peers arrive UNTRUSTED). Existing peers are refreshed, not
+     * replaced, so accumulated trust state survives re-discovery.
+     */
+    registerExternalPeer(node: FederationNode): FederationNode;
+    removePeer(nodeId: string): boolean;
+    getPeer(nodeId: string): FederationNode | undefined;
+    listPeers(): FederationNode[];
+    listActivePeers(): FederationNode[];
+    pruneStale(): string[];
+    startPeriodicDiscovery(): void;
+    stopPeriodicDiscovery(): void;
+    private findByEndpoint;
+    private hashEndpoint;
+}
+//# sourceMappingURL=discovery-service.d.ts.map