@almadar/agent 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,742 @@
+import { SubAgent } from './types.js';
+export { AgentDependencies, CombineOrbitalsFn, CombinerOptions, CombinerResult, ConvertDomainToSchemaFn, DomainConversionResult, GenerateFullOrbitalFn, GenerationLog, OrbitalGenerationOptions, OrbitalGenerationResult } from './types.js';
+export { C as CompleteEvent, b as ContinueRequest, c as ContinueRequestSchema, E as ErrorEvent, d as ExtractedRequirementsInput, e as ExtractedRequirementsSchema, G as GenerateRequest, f as GenerateRequestSchema, g as GenerationLogEvent, I as InterruptEvent, M as MessageEvent, R as ResumeRequest, h as ResumeRequestSchema, a as SSEEvent, S as SSEEventType, i as StartEvent, j as SubagentEvent, T as TodoUpdateEvent, k as ToolCallEvent, l as ToolResultEvent, m as createSSEEvent, n as formatSSEEvent, o as isSSECompleteEvent, p as isSSEErrorEvent, q as isSSEGenerationLogEvent, r as isSSEInterruptEvent, s as isSSEMessageEvent, t as isSSEStartEvent, u as isSSESubagentEvent, v as isSSETodoDetailEvent, w as isSSETodoUpdateEvent, x as isSSEToolCallEvent, y as parseSSEEvent } from './api-types-BW_58thJ.js';
+export { TraitCompleteCallback, TraitEventCallback, TraitSpec, TraitSubagentToolOptions, createAgentTools, createApplyChunkTool, createCombineSchemasTool, createExecuteTool, createExtractChunkTool, createFinishTaskTool, createGenerateSchemaTool, createQuerySchemaStructureTool, createSchemaChunkingTools, createTraitEventWrapper, createTraitSubagentTool, createValidateSchemaTool, validateCommandPaths } from './tools/index.js';
+import { DomainContext, OrbitalSchema, Orbital, OrbitalDefinition, FullOrbitalUnit as FullOrbitalUnit$1 } from '@almadar/core/types';
+import { LLMClient } from '@almadar/llm';
+export { createCompactSystemPrompt, createSystemPrompt } from './prompts/index.js';
+import { BaseMessage } from '@langchain/core/messages';
+export { EVENT_BUDGETS, SessionManager, SessionManagerOptions, Skill, SkillAgentOptions, SkillAgentResult, SkillLoader, SkillMeta, SkillRefLoader, createSkillAgent, getBudgetWarningMessage, getEventBudget, getInterruptConfig, resumeSkillAgent } from './agent/index.js';
+export { F as FirestoreCheckpointer, a as FirestoreCheckpointerOptions, b as FirestoreDb, c as FirestoreTimestamp, P as PersistenceMode, S as Session, d as SessionMetadata, e as SessionRecord } from './firestore-checkpointer-DxbQ10ve.js';
+export { FirestoreSessionStore, FirestoreSessionStoreOptions, FirestoreStore, FirestoreStoreOptions, MemorySessionBackend } from './persistence/index.js';
+export { RawAgentEvent, extractFileOperation, extractInterruptData, hasInterrupt, isFileOperation, isTodoUpdate, transformAgentEvent, transformAgentEventMulti } from './event-transformer/index.js';
+export { Command } from '@langchain/langgraph';
+export { D as DomainOrbitalCompleteCallback, a as DomainOrbitalEventCallback, b as DomainOrbitalSpec, c as DomainOrbitalToolOptions, O as OrbitalCompleteCallback, d as OrbitalRequirements, e as OrbitalSubagentToolOptions, S as SubagentEventCallback, f as createConstructCombinedDomainTool, g as createDomainOrbitalTools, h as createGenerateOrbitalDomainTool, i as createOrbitalSubagentTool, j as createSubagentEventWrapper } from './orbital-subagent-BsQBhKzi.js';
+import 'zod';
+import '@langchain/core/tools';
+import '@langchain/langgraph-checkpoint';
+import '@langchain/core/runnables';
+
+/**
+ * Orbital Combiner
+ *
+ * Deterministically combines multiple Orbitals into a single OrbitalSchema.
+ * This removes the need for LLM involvement in the combining step.
+ *
+ * All UI is rendered via render_ui effects from traits (no static sections).
+ *
+ * NOTE: Validation is handled externally via `orbital validate` CLI.
+ * The combiner only assembles schemas - it does not validate them.
+ *
+ * @packageDocumentation
+ */
+
+interface OrbitalSchemaValidationResult {
+    valid: boolean;
+    errors: Array<{
+        code: string;
+        message: string;
+        path?: string;
+    }>;
+    warnings: Array<{
+        code: string;
+        message: string;
+        path?: string;
+    }>;
+}
+type FullOrbitalUnit = Orbital;
+interface CombinerOptions {
+    /** Application name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Schema version */
+    version?: string;
+    /** Domain context */
+    domain?: DomainContext;
+    /** Whether to run validation (default: true) */
+    validate?: boolean;
+    /** Global theme */
+    theme?: string;
+    /** Default route (first page if not specified) */
+    defaultRoute?: string;
+}
+interface CombinerResult {
+    /** Whether combining succeeded */
+    success: boolean;
+    /** The combined OrbitalSchema (if successful) */
+    schema?: OrbitalSchema;
+    /** Validation result (if validation was run) */
+    validation?: OrbitalSchemaValidationResult;
+    /** Error message (if failed) */
+    error?: string;
+    /** Statistics about the combining */
+    stats: {
+        totalOrbitals: number;
+        totalEntities: number;
+        totalPages: number;
+        totalTraits: number;
+    };
+}
+/**
+ * Combine multiple Orbitals into a single OrbitalSchema.
+ *
+ * This function performs deterministic merging:
+ * 1. Builds an OrbitalSchema from the Orbitals
+ * 2. Optionally runs validation
+ *
+ * Note: All UI is rendered via render_ui effects from traits.
+ *
+ * @example
+ * ```typescript
+ * const result = combineOrbitals([taskOrbital, userOrbital], {
+ *   name: 'My App',
+ *   validate: true,
+ * });
+ *
+ * if (result.success) {
+ *   // Write schema to file
+ *   await fs.writeFile('schema.json', JSON.stringify(result.schema, null, 2));
+ * } else {
+ *   console.error(result.error);
+ *   console.error(result.validation?.errors);
+ * }
+ * ```
+ */
+declare function combineOrbitals(orbitals: FullOrbitalUnit[], options: CombinerOptions): CombinerResult;
+/**
+ * Combine orbitals and return only the schema (throws on error).
+ * Use this when you want a simple API and will handle errors upstream.
+ */
+declare function combineOrbitalsToSchema(orbitals: FullOrbitalUnit[], options: CombinerOptions): OrbitalSchema;
+/**
+ * Estimate the combination complexity (for progress indication).
+ */
+declare function estimateCombineComplexity(orbitals: FullOrbitalUnit[]): {
+    entities: number;
+    pages: number;
+    traits: number;
+    totalSections: number;
+};
+
+/**
+ * Effect operator mapping: Both systems use the same operator names
+ */
+declare const EFFECT_OPERATORS: readonly ["set", "emit", "navigate", "render-ui", "persist", "call-service", "spawn", "despawn", "do", "notify"];
+/**
+ * Effect operator names (S-expression first element)
+ * These are the operators used in S-expression effects like ['emit', ...]
+ */
+type EffectType = (typeof EFFECT_OPERATORS)[number];
+interface SourceLocation {
+    line: number;
+    column: number;
+    offset: number;
+}
+interface SourceRange {
+    start: SourceLocation;
+    end: SourceLocation;
+}
+interface ASTNode {
+    type: string;
+    range?: SourceRange;
+}
+/**
+ * Domain Language field types
+ *
+ * Note: These map to OrbitalSchema types via DOMAIN_TO_SCHEMA_FIELD_TYPE
+ */
+type DomainFieldType = 'text' | 'long text' | 'number' | 'currency' | 'date' | 'timestamp' | 'datetime' | 'yes/no' | 'enum' | 'list' | 'object' | 'relation';
+interface DomainField extends ASTNode {
+    type: 'field';
+    name: string;
+    fieldType: DomainFieldType;
+    required: boolean;
+    unique: boolean;
+    auto: boolean;
+    default?: unknown;
+    enumValues?: string[];
+}
+type RelationshipType = 'belongs_to' | 'has_many' | 'has_one';
+interface DomainRelationship extends ASTNode {
+    type: 'relationship';
+    relationshipType: RelationshipType;
+    targetEntity: string;
+    alias?: string;
+}
+interface DomainEntity extends ASTNode {
+    type: 'entity';
+    name: string;
+    description: string;
+    fields: DomainField[];
+    relationships: DomainRelationship[];
+    states?: string[];
+    initialState?: string;
+}
+interface DomainPageSection extends ASTNode {
+    type: 'page_section';
+    description: string;
+}
+interface DomainPageAction extends ASTNode {
+    type: 'page_action';
+    trigger: string;
+    action: string;
+}
+interface DomainPage extends ASTNode {
+    type: 'page';
+    name: string;
+    description: string;
+    purpose: string;
+    url: string;
+    primaryEntity?: string;
+    traitName?: string;
+    sections: DomainPageSection[];
+    actions: DomainPageAction[];
+    onAccess?: string;
+}
+type ComparisonOperator = '==' | '!=' | '>' | '<' | '>=' | '<=';
+type LogicalOperator = 'AND' | 'OR';
+interface FieldReference extends ASTNode {
+    type: 'field_reference';
+    entityName: string;
+    fieldName: string;
+}
+interface FieldCheckCondition extends ASTNode {
+    type: 'field_check';
+    field: FieldReference;
+    check: 'provided' | 'empty' | 'equals';
+    value?: string | number | boolean;
+}
+interface ComparisonCondition extends ASTNode {
+    type: 'comparison';
+    field: FieldReference;
+    operator: ComparisonOperator;
+    value: string | number | boolean;
+}
+interface UserCheckCondition extends ASTNode {
+    type: 'user_check';
+    check: 'is_role' | 'owns_this';
+    role?: string;
+    ownerField?: string;
+}
+interface LogicalCondition extends ASTNode {
+    type: 'logical';
+    operator: LogicalOperator;
+    left: GuardCondition;
+    right: GuardCondition;
+}
+type GuardCondition = FieldCheckCondition | ComparisonCondition | UserCheckCondition | LogicalCondition;
+interface DomainGuard extends ASTNode {
+    type: 'guard';
+    condition: GuardCondition;
+    raw: string;
+}
+interface DomainEffect extends ASTNode {
+    type: 'effect';
+    effectType: EffectType;
+    description: string;
+    config: Record<string, unknown>;
+}
+interface DomainTransition extends ASTNode {
+    type: 'transition';
+    fromState: string;
+    toState: string;
+    event: string;
+    guards: DomainGuard[];
+    effects: DomainEffect[];
+}
+interface DomainTick extends ASTNode {
+    type: 'tick';
+    name: string;
+    interval: string;
+    intervalMs?: number;
+    guard?: DomainGuard;
+    effects: DomainEffect[];
+}
+interface DomainBehavior extends ASTNode {
+    type: 'behavior';
+    name: string;
+    entityName: string;
+    states: string[];
+    initialState: string;
+    transitions: DomainTransition[];
+    ticks: DomainTick[];
+    rules: string[];
+}
+interface DomainDocument extends ASTNode {
+    type: 'document';
+    entities: DomainEntity[];
+    pages: DomainPage[];
+    behaviors: DomainBehavior[];
+}
+interface SectionMapping {
+    sectionId: string;
+    sectionType: 'entity' | 'page' | 'behavior' | 'tick';
+    schemaPath: string;
+    domainText: string;
+    aiDescription?: string;
+    range?: SourceRange;
+    lastModified?: number;
+}
+interface ParseError {
+    message: string;
+    range?: SourceRange;
+    suggestion?: string;
+}
+
+/**
+ * Schema to Domain Converter
+ *
+ * Converts a complete OrbitalSchema to domain language text.
+ * Generates three sections: Entities, Pages, and Behaviors.
+ *
+ * Updated to read from OrbitalSchema where entities, pages, and traits
+ * are grouped into Orbital units. Also supports legacy KFlowSchema format
+ * for backward compatibility.
+ */
+
+interface SchemaToDomainResult {
+    /** The complete domain text document */
+    domainText: string;
+    /** Parsed AST representation */
+    document: DomainDocument;
+    /** Mapping of sections to schema paths */
+    mappings: SectionMapping[];
+    /** Separate section texts for individual editing */
+    sections: {
+        entities: string[];
+        pages: string[];
+        behaviors: string[];
+    };
+}
+/**
+ * Legacy KFlowSchema format (for backward compatibility)
+ */
+interface LegacyKFlowSchema {
+    name?: string;
+    dataEntities?: Array<Record<string, unknown>>;
+    ui?: {
+        pages?: Array<Record<string, unknown>>;
+    };
+    traits?: Array<Record<string, unknown>>;
+    ticks?: Array<Record<string, unknown>>;
+}
+/**
+ * Combined input type for the converter
+ */
+type SchemaInput = OrbitalSchema | LegacyKFlowSchema;
+/**
+ * Convert a complete OrbitalSchema or legacy KFlowSchema to domain language
+ */
+declare function convertSchemaToDomain(schema: SchemaInput): SchemaToDomainResult;
+
+/**
+ * Domain to Schema Converter
+ *
+ * Applies domain language text changes to an OrbitalSchema.
+ * Supports incremental updates (single section) and full replacement.
+ *
+ * Updated to use OrbitalSchema where entities, pages, and traits
+ * are grouped into Orbital units instead of flat arrays.
+ */
+
+interface DomainToSchemaResult {
+    /** Whether the conversion was successful */
+    success: boolean;
+    /** The updated schema */
+    schema: OrbitalSchema;
+    /** Any parse errors encountered */
+    errors: ParseError[];
+    /** Warnings (non-fatal issues) */
+    warnings: ParseError[];
+    /** Updated section mappings */
+    mappings: SectionMapping[];
+}
+/**
+ * Parse a complete domain document and convert to OrbitalSchema
+ */
+declare function convertDomainToSchema(domainText: string, baseSchema?: OrbitalSchema): DomainToSchemaResult;
+/**
+ * Apply a single section update to an OrbitalSchema
+ */
+declare function applySectionUpdate(schema: OrbitalSchema, sectionType: 'entity' | 'page' | 'behavior' | 'tick', sectionId: string, newDomainText: string): DomainToSchemaResult;
+/**
+ * Delete a section from the schema
+ */
+declare function deleteSection(schema: OrbitalSchema, sectionType: 'entity' | 'page' | 'behavior' | 'tick', sectionId: string): OrbitalSchema;
+
+/**
+ * Orbital Generator
+ *
+ * Provides utilities for generating FullOrbitalUnit definitions from
+ * lightweight OrbitalUnit inputs. Designed for SUBAGENT use where each
+ * orbital is generated separately for better caching.
+ *
+ * ## Subagent Caching Pattern
+ *
+ * When generating multiple orbitals in a subagent pattern:
+ * 1. Main agent decomposes request → OrbitalUnit[]
+ * 2. For each orbital, subagent calls generateFullOrbital()
+ * 3. Each subagent call uses the SAME cached system prompt blocks
+ * 4. Anthropic caches at request level → subsequent calls get 90% discount
+ *
+ * This is MORE efficient than batch generation because:
+ * - System prompt is cached and reused across subagent calls
+ * - Template guidance is cached per fingerprint
+ * - Only the orbital-specific content varies
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Extracted requirements from the analysis phase.
+ * Matches ExtractedRequirements from agents/orchestrator/shared/requirements.ts
+ */
+interface ExtractedRequirements {
+    /** Entity names to create */
+    entities: string[];
+    /** State names that should exist */
+    states: string[];
+    /** Event/action names */
+    events: string[];
+    /** Business rules (become guards) */
+    guards: string[];
+    /** Page types needed */
+    pages: string[];
+    /** Notifications/side-effects */
+    effects: string[];
+    /** Raw requirement statements */
+    rawRequirements: string[];
+}
+type OrbitalUnit = OrbitalDefinition;
+/**
+ * A structured log entry from the generation process.
+ * Used for debugging and observability of subagent reasoning.
+ */
+interface GenerationLog {
+    /** Timestamp of the log entry */
+    timestamp: number;
+    /** Log level */
+    level: 'info' | 'warn' | 'error' | 'debug';
+    /** Log message */
+    message: string;
+    /** Optional structured data */
+    data?: Record<string, unknown>;
+}
+interface OrbitalGenerationOptions {
+    /** Maximum tokens for generation */
+    maxTokens?: number;
+    /** Enable validation after generation */
+    validate?: boolean;
+    /** Callback for real-time log streaming (SSE integration) */
+    onLog?: (log: GenerationLog, orbitalName?: string) => void;
+    /** Optional requirements relevant to this orbital (from analysis) */
+    requirements?: Partial<ExtractedRequirements>;
+}
+interface OrbitalGenerationResult {
+    /** Generated full orbital unit */
+    orbital: FullOrbitalUnit$1;
+    /** Fingerprint used for caching */
+    fingerprint: string;
+    /** Whether template guidance was used */
+    usedTemplate: boolean;
+    /** Token usage */
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    /** Validation result */
+    validation?: {
+        valid: boolean;
+        errorCount: number;
+        warningCount: number;
+    };
+    /** Structured logs from the generation process */
+    logs: GenerationLog[];
+}
+/**
+ * Generate a full orbital unit from a lightweight orbital input.
+ *
+ * DESIGNED FOR SUBAGENT USE: Call this once per orbital in separate
+ * subagent invocations. Caching works across calls because:
+ * - System prompt blocks are marked as cacheable
+ * - Anthropic caches at the request level
+ * - Subsequent calls with same system prompt get cache hits
+ *
+ * @example
+ * ```typescript
+ * // In subagent for each orbital:
+ * const result = await generateFullOrbital(client, orbitalUnit, { validate: true });
+ * // First call: Cache WRITE: 3500 tokens
+ * // Second call: Cache HIT: 3500 tokens (90% discount!)
+ * ```
+ */
+declare function generateFullOrbital(client: LLMClient, orbital: OrbitalUnit, options?: OrbitalGenerationOptions): Promise<OrbitalGenerationResult>;
+/**
+ * Estimate cache savings for a set of orbitals.
+ *
+ * Use this to predict how much caching will help for a decomposition.
+ */
+declare function estimateCacheSavings(orbitals: OrbitalUnit[]): {
+    totalOrbitals: number;
+    uniqueFingerprints: number;
+    estimatedCacheHits: number;
+    estimatedSavingsPercent: number;
+};
+
+/**
+ * KFlow DeepAgent Subagents
+ *
+ * Specialized subagents for complex schema generation tasks.
+ * These are spawned via the `task()` built-in tool.
+ *
+ * Uses @almadar/skills for schema reference documentation.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Create the Schema Generator Subagent configuration.
+ *
+ * Focused agent for generating KFlow schemas from requirements.
+ * Writes schema to file and verifies it exists.
+ */
+declare function createSchemaGeneratorSubagent(): SubAgent;
+/**
+ * Create the Error Fixer Subagent configuration.
+ *
+ * Focused agent for fixing validation and compilation errors.
+ */
+declare function createErrorFixerSubagent(): SubAgent;
+/**
+ * Create the Test Analyzer Subagent configuration.
+ *
+ * Focused agent for analyzing test failures and suggesting fixes.
+ */
+declare function createTestAnalyzerSubagent(): SubAgent;
+/**
+ * Create all subagent configurations.
+ */
+declare function createSubagents(): SubAgent[];
+/**
+ * Create subagent configs as a record for easy lookup.
+ */
+declare function createSubagentConfigs(): Record<string, SubAgent>;
+
+/**
+ * DeepAgent SSE Event Types
+ *
+ * Type definitions for Server-Sent Events from the DeepAgent streaming endpoint.
+ * Use these types for client-side consumption of /deepagent/generate-stream.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Initial event sent when streaming begins.
+ */
+interface DeepAgentStartEvent {
+    type: 'start';
+    sessionId: string;
+}
+/**
+ * Agent execution event (tool calls, messages, etc.).
+ */
+interface DeepAgentExecutionEvent {
+    type: 'event';
+    node?: string;
+    toolCall?: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+    toolResult?: {
+        name: string;
+        result: unknown;
+    };
+    message?: {
+        role: 'assistant' | 'user' | 'system';
+        content: string;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Schema generated event.
+ */
+interface DeepAgentSchemaEvent {
+    type: 'schema';
+    schema: Record<string, unknown>;
+}
+/**
+ * Completion event sent when generation finishes successfully.
+ */
+interface DeepAgentCompleteEvent {
+    type: 'complete';
+    sessionId: string;
+    appCompiled: boolean;
+}
+/**
+ * Error event sent when generation fails.
+ */
+interface DeepAgentErrorEvent {
+    type: 'error';
+    error: string;
+}
+/**
+ * Union of all possible DeepAgent SSE events.
+ */
+type DeepAgentEvent = DeepAgentStartEvent | DeepAgentExecutionEvent | DeepAgentSchemaEvent | DeepAgentCompleteEvent | DeepAgentErrorEvent;
+/**
+ * Parse an SSE data line into a DeepAgentEvent.
+ */
+declare function parseDeepAgentEvent(data: string): DeepAgentEvent;
+/**
+ * Type guard for start events.
+ */
+declare function isStartEvent(event: DeepAgentEvent): event is DeepAgentStartEvent;
+/**
+ * Type guard for execution events.
+ */
+declare function isExecutionEvent(event: DeepAgentEvent): event is DeepAgentExecutionEvent;
+/**
+ * Type guard for schema events.
+ */
+declare function isSchemaEvent(event: DeepAgentEvent): event is DeepAgentSchemaEvent;
+/**
+ * Type guard for complete events.
+ */
+declare function isCompleteEvent(event: DeepAgentEvent): event is DeepAgentCompleteEvent;
+/**
+ * Type guard for error events.
+ */
+declare function isErrorEvent(event: DeepAgentEvent): event is DeepAgentErrorEvent;
+
+/**
+ * Context Compaction for DeepAgent
+ *
+ * Provides middleware to manage context length in long-running agent sessions.
+ * Uses @langchain/core's trimMessages to keep context within token limits.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Configuration for context compaction.
+ */
+interface ContextCompactionConfig {
+    /**
+     * Maximum number of tokens before triggering compaction.
+     * Default: 150000 (leaves headroom for Claude's 200K context)
+     */
+    maxTokens?: number;
+    /**
+     * Number of recent messages to always keep.
+     * Default: 10
+     */
+    keepRecentMessages?: number;
+    /**
+     * Whether to include the system message in trimming.
+     * Default: false (system message is always kept)
+     */
+    includeSystem?: boolean;
+    /**
+     * Strategy for trimming: 'first' keeps first messages, 'last' keeps last messages.
+     * Default: 'last'
+     */
+    strategy?: 'first' | 'last';
+}
+/**
+ * Default configuration for context compaction.
+ */
+declare const DEFAULT_COMPACTION_CONFIG: Required<ContextCompactionConfig>;
+/**
+ * Check if messages need compaction based on estimated token count.
+ */
+declare function needsCompaction(messages: BaseMessage[], threshold?: number): boolean;
+/**
+ * Create a message summarizer prompt for compacting old context.
+ */
+declare function createSummaryPrompt(messages: BaseMessage[]): string;
+/**
+ * Estimate token count for messages using character-based heuristic.
+ */
+declare function estimateTokens(messages: BaseMessage[]): number;
+
+/**
+ * Metrics Collection for DeepAgent Evaluation
+ *
+ * Tracks success rates, iteration counts, token usage, and timing
+ * for agent generation tests.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Metrics for a single generation attempt.
+ */
+interface GenerationMetrics {
+    testName: string;
+    complexity: 'simple' | 'medium' | 'complex';
+    success: boolean;
+    iterations: number;
+    timeMs: number;
+    tokenUsage?: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    error?: string;
+    timestamp?: number;
+}
+/**
+ * Aggregated metrics summary.
+ */
+interface MetricsSummary {
+    total: number;
+    passed: number;
+    failed: number;
+    successRate: number;
+    avgIterations: number;
+    avgTimeMs: number;
+    avgTokens: number;
+    byComplexity: {
+        simple: {
+            total: number;
+            passed: number;
+            successRate: number;
+        };
+        medium: {
+            total: number;
+            passed: number;
+            successRate: number;
+        };
+        complex: {
+            total: number;
+            passed: number;
+            successRate: number;
+        };
+    };
+}
+/**
+ * Collects and aggregates generation metrics.
+ */
+declare class MetricsCollector {
+    private metrics;
+    record(metrics: GenerationMetrics): void;
+    getAll(): GenerationMetrics[];
+    getSummary(): MetricsSummary;
+    private getComplexitySummary;
+    getFailures(): GenerationMetrics[];
+    getMultiIterationTests(): GenerationMetrics[];
+    clear(): void;
+    saveToFile(filePath: string): Promise<void>;
+    loadFromFile(filePath: string): Promise<void>;
+}
+/**
+ * Format metrics summary as a readable string.
+ */
+declare function formatSummary(summary: MetricsSummary): string;
+/**
+ * Analyze failure patterns to suggest prompt improvements.
+ */
+declare function analyzeFailures(failures: GenerationMetrics[]): string[];
+
+export { type ContextCompactionConfig, DEFAULT_COMPACTION_CONFIG, type DeepAgentCompleteEvent, type DeepAgentErrorEvent, type DeepAgentEvent, type DeepAgentExecutionEvent, type DeepAgentSchemaEvent, type DeepAgentStartEvent, type DomainDocument, type DomainToSchemaResult, type GenerationMetrics, MetricsCollector, type MetricsSummary, type CombinerOptions as OrbitalCombinerOptions, type CombinerResult as OrbitalCombinerResult, type OrbitalSchemaValidationResult, type ParseError, type SchemaToDomainResult, type SectionMapping, SubAgent, analyzeFailures, applySectionUpdate, combineOrbitals, combineOrbitalsToSchema, convertDomainToSchema, convertSchemaToDomain, createErrorFixerSubagent, createSchemaGeneratorSubagent, createSubagentConfigs, createSubagents, createSummaryPrompt, createTestAnalyzerSubagent, deleteSection, estimateCacheSavings, estimateCombineComplexity, estimateTokens, formatSummary, generateFullOrbital, isCompleteEvent, isErrorEvent, isExecutionEvent, isSchemaEvent, isStartEvent, needsCompaction, parseDeepAgentEvent };