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

package/dist/domain/services/wg-mesh-service.d.ts

@@ -1,156 +0,0 @@
-/**
- * ADR-111 Phase 2 — WgMeshService.
- *
- * Pure-projection service: takes the federation peer registry + local
- * WG identity and produces (a) a `wg-quick`-compatible config string,
- * (b) per-peer `wg set` commands the operator runs to converge an
- * already-running interface, and (c) the AllowedIPs slice that maps to
- * each peer's trust level.
- *
- * Deliberately does NOT shell out. Bringing up a network interface
- * requires root and modifies system state — per CLAUDE.md's
- * destructive-actions guidance the service emits the commands; the
- * operator (or a thin shell wrapper they audit) runs them.
- *
- * Phase 3 (breaker integration) consumes this service: peer state
- * transitions invoke removeAllowedIPs/removePeer/restoreAllowedIPs,
- * which produce commands without side effects.
- */
-import { TrustLevel } from '../entities/trust-level.js';
-import { FederationNode } from '../entities/federation-node.js';
-import type { WgLocalKey } from '../value-objects/wg-config.js';
-export interface WgPortRule {
-    readonly proto: 'tcp' | 'udp' | 'all';
-    readonly port?: number;
-    readonly portRange?: readonly [number, number];
-}
-/**
- * Trust-level → reachability. ADR-111's `WG_NETWORK_GATES`.
- *
- * Note: WireGuard's `AllowedIPs` is L3 routing, not L4 ACL — these port
- * rules describe what the L4 firewall (Phase 4: nftables/pf) should
- * enforce. v1 (this phase) only produces the rules; Phase 4 projects
- * them into kernel firewall syntax. Until then, callers using v1
- * fall back to the simpler "AllowedIPs = peer's mesh IP" model (option
- * (b) in the ADR — app-layer auth carries the access decision).
- */
-export declare const WG_NETWORK_GATES: Record<TrustLevel, readonly WgPortRule[]>;
-/**
- * Minimum trust level whose peers get a `[Peer]` block in the WG config.
- * UNTRUSTED stays out of the mesh entirely — it's the explicit drop bucket.
- */
-export declare const WG_MIN_MESH_TRUST: TrustLevel;
-export interface WgPeerFields {
-    readonly wgPublicKey: string;
-    readonly wgMeshIP: string;
-    readonly wgEndpoint: string;
-}
-/**
- * Return the validated peer wg fields, or null if any is malformed or
- * out-of-range. Callers treat null as "peer not eligible for mesh" — the
- * peer stays in the federation discovery registry but is excluded from
- * the wg config and any wg commands.
- */
-export declare function readSafePeerWgFields(peer: FederationNode): WgPeerFields | null;
-export interface WgMeshServiceConfig {
-    /** Local interface name. Defaults to `ruflo-fed`. */
-    readonly interfaceName?: string;
-    /** Local UDP listen port. WireGuard's standard is 51820. */
-    readonly listenPort?: number;
-    /** Mesh subnet for AllowedIPs filtering. Defaults to DEFAULT_MESH_SUBNET. */
-    readonly meshSubnet?: string;
-}
-export interface WgPeerSummary {
-    readonly nodeId: string;
-    readonly trustLevel: TrustLevel;
-    readonly trustLabel: string;
-    readonly meshIP: string;
-    readonly endpoint: string;
-    readonly publicKey: string;
-    readonly state: 'active' | 'suspended' | 'evicted';
-    readonly allowedIPs: readonly string[];
-}
-/**
- * A planned `wg(8)` mutation. Service consumers either execute these or
- * surface them to the operator. Strings are validated for shell metachars
- * before being formatted into a command — callers should still review.
- */
-export interface WgCommand {
-    readonly verb: 'set-allowed-ips' | 'remove-allowed-ips' | 'remove-peer' | 'add-peer';
-    /** Public key of the peer this command targets. */
-    readonly peerPublicKey: string;
-    /** Render to a `wg set <iface> peer <pk> ...` shell-ready string. */
-    readonly cmd: string;
-    /** Human-readable rationale for audit logs. */
-    readonly rationale: string;
-}
-export declare class WgMeshService {
-    private readonly interfaceName;
-    private readonly listenPort;
-    private readonly meshSubnet;
-    private localKey;
-    private localMeshIP;
-    /** Per-peer AllowedIPs after the last applyTrustLevelToAllowedIPs() call. Drives restore from breaker. */
-    private readonly lastAppliedAllowedIPs;
-    /** Peer-pubkey → suspended flag for breaker integration. */
-    private readonly suspended;
-    /** Peer-pubkey → evicted flag. */
-    private readonly evicted;
-    constructor(config?: WgMeshServiceConfig);
-    /** Bind the local WG identity. Required before buildInterfaceConfig(). */
-    setLocalIdentity(key: WgLocalKey, meshIP: string): void;
-    getInterfaceName(): string;
-    getMeshSubnet(): string;
-    /**
-     * Build a `wg-quick`-compatible config string from current peers.
-     *
-     * Peers below WG_MIN_MESH_TRUST (UNTRUSTED) are excluded entirely.
-     * Suspended peers stay in the config but with `AllowedIPs =` empty
-     * (soft-block). Evicted peers are dropped completely.
-     *
-     * Operator writes this to `/etc/wireguard/<interface>.conf` and runs
-     * `wg-quick up <interface>`.
-     */
-    buildInterfaceConfig(peers: readonly FederationNode[]): string;
-    /**
-     * Compute the AllowedIPs slice for a peer at its current trust level.
-     * v1: each peer gets its own /32 mesh IP. Phase 4 will narrow this
-     * further via firewall rules; v1 keeps L3 broad and relies on the app
-     * layer + trust gates for access decisions.
-     */
-    computeAllowedIPs(peer: FederationNode, meshIP: string): readonly string[];
-    /**
-     * Apply trust level → AllowedIPs as a `wg set` command for an
-     * already-running interface. Used when a peer joins or its trust level
-     * changes without needing a full config rewrite.
-     */
-    applyTrustLevelToAllowedIPs(peer: FederationNode, meshIP: string, pubkey: string): WgCommand;
-    /**
-     * Phase 3 hook — peer SUSPENDED. Clear AllowedIPs (soft-block: keeps
-     * the peer's public key registered with the interface but blocks all
-     * routing to/from it).
-     */
-    removeAllowedIPs(peer: FederationNode, pubkey: string, reason?: string): WgCommand;
-    /**
-     * Phase 3 hook — peer reactivated. Restore the AllowedIPs slice that
-     * was active before suspension. Returns null if the peer was never
-     * suspended (idempotent).
-     */
-    restoreAllowedIPs(peer: FederationNode, meshIP: string, pubkey: string): WgCommand | null;
-    /**
-     * Phase 3 hook — peer EVICTED. Terminal removal from the mesh; the
-     * peer's `[Peer]` block is dropped on next config rebuild and an
-     * immediate `wg set <iface> peer <pk> remove` is emitted to flush
-     * runtime state without a config reload.
-     */
-    removePeer(peer: FederationNode, pubkey: string, reason?: string): WgCommand;
-    /** Summarize the mesh state for `federation_wg_status` (Phase 6) and audit. */
-    summarize(peers: readonly FederationNode[]): readonly WgPeerSummary[];
-    /**
-     * Defense-in-depth: validate that all bits we splice into a shell
-     * command are alphanumeric / base64 / WG-allowed chars. Refuses the
-     * command rather than ship a substring that might escape its slot.
-     */
-    private formatCmd;
-}
-//# sourceMappingURL=wg-mesh-service.d.ts.map

