@agent-evolve/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,773 @@
+interface AgentConfig {
+    id: string;
+    name: string;
+    domain: string;
+    sub_domains?: string[];
+    readable_partitions: string[];
+    writable_partitions: string[];
+}
+
+interface IntentObject {
+    task_type: string;
+    domain: string;
+    complexity: 'low' | 'medium' | 'high';
+    target_audience: string;
+    output_format: string;
+    style: string;
+    key_entities: string[];
+    constraints: string[];
+    confidence: number;
+    unresolved: string[];
+    source_trace: {
+        [field: string]: 'user_input' | 'memory' | 'knowledge' | 'default' | 'llm_extract' | 'memory(conflict)';
+    };
+}
+interface RoughIntent {
+    task_type: string;
+    domain: string;
+    complexity: 'low' | 'medium' | 'high';
+    key_entities: string[];
+    missing: string[];
+}
+declare const DEFAULT_ROUGH_INTENT: RoughIntent;
+
+interface AgentEvolveAdapter {
+    onMessage(msg: UserMessage): Promise<EnhancedContext>;
+    injectSystemPrompt(original: string): string;
+    parseIntentFromResponse(response: string): RoughIntent;
+    sendConfirmation(intent: IntentObject): Promise<boolean>;
+    askQuestions(questions: string[]): Promise<Record<string, string>>;
+}
+interface UserMessage {
+    text: string;
+    sender_id: string;
+    session_id: string;
+    channel: string;
+    timestamp: string;
+}
+type Source = 'user_input' | 'memory' | 'knowledge' | 'default' | 'llm_extract' | 'memory(conflict)' | 'recent_pref';
+interface RegistryEntry {
+    id: string;
+    summary: string;
+    tags: string[];
+    storage_ptr: string;
+    data_type: string;
+    confidence: number;
+    verified_cnt: number;
+    partition: string;
+    source_agent?: string | null;
+    created_at: string;
+    last_accessed?: string | null;
+    access_count: number;
+    status: 'active' | 'stale' | 'hypothesis' | 'rolled_back';
+}
+interface FillResult extends RegistryEntry {
+    source: Source;
+    field?: string;
+    value?: string;
+}
+interface Conflict {
+    field: string;
+    options: FillResult[];
+}
+interface ResolvedFills {
+    resolved: Record<string, FillResult>;
+    conflicts: Conflict[];
+}
+interface ConfirmThreshold {
+    skip: number;
+    quick: number;
+}
+interface RetrievalTrace {
+    id: string;
+    intent_id?: string | undefined;
+    query_tags: string[];
+    partitions_searched: string[];
+    hits: string[];
+    loaded_l0: string[];
+    promoted_l1: string[];
+    promoted_l2: string[];
+    injected: string[];
+    created_at?: string | undefined;
+}
+interface PipelineConfig {
+    priorityRules: PriorityRules;
+    confirmThreshold: ConfirmThreshold;
+}
+interface PipelineResult {
+    intent: IntentObject;
+    trace: RetrievalTrace;
+    needsConfirmation?: boolean;
+    confirmMessage?: string;
+}
+interface RawData {
+    id?: string;
+    content: string;
+    storageLocation: string;
+    type: string;
+    sourceAgent: string;
+    partition?: string;
+    tags?: string[];
+}
+interface EnhancedContext {
+    userMessage: UserMessage['text'];
+    systemPrompt?: string;
+    agentConfig?: AgentConfig;
+    fills?: FillResult[];
+    metadata?: Record<string, unknown>;
+}
+interface PriorityRules {
+    order: Source[];
+}
+
+interface ExperienceEntry {
+    id: string;
+    summary: string;
+    condition: {
+        task_type?: string | undefined;
+        domain?: string | undefined;
+        entities?: string[] | undefined;
+        environment?: string | undefined;
+    };
+    conclusion: string;
+    action: string;
+    confidence: number;
+    full_context?: {
+        original_task: string;
+        execution_log: string;
+        evaluation: Record<string, any>;
+    };
+    source_agent: string;
+    source_trace_id: string;
+    verified_count: number;
+    created_at: string;
+    status: 'active' | 'hypothesis' | 'rolled_back';
+    target: 'skill_doc' | 'memory' | 'knowledge_global' | 'knowledge_dept';
+    partition: string;
+    abstracted_from?: string[];
+    is_abstract: boolean;
+}
+
+interface SearchFilters {
+    tags?: string[];
+    partition?: string | string[];
+    dataType?: string | string[];
+    minConfidence?: number;
+    limit?: number;
+}
+interface RegistryInsertInput {
+    id?: string;
+    summary: string;
+    tags?: string[];
+    storage_ptr: string;
+    data_type?: string;
+    confidence?: number;
+    verified_cnt?: number;
+    partition?: string;
+    source_agent?: string;
+    created_at?: string;
+    last_accessed?: string | null;
+    access_count?: number;
+    status?: RegistryEntry['status'];
+}
+type RegistryUpdateInput = Partial<Omit<RegistryInsertInput, 'id'>>;
+declare class IndexTable {
+    private readonly db;
+    constructor(dbPath?: string);
+    insert(entry: RegistryInsertInput): string;
+    get(id: string): RegistryEntry | null;
+    update(id: string, updates: RegistryUpdateInput): boolean;
+    delete(id: string): boolean;
+    search(filters?: SearchFilters): RegistryEntry[];
+    recordAccess(id: string): boolean;
+    saveTrace(trace: RetrievalTrace): string;
+    getTrace(id: string): RetrievalTrace | null;
+    close(): void;
+}
+
+declare function extractKeywords(userMsg: string): string[];
+declare function resolveSource(entry: RegistryEntry): Source;
+declare function dedup(results: FillResult[]): FillResult[];
+declare function contextFill(userMsg: string, registry: IndexTable, agentConfig: AgentConfig): Promise<FillResult[]>;
+declare function contextFillRefine(rough: RoughIntent, initial: FillResult[], registry: IndexTable, agentConfig: AgentConfig): Promise<FillResult[]>;
+
+declare const EXTRACTION_PROMPT = "\nAfter your response, output a JSON block (invisible to user):\n```intent\n{\"task_type\":\"...\",\"domain\":\"...\",\"complexity\":\"low|medium|high\",\n\"key_entities\":[\"...\"],\"missing\":[\"...\"]}\n```";
+declare function parseIntentBlock(response: string): RoughIntent;
+declare function stripIntentBlock(response: string): string;
+
+declare function groupByField(fills: FillResult[]): Record<string, FillResult[]>;
+declare function isConflicting(a: FillResult, b: FillResult): boolean;
+declare function conflictDetect(fills: FillResult[], rules?: PriorityRules): ResolvedFills;
+
+declare function calcConfidence(rough: RoughIntent, resolved: ResolvedFills): number;
+declare function extractConstraints(resolved: ResolvedFills): string[];
+type IntentSource = 'user_input' | 'memory' | 'knowledge' | 'default' | 'llm_extract' | 'memory(conflict)';
+declare function buildSourceTrace(rough: RoughIntent, resolved: ResolvedFills): Record<string, IntentSource>;
+declare function structure(rough: RoughIntent, resolved: ResolvedFills, _userMsg: string): IntentObject;
+
+declare const DEFAULT_THRESHOLD: ConfirmThreshold;
+declare function buildQuestions(intent: IntentObject): string[];
+declare function updateIntent(intent: IntentObject, answers: Record<string, string>): IntentObject;
+declare function confirmIfNeeded(intent: IntentObject, adapter: AgentEvolveAdapter, threshold?: ConfirmThreshold): Promise<IntentObject>;
+
+declare function buildTrace(rough: RoughIntent, searchResults: FillResult[], refined: FillResult[], _resolved: {
+    resolved: Record<string, FillResult>;
+}, confirmed: IntentObject): RetrievalTrace;
+declare function intentPipeline(userMsg: string, adapter: AgentEvolveAdapter, registry: IndexTable, agentConfig: AgentConfig, config: PipelineConfig): Promise<PipelineResult>;
+
+interface AttentionBudget {
+    maxTokens: number;
+    globalPrinciplesRatio: number;
+    memoryRatio: number;
+    skillDocsRatio: number;
+}
+declare const DEFAULT_ATTENTION_BUDGET: AttentionBudget;
+interface AttentionSlot {
+    category: 'global_principle' | 'memory' | 'skill_doc';
+    content: string;
+    relevanceScore: number;
+    tokenEstimate: number;
+}
+declare function selectAttentionSlots(fills: FillResult[], intent: IntentObject, globalPrinciples: string[], skillDocs: string[], budget?: AttentionBudget): AttentionSlot[];
+declare function assembleContext(slots: AttentionSlot[]): string;
+
+declare function extractTags(data: RawData): string[];
+declare function resolvePartition(sourceAgent: string): string;
+declare function autoIngest(data: RawData, registry: IndexTable): Promise<string>;
+
+/**
+ * Deterministic task auto-verification.
+ * Code tasks: run tests, pass = correct.
+ * Data tasks: format + field completeness validation.
+ */
+interface VerificationRule {
+    type: 'regex' | 'json_schema' | 'field_presence' | 'custom';
+    pattern?: string;
+    fields?: string[];
+    validator?: (output: string) => boolean;
+}
+interface VerificationResult {
+    passed: boolean;
+    checks: Array<{
+        rule: string;
+        passed: boolean;
+        message?: string;
+    }>;
+    overallScore: number;
+}
+declare function verifyRegex(output: string, pattern: string): boolean;
+declare function verifyFieldPresence(output: string, fields: string[]): {
+    present: string[];
+    missing: string[];
+};
+declare function verifyJsonSchema(output: string, fields: string[]): boolean;
+declare function runVerification(output: string, rules: VerificationRule[]): VerificationResult;
+
+/**
+ * Non-deterministic task sub-dimension evaluation.
+ * Instead of asking "good or bad?", decompose into judgeable sub-dimensions.
+ */
+interface SubDimension {
+    name: string;
+    weight: number;
+    evaluator: 'auto' | 'agent_review' | 'human';
+    autoCheck?: (output: string) => number;
+    description?: string;
+}
+interface EvaluationTemplate {
+    id: string;
+    name: string;
+    taskTypes: string[];
+    dimensions: SubDimension[];
+}
+interface DimensionScore {
+    dimension: string;
+    score: number;
+    evaluator: 'auto' | 'agent_review' | 'human';
+    feedback?: string;
+}
+interface EvaluationResult {
+    templateId: string;
+    scores: DimensionScore[];
+    overallScore: number;
+    needsHumanReview: string[];
+    needsAgentReview: string[];
+}
+declare function checkWordCount(min: number, max: number): (output: string) => number;
+declare function checkKeywordCoverage(keywords: string[]): (output: string) => number;
+declare function checkFormatCompliance(expectedFormat: string): (output: string) => number;
+declare function evaluate(output: string, template: EvaluationTemplate, agentScores?: Record<string, number>, humanScores?: Record<string, number>): EvaluationResult;
+declare const TEMPLATES: Record<string, EvaluationTemplate>;
+
+/**
+ * Prediction deviation learning.
+ * Before execution: estimate tokens / duration / steps / risk.
+ * After execution: compare actual values. Deviation = learning signal.
+ */
+interface Prediction {
+    intentId: string;
+    taskType: string;
+    estimates: {
+        tokens?: number;
+        durationMs?: number;
+        steps?: number;
+        skillCount?: number;
+    };
+}
+interface Actual {
+    tokens?: number;
+    durationMs?: number;
+    steps?: number;
+    skillCount?: number;
+}
+type DeviationLevel = 'normal' | 'mild' | 'significant' | 'reverse';
+interface DeviationResult {
+    dimension: string;
+    estimated: number;
+    actual: number;
+    ratio: number;
+    level: DeviationLevel;
+    alpha: number;
+    newEstimate: number;
+}
+interface PredictionAnalysis {
+    intentId: string;
+    taskType: string;
+    deviations: DeviationResult[];
+    needsModelUpdate: boolean;
+}
+declare function analyzePrediction(prediction: Prediction, actual: Actual): PredictionAnalysis;
+declare class DeviationAccumulator {
+    private counts;
+    record(taskType: string, dimension: string, level: DeviationLevel): boolean;
+    getCount(taskType: string, dimension: string): number;
+    reset(taskType: string, dimension: string): void;
+}
+
+/**
+ * Structured human feedback collection.
+ * Checkbox-style templates instead of open-ended text. Lower friction = more feedback.
+ */
+interface FeedbackDimension {
+    id: string;
+    label: string;
+    type: 'rating' | 'select' | 'boolean';
+    options?: string[];
+    scale?: [number, number];
+}
+interface FeedbackTemplate {
+    id: string;
+    taskType: string;
+    dimensions: FeedbackDimension[];
+}
+interface FeedbackResponse {
+    templateId: string;
+    taskId: string;
+    intentId: string;
+    responses: Record<string, number | string | boolean>;
+    timestamp: string;
+    freeText?: string;
+}
+interface FeedbackSummary {
+    taskType: string;
+    totalResponses: number;
+    dimensionAverages: Record<string, number>;
+    commonIssues: string[];
+}
+declare const FEEDBACK_TEMPLATES: Record<string, FeedbackTemplate>;
+declare function selectTemplate(taskType: string): FeedbackTemplate;
+declare function normalizeFeedback(response: FeedbackResponse, template: FeedbackTemplate): Record<string, number>;
+declare function summarizeFeedback(responses: FeedbackResponse[], template: FeedbackTemplate): FeedbackSummary;
+
+/**
+ * Attribution Analysis Engine.
+ * When task results are poor, pinpoint which stage caused the problem.
+ */
+
+type AttributionTarget = 'intent_recognition' | 'skill_selection' | 'memory_retrieval' | 'output_quality' | 'unknown';
+interface Attribution {
+    target: AttributionTarget;
+    confidence: number;
+    evidence: string;
+    isHypothesis: boolean;
+}
+interface AttributionResult {
+    intentId: string;
+    attributions: Attribution[];
+    primaryCause: AttributionTarget;
+    actionable: boolean;
+}
+declare function attributeIntentError(intent: IntentObject, groundTruth: {
+    task_type: string;
+    domain: string;
+}): Attribution | null;
+declare function attributeRetrievalError(trace: RetrievalTrace, expectedHits: string[]): Attribution | null;
+declare function attributeOutputError(evaluation: EvaluationResult): Attribution | null;
+declare function analyzeAttribution(intent: IntentObject, trace: RetrievalTrace, evaluation: EvaluationResult, groundTruth?: {
+    task_type: string;
+    domain: string;
+}, expectedHits?: string[]): AttributionResult;
+
+/**
+ * Experience routing: write learnings to the right place.
+ * - Professional knowledge / pitfalls → Skill docs (skill partition)
+ * - User preferences → User memory (personal partition)
+ * - Task type experience → Task memory (domain partition)
+ * - Cross-scenario rules → Shared knowledge (global partition)
+ */
+
+type RouteTarget = ExperienceEntry['target'];
+interface RoutingDecision {
+    target: RouteTarget;
+    partition: string;
+    reason: string;
+}
+declare function routeExperience(attribution: Attribution, taskType: string, domain: string, sourceAgent: string): RoutingDecision;
+declare function createExperienceEntry(attribution: Attribution, routing: RoutingDecision, taskType: string, domain: string, sourceAgent: string, traceId: string): ExperienceEntry;
+
+/**
+ * Two-layer distillation mechanism.
+ * Layer 1: Concrete experiences (with environment tags)
+ * Layer 2: Abstract methods (stripped of environment specifics)
+ *
+ * Concrete: "中文广告标题社交媒体场景下 15 字以内效果最好"
+ * Abstract: "标题类内容存在最优长度区间，应基于历史数据找到该区间"
+ */
+
+interface DistillationResult {
+    abstractEntry: ExperienceEntry;
+    sourceIds: string[];
+    pattern: string;
+}
+/**
+ * Group concrete experiences by task_type + conclusion pattern.
+ * When 3+ experiences share a pattern, they're candidates for abstraction.
+ */
+declare function findDistillationCandidates(experiences: ExperienceEntry[], minGroupSize?: number): Map<string, ExperienceEntry[]>;
+/**
+ * Strip environment-specific details from a concrete experience.
+ * Remove specific numbers, languages, platforms, etc.
+ */
+declare function abstractify(conclusion: string, action: string): {
+    conclusion: string;
+    action: string;
+};
+/**
+ * Distill a group of concrete experiences into one abstract method.
+ */
+declare function distillGroup(group: ExperienceEntry[]): DistillationResult | null;
+/**
+ * Full distillation pass: find candidates and produce abstractions.
+ */
+declare function runDistillation(experiences: ExperienceEntry[], minGroupSize?: number): DistillationResult[];
+
+/**
+ * Cross-agent propagation + verification weighting.
+ * - Verified experiences get higher weight
+ * - Contradicted experiences auto-downweight
+ * - All agents share a global knowledge partition
+ */
+
+interface PropagationEvent {
+    experienceId: string;
+    fromAgent: string;
+    toPartition: string;
+    action: 'publish' | 'verify' | 'challenge';
+    timestamp: string;
+}
+/**
+ * Publish a verified experience to global partition for other agents.
+ */
+declare function publishToGlobal(experience: ExperienceEntry): PropagationEvent;
+/**
+ * Verify an experience: another agent confirms it works.
+ * Increases verified_count and confidence.
+ */
+declare function verifyExperience(experience: ExperienceEntry, verifyingAgent: string): {
+    updated: ExperienceEntry;
+    event: PropagationEvent;
+};
+/**
+ * Challenge an experience: new evidence contradicts it.
+ * Decreases confidence and marks for review.
+ */
+declare function challengeExperience(experience: ExperienceEntry, challengingAgent: string, evidence: string): {
+    updated: ExperienceEntry;
+    event: PropagationEvent;
+};
+/**
+ * Rank experiences by reliability for retrieval.
+ * verified_count * confidence = effective weight.
+ */
+declare function rankByReliability(experiences: ExperienceEntry[]): ExperienceEntry[];
+/**
+ * Filter experiences that are safe to propagate.
+ * Must be active, confidence >= 0.5, verified at least once.
+ */
+declare function filterPropagatable(experiences: ExperienceEntry[]): ExperienceEntry[];
+
+/**
+ * Rollback mechanism.
+ * Track post-write task performance. If same-type task success rate drops,
+ * auto-rollback the most recent experience writes.
+ */
+
+interface PerformanceWindow {
+    taskType: string;
+    recentScores: number[];
+    baselineAvg: number;
+    currentAvg: number;
+}
+interface RollbackDecision {
+    shouldRollback: boolean;
+    experienceId: string;
+    reason: string;
+    baselineAvg: number;
+    currentAvg: number;
+    degradation: number;
+}
+/**
+ * Check if performance has degraded after an experience was written.
+ * Threshold: 15% drop triggers rollback.
+ */
+declare function checkPerformanceDegradation(window: PerformanceWindow, degradationThreshold?: number): boolean;
+/**
+ * Decide whether to rollback an experience.
+ */
+declare function decideRollback(experience: ExperienceEntry, window: PerformanceWindow, threshold?: number): RollbackDecision;
+/**
+ * Execute rollback: mark experience as rolled_back.
+ * If this experience was used to create abstractions, mark those as "evidence chain incomplete".
+ */
+declare function executeRollback(experience: ExperienceEntry, relatedAbstracts?: ExperienceEntry[]): {
+    rolledBack: ExperienceEntry;
+    affectedAbstracts: ExperienceEntry[];
+};
+/**
+ * Calculate performance window from a list of recent scores.
+ */
+declare function buildPerformanceWindow(taskType: string, allScores: number[], splitAt: number): PerformanceWindow;
+
+/**
+ * Agent-to-agent compressed encoding communication.
+ * First communication uses full JSON, high-frequency values auto-register short codes.
+ * Codec table shared across all agents via registry.
+ */
+interface CodecEntry {
+    shortCode: string;
+    fullValue: string;
+    usageCount: number;
+}
+declare class Codec {
+    private codeToValue;
+    private valueToCode;
+    private usageCounts;
+    private nextCodeId;
+    private readonly autoRegisterThreshold;
+    constructor(options?: {
+        autoRegisterThreshold?: number;
+    });
+    /**
+     * Register a short code for a frequently used value.
+     */
+    register(fullValue: string, shortCode?: string): string;
+    /**
+     * Record usage of a value. Auto-registers after threshold.
+     * Returns short code if registered, undefined otherwise.
+     */
+    recordUsage(value: string): string | undefined;
+    /**
+     * Encode a message: replace registered full values with short codes.
+     */
+    encode(message: Record<string, string>): Record<string, string>;
+    /**
+     * Decode a message: replace short codes with full values.
+     */
+    decode(message: Record<string, string>): Record<string, string>;
+    /**
+     * Get all registered entries for persistence.
+     */
+    getEntries(): CodecEntry[];
+    /**
+     * Load entries from persistence.
+     */
+    loadEntries(entries: CodecEntry[]): void;
+    /**
+     * Cleanup: remove low-frequency codes.
+     */
+    cleanup(minUsage?: number): number;
+}
+
+/**
+ * Evaluation Template Market.
+ * Users and community contribute task evaluation templates.
+ * Templates define sub-dimension breakdown, auto-check rules, agent review rules.
+ */
+
+interface TemplateSubmission {
+    template: EvaluationTemplate;
+    author: string;
+    description: string;
+    submittedAt: string;
+    status: 'pending' | 'approved' | 'rejected';
+}
+interface TemplateRating {
+    templateId: string;
+    usageCount: number;
+    avgEffectiveness: number;
+    upvotes: number;
+    downvotes: number;
+}
+interface MarketQuery {
+    taskType?: string;
+    minRating?: number;
+    limit?: number;
+    sortBy?: 'rating' | 'usage' | 'newest';
+}
+declare class TemplateMarket {
+    private templates;
+    private ratings;
+    /**
+     * Submit a new template for review.
+     */
+    submit(submission: TemplateSubmission): string;
+    /**
+     * Approve a pending template.
+     */
+    approve(templateId: string): boolean;
+    /**
+     * Reject a pending template.
+     */
+    reject(templateId: string): boolean;
+    /**
+     * Search templates by criteria.
+     */
+    search(query?: MarketQuery): Array<{
+        submission: TemplateSubmission;
+        rating: TemplateRating;
+    }>;
+    /**
+     * Record a template usage and update effectiveness.
+     */
+    recordUsage(templateId: string, effectiveness: number): void;
+    /**
+     * Upvote a template.
+     */
+    upvote(templateId: string): void;
+    /**
+     * Downvote a template.
+     */
+    downvote(templateId: string): void;
+    /**
+     * Get a specific template by ID.
+     */
+    get(templateId: string): TemplateSubmission | undefined;
+    /**
+     * Get rating for a template.
+     */
+    getRating(templateId: string): TemplateRating | undefined;
+    /**
+     * List all templates (including pending/rejected for admin).
+     */
+    listAll(): TemplateSubmission[];
+}
+
+/**
+ * Industry preset packs for cold-start reduction.
+ * Pre-built knowledge, rules, and templates for common industries.
+ */
+
+interface IndustryPack {
+    id: string;
+    name: string;
+    industry: string;
+    description: string;
+    knowledge: Array<{
+        summary: string;
+        tags: string[];
+        partition: string;
+    }>;
+    templates: EvaluationTemplate[];
+    rules: Array<{
+        field: string;
+        value: string;
+        source: string;
+    }>;
+}
+declare const MARKETING_PACK: IndustryPack;
+declare const SOFTWARE_DEV_PACK: IndustryPack;
+declare const CONTENT_PACK: IndustryPack;
+declare const ALL_PACKS: Record<string, IndustryPack>;
+/**
+ * Install an industry pack: seed registry with knowledge + register templates.
+ */
+declare function getPackKnowledge(packId: string): IndustryPack['knowledge'];
+declare function getPackTemplates(packId: string): EvaluationTemplate[];
+declare function getPackRules(packId: string): IndustryPack['rules'];
+declare function listPacks(): Array<{
+    id: string;
+    name: string;
+    industry: string;
+    description: string;
+}>;
+
+/**
+ * Visualization dashboard data provider.
+ * Aggregates retrieval traces, attribution analysis, experience flow,
+ * and cross-agent propagation into dashboard-ready data structures.
+ */
+
+interface DashboardOverview {
+    totalTasks: number;
+    totalExperiences: number;
+    activeExperiences: number;
+    hypotheses: number;
+    rolledBack: number;
+    abstractMethods: number;
+    avgConfidence: number;
+}
+interface RetrievalStats {
+    totalQueries: number;
+    avgHitsPerQuery: number;
+    avgInjectedPerQuery: number;
+    topPartitions: Array<{
+        partition: string;
+        count: number;
+    }>;
+    topTags: Array<{
+        tag: string;
+        count: number;
+    }>;
+}
+interface AttributionBreakdown {
+    total: number;
+    byTarget: Record<AttributionTarget, number>;
+    actionableRate: number;
+    topIssues: Array<{
+        target: AttributionTarget;
+        count: number;
+    }>;
+}
+interface DeviationTrend {
+    taskType: string;
+    dimension: string;
+    avgRatio: number;
+    levelDistribution: Record<DeviationLevel, number>;
+}
+interface PropagationFlow {
+    totalPublished: number;
+    totalVerified: number;
+    totalChallenged: number;
+    avgVerifiedCount: number;
+}
+declare function computeOverview(experiences: ExperienceEntry[]): DashboardOverview;
+declare function computeRetrievalStats(traces: RetrievalTrace[]): RetrievalStats;
+declare function computeAttributionBreakdown(attributions: AttributionResult[]): AttributionBreakdown;
+declare function computeDeviationTrends(analyses: PredictionAnalysis[]): DeviationTrend[];
+declare function computePropagationFlow(experiences: ExperienceEntry[]): PropagationFlow;
+
+declare function safeguard<T>(fn: () => Promise<T>, fallbackValue: T, options?: {
+    logError?: boolean;
+}): Promise<T>;
+
+export { ALL_PACKS, type Actual, type AgentConfig, type AgentEvolveAdapter, type AttentionBudget, type AttentionSlot, type Attribution, type AttributionBreakdown, type AttributionResult, type AttributionTarget, CONTENT_PACK, Codec, type CodecEntry, type ConfirmThreshold, type Conflict, DEFAULT_ATTENTION_BUDGET, DEFAULT_ROUGH_INTENT, DEFAULT_THRESHOLD, type DashboardOverview, DeviationAccumulator, type DeviationLevel, type DeviationResult, type DeviationTrend, type DimensionScore, type DistillationResult, EXTRACTION_PROMPT, type EnhancedContext, type EvaluationResult, type EvaluationTemplate, type ExperienceEntry, FEEDBACK_TEMPLATES, type FeedbackDimension, type FeedbackResponse, type FeedbackSummary, type FeedbackTemplate, type FillResult, IndexTable, type IndustryPack, type IntentObject, MARKETING_PACK, type MarketQuery, type PerformanceWindow, type PipelineConfig, type PipelineResult, type Prediction, type PredictionAnalysis, type PriorityRules, type PropagationEvent, type PropagationFlow, type RawData, type RegistryEntry, type RegistryInsertInput, type RegistryUpdateInput, type ResolvedFills, type RetrievalStats, type RetrievalTrace, type RollbackDecision, type RoughIntent, type RouteTarget, type RoutingDecision, SOFTWARE_DEV_PACK, type SearchFilters, type Source, type SubDimension, TEMPLATES, TemplateMarket, type TemplateRating, type TemplateSubmission, type UserMessage, type VerificationResult, type VerificationRule, abstractify, analyzeAttribution, analyzePrediction, assembleContext, attributeIntentError, attributeOutputError, attributeRetrievalError, autoIngest, buildPerformanceWindow, buildQuestions, buildSourceTrace, buildTrace, calcConfidence, challengeExperience, checkFormatCompliance, checkKeywordCoverage, checkPerformanceDegradation, checkWordCount, computeAttributionBreakdown, computeDeviationTrends, computeOverview, computePropagationFlow, computeRetrievalStats, confirmIfNeeded, conflictDetect, contextFill, contextFillRefine, createExperienceEntry, decideRollback, dedup, distillGroup, evaluate, executeRollback, extractConstraints, extractKeywords, extractTags, filterPropagatable, findDistillationCandidates, getPackKnowledge, getPackRules, getPackTemplates, groupByField, intentPipeline, isConflicting, listPacks, normalizeFeedback, parseIntentBlock, publishToGlobal, rankByReliability, resolvePartition, resolveSource, routeExperience, runDistillation, runVerification, safeguard, selectAttentionSlots, selectTemplate, stripIntentBlock, structure, summarizeFeedback, updateIntent, verifyExperience, verifyFieldPresence, verifyJsonSchema, verifyRegex };