@llm-dev-ops/agentics-cli 1.4.25 → 1.4.27

package/dist/bundled-agents/analytics-hub-agents/dist/contracts/ecosystem-collaboration-agent.d.ts

@@ -0,0 +1,1445 @@
+/**
+ * Ecosystem Collaboration Agent Contract
+ *
+ * Defines inputs, outputs, validation rules, and boundaries for the
+ * Ecosystem Collaboration Agent (Phase 5 - Layer 1).
+ *
+ * Classification: ANALYTICAL SYNTHESIS / AGGREGATION / CROSS-SYSTEM ANALYTICS
+ *
+ * This agent performs:
+ * - Aggregation of ecosystem partner signals
+ * - Indexing of collaboration metrics
+ * - Cross-system analytics across LLM ecosystem
+ *
+ * MUST NOT:
+ * - Mutate state
+ * - Commit actions
+ * - Draw conclusions (emit signals only)
+ *
+ * @module contracts/ecosystem-collaboration-agent
+ */
+import { z } from 'zod';
+export declare const AGENT_ID = "ecosystem-collaboration-agent";
+export declare const AGENT_VERSION = "1.0.0";
+/**
+ * Signal types emitted by this agent
+ * Per DecisionEvent rules: consensus_signal, aggregation_signal, strategic_signal
+ */
+export declare const SIGNAL_TYPES: {
+    readonly CONSENSUS_SIGNAL: "consensus_signal";
+    readonly AGGREGATION_SIGNAL: "aggregation_signal";
+    readonly STRATEGIC_SIGNAL: "strategic_signal";
+};
+export declare const PERFORMANCE_BUDGETS: {
+    readonly MAX_TOKENS: 1500;
+    readonly MAX_LATENCY_MS: 3000;
+};
+/**
+ * Ecosystem partner signal input
+ */
+export declare const EcosystemSignalSchema: z.ZodObject<{
+    /** Partner system identifier */
+    partnerId: z.ZodString;
+    /** Signal source system */
+    sourceSystem: z.ZodString;
+    /** Signal category */
+    category: z.ZodEnum<["performance", "cost", "quality", "availability", "latency"]>;
+    /** Metric value */
+    value: z.ZodNumber;
+    /** Unit of measurement */
+    unit: z.ZodString;
+    /** Signal confidence (0-1) */
+    confidence: z.ZodNumber;
+    /** Signal timestamp */
+    timestamp: z.ZodString;
+    /** Optional metadata */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    value: number;
+    confidence: number;
+    category: "cost" | "performance" | "quality" | "availability" | "latency";
+    unit: string;
+    partnerId: string;
+    sourceSystem: string;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    timestamp: string;
+    value: number;
+    confidence: number;
+    category: "cost" | "performance" | "quality" | "availability" | "latency";
+    unit: string;
+    partnerId: string;
+    sourceSystem: string;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Cross-system correlation request
+ */
+export declare const CrossSystemQuerySchema: z.ZodObject<{
+    /** Source systems to correlate */
+    sourceSystems: z.ZodArray<z.ZodString, "many">;
+    /** Metrics to analyze */
+    metrics: z.ZodArray<z.ZodString, "many">;
+    /** Time range for analysis */
+    timeRange: z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        start: string;
+        end: string;
+    }, {
+        start: string;
+        end: string;
+    }>;
+    /** Correlation threshold */
+    correlationThreshold: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    metrics: string[];
+    timeRange: {
+        start: string;
+        end: string;
+    };
+    sourceSystems: string[];
+    correlationThreshold: number;
+}, {
+    metrics: string[];
+    timeRange: {
+        start: string;
+        end: string;
+    };
+    sourceSystems: string[];
+    correlationThreshold?: number | undefined;
+}>;
+/**
+ * Main input schema for Ecosystem Collaboration Agent
+ */
+export declare const EcosystemCollaborationInputSchema: z.ZodObject<{
+    /** Request ID for tracing */
+    requestId: z.ZodString;
+    /** Ecosystem signals to aggregate */
+    signals: z.ZodArray<z.ZodObject<{
+        /** Partner system identifier */
+        partnerId: z.ZodString;
+        /** Signal source system */
+        sourceSystem: z.ZodString;
+        /** Signal category */
+        category: z.ZodEnum<["performance", "cost", "quality", "availability", "latency"]>;
+        /** Metric value */
+        value: z.ZodNumber;
+        /** Unit of measurement */
+        unit: z.ZodString;
+        /** Signal confidence (0-1) */
+        confidence: z.ZodNumber;
+        /** Signal timestamp */
+        timestamp: z.ZodString;
+        /** Optional metadata */
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        value: number;
+        confidence: number;
+        category: "cost" | "performance" | "quality" | "availability" | "latency";
+        unit: string;
+        partnerId: string;
+        sourceSystem: string;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        timestamp: string;
+        value: number;
+        confidence: number;
+        category: "cost" | "performance" | "quality" | "availability" | "latency";
+        unit: string;
+        partnerId: string;
+        sourceSystem: string;
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">;
+    /** Cross-system queries */
+    crossSystemQueries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Source systems to correlate */
+        sourceSystems: z.ZodArray<z.ZodString, "many">;
+        /** Metrics to analyze */
+        metrics: z.ZodArray<z.ZodString, "many">;
+        /** Time range for analysis */
+        timeRange: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            start: string;
+            end: string;
+        }, {
+            start: string;
+            end: string;
+        }>;
+        /** Correlation threshold */
+        correlationThreshold: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        metrics: string[];
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        sourceSystems: string[];
+        correlationThreshold: number;
+    }, {
+        metrics: string[];
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        sourceSystems: string[];
+        correlationThreshold?: number | undefined;
+    }>, "many">>;
+    /** Aggregation options */
+    options: z.ZodDefault<z.ZodObject<{
+        /** Aggregation granularity */
+        granularity: z.ZodDefault<z.ZodEnum<["minute", "hour", "day", "week"]>>;
+        /** Include index update */
+        updateIndex: z.ZodDefault<z.ZodBoolean>;
+        /** Include cross-system analytics */
+        crossSystemAnalytics: z.ZodDefault<z.ZodBoolean>;
+        /** Signal scope filter */
+        scopeFilter: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        granularity: "minute" | "hour" | "day" | "week";
+        updateIndex: boolean;
+        crossSystemAnalytics: boolean;
+        scopeFilter?: string[] | undefined;
+    }, {
+        scopeFilter?: string[] | undefined;
+        granularity?: "minute" | "hour" | "day" | "week" | undefined;
+        updateIndex?: boolean | undefined;
+        crossSystemAnalytics?: boolean | undefined;
+    }>>;
+    /** Execution reference for tracing */
+    executionRef: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        granularity: "minute" | "hour" | "day" | "week";
+        updateIndex: boolean;
+        crossSystemAnalytics: boolean;
+        scopeFilter?: string[] | undefined;
+    };
+    signals: {
+        timestamp: string;
+        value: number;
+        confidence: number;
+        category: "cost" | "performance" | "quality" | "availability" | "latency";
+        unit: string;
+        partnerId: string;
+        sourceSystem: string;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    requestId: string;
+    executionRef?: string | undefined;
+    crossSystemQueries?: {
+        metrics: string[];
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        sourceSystems: string[];
+        correlationThreshold: number;
+    }[] | undefined;
+}, {
+    signals: {
+        timestamp: string;
+        value: number;
+        confidence: number;
+        category: "cost" | "performance" | "quality" | "availability" | "latency";
+        unit: string;
+        partnerId: string;
+        sourceSystem: string;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    requestId: string;
+    options?: {
+        scopeFilter?: string[] | undefined;
+        granularity?: "minute" | "hour" | "day" | "week" | undefined;
+        updateIndex?: boolean | undefined;
+        crossSystemAnalytics?: boolean | undefined;
+    } | undefined;
+    executionRef?: string | undefined;
+    crossSystemQueries?: {
+        metrics: string[];
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        sourceSystems: string[];
+        correlationThreshold?: number | undefined;
+    }[] | undefined;
+}>;
+export type EcosystemSignal = z.infer<typeof EcosystemSignalSchema>;
+export type CrossSystemQuery = z.infer<typeof CrossSystemQuerySchema>;
+export type EcosystemCollaborationInput = z.infer<typeof EcosystemCollaborationInputSchema>;
+/**
+ * Aggregation signal output (no conclusions, data only)
+ */
+export declare const AggregationSignalSchema: z.ZodObject<{
+    signalType: z.ZodLiteral<"aggregation_signal">;
+    partnerId: z.ZodString;
+    category: z.ZodString;
+    aggregatedValue: z.ZodNumber;
+    sampleCount: z.ZodNumber;
+    timeRange: z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        start: string;
+        end: string;
+    }, {
+        start: string;
+        end: string;
+    }>;
+    confidence: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    timeRange: {
+        start: string;
+        end: string;
+    };
+    category: string;
+    partnerId: string;
+    signalType: "aggregation_signal";
+    aggregatedValue: number;
+    sampleCount: number;
+}, {
+    confidence: number;
+    timeRange: {
+        start: string;
+        end: string;
+    };
+    category: string;
+    partnerId: string;
+    signalType: "aggregation_signal";
+    aggregatedValue: number;
+    sampleCount: number;
+}>;
+/**
+ * Consensus signal output (no conclusions, alignment data only)
+ */
+export declare const ConsensusSignalSchema: z.ZodObject<{
+    signalType: z.ZodLiteral<"consensus_signal">;
+    metric: z.ZodString;
+    systems: z.ZodArray<z.ZodString, "many">;
+    alignmentScore: z.ZodNumber;
+    divergenceFactors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        system: z.ZodString;
+        deviation: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        system: string;
+        deviation: number;
+    }, {
+        system: string;
+        deviation: number;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    metric: string;
+    signalType: "consensus_signal";
+    systems: string[];
+    alignmentScore: number;
+    divergenceFactors?: {
+        system: string;
+        deviation: number;
+    }[] | undefined;
+}, {
+    metric: string;
+    signalType: "consensus_signal";
+    systems: string[];
+    alignmentScore: number;
+    divergenceFactors?: {
+        system: string;
+        deviation: number;
+    }[] | undefined;
+}>;
+/**
+ * Strategic signal output (no conclusions, correlation data only)
+ */
+export declare const StrategicSignalSchema: z.ZodObject<{
+    signalType: z.ZodLiteral<"strategic_signal">;
+    correlationPairs: z.ZodArray<z.ZodObject<{
+        systemA: z.ZodString;
+        systemB: z.ZodString;
+        metricA: z.ZodString;
+        metricB: z.ZodString;
+        correlationCoefficient: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        correlationCoefficient: number;
+        systemA: string;
+        systemB: string;
+        metricA: string;
+        metricB: string;
+    }, {
+        correlationCoefficient: number;
+        systemA: string;
+        systemB: string;
+        metricA: string;
+        metricB: string;
+    }>, "many">;
+    timeRange: z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        start: string;
+        end: string;
+    }, {
+        start: string;
+        end: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    timeRange: {
+        start: string;
+        end: string;
+    };
+    signalType: "strategic_signal";
+    correlationPairs: {
+        correlationCoefficient: number;
+        systemA: string;
+        systemB: string;
+        metricA: string;
+        metricB: string;
+    }[];
+}, {
+    timeRange: {
+        start: string;
+        end: string;
+    };
+    signalType: "strategic_signal";
+    correlationPairs: {
+        correlationCoefficient: number;
+        systemA: string;
+        systemB: string;
+        metricA: string;
+        metricB: string;
+    }[];
+}>;
+/**
+ * Index entry for ecosystem data
+ */
+export declare const IndexEntrySchema: z.ZodObject<{
+    partnerId: z.ZodString;
+    category: z.ZodString;
+    lastUpdated: z.ZodString;
+    signalCount: z.ZodNumber;
+    avgConfidence: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    signalCount: number;
+    category: string;
+    partnerId: string;
+    lastUpdated: string;
+    avgConfidence: number;
+}, {
+    signalCount: number;
+    category: string;
+    partnerId: string;
+    lastUpdated: string;
+    avgConfidence: number;
+}>;
+/**
+ * Complete response schema
+ */
+export declare const EcosystemCollaborationResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    requestId: z.ZodString;
+    /** Aggregation signals emitted */
+    aggregationSignals: z.ZodArray<z.ZodObject<{
+        signalType: z.ZodLiteral<"aggregation_signal">;
+        partnerId: z.ZodString;
+        category: z.ZodString;
+        aggregatedValue: z.ZodNumber;
+        sampleCount: z.ZodNumber;
+        timeRange: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            start: string;
+            end: string;
+        }, {
+            start: string;
+            end: string;
+        }>;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        category: string;
+        partnerId: string;
+        signalType: "aggregation_signal";
+        aggregatedValue: number;
+        sampleCount: number;
+    }, {
+        confidence: number;
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        category: string;
+        partnerId: string;
+        signalType: "aggregation_signal";
+        aggregatedValue: number;
+        sampleCount: number;
+    }>, "many">;
+    /** Consensus signals emitted */
+    consensusSignals: z.ZodArray<z.ZodObject<{
+        signalType: z.ZodLiteral<"consensus_signal">;
+        metric: z.ZodString;
+        systems: z.ZodArray<z.ZodString, "many">;
+        alignmentScore: z.ZodNumber;
+        divergenceFactors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            system: z.ZodString;
+            deviation: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            system: string;
+            deviation: number;
+        }, {
+            system: string;
+            deviation: number;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        metric: string;
+        signalType: "consensus_signal";
+        systems: string[];
+        alignmentScore: number;
+        divergenceFactors?: {
+            system: string;
+            deviation: number;
+        }[] | undefined;
+    }, {
+        metric: string;
+        signalType: "consensus_signal";
+        systems: string[];
+        alignmentScore: number;
+        divergenceFactors?: {
+            system: string;
+            deviation: number;
+        }[] | undefined;
+    }>, "many">;
+    /** Strategic signals emitted */
+    strategicSignals: z.ZodArray<z.ZodObject<{
+        signalType: z.ZodLiteral<"strategic_signal">;
+        correlationPairs: z.ZodArray<z.ZodObject<{
+            systemA: z.ZodString;
+            systemB: z.ZodString;
+            metricA: z.ZodString;
+            metricB: z.ZodString;
+            correlationCoefficient: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            correlationCoefficient: number;
+            systemA: string;
+            systemB: string;
+            metricA: string;
+            metricB: string;
+        }, {
+            correlationCoefficient: number;
+            systemA: string;
+            systemB: string;
+            metricA: string;
+            metricB: string;
+        }>, "many">;
+        timeRange: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            start: string;
+            end: string;
+        }, {
+            start: string;
+            end: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        signalType: "strategic_signal";
+        correlationPairs: {
+            correlationCoefficient: number;
+            systemA: string;
+            systemB: string;
+            metricA: string;
+            metricB: string;
+        }[];
+    }, {
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        signalType: "strategic_signal";
+        correlationPairs: {
+            correlationCoefficient: number;
+            systemA: string;
+            systemB: string;
+            metricA: string;
+            metricB: string;
+        }[];
+    }>, "many">;
+    /** Updated index entries */
+    indexEntries: z.ZodArray<z.ZodObject<{
+        partnerId: z.ZodString;
+        category: z.ZodString;
+        lastUpdated: z.ZodString;
+        signalCount: z.ZodNumber;
+        avgConfidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        signalCount: number;
+        category: string;
+        partnerId: string;
+        lastUpdated: string;
+        avgConfidence: number;
+    }, {
+        signalCount: number;
+        category: string;
+        partnerId: string;
+        lastUpdated: string;
+        avgConfidence: number;
+    }>, "many">;
+    /** Processing metadata */
+    processingMetadata: z.ZodObject<{
+        signalsProcessed: z.ZodNumber;
+        computationTimeMs: z.ZodNumber;
+        tokenCount: z.ZodNumber;
+        latencyMs: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        signalsProcessed: number;
+        computationTimeMs: number;
+        latencyMs: number;
+        tokenCount: number;
+    }, {
+        signalsProcessed: number;
+        computationTimeMs: number;
+        latencyMs: number;
+        tokenCount: number;
+    }>;
+    /** Decision event reference */
+    decisionEventId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    processingMetadata: {
+        signalsProcessed: number;
+        computationTimeMs: number;
+        latencyMs: number;
+        tokenCount: number;
+    };
+    success: boolean;
+    requestId: string;
+    aggregationSignals: {
+        confidence: number;
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        category: string;
+        partnerId: string;
+        signalType: "aggregation_signal";
+        aggregatedValue: number;
+        sampleCount: number;
+    }[];
+    consensusSignals: {
+        metric: string;
+        signalType: "consensus_signal";
+        systems: string[];
+        alignmentScore: number;
+        divergenceFactors?: {
+            system: string;
+            deviation: number;
+        }[] | undefined;
+    }[];
+    strategicSignals: {
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        signalType: "strategic_signal";
+        correlationPairs: {
+            correlationCoefficient: number;
+            systemA: string;
+            systemB: string;
+            metricA: string;
+            metricB: string;
+        }[];
+    }[];
+    indexEntries: {
+        signalCount: number;
+        category: string;
+        partnerId: string;
+        lastUpdated: string;
+        avgConfidence: number;
+    }[];
+    decisionEventId?: string | undefined;
+}, {
+    processingMetadata: {
+        signalsProcessed: number;
+        computationTimeMs: number;
+        latencyMs: number;
+        tokenCount: number;
+    };
+    success: boolean;
+    requestId: string;
+    aggregationSignals: {
+        confidence: number;
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        category: string;
+        partnerId: string;
+        signalType: "aggregation_signal";
+        aggregatedValue: number;
+        sampleCount: number;
+    }[];
+    consensusSignals: {
+        metric: string;
+        signalType: "consensus_signal";
+        systems: string[];
+        alignmentScore: number;
+        divergenceFactors?: {
+            system: string;
+            deviation: number;
+        }[] | undefined;
+    }[];
+    strategicSignals: {
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        signalType: "strategic_signal";
+        correlationPairs: {
+            correlationCoefficient: number;
+            systemA: string;
+            systemB: string;
+            metricA: string;
+            metricB: string;
+        }[];
+    }[];
+    indexEntries: {
+        signalCount: number;
+        category: string;
+        partnerId: string;
+        lastUpdated: string;
+        avgConfidence: number;
+    }[];
+    decisionEventId?: string | undefined;
+}>;
+export type AggregationSignal = z.infer<typeof AggregationSignalSchema>;
+export type ConsensusSignal = z.infer<typeof ConsensusSignalSchema>;
+export type StrategicSignal = z.infer<typeof StrategicSignalSchema>;
+export type IndexEntry = z.infer<typeof IndexEntrySchema>;
+export type EcosystemCollaborationResponse = z.infer<typeof EcosystemCollaborationResponseSchema>;
+/**
+ * Constraint applied during ecosystem analysis
+ */
+export declare const EcosystemConstraintSchema: z.ZodObject<{
+    scope: z.ZodString;
+    dataBoundaries: z.ZodObject<{
+        startTime: z.ZodString;
+        endTime: z.ZodString;
+        systems: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        startTime: string;
+        endTime: string;
+        systems?: string[] | undefined;
+    }, {
+        startTime: string;
+        endTime: string;
+        systems?: string[] | undefined;
+    }>;
+    performanceBudget: z.ZodObject<{
+        maxTokens: z.ZodNumber;
+        maxLatencyMs: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        maxTokens: number;
+        maxLatencyMs: number;
+    }, {
+        maxTokens: number;
+        maxLatencyMs: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    scope: string;
+    dataBoundaries: {
+        startTime: string;
+        endTime: string;
+        systems?: string[] | undefined;
+    };
+    performanceBudget: {
+        maxTokens: number;
+        maxLatencyMs: number;
+    };
+}, {
+    scope: string;
+    dataBoundaries: {
+        startTime: string;
+        endTime: string;
+        systems?: string[] | undefined;
+    };
+    performanceBudget: {
+        maxTokens: number;
+        maxLatencyMs: number;
+    };
+}>;
+/**
+ * DecisionEvent outputs for ecosystem collaboration
+ */
+export declare const EcosystemOutputSchema: z.ZodObject<{
+    aggregationSignals: z.ZodArray<z.ZodObject<{
+        signalType: z.ZodLiteral<"aggregation_signal">;
+        partnerId: z.ZodString;
+        category: z.ZodString;
+        aggregatedValue: z.ZodNumber;
+        sampleCount: z.ZodNumber;
+        timeRange: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            start: string;
+            end: string;
+        }, {
+            start: string;
+            end: string;
+        }>;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        category: string;
+        partnerId: string;
+        signalType: "aggregation_signal";
+        aggregatedValue: number;
+        sampleCount: number;
+    }, {
+        confidence: number;
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        category: string;
+        partnerId: string;
+        signalType: "aggregation_signal";
+        aggregatedValue: number;
+        sampleCount: number;
+    }>, "many">;
+    consensusSignals: z.ZodArray<z.ZodObject<{
+        signalType: z.ZodLiteral<"consensus_signal">;
+        metric: z.ZodString;
+        systems: z.ZodArray<z.ZodString, "many">;
+        alignmentScore: z.ZodNumber;
+        divergenceFactors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            system: z.ZodString;
+            deviation: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            system: string;
+            deviation: number;
+        }, {
+            system: string;
+            deviation: number;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        metric: string;
+        signalType: "consensus_signal";
+        systems: string[];
+        alignmentScore: number;
+        divergenceFactors?: {
+            system: string;
+            deviation: number;
+        }[] | undefined;
+    }, {
+        metric: string;
+        signalType: "consensus_signal";
+        systems: string[];
+        alignmentScore: number;
+        divergenceFactors?: {
+            system: string;
+            deviation: number;
+        }[] | undefined;
+    }>, "many">;
+    strategicSignals: z.ZodArray<z.ZodObject<{
+        signalType: z.ZodLiteral<"strategic_signal">;
+        correlationPairs: z.ZodArray<z.ZodObject<{
+            systemA: z.ZodString;
+            systemB: z.ZodString;
+            metricA: z.ZodString;
+            metricB: z.ZodString;
+            correlationCoefficient: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            correlationCoefficient: number;
+            systemA: string;
+            systemB: string;
+            metricA: string;
+            metricB: string;
+        }, {
+            correlationCoefficient: number;
+            systemA: string;
+            systemB: string;
+            metricA: string;
+            metricB: string;
+        }>, "many">;
+        timeRange: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            start: string;
+            end: string;
+        }, {
+            start: string;
+            end: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        signalType: "strategic_signal";
+        correlationPairs: {
+            correlationCoefficient: number;
+            systemA: string;
+            systemB: string;
+            metricA: string;
+            metricB: string;
+        }[];
+    }, {
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        signalType: "strategic_signal";
+        correlationPairs: {
+            correlationCoefficient: number;
+            systemA: string;
+            systemB: string;
+            metricA: string;
+            metricB: string;
+        }[];
+    }>, "many">;
+    indexEntriesUpdated: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    aggregationSignals: {
+        confidence: number;
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        category: string;
+        partnerId: string;
+        signalType: "aggregation_signal";
+        aggregatedValue: number;
+        sampleCount: number;
+    }[];
+    consensusSignals: {
+        metric: string;
+        signalType: "consensus_signal";
+        systems: string[];
+        alignmentScore: number;
+        divergenceFactors?: {
+            system: string;
+            deviation: number;
+        }[] | undefined;
+    }[];
+    strategicSignals: {
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        signalType: "strategic_signal";
+        correlationPairs: {
+            correlationCoefficient: number;
+            systemA: string;
+            systemB: string;
+            metricA: string;
+            metricB: string;
+        }[];
+    }[];
+    indexEntriesUpdated: number;
+}, {
+    aggregationSignals: {
+        confidence: number;
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        category: string;
+        partnerId: string;
+        signalType: "aggregation_signal";
+        aggregatedValue: number;
+        sampleCount: number;
+    }[];
+    consensusSignals: {
+        metric: string;
+        signalType: "consensus_signal";
+        systems: string[];
+        alignmentScore: number;
+        divergenceFactors?: {
+            system: string;
+            deviation: number;
+        }[] | undefined;
+    }[];
+    strategicSignals: {
+        timeRange: {
+            start: string;
+            end: string;
+        };
+        signalType: "strategic_signal";
+        correlationPairs: {
+            correlationCoefficient: number;
+            systemA: string;
+            systemB: string;
+            metricA: string;
+            metricB: string;
+        }[];
+    }[];
+    indexEntriesUpdated: number;
+}>;
+/**
+ * DecisionEvent for Ecosystem Collaboration Agent
+ */
+export declare const EcosystemDecisionEventSchema: z.ZodObject<{
+    agent_id: z.ZodLiteral<"ecosystem-collaboration-agent">;
+    agent_version: z.ZodString;
+    decision_type: z.ZodEnum<["consensus_signal", "aggregation_signal", "strategic_signal"]>;
+    inputs_hash: z.ZodString;
+    outputs: z.ZodObject<{
+        aggregationSignals: z.ZodArray<z.ZodObject<{
+            signalType: z.ZodLiteral<"aggregation_signal">;
+            partnerId: z.ZodString;
+            category: z.ZodString;
+            aggregatedValue: z.ZodNumber;
+            sampleCount: z.ZodNumber;
+            timeRange: z.ZodObject<{
+                start: z.ZodString;
+                end: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                start: string;
+                end: string;
+            }, {
+                start: string;
+                end: string;
+            }>;
+            confidence: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            confidence: number;
+            timeRange: {
+                start: string;
+                end: string;
+            };
+            category: string;
+            partnerId: string;
+            signalType: "aggregation_signal";
+            aggregatedValue: number;
+            sampleCount: number;
+        }, {
+            confidence: number;
+            timeRange: {
+                start: string;
+                end: string;
+            };
+            category: string;
+            partnerId: string;
+            signalType: "aggregation_signal";
+            aggregatedValue: number;
+            sampleCount: number;
+        }>, "many">;
+        consensusSignals: z.ZodArray<z.ZodObject<{
+            signalType: z.ZodLiteral<"consensus_signal">;
+            metric: z.ZodString;
+            systems: z.ZodArray<z.ZodString, "many">;
+            alignmentScore: z.ZodNumber;
+            divergenceFactors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                system: z.ZodString;
+                deviation: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                system: string;
+                deviation: number;
+            }, {
+                system: string;
+                deviation: number;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            metric: string;
+            signalType: "consensus_signal";
+            systems: string[];
+            alignmentScore: number;
+            divergenceFactors?: {
+                system: string;
+                deviation: number;
+            }[] | undefined;
+        }, {
+            metric: string;
+            signalType: "consensus_signal";
+            systems: string[];
+            alignmentScore: number;
+            divergenceFactors?: {
+                system: string;
+                deviation: number;
+            }[] | undefined;
+        }>, "many">;
+        strategicSignals: z.ZodArray<z.ZodObject<{
+            signalType: z.ZodLiteral<"strategic_signal">;
+            correlationPairs: z.ZodArray<z.ZodObject<{
+                systemA: z.ZodString;
+                systemB: z.ZodString;
+                metricA: z.ZodString;
+                metricB: z.ZodString;
+                correlationCoefficient: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                correlationCoefficient: number;
+                systemA: string;
+                systemB: string;
+                metricA: string;
+                metricB: string;
+            }, {
+                correlationCoefficient: number;
+                systemA: string;
+                systemB: string;
+                metricA: string;
+                metricB: string;
+            }>, "many">;
+            timeRange: z.ZodObject<{
+                start: z.ZodString;
+                end: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                start: string;
+                end: string;
+            }, {
+                start: string;
+                end: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            timeRange: {
+                start: string;
+                end: string;
+            };
+            signalType: "strategic_signal";
+            correlationPairs: {
+                correlationCoefficient: number;
+                systemA: string;
+                systemB: string;
+                metricA: string;
+                metricB: string;
+            }[];
+        }, {
+            timeRange: {
+                start: string;
+                end: string;
+            };
+            signalType: "strategic_signal";
+            correlationPairs: {
+                correlationCoefficient: number;
+                systemA: string;
+                systemB: string;
+                metricA: string;
+                metricB: string;
+            }[];
+        }>, "many">;
+        indexEntriesUpdated: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        aggregationSignals: {
+            confidence: number;
+            timeRange: {
+                start: string;
+                end: string;
+            };
+            category: string;
+            partnerId: string;
+            signalType: "aggregation_signal";
+            aggregatedValue: number;
+            sampleCount: number;
+        }[];
+        consensusSignals: {
+            metric: string;
+            signalType: "consensus_signal";
+            systems: string[];
+            alignmentScore: number;
+            divergenceFactors?: {
+                system: string;
+                deviation: number;
+            }[] | undefined;
+        }[];
+        strategicSignals: {
+            timeRange: {
+                start: string;
+                end: string;
+            };
+            signalType: "strategic_signal";
+            correlationPairs: {
+                correlationCoefficient: number;
+                systemA: string;
+                systemB: string;
+                metricA: string;
+                metricB: string;
+            }[];
+        }[];
+        indexEntriesUpdated: number;
+    }, {
+        aggregationSignals: {
+            confidence: number;
+            timeRange: {
+                start: string;
+                end: string;
+            };
+            category: string;
+            partnerId: string;
+            signalType: "aggregation_signal";
+            aggregatedValue: number;
+            sampleCount: number;
+        }[];
+        consensusSignals: {
+            metric: string;
+            signalType: "consensus_signal";
+            systems: string[];
+            alignmentScore: number;
+            divergenceFactors?: {
+                system: string;
+                deviation: number;
+            }[] | undefined;
+        }[];
+        strategicSignals: {
+            timeRange: {
+                start: string;
+                end: string;
+            };
+            signalType: "strategic_signal";
+            correlationPairs: {
+                correlationCoefficient: number;
+                systemA: string;
+                systemB: string;
+                metricA: string;
+                metricB: string;
+            }[];
+        }[];
+        indexEntriesUpdated: number;
+    }>;
+    confidence: z.ZodNumber;
+    constraints_applied: z.ZodArray<z.ZodObject<{
+        scope: z.ZodString;
+        dataBoundaries: z.ZodObject<{
+            startTime: z.ZodString;
+            endTime: z.ZodString;
+            systems: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            startTime: string;
+            endTime: string;
+            systems?: string[] | undefined;
+        }, {
+            startTime: string;
+            endTime: string;
+            systems?: string[] | undefined;
+        }>;
+        performanceBudget: z.ZodObject<{
+            maxTokens: z.ZodNumber;
+            maxLatencyMs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            maxTokens: number;
+            maxLatencyMs: number;
+        }, {
+            maxTokens: number;
+            maxLatencyMs: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        scope: string;
+        dataBoundaries: {
+            startTime: string;
+            endTime: string;
+            systems?: string[] | undefined;
+        };
+        performanceBudget: {
+            maxTokens: number;
+            maxLatencyMs: number;
+        };
+    }, {
+        scope: string;
+        dataBoundaries: {
+            startTime: string;
+            endTime: string;
+            systems?: string[] | undefined;
+        };
+        performanceBudget: {
+            maxTokens: number;
+            maxLatencyMs: number;
+        };
+    }>, "many">;
+    execution_ref: z.ZodString;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    agent_id: "ecosystem-collaboration-agent";
+    agent_version: string;
+    decision_type: "consensus_signal" | "aggregation_signal" | "strategic_signal";
+    inputs_hash: string;
+    outputs: {
+        aggregationSignals: {
+            confidence: number;
+            timeRange: {
+                start: string;
+                end: string;
+            };
+            category: string;
+            partnerId: string;
+            signalType: "aggregation_signal";
+            aggregatedValue: number;
+            sampleCount: number;
+        }[];
+        consensusSignals: {
+            metric: string;
+            signalType: "consensus_signal";
+            systems: string[];
+            alignmentScore: number;
+            divergenceFactors?: {
+                system: string;
+                deviation: number;
+            }[] | undefined;
+        }[];
+        strategicSignals: {
+            timeRange: {
+                start: string;
+                end: string;
+            };
+            signalType: "strategic_signal";
+            correlationPairs: {
+                correlationCoefficient: number;
+                systemA: string;
+                systemB: string;
+                metricA: string;
+                metricB: string;
+            }[];
+        }[];
+        indexEntriesUpdated: number;
+    };
+    confidence: number;
+    constraints_applied: {
+        scope: string;
+        dataBoundaries: {
+            startTime: string;
+            endTime: string;
+            systems?: string[] | undefined;
+        };
+        performanceBudget: {
+            maxTokens: number;
+            maxLatencyMs: number;
+        };
+    }[];
+    execution_ref: string;
+}, {
+    timestamp: string;
+    agent_id: "ecosystem-collaboration-agent";
+    agent_version: string;
+    decision_type: "consensus_signal" | "aggregation_signal" | "strategic_signal";
+    inputs_hash: string;
+    outputs: {
+        aggregationSignals: {
+            confidence: number;
+            timeRange: {
+                start: string;
+                end: string;
+            };
+            category: string;
+            partnerId: string;
+            signalType: "aggregation_signal";
+            aggregatedValue: number;
+            sampleCount: number;
+        }[];
+        consensusSignals: {
+            metric: string;
+            signalType: "consensus_signal";
+            systems: string[];
+            alignmentScore: number;
+            divergenceFactors?: {
+                system: string;
+                deviation: number;
+            }[] | undefined;
+        }[];
+        strategicSignals: {
+            timeRange: {
+                start: string;
+                end: string;
+            };
+            signalType: "strategic_signal";
+            correlationPairs: {
+                correlationCoefficient: number;
+                systemA: string;
+                systemB: string;
+                metricA: string;
+                metricB: string;
+            }[];
+        }[];
+        indexEntriesUpdated: number;
+    };
+    confidence: number;
+    constraints_applied: {
+        scope: string;
+        dataBoundaries: {
+            startTime: string;
+            endTime: string;
+            systems?: string[] | undefined;
+        };
+        performanceBudget: {
+            maxTokens: number;
+            maxLatencyMs: number;
+        };
+    }[];
+    execution_ref: string;
+}>;
+export type EcosystemConstraint = z.infer<typeof EcosystemConstraintSchema>;
+export type EcosystemOutput = z.infer<typeof EcosystemOutputSchema>;
+export type EcosystemDecisionEvent = z.infer<typeof EcosystemDecisionEventSchema>;
+/**
+ * Explicit boundaries - what this agent MUST NOT do
+ */
+export declare const AGENT_BOUNDARIES: {
+    readonly PROHIBITED_ACTIONS: readonly ["Mutate state in any system", "Commit actions or trigger workflows", "Draw conclusions from data", "Make recommendations", "Enforce policies or constraints", "Execute other agents", "Connect directly to SQL databases", "Execute raw SQL queries", "Modify execution behavior", "Auto-remediate issues"];
+    readonly PROHIBITED_INTEGRATIONS: readonly ["Google SQL (Postgres) - use ruvector-service only", "Workflow execution engines", "Policy enforcement systems", "Action dispatch systems"];
+    readonly OUTPUT_RESTRICTIONS: readonly ["No conclusions - only emit signals", "No recommendations - only correlations", "No actions - only aggregations"];
+};
+/**
+ * Permitted actions for this agent
+ */
+export declare const AGENT_PERMISSIONS: {
+    readonly PERMITTED_ACTIONS: readonly ["Aggregate signals from ecosystem partners", "Index collaboration metrics", "Perform cross-system analytics", "Compute correlations between systems", "Emit consensus_signal events", "Emit aggregation_signal events", "Emit strategic_signal events", "Read from ecosystem partner APIs", "Persist DecisionEvents via ruvector-service"];
+    readonly PERMITTED_CONSUMERS: readonly ["LLM-Governance-Dashboard (read-only)", "Executive reporting systems", "Strategic analytics consumers", "Partner ecosystem dashboards"];
+};
+export declare const ANALYTICS_CLASSIFICATION: {
+    readonly type: "ANALYTICAL_SYNTHESIS";
+    readonly subtype: "ECOSYSTEM_COLLABORATION";
+    readonly scope: "CROSS_SYSTEM_AGGREGATION";
+    readonly phase: 5;
+    readonly layer: 1;
+    readonly readOnly: true;
+    readonly stateMutation: false;
+    readonly actionCommit: false;
+    readonly executionPath: "OUTSIDE_CRITICAL_PATH";
+};
+export declare const FAILURE_MODES: {
+    readonly VALIDATION_FAILURE: {
+        readonly code: "ECOSYSTEM_VALIDATION_FAILURE";
+        readonly recoverable: true;
+        readonly action: "Return validation error, do not emit DecisionEvent";
+    };
+    readonly INSUFFICIENT_SIGNALS: {
+        readonly code: "ECOSYSTEM_INSUFFICIENT_SIGNALS";
+        readonly recoverable: true;
+        readonly action: "Return partial result with low confidence";
+    };
+    readonly PERSISTENCE_FAILURE: {
+        readonly code: "ECOSYSTEM_PERSISTENCE_FAILURE";
+        readonly recoverable: false;
+        readonly action: "Log error, return failure response";
+    };
+    readonly PERFORMANCE_BUDGET_EXCEEDED: {
+        readonly code: "ECOSYSTEM_PERFORMANCE_EXCEEDED";
+        readonly recoverable: false;
+        readonly action: "Abort computation, return budget exceeded error";
+    };
+    readonly CROSS_SYSTEM_TIMEOUT: {
+        readonly code: "ECOSYSTEM_CROSS_SYSTEM_TIMEOUT";
+        readonly recoverable: false;
+        readonly action: "Return partial results, log timeout";
+    };
+};
+/**
+ * Create SHA-256 hash of inputs for reproducibility
+ */
+export declare function createInputsHash(inputs: unknown): string;
+//# sourceMappingURL=ecosystem-collaboration-agent.d.ts.map