package/dist/domain/services/wg-witness-service.d.ts

@@ -1,98 +0,0 @@
-/**
- * ADR-111 Phase 5 — Witness attestation chain for WG mesh mutations.
- *
- * Every coordination change (peer added/suspended/evicted/reactivated,
- * keypair rotated) appends a signed entry to an append-only log
- * `.claude-flow/federation/wg-changes.log`. The signature is over a
- * canonical JSON encoding of the entry's content fields, using the
- * operator's federation Ed25519 key — the same identity that signs
- * federation manifests, so anyone who already trusts the manifest chain
- * automatically trusts the WG change chain.
- *
- * Append-only via O_APPEND open + entries chained by prevHash (sha256 of
- * the previous entry's canonical bytes). Tampering with history requires
- * forging a chain of signatures with the operator's key.
- *
- * The periodic ruflo witness regen (plugins/ruflo-core/scripts/witness/)
- * includes wg-changes.log as one of its watched artifacts (operator wires
- * this via witness-fixes.json).
- *
- * Pure service: emits the canonical bytes and the signature to write.
- * Caller does the I/O so this stays unit-testable without fs mocks.
- */
-import type { WgCommand } from './wg-mesh-service.js';
-export type WgWitnessEventType = 'peer-added' | 'peer-removed-suspended' | 'peer-restored' | 'peer-evicted' | 'key-rotated' | 'interface-config-applied';
-/**
- * Canonical fields of a witness entry. The hash + signature are computed
- * over these in a stable JSON encoding (sorted keys, no whitespace).
- */
-export interface WgWitnessContent {
-    readonly version: '1';
-    readonly type: WgWitnessEventType;
-    readonly timestamp: string;
-    readonly nodeId: string;
-    /** Public key of the affected peer, if any. */
-    readonly peerPublicKey?: string;
-    /** Mesh IP affected, if any. */
-    readonly meshIP?: string;
-    /** wg command that was emitted, if any. */
-    readonly wgCommand?: string;
-    /** Human-readable rationale for the audit log. */
-    readonly rationale: string;
-    /** Hash of the previous entry in the chain (sha256 hex), or empty for the genesis entry. */
-    readonly prevHash: string;
-}
-/**
- * Full witness entry as it appears on disk — content + the operator's
- * Ed25519 signature over the canonical encoding of content.
- */
-export interface WgWitnessEntry {
-    readonly content: WgWitnessContent;
-    readonly hash: string;
-    readonly signature: string;
-}
-export interface WgWitnessSigner {
-    /** Returns an Ed25519 signature (base64) over the given canonical bytes. */
-    sign(bytes: Buffer): Promise<string>;
-}
-/**
- * Stable JSON serialization for hashing/signing. Keys are sorted; no
- * whitespace; undefined fields omitted. Same shape on every host so
- * cross-host verifiers produce identical hashes.
- */
-export declare function canonicalizeContent(content: WgWitnessContent): Buffer;
-export declare function hashContent(content: WgWitnessContent): string;
-export declare class WgWitnessService {
-    private readonly nodeId;
-    private readonly signer;
-    private lastHash;
-    constructor(nodeId: string, signer: WgWitnessSigner);
-    /**
-     * Override the previous-hash pointer (used when resuming from an existing
-     * log on disk). Caller reads the last entry from `wg-changes.log` and
-     * passes its `hash` here before appending more.
-     */
-    setLastHash(hash: string): void;
-    /** Build + sign an entry. Caller is responsible for the actual append-write. */
-    build(type: WgWitnessEventType, fields: Omit<WgWitnessContent, 'version' | 'type' | 'timestamp' | 'nodeId' | 'prevHash'>): Promise<WgWitnessEntry>;
-    /**
-     * Convenience: take a WgCommand emitted by WgMeshService Phase 2/3 and
-     * produce a witness entry of the right type. Maps verb → eventType.
-     */
-    attestWgCommand(cmd: WgCommand, meshIP?: string): Promise<WgWitnessEntry>;
-}
-/**
- * Verify a single entry's signature + hash. Caller verifies the chain by
- * iterating entries and confirming each entry's `prevHash` equals the
- * preceding entry's `hash`.
- */
-export declare function verifyWitnessEntry(entry: WgWitnessEntry, verify: (bytes: Buffer, signature: string) => Promise<boolean>): Promise<boolean>;
-/**
- * Verify a full chain — every entry valid + chain link unbroken.
- */
-export declare function verifyWitnessChain(entries: readonly WgWitnessEntry[], verify: (bytes: Buffer, signature: string) => Promise<boolean>): Promise<{
-    ok: boolean;
-    failedAt?: number;
-    reason?: string;
-}>;
-//# sourceMappingURL=wg-witness-service.d.ts.map

package/dist/domain/value-objects/federation-budget.d.ts

@@ -1,89 +0,0 @@
-/**
- * Federation budget + hop counter (ADR-097 Phase 1).
- *
- * Carried in {@link FederationEnvelope} alongside the existing
- * sourceNodeId/targetNodeId/payload. Sender supplies the original limits;
- * each outbound hop increments hopCount and decrements remaining budget.
- *
- * Phase 1 enforces at the *send* side because there is no inbound
- * dispatcher today (sendToNode is a stub — see researcher report).
- * Phase 2 will move the decrement to receive once the inbound path lands.
- *
- * Security invariants pinned by the reviewer (audit_1776853149979 follow-up):
- *
- *   1. validateBudget rejects NaN, ±Infinity, negative numbers, and
- *      non-integer hop counts. Returns a discriminated result so callers
- *      cannot accidentally use a bad budget unchecked.
- *   2. enforceBudget runs check-then-decrement in a single synchronous
- *      function with no awaits inside — two concurrent send calls cannot
- *      both pass the pre-check.
- *   3. Errors return constant strings ("HOP_LIMIT_EXCEEDED" /
- *      "BUDGET_EXCEEDED") with no remaining-budget echo so a caller can't
- *      use the error response as an oracle for the threshold.
- */
-/** Maximum hops a federation message may travel before the breaker opens. */
-export declare const DEFAULT_MAX_HOPS = 8;
-/**
- * Caller-supplied budget. All fields are optional; omitted fields are
- * treated as Infinity for the corresponding axis. Created via validateBudget;
- * never construct directly.
- */
-export interface Budget {
-    readonly maxHops: number;
-    readonly maxTokens: number;
-    readonly maxUsd: number;
-}
-/** Discriminated result of validating raw user input into a Budget. */
-export type BudgetValidationResult = {
-    ok: true;
-    budget: Budget;
-} | {
-    ok: false;
-    error: string;
-};
-/**
- * Validate a raw budget object. Pure, no side effects. Caller obtains either
- * a guaranteed-safe Budget or a structured error suitable for logging.
- *
- * Accepts undefined/null and returns a default unbounded budget (maxHops =
- * DEFAULT_MAX_HOPS, tokens/usd = Infinity). This preserves backward
- * compatibility for callers that don't pass a budget at all.
- */
-export declare function validateBudget(raw: unknown, overrideMaxHops?: unknown): BudgetValidationResult;
-/**
- * Enforcement decision returned by enforceBudget. Discriminated so the
- * caller can map directly to a constant-string error — no remaining-budget
- * echo on the failure side (anti-oracle).
- */
-export type BudgetEnforcement = {
-    ok: true;
-    nextHopCount: number;
-    remaining: Budget;
-} | {
-    ok: false;
-    reason: 'HOP_LIMIT_EXCEEDED' | 'BUDGET_EXCEEDED';
-};
-/**
- * Atomic (single synchronous function, no internal awaits) hop check.
- *
- * Returns the hopCount value the OUTBOUND envelope should carry plus the
- * remaining budget that downstream peers will see. Callers must use the
- * returned values; mutating the input Budget is forbidden (it's readonly).
- *
- * Contract:
- *   - hopCount represents how many hops the message has already taken.
- *   - The next outbound hop increments it: nextHopCount = hopCount + 1.
- *   - The check fires AFTER increment: nextHopCount must be <= maxHops.
- *   - This means maxHops=0 refuses to forward at all, which matches the
- *     ADR's "no remote delegation allowed" semantic.
- *
- * tokensSpent / usdSpent are caller-reported actuals from the immediately
- * preceding leg (or 0 on the originator). The check fires on the
- * *post-spend* totals so a leg that overshoots is caught before the next
- * outbound dispatch.
- */
-export declare function enforceBudget(budget: Budget, hopCount: number, spent?: {
-    tokens: number;
-    usd: number;
-}): BudgetEnforcement;
-//# sourceMappingURL=federation-budget.d.ts.map

package/dist/domain/value-objects/federation-node-state.d.ts

@@ -1,92 +0,0 @@
-/**
- * Federation peer state machine (ADR-097 Phase 2).
- *
- * Phase 1 shipped the budget envelope + enforcer that travels with every
- * outbound message. Phase 2 adds the per-peer breaker: when a peer crosses a
- * cost or failure threshold, transition it to SUSPENDED so subsequent
- * `federation_send` calls short-circuit. After a cooldown the peer can
- * recover; if it stays bad the breaker escalates to EVICTED.
- *
- * This module is the *value object* layer — pure, no I/O. The breaker
- * service (Phase 2.b, separate file) reads cost-tracker telemetry, evaluates
- * thresholds, and calls `transition` on the FederationNode entity. Decoupling
- * the state machine from the policy lets tests pin transitions without
- * standing up the cost bus.
- *
- * Security invariants pinned by the spec:
- *
- *   1. EVICTED is terminal under normal flow. The only way out is an
- *      explicit `reactivate` call (operator-initiated). This prevents a
- *      misbehaving peer from auto-recovering through the cooldown.
- *   2. canTransition is the single source of truth for legality. Any path
- *      that mutates state MUST consult it; direct field writes are not
- *      permitted (entity getter/setter shape enforces this).
- *   3. Reasons are constant strings, no remaining-budget echo on failure
- *      (matches Phase 1's anti-oracle posture).
- *   4. Default cooldown is conservative (30 min) so a transient spike
- *      cannot ping-pong a peer ACTIVE↔SUSPENDED at high frequency.
- */
-/** Lifecycle state of a federation peer. */
-export declare enum FederationNodeState {
-    /** Default; healthy. `federation_send` accepts deliveries. */
-    ACTIVE = "ACTIVE",
-    /** Breaker tripped. Sends short-circuit with PEER_SUSPENDED. */
-    SUSPENDED = "SUSPENDED",
-    /** Removed from active rotation. Sends short-circuit with PEER_EVICTED. */
-    EVICTED = "EVICTED"
-}
-/** Reason a peer was suspended/evicted. Constant strings — no echo of caps. */
-export type SuspensionReason = 'COST_THRESHOLD_EXCEEDED' | 'FAILURE_RATIO_EXCEEDED' | 'MANUAL_SUSPEND' | 'GRACE_PERIOD_EXPIRED' | 'MANUAL_EVICT';
-/**
- * Default cooldown a SUSPENDED peer must wait before being eligible for
- * SUSPENDED → ACTIVE. 30 minutes matches the ADR-097 Part 2 spec and is
- * intentionally well past the prompt-cache window so a recovery probe is
- * cheap to amortize.
- */
-export declare const DEFAULT_SUSPENSION_COOLDOWN_MS: number;
-/**
- * Default age at which a continuously-SUSPENDED peer is auto-escalated to
- * EVICTED. 24 hours per spec — long enough to ride out a cost-tracker
- * outage without false eviction, short enough that a genuinely-broken peer
- * doesn't linger forever.
- */
-export declare const DEFAULT_AUTO_EVICTION_AGE_MS: number;
-/** A successful transition's reason payload (for the audit trail). */
-export interface TransitionReason {
-    readonly reason: SuspensionReason;
-    /** Optional opaque correlation key — task ID, breaker run ID, etc. */
-    readonly correlationId?: string;
-}
-/**
- * Static legality table for state transitions. Returns true iff the
- * `from -> to` edge is in the allowed set. Used by the entity to reject
- * illegal mutations before applying them.
- *
- * Allowed edges:
- *   ACTIVE    → SUSPENDED  (breaker trips)
- *   SUSPENDED → ACTIVE     (cooldown + probe success)
- *   SUSPENDED → EVICTED    (grace expired, or manual evict)
- *   ACTIVE    → EVICTED    (manual evict only — skips suspend)
- *   EVICTED   → ACTIVE     (manual reactivate only)
- *
- * Disallowed (anything else, including self-loops, is a no-op error).
- */
-export declare function canTransition(from: FederationNodeState, to: FederationNodeState): boolean;
-/**
- * Should a SUSPENDED peer be eligible for SUSPENDED → ACTIVE based purely
- * on elapsed time? The breaker still has to confirm health via probe before
- * it actually calls reactivate; this just answers "is the cooldown done?"
- *
- * Pure function of (suspendedAt, now, cooldownMs) so it's trivially
- * deterministic in tests.
- */
-export declare function isCooldownElapsed(suspendedAt: Date, now: Date, cooldownMs?: number): boolean;
-/**
- * Should a SUSPENDED peer be auto-escalated to EVICTED based on the age of
- * its suspension? Returns true once the peer has been continuously
- * SUSPENDED past the configured limit (default 24h). The breaker calls
- * this on each tick and, if true, issues the SUSPENDED → EVICTED
- * transition with reason GRACE_PERIOD_EXPIRED.
- */
-export declare function shouldAutoEvict(suspendedAt: Date, now: Date, ageLimitMs?: number): boolean;
-//# sourceMappingURL=federation-node-state.d.ts.map

package/dist/domain/value-objects/wg-config.d.ts

@@ -1,70 +0,0 @@
-/**
- * ADR-111 Phase 1 — WireGuard configuration value objects.
- *
- * Pure types + deterministic helpers. No I/O, no shell calls. Used by
- * WgMeshService (Phase 2) and surfaced in FederationManifest (Phase 1) so
- * peers can publish their WG identity inside the same Ed25519-signed
- * manifest that already carries their federation identity.
- */
-/**
- * The WG section of a FederationManifest. Optional — present only when
- * the local node has opted in via `config.wgMesh: true`.
- *
- * - publicKey is the X25519 public key in base64 (32-byte raw → 44 chars
- *   including '=' padding), exactly the format `wg-quick`/`wg setconf`
- *   accept. Never include the private key in the manifest.
- * - endpoint is `host:port` reachable on UDP. May be a hostname (resolved
- *   by the consumer) or an IPv4/v6 literal. The port is WireGuard's, not
- *   federation's WS port — usually 51820.
- * - meshIP is the assigned /32 inside the federation mesh subnet
- *   (10.50.0.0/16 by default). Stored as `a.b.c.d/32`.
- */
-export interface WgManifestSection {
-    readonly publicKey: string;
-    readonly endpoint: string;
-    readonly meshIP: string;
-}
-/**
- * A locally-generated WG keypair. Kept entirely off the wire — `publicKey`
- * is what gets published in the manifest; `privateKey` stays on disk
- * (mode 0600) and in this in-memory object.
- */
-export interface WgLocalKey {
-    readonly publicKey: string;
-    readonly privateKey: string;
-    readonly createdAt: string;
-}
-/**
- * Default federation mesh subnet. RFC1918 private space outside the
- * common LAN/k8s ranges and Tailscale's 100.64.0.0/10. Documented in
- * the ADR. Birthday-collision probability stays under 1% up to ~36
- * peers and under 50% at ~302 peers — within the v1 ≤50-peer target.
- */
-export declare const DEFAULT_MESH_SUBNET = "10.50.0.0/16";
-/**
- * Generate an X25519 keypair in the format WireGuard accepts.
- *
- * WireGuard keys are 32 raw bytes encoded base64 (44 chars with '='
- * padding). Node's `generateKeyPairSync('x25519')` returns PKCS8/SPKI
- * DER envelopes — we extract the trailing 32 bytes which are the raw
- * key material (the DER prefix is constant for X25519).
- *
- * No new dependencies: Node 18+ has X25519 support in core crypto.
- */
-export declare function generateWgKeyPair(): WgLocalKey;
-/**
- * Derive a deterministic mesh IP for `nodeId` inside `subnet`.
- *
- * Strategy: sha256(nodeId) → top bytes interpreted as host portion of the
- * subnet, clamped to avoid the network address (.0) and broadcast (.255)
- * of any /24 inside the subnet. This is collision-resistant in the
- * birthday-paradox sense — see ADR for thresholds.
- *
- * `usedIPs` (when provided) gives previously-assigned IPs in the mesh.
- * If the derived IP is already taken, the function probes `nodeId + '\x00'`,
- * `nodeId + '\x01'`, … until a free slot is found. Bounded to 1024 probes;
- * exceeding that means the subnet is functionally exhausted and the caller
- * should jump to a larger range (see ADR `10.50.0.0/12` recommendation).
- */
-export declare function deriveMeshIP(nodeId: string, subnet?: string, usedIPs?: ReadonlySet<string>): string;
-//# sourceMappingURL=wg-config.d.ts.map

package/dist/index.d.ts

@@ -1,24 +0,0 @@
-export { AgentFederationPlugin } from './plugin.js';
-export { FederationNode, type FederationNodeProps, type FederationNodeCapabilities, type FederationNodeMetadata, type FederationNodeStateRecord } from './domain/entities/federation-node.js';
-export { FederationNodeState, type SuspensionReason, type TransitionReason, canTransition, isCooldownElapsed, shouldAutoEvict, DEFAULT_SUSPENSION_COOLDOWN_MS, DEFAULT_AUTO_EVICTION_AGE_MS, } from './domain/value-objects/federation-node-state.js';
-export { FederationBreakerService, evaluatePolicy, DEFAULT_BREAKER_POLICY, DEFAULT_MAX_SAMPLES_PER_PEER, type BreakerPolicy, type BreakerDecision, type SendOutcome, } from './application/federation-breaker-service.js';
-export { InMemorySpendReporter, MemorySpendReporter, DEFAULT_FEDERATION_SPEND_NAMESPACE, DEFAULT_FEDERATION_SPEND_TTL_SECONDS, type SpendReporter, type MemoryStore, type MemorySpendReporterConfig, type FederationSpendEvent, } from './application/spend-reporter.js';
-export { FederationSession, type FederationSessionProps, type SessionMetrics } from './domain/entities/federation-session.js';
-export { FederationEnvelope, type FederationEnvelopeProps, type FederationMessageType, type PIIScanResult, type PIIScanDetection, type PIIScanAction, CONSENSUS_REQUIRED_TYPES, } from './domain/entities/federation-envelope.js';
-export { TrustLevel, TRUST_TRANSITION_THRESHOLDS, CAPABILITY_GATES, isOperationAllowed, getTrustLevelLabel, type TrustTransitionThreshold, } from './domain/entities/trust-level.js';
-export { PIIPipelineService, type PIIType, type PIIAction, type PIIDetection, type PIIPolicyConfig, type PIICalibration, type PIITransformResult, type PIIConfidenceThresholds, type PIIPipelineServiceDeps, } from './domain/services/pii-pipeline-service.js';
-export { DiscoveryService, type DiscoveryMechanism, type FederationManifest, type DiscoveryServiceDeps, type DiscoveryConfig, } from './domain/services/discovery-service.js';
-export { HandshakeService, type HandshakeChallenge, type HandshakeChallengeResponse, type HandshakeResult, type HandshakeServiceDeps, type HandshakeConfig, } from './domain/services/handshake-service.js';
-export { RoutingService, type RoutingMode, type RoutingResult, type ConsensusProposal, type RoutingServiceDeps, } from './domain/services/routing-service.js';
-export { AuditService, type FederationAuditEvent, type FederationAuditEventType, type AuditSeverity, type AuditCategory, type ComplianceMode, type AuditQuery, type AuditExportFormat, type AuditServiceDeps, type AuditServiceConfig, } from './domain/services/audit-service.js';
-export { TrustEvaluator, type TrustScoreComponents, type TrustTransitionResult, type ImmediateDowngradeReason, type TrustEvaluatorDeps, } from './application/trust-evaluator.js';
-export { FederationCoordinator, type FederationCoordinatorConfig, type FederationStatus, } from './application/federation-coordinator.js';
-export { PolicyEngine, type FederationClaimType, type SecurityPolicy, type PolicyEvaluationResult, type PolicyEngineDeps, } from './application/policy-engine.js';
-export { createFederationClaimChecker, type FederationAuthorizationMode, type FederationClaimChecker, type FederationClaimCheckerConfig, } from './application/claim-checker.js';
-export { DEFAULT_ENVELOPE_SIGNATURE_MODE, JCS_SIGNATURE_PROTOCOL, canonicalizeEnvelopeForVerify, isLegacyEnvelopeTypeAllowed, selectEnvelopeSignatureVersion, type EnvelopeSignatureMode, type EnvelopeSignatureVersion, } from './application/inbound-dispatcher.js';
-export { FEDERATION_PLUGIN_VERSION } from './version.js';
-export { A2A_PROTOCOL_VERSION, A2A_WELL_KNOWN_PATH, RUFLO_FEDERATION_BINDING, RUFLO_FEDERATION_EXTENSION_URI, toAgentCard, fromAgentCard, validateAgentCard, type A2AAgentCard, type A2AAgentInterface, type A2AAgentSkill, type A2AAgentCapabilities, type A2AAgentExtension, type A2AAgentProvider, type ToAgentCardOptions, type AgentCardValidation, } from './a2a/agent-card.js';
-export { projectPlannerSafeAgentCard, type PlannerCapabilityDefinition, type PlannerDescriptorPolicy, type PlannerSafeAgentDescriptor, type PlannerDescriptorProjection, } from './a2a/planner-descriptor.js';
-export { startAgentCardServer, isLoopbackHost, type AgentCardServerOptions, type AgentCardServerHandle, } from './a2a/well-known.js';
-export { fetchAgentCard, consumeAgentCard, resolveAgentCardUrl, type FetchAgentCardOptions, type FetchAgentCardResult, } from './a2a/consume.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/mcp-tools.d.ts

@@ -1,10 +0,0 @@
-import type { MCPToolDefinition } from '@claude-flow/shared/src/plugin-interface.js';
-import type { PluginContext } from '@claude-flow/shared/src/plugin-interface.js';
-import type { FederationCoordinator } from './application/federation-coordinator.js';
-import type { WgMeshService } from './domain/services/wg-mesh-service.js';
-type CoordinatorGetter = () => FederationCoordinator | null;
-type ContextGetter = () => PluginContext | null;
-type WgMeshGetter = () => WgMeshService | null;
-export declare function createMcpTools(getCoordinator: CoordinatorGetter, getContext: ContextGetter, getWgMesh?: WgMeshGetter): MCPToolDefinition[];
-export {};
-//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/plugin.d.ts

@@ -1,19 +0,0 @@
-import type { ClaudeFlowPlugin, PluginContext, MCPToolDefinition, CLICommandDefinition, AgentTypeDefinition } from '@claude-flow/shared/src/plugin-interface.js';
-export declare class AgentFederationPlugin implements ClaudeFlowPlugin {
-    readonly name = "@claude-flow/plugin-agent-federation";
-    readonly version: "1.0.0-alpha.18";
-    readonly description = "Cross-installation agent federation with PII protection and AI defence";
-    readonly author = "Claude Flow Team";
-    readonly dependencies: string[];
-    private coordinator;
-    private context;
-    private transport;
-    private agentCardServer;
-    initialize(context: PluginContext): Promise<void>;
-    shutdown(): Promise<void>;
-    registerMCPTools(): MCPToolDefinition[];
-    registerCLICommands(): CLICommandDefinition[];
-    registerAgentTypes(): AgentTypeDefinition[];
-    healthCheck(): Promise<boolean>;
-}
-//# sourceMappingURL=plugin.d.ts.map

package/dist/transport/midstream-aware-loader.d.ts

@@ -1,72 +0,0 @@
-/**
- * Midstream-aware federation transport loader (ADR-120, Step 2).
- *
- * Extends the agentic-flow `loadQuicTransport` loader pattern with a
- * preferred branch that probes `midstreamer` first. When `midstreamer`
- * ships real QUIC (currently the WASM build is a counter-tracking
- * stub per ADR-119), this loader picks it up automatically without
- * any change to consumer plugins.
- *
- * Resolution order:
- *
- *   1. If `MIDSTREAMER_QUIC_NATIVE=1` AND the `midstreamer` module
- *      exposes a real `QuicMultistream`-derived `AgentTransport`,
- *      use it. (Today: probes fail closed and we fall through.)
- *
- *   2. Otherwise: defer to agentic-flow's existing loader, which
- *      itself respects `AGENTIC_FLOW_QUIC_NATIVE=1` (ADR-108) and
- *      falls back to WebSocket (ADR-104) otherwise.
- *
- * The loader is opt-in: callers must explicitly invoke
- * `loadFederationTransport()` instead of `loadQuicTransport()`.
- * Behavior is identical to `loadQuicTransport()` until upstream
- * `midstreamer` ships its real QUIC build AND the operator sets the
- * env flag — so this change is safe to land before any of that
- * happens.
- *
- * Re-exports the `AgentTransport` / `AgentMessage` / `QuicTransportConfig`
- * surface from agentic-flow so consumers only import from one place.
- */
-export interface AgentMessage {
-    id: string;
-    type: 'task' | 'result' | 'status' | 'coordination' | 'heartbeat' | string;
-    payload: unknown;
-    metadata?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-export interface AgentTransport {
-    send: (address: string, message: AgentMessage) => Promise<void>;
-    onMessage: (handler: (address: string, message: AgentMessage) => void) => void;
-    listen?: (port: number, host?: string) => Promise<void>;
-    close?: () => Promise<void> | void;
-    [key: string]: unknown;
-}
-export interface QuicTransportConfig {
-    port?: number;
-    host?: string;
-    serverName?: string;
-    [key: string]: unknown;
-}
-/** Result envelope describing which backend the loader picked. */
-export interface LoadedFederationTransport {
-    /** The live transport. Send/receive against this. */
-    transport: AgentTransport;
-    /** Which loader branch resolved. Useful for logs/metrics. */
-    source: 'midstreamer-native' | 'agentic-flow-loader' | 'websocket-fallback';
-    /** Free-form note when a probe failed (helps explain a fallback). */
-    fallbackReason?: string;
-}
-/**
- * Top-level loader for federation transport. Identical signature to
- * agentic-flow's `loadQuicTransport`, but with the midstreamer-first
- * preference. Use this from `plugins/ruflo-federation` in place of
- * the bare `loadQuicTransport`.
- *
- * Failure mode: if midstreamer is requested but rejects (stub, init
- * error, missing package), this function falls through to the
- * agentic-flow loader. If current agentic-flow does not export its
- * historical loader subpath, the plugin-owned WebSocket fallback is
- * used directly (ADR-104, #2618).
- */
-export declare function loadFederationTransport(config?: QuicTransportConfig): Promise<LoadedFederationTransport>;
-//# sourceMappingURL=midstream-aware-loader.d.ts.map

package/dist/version.d.ts

@@ -1,3 +0,0 @@
-/** Single source of truth for runtime, manifest, CLI, and MCP version metadata. */
-export declare const FEDERATION_PLUGIN_VERSION: "1.0.0-alpha.18";
-//# sourceMappingURL=version.d.ts.map