@almadar/agent 1.6.4 → 2.0.1

package/dist/index.d.ts

@@ -1,1679 +1,59 @@
-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-CXrq-fts.js';
-import { O as OrbitalUnit, a as OrbitalGenerationOptions$1, b as OrbitalGenerationResult$1, A as AuditLog } from './index-DW3F-Ihx.js';
-export { c as AuditEntry, T as TraitCompleteCallback, d as TraitEventCallback, e as TraitSpec, f as TraitSubagentToolOptions, g as createAgentTools, h as createApplyChunkTool, i as createCombineSchemasTool, j as createExecuteTool, k as createExtractChunkTool, l as createFinishTaskTool, m as createGenerateSchemaTool, n as createQuerySchemaStructureTool, o as createSchemaChunkingTools, p as createTraitEventWrapper, q as createTraitSubagentTool, r as createValidateSchemaTool, v as validateCommandPaths } from './index-DW3F-Ihx.js';
-import { DomainContext, OrbitalSchema, Orbital } from '@almadar/core/types';
-export { DomainDocument, DomainToSchemaResult, ParseError, SchemaToDomainResult, SectionMapping, applySectionUpdate, convertDomainToSchema, convertSchemaToDomain, deleteSection } from '@almadar/core/domain-language';
-import { LLMClient } from '@almadar/llm';
-import { U as UserPreference, M as MemoryManager, G as GenerationSession } from './index-DZn69no8.js';
-export { A as ActionGate, C as CRITICAL_COMMAND_PATTERNS, a as CheckpointRecord, b as ContextCompactionConfig, D as DEFAULT_COMPACTION_CONFIG, E as EVENT_BUDGETS, I as InterruptRecord, c as MemoryManagerOptions, d as MemoryOrbitalSchema, P as PatternAffinity, e as ProjectContext, S as SessionManager, f as SessionManagerOptions, g as Skill, h as SkillAgentOptions, i as SkillAgentResult, j as SkillLoader, k as SkillMeta, l as SkillRefLoader, T as TOOL_GATES, m as ToolApprovalPreference, n as ToolTelemetry, o as UserFeedback, W as WorkflowToolWrapper, p as WorkflowToolWrapperOptions, q as classifyCommand, r as createEvalWorkflowWrapper, s as createSkillAgent, t as createSummaryPrompt, u as createWorkflowToolWrapper, v as estimateTokens, w as getBudgetWarningMessage, x as getEventBudget, y as getInterruptConfig, z as needsCompaction, B as resumeSkillAgent } from './index-DZn69no8.js';
-import { S as SessionMetadata } from './firestore-checkpointer-CkNKXoun.js';
-export { F as FirestoreCheckpointer, a as FirestoreCheckpointerOptions, b as FirestoreDb, c as FirestoreTimestamp, P as PersistenceMode, d as Session, e as SessionRecord } from './firestore-checkpointer-CkNKXoun.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';
-import { EventEmitter } from 'events';
-import { Checkpoint } from '@langchain/langgraph-checkpoint';
-import { OrbitalDefinition } from '@almadar/core';
-export { FileMeta, FirestoreSink, FirestoreSinkConfig, GitClient, GitLogEntry, GitSink, GitStatus, MemorySnapshot, SinkManager, SinkResult, WORKSPACE_LAYOUT, WorkspaceConfig, WorkspaceManager, WorkspaceSink, createProjectOrbTemplate, createSchemaOrbTemplate, createUserOrbTemplate, parseOrb, readOrb, readOrbInstances, serializeOrb, writeOrb, writeOrbInstances } from './workspace/index.js';
-export { Command } from '@langchain/langgraph';
-export { a as DomainOrbitalCompleteCallback, D 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-BdFuf77p.js';
-import 'zod';
-import '@langchain/core/tools';
-import '@langchain/core/messages';
-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;
-};
-
-/**
- * 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
- */
-
-/**
- * Extended options for single orbital generation.
- * @deprecated Use shared OrbitalGenerationOptions instead
- */
-interface OrbitalGenerationOptions extends OrbitalGenerationOptions$1 {
-}
-/**
- * Extended result for single orbital generation.
- * @deprecated Use shared OrbitalGenerationResult instead
- */
-interface OrbitalGenerationResult extends OrbitalGenerationResult$1 {
-}
-/**
- * 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;
-
-/**
- * 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[];
-
-/**
- * Preference Learner
- *
- * Uses LLM to infer user preferences from generation sessions.
- * Leverages @almadar/llm for structured output.
- *
- * @packageDocumentation
- */
-
-interface PreferenceLearnerOptions {
-    /** LLM client for inference */
-    llmClient?: LLMClient;
-    /** Memory manager for persistence */
-    memoryManager: MemoryManager;
-    /** Confidence threshold for auto-accepting preferences */
-    confidenceThreshold?: number;
-}
-interface InferredPreference {
-    /** The preference field being inferred */
-    field: keyof Omit<UserPreference, 'id' | 'userId' | 'learnedAt'>;
-    /** The inferred value */
-    value: unknown;
-    /** Confidence level (0-1) */
-    confidence: number;
-    /** Explanation of why this was inferred */
-    reasoning: string;
-}
-interface PreferenceAnalysis {
-    /** List of inferred preferences */
-    inferences: InferredPreference[];
-    /** Whether the inference is high confidence */
-    isHighConfidence: boolean;
-}
-declare class PreferenceLearner {
-    private llmClient;
-    private memoryManager;
-    private confidenceThreshold;
-    constructor(options: PreferenceLearnerOptions);
-    /**
-     * Analyze a session and infer user preferences
-     */
-    analyzeSession(session: GenerationSession): Promise<PreferenceAnalysis>;
-    /**
-     * Learn from a session and update preferences if confidence is high
-     */
-    learnFromSession(session: GenerationSession): Promise<UserPreference | null>;
-    /**
-     * Batch learn from multiple sessions
-     */
-    batchLearn(sessions: GenerationSession[]): Promise<UserPreference | null>;
-    private buildAnalysisPrompt;
-    private buildAggregatePrompt;
-    private parseAnalysisResponse;
-    private isValidNamingConvention;
-    private isValidValidationStyle;
-}
-declare function createPreferenceLearner(options: PreferenceLearnerOptions): PreferenceLearner;
-
-/**
- * Agentic Search - GAP-006
- *
- * Reasoning-based search through memory orbitals.
- * Unlike RAG (vector similarity), this uses agent traversal with understanding
- * of state transitions, patterns, and temporal relationships.
- *
- * @packageDocumentation
- */
-
-/**
- * Search strategy for agentic search
- */
-type SearchStrategy = 'temporal' | 'semantic' | 'pattern' | 'hybrid';
-/**
- * Search parameters
- */
-interface AgenticSearchParams {
-    /** User to search memory for */
-    userId: string;
-    /** Natural language query */
-    query: string;
-    /** Search strategy */
-    strategy?: SearchStrategy;
-    /** Maximum search depth (levels of traversal) */
-    depth?: number;
-    /** App/project context to filter by */
-    appId?: string;
-    /** Maximum results to return */
-    limit?: number;
-}
-/**
- * Search result with relevance score
- */
-interface SearchResult {
-    /** Type of memory found */
-    type: 'preference' | 'session' | 'project' | 'interrupt' | 'checkpoint' | 'pattern';
-    /** The actual data */
-    data: unknown;
-    /** Relevance score (0-1) */
-    relevance: number;
-    /** Why this result matched */
-    reasoning: string;
-    /** Source collection */
-    source: string;
-    /** Timestamp for temporal sorting */
-    timestamp?: Date;
-}
-/**
- * Search result with aggregated insights
- */
-interface AgenticSearchResponse {
-    /** Individual search results */
-    results: SearchResult[];
-    /** Aggregated insights from results */
-    insights: {
-        /** Summary of what was found */
-        summary: string;
-        /** Common patterns identified */
-        patterns: string[];
-        /** Temporal trends */
-        trends: string[];
-        /** Suggested next actions */
-        suggestions: string[];
-    };
-    /** Search metadata */
-    metadata: {
-        strategy: SearchStrategy;
-        depth: number;
-        duration: number;
-        totalResults: number;
-    };
-}
-declare class AgenticSearchEngine {
-    private memoryManager;
-    constructor(memoryManager: MemoryManager);
-    /**
-     * Perform agentic search through memory
-     */
-    search(params: AgenticSearchParams): Promise<AgenticSearchResponse>;
-    /**
-     * Temporal search - "What did I do last week?"
-     * Navigates memory by time relationships
-     */
-    private temporalSearch;
-    /**
-     * Semantic search - "How did I handle user roles?"
-     * Reasoning-based understanding of structure
-     */
-    private semanticSearch;
-    /**
-     * Pattern search - "Show me all list views I've built"
-     * Searches for specific patterns and effects
-     */
-    private patternSearch;
-    /**
-     * Hybrid search - combines all strategies
-     */
-    private hybridSearch;
-    /**
-     * Extract semantic concepts from query
-     */
-    private extractConcepts;
-    /**
-     * Extract potential entity names from query
-     */
-    private extractEntityNames;
-    /**
-     * Generate insights from search results
-     */
-    private generateInsights;
-}
-/**
- * Create an agentic search engine
- */
-declare function createAgenticSearchEngine(memoryManager: MemoryManager): AgenticSearchEngine;
-
-/**
- * Observability - GAP-008
- *
- * Comprehensive observability layer for DeepAgent including:
- * - Event tracking
- * - Session metrics
- * - Performance monitoring
- * - Health checks
- *
- * @packageDocumentation
- */
-/**
- * Observable event types
- */
-type ObservableEventType = 'session_start' | 'session_end' | 'tool_call' | 'tool_result' | 'interrupt' | 'checkpoint_save' | 'checkpoint_restore' | 'error' | 'llm_call' | 'memory_sync';
-/**
- * Observable event
- */
-interface ObservableEvent {
-    /** Event type */
-    type: ObservableEventType;
-    /** Timestamp */
-    timestamp: number;
-    /** Session/thread ID */
-    sessionId: string;
-    /** User ID */
-    userId?: string;
-    /** Event payload */
-    payload: Record<string, unknown>;
-    /** Duration in ms (if applicable) */
-    duration?: number;
-    /** Error information */
-    error?: {
-        message: string;
-        code?: string;
-        stack?: string;
-    };
-}
-/**
- * Session telemetry
- */
-interface SessionTelemetry {
-    /** Session ID */
-    sessionId: string;
-    /** User ID */
-    userId?: string;
-    /** Session start time */
-    startedAt: number;
-    /** Session end time */
-    endedAt?: number;
-    /** Number of tool calls */
-    toolCallCount: number;
-    /** Number of LLM calls */
-    llmCallCount: number;
-    /** Number of interrupts */
-    interruptCount: number;
-    /** Number of checkpoints */
-    checkpointCount: number;
-    /** Total tokens used */
-    totalTokens: number;
-    /** Errors encountered */
-    errors: Array<{
-        timestamp: number;
-        message: string;
-        type: string;
-    }>;
-    /** Final status */
-    status: 'running' | 'completed' | 'failed' | 'interrupted';
-}
-/**
- * Performance snapshot
- */
-interface PerformanceSnapshot {
-    /** Timestamp */
-    timestamp: number;
-    /** Active sessions */
-    activeSessions: number;
-    /** Total sessions (all time) */
-    totalSessions: number;
-    /** Average session duration */
-    avgSessionDuration: number;
-    /** Success rate (last 24h) */
-    successRate24h: number;
-    /** Error rate (last 24h) */
-    errorRate24h: number;
-    /** Average tokens per session */
-    avgTokensPerSession: number;
-}
-/**
- * Health check result
- */
-interface HealthCheckResult {
-    /** Component name */
-    component: string;
-    /** Health status */
-    status: 'healthy' | 'degraded' | 'unhealthy';
-    /** Response time in ms */
-    responseTime: number;
-    /** Last checked timestamp */
-    checkedAt: number;
-    /** Error message if unhealthy */
-    error?: string;
-}
-declare class ObservabilityCollector {
-    private events;
-    private sessions;
-    private maxEvents;
-    constructor(options?: {
-        maxEvents?: number;
-    });
-    /**
-     * Record an observable event
-     */
-    recordEvent(event: Omit<ObservableEvent, 'timestamp'>): void;
-    /**
-     * Start session tracking
-     */
-    startSession(sessionId: string, userId?: string): void;
-    /**
-     * End session tracking
-     */
-    endSession(sessionId: string, status?: SessionTelemetry['status']): void;
-    /**
-     * Record tool call
-     */
-    recordToolCall(sessionId: string, toolName: string, args: Record<string, unknown>, duration?: number): void;
-    /**
-     * Record LLM call
-     */
-    recordLLMCall(sessionId: string, model: string, tokens: {
-        input: number;
-        output: number;
-    }, duration?: number): void;
-    /**
-     * Record error
-     */
-    recordError(sessionId: string, error: Error, context?: Record<string, unknown>): void;
-    /**
-     * Get events by type
-     */
-    getEvents(type?: ObservableEventType, sessionId?: string): ObservableEvent[];
-    /**
-     * Get session telemetry
-     */
-    getSessionTelemetry(sessionId: string): SessionTelemetry | undefined;
-    /**
-     * Get all active sessions
-     */
-    getActiveSessions(): SessionTelemetry[];
-    /**
-     * Get performance snapshot
-     */
-    getPerformanceSnapshot(): PerformanceSnapshot;
-    /**
-     * Perform health check
-     */
-    healthCheck(): Promise<HealthCheckResult[]>;
-    /**
-     * Export metrics for external systems
-     */
-    exportMetrics(): {
-        events: ObservableEvent[];
-        sessions: SessionTelemetry[];
-        snapshot: PerformanceSnapshot;
-        health: HealthCheckResult[];
-    };
-    /**
-     * Clear all data
-     */
-    clear(): void;
-    private updateSessionTelemetry;
-}
-/**
- * Get or create global observability collector
- */
-declare function getObservabilityCollector(): ObservabilityCollector;
-/**
- * Reset global observability collector
- */
-declare function resetObservabilityCollector(): void;
-/**
- * Record event to global collector
- */
-declare function recordEvent(event: Omit<ObservableEvent, 'timestamp'>): void;
-/**
- * Start session in global collector
- */
-declare function startObservabilitySession(sessionId: string, userId?: string): void;
-/**
- * End session in global collector
- */
-declare function endObservabilitySession(sessionId: string, status?: SessionTelemetry['status']): void;
-/**
- * Get performance snapshot from global collector
- */
-declare function getPerformanceSnapshot(): PerformanceSnapshot;
-
-/**
- * Multi-User Support - GAP-009
- *
- * Provides proper user isolation and session scoping for multi-user environments.
- * Ensures users can only access their own sessions, memory, and data.
- *
- * @packageDocumentation
- */
-
-/**
- * User context for multi-user operations
- */
-interface UserContext {
-    /** User ID */
-    userId: string;
-    /** Organization/tenant ID (for multi-tenant) */
-    orgId?: string;
-    /** User roles/permissions */
-    roles?: string[];
-    /** Session ID scope (optional) */
-    sessionScope?: string[];
-}
-/**
- * Scoped session metadata with user ownership
- */
-interface ScopedSessionMetadata extends SessionMetadata {
-    /** Owning user ID */
-    userId: string;
-    /** Organization ID */
-    orgId?: string;
-    /** Created by (for audit) */
-    createdBy: string;
-    /** Last accessed by */
-    lastAccessedBy?: string;
-    /** Access control list */
-    acl?: {
-        /** Users who can read this session */
-        readers?: string[];
-        /** Users who can write/modify */
-        writers?: string[];
-        /** Publicly accessible */
-        isPublic?: boolean;
-    };
-}
-/**
- * Access check result
- */
-interface AccessCheckResult {
-    /** Whether access is granted */
-    allowed: boolean;
-    /** Reason if denied */
-    reason?: string;
-    /** Required permission level */
-    requiredRole?: string;
-}
-/**
- * User session stats
- */
-interface UserSessionStats {
-    /** User ID */
-    userId: string;
-    /** Total sessions */
-    totalSessions: number;
-    /** Active sessions */
-    activeSessions: number;
-    /** Completed sessions */
-    completedSessions: number;
-    /** Sessions by skill */
-    sessionsBySkill: Record<string, number>;
-    /** Last activity timestamp */
-    lastActivityAt?: number;
-}
-declare class MultiUserManager {
-    private sessionOwnership;
-    private userSessions;
-    /**
-     * Check if a user owns a session
-     */
-    isSessionOwner(threadId: string, userId: string): boolean;
-    /**
-     * Check if a user can access a session
-     */
-    canAccessSession(threadId: string, userContext: UserContext): AccessCheckResult;
-    /**
-     * Assign session ownership
-     */
-    assignSessionOwnership(threadId: string, userId: string): void;
-    /**
-     * Get all sessions for a user
-     */
-    getUserSessions(userId: string): string[];
-    /**
-     * Get session owner
-     */
-    getSessionOwner(threadId: string): string | undefined;
-    /**
-     * Remove session ownership
-     */
-    removeSession(threadId: string): void;
-    /**
-     * Check if user has any sessions
-     */
-    hasSessions(userId: string): boolean;
-    /**
-     * Get user session count
-     */
-    getSessionCount(userId: string): number;
-    /**
-     * Transfer session ownership
-     */
-    transferOwnership(threadId: string, fromUserId: string, toUserId: string): AccessCheckResult;
-    /**
-     * Share session with another user
-     */
-    shareSession(threadId: string, ownerId: string, targetUserId: string, permission?: 'read' | 'write'): AccessCheckResult;
-    /**
-     * Get all user IDs with sessions
-     */
-    getAllUsers(): string[];
-    /**
-     * Clear all data (for testing)
-     */
-    clear(): void;
-    /**
-     * Create scoped session metadata
-     */
-    createScopedMetadata(metadata: SessionMetadata, userContext: UserContext): ScopedSessionMetadata;
-    /**
-     * Validate user context
-     */
-    validateUserContext(userContext: unknown): userContext is UserContext;
-}
-/**
- * Get or create global multi-user manager
- */
-declare function getMultiUserManager(): MultiUserManager;
-/**
- * Reset global multi-user manager
- */
-declare function resetMultiUserManager(): void;
-/**
- * Create user context from request
- */
-declare function createUserContext(userId: string, options?: {
-    orgId?: string;
-    roles?: string[];
-}): UserContext;
-/**
- * Check if user is admin
- */
-declare function isAdmin(userContext: UserContext): boolean;
-/**
- * Require ownership or throw
- */
-declare function requireOwnership(threadId: string, userContext: UserContext, manager?: MultiUserManager): void;
-
-/**
- * State Synchronization Support - GAP-010
- *
- * Provides agent-side support for real-time state synchronization.
- * The actual transport (WebSocket/SSE) is handled by @almadar/server.
- *
- * This module provides:
- * - State change notifications
- * - Conflict resolution utilities
- * - State serialization for sync
- * - Event emitters for server integration
- *
- * @packageDocumentation
- */
-
-/**
- * State change event types
- */
-type StateChangeType = 'checkpoint_created' | 'checkpoint_updated' | 'session_started' | 'session_ended' | 'tool_executed' | 'memory_updated' | 'interrupt_triggered' | 'interrupt_resolved';
-/**
- * State change event
- */
-interface StateChangeEvent {
-    /** Change type */
-    type: StateChangeType;
-    /** Thread/session ID */
-    threadId: string;
-    /** User ID */
-    userId?: string;
-    /** Timestamp */
-    timestamp: number;
-    /** Change payload */
-    payload: Record<string, unknown>;
-    /** Version vector for conflict resolution */
-    version: VersionVector;
-    /** Source client ID */
-    sourceClientId?: string;
-}
-/**
- * Version vector for conflict resolution
- */
-interface VersionVector {
-    /** Logical timestamp */
-    timestamp: number;
-    /** Sequence number */
-    sequence: number;
-    /** Node/client ID */
-    nodeId: string;
-}
-/**
- * Sync state snapshot
- */
-interface StateSyncSnapshot {
-    /** Thread ID */
-    threadId: string;
-    /** Current checkpoint */
-    checkpoint?: Checkpoint;
-    /** Session metadata */
-    sessionMetadata?: Record<string, unknown>;
-    /** Memory state */
-    memoryState?: Record<string, unknown>;
-    /** Version vector */
-    version: VersionVector;
-    /** Last updated */
-    lastUpdated: number;
-}
-/**
- * Conflict resolution result
- */
-interface ConflictResolution {
-    /** Whether conflict was resolved */
-    resolved: boolean;
-    /** Winning state if resolved */
-    winningState?: StateSyncSnapshot;
-    /** Conflicting changes if not resolved */
-    conflicts?: Array<{
-        clientA: StateChangeEvent;
-        clientB: StateChangeEvent;
-    }>;
-    /** Resolution strategy used */
-    strategy: 'last_write_wins' | 'merge' | 'manual';
-}
-/**
- * Sync configuration
- */
-interface StateSyncConfig {
-    /** Enable sync */
-    enabled: boolean;
-    /** Conflict resolution strategy */
-    conflictStrategy: 'last_write_wins' | 'merge' | 'manual';
-    /** Throttle interval (ms) */
-    throttleInterval: number;
-    /** Max retry attempts */
-    maxRetries: number;
-    /** Client ID */
-    clientId: string;
-}
-declare class StateSyncManager extends EventEmitter {
-    private config;
-    private sequenceNumber;
-    private pendingChanges;
-    private throttleTimer;
-    constructor(config?: Partial<StateSyncConfig>);
-    /**
-     * Notify that state has changed (called by agent internals)
-     */
-    notifyStateChange(type: StateChangeType, threadId: string, payload: Record<string, unknown>, userId?: string): void;
-    /**
-     * Receive state change from server (called by server transport)
-     */
-    receiveRemoteChange(event: StateChangeEvent): void;
-    /**
-     * Create sync snapshot for current state
-     */
-    createSnapshot(threadId: string, state: {
-        checkpoint?: Checkpoint;
-        sessionMetadata?: Record<string, unknown>;
-        memoryState?: Record<string, unknown>;
-    }): StateSyncSnapshot;
-    /**
-     * Compare two version vectors
-     * Returns: -1 if a < b, 0 if concurrent/equal, 1 if a > b
-     */
-    compareVersions(a: VersionVector, b: VersionVector): number;
-    /**
-     * Check if there are pending changes to sync
-     */
-    hasPendingChanges(): boolean;
-    /**
-     * Get and clear pending changes
-     */
-    flushPendingChanges(): StateChangeEvent[];
-    /**
-     * Get sync configuration
-     */
-    getConfig(): StateSyncConfig;
-    /**
-     * Update sync configuration
-     */
-    updateConfig(config: Partial<StateSyncConfig>): void;
-    /**
-     * Dispose resources
-     */
-    dispose(): void;
-    private generateClientId;
-    private createVersionVector;
-    private scheduleSync;
-    private findConflicts;
-    private resolveConflicts;
-}
-/**
- * Get or create global state sync manager
- */
-declare function getStateSyncManager(config?: Partial<StateSyncConfig>): StateSyncManager;
-/**
- * Reset global state sync manager
- */
-declare function resetStateSyncManager(): void;
-/**
- * Create a synchronized wrapper for session operations
- */
-declare function withSync<T extends (...args: unknown[]) => unknown>(fn: T, syncManager: StateSyncManager, options: {
-    threadId: string;
-    type: StateChangeType;
-    getPayload: (...args: unknown[]) => Record<string, unknown>;
-}): T;
-/**
- * Debounce sync notifications
- */
-declare function debounceSync(syncManager: StateSyncManager, delay?: number): (type: StateChangeType, threadId: string, payload: Record<string, unknown>) => void;
-
-/**
- * Online Evaluations - Phase 3.2a: Simple Sampling
- *
- * 10% traffic sampling with async validation and basic alerting.
- * Non-blocking - runs in background without affecting user response.
- *
- * @packageDocumentation
- */
-
-interface SamplingConfig {
-    /** Sampling rate (0.0 - 1.0) */
-    sampleRate: number;
-    /** Async queue size */
-    maxQueueSize: number;
-    /** Validation timeout */
-    validationTimeoutMs: number;
-    /** Alert threshold for error rate */
-    errorRateThreshold: number;
-    /** Alert window in ms */
-    alertWindowMs: number;
-}
-interface EvalSample {
-    sampleId: string;
-    timestamp: number;
-    request: {
-        prompt: string;
-        provider: string;
-        model: string;
-    };
-    result: {
-        success: boolean;
-        schema?: unknown;
-        error?: string;
-        latencyMs: number;
-    };
-    validation?: {
-        automatedScore: number;
-        syntaxErrors: number;
-        structureWarnings: number;
-        timestamp: number;
-    };
-}
-interface ErrorAlert {
-    alertId: string;
-    timestamp: number;
-    errorRate: number;
-    threshold: number;
-    windowStart: number;
-    sampleCount: number;
-    errorCount: number;
-}
-interface SamplingStats {
-    totalSampled: number;
-    totalValidated: number;
-    averageScore: number;
-    currentErrorRate: number;
-    queueSize: number;
-    isHealthy: boolean;
-}
-declare class OnlineEvalSampler extends EventEmitter {
-    private config;
-    private queue;
-    private samples;
-    private errorWindow;
-    private isProcessing;
-    constructor(config?: Partial<SamplingConfig>);
-    /**
-     * Check if a request should be sampled
-     * Uses hash-based sampling for consistency
-     */
-    shouldSample(requestId: string): boolean;
-    /**
-     * Add a sample to the queue for async validation
-     */
-    sample(requestId: string, request: {
-        prompt: string;
-        provider: string;
-        model: string;
-    }, result: {
-        success: boolean;
-        schema?: unknown;
-        error?: string;
-        latencyMs: number;
-    }): Promise<void>;
-    /**
-     * Pull samples for manual review
-     */
-    pullSamples(options?: {
-        date?: Date;
-        limit?: number;
-        minScore?: number;
-    }): Promise<EvalSample[]>;
-    /**
-     * Get current stats
-     */
-    getStats(): SamplingStats;
-    /**
-     * Stop the processor
-     */
-    stop(): void;
-    private startProcessor;
-    private validateSample;
-    private runAutomatedValidation;
-    private trackError;
-    private calculateErrorRate;
-}
-interface ReviewOptions {
-    date?: string;
-    limit?: number;
-    minScore?: number;
-    format?: 'json' | 'table';
-}
-declare function reviewSamples(sampler: OnlineEvalSampler, options?: ReviewOptions): Promise<void>;
-declare function createOnlineEvalSampler(config?: Partial<SamplingConfig>): OnlineEvalSampler;
-
-/**
- * Tool Composition & Chaining - Phase 3.3
- *
- * Composable tool workflows with parallel execution, error handling,
- * and conditional branching.
- *
- * @packageDocumentation
- */
-type ToolStepStatus = 'pending' | 'running' | 'success' | 'error' | 'skipped';
-interface ToolStep {
-    id: string;
-    name: string;
-    tool: string;
-    input: Record<string, unknown> | ((context: WorkflowContext) => Record<string, unknown>);
-    condition?: (context: WorkflowContext) => boolean;
-    dependsOn?: string[];
-    status: ToolStepStatus;
-    output?: unknown;
-    error?: string;
-    startTime?: number;
-    endTime?: number;
-}
-interface WorkflowContext {
-    workflowId: string;
-    inputs: Record<string, unknown>;
-    outputs: Record<string, unknown>;
-    stepResults: Map<string, {
-        success: boolean;
-        output?: unknown;
-        error?: string;
-    }>;
-    metadata: {
-        startTime: number;
-        stepsCompleted: number;
-        stepsFailed: number;
-    };
-}
-interface WorkflowDefinition {
-    name: string;
-    description: string;
-    inputs: Record<string, {
-        type: string;
-        required: boolean;
-        default?: unknown;
-    }>;
-    steps: ToolStep[];
-    onError?: 'stop' | 'continue' | 'retry';
-    maxRetries?: number;
-}
-interface WorkflowExecutionResult {
-    success: boolean;
-    workflowId: string;
-    context: WorkflowContext;
-    steps: ToolStep[];
-    durationMs: number;
-    error?: string;
-}
-interface ParallelExecutionResult {
-    stepId: string;
-    success: boolean;
-    output?: unknown;
-    error?: string;
-    durationMs: number;
-}
-interface ToolExecutor {
-    execute(tool: string, input: Record<string, unknown>): Promise<unknown>;
-}
-declare class WorkflowEngine {
-    private executor;
-    private workflows;
-    constructor(executor: ToolExecutor);
-    /**
-     * Register a workflow definition
-     */
-    registerWorkflow(definition: WorkflowDefinition): void;
-    /**
-     * Execute a workflow by name
-     */
-    executeWorkflow(workflowName: string, inputs: Record<string, unknown>): Promise<WorkflowExecutionResult>;
-    /**
-     * Execute a workflow definition directly
-     */
-    runWorkflow(definition: WorkflowDefinition, inputs: Record<string, unknown>): Promise<WorkflowExecutionResult>;
-    /**
-     * Execute independent steps in parallel
-     */
-    executeParallel(steps: Array<{
-        id: string;
-        tool: string;
-        input: Record<string, unknown>;
-    }>, context: WorkflowContext): Promise<ParallelExecutionResult[]>;
-    /**
-     * Create a workflow builder for fluent API
-     */
-    createWorkflow(name: string, description: string): WorkflowBuilder;
-    private executeStep;
-    private resolveDependencies;
-}
-declare class WorkflowBuilder {
-    private engine;
-    private definition;
-    constructor(engine: WorkflowEngine, name: string, description: string);
-    input(name: string, type: string, required?: boolean, defaultValue?: unknown): this;
-    step(id: string, tool: string, input: Record<string, unknown> | ((context: WorkflowContext) => Record<string, unknown>), options?: {
-        dependsOn?: string[];
-        condition?: (context: WorkflowContext) => boolean;
-    }): this;
-    parallel(steps: Array<{
-        id: string;
-        tool: string;
-        input: Record<string, unknown>;
-    }>): this;
-    onError(policy: 'stop' | 'continue' | 'retry'): this;
-    retry(maxRetries: number): this;
-    build(): WorkflowDefinition;
-    execute(inputs: Record<string, unknown>): Promise<WorkflowExecutionResult>;
-}
-declare function createSchemaGenerationWorkflow(engine: WorkflowEngine): WorkflowDefinition;
-declare function createWorkflowEngine(executor: ToolExecutor): WorkflowEngine;
-
-/**
- * Complexity Classifier
- *
- * Determines the complexity of an orbital generation request
- * based on the number of orbitals identified during decomposition.
- */
-type ComplexityLevel = 'simple' | 'medium' | 'complex';
-interface ComplexityResult {
-    level: ComplexityLevel;
-    orbitalCount: number;
-    recommendedProvider: 'qwen' | 'multi-provider';
-    reasoning: string;
-}
-/**
- * Classify complexity based on orbital count
- *
- * Simple: 1 orbital
- * Medium: 2-3 orbitals
- * Complex: 4+ orbitals
- */
-declare function classifyComplexity(orbitalCount: number): ComplexityResult;
-/**
- * Quick complexity check without full decomposition
- * Based on keywords and request length heuristics
- */
-declare function estimateComplexity(prompt: string): {
-    estimatedLevel: ComplexityLevel;
-    confidence: 'high' | 'medium' | 'low';
-};
-/**
- * Get execution strategy based on complexity
- */
-declare function getExecutionStrategy(complexity: ComplexityResult): {
-    type: 'single' | 'multi-provider';
-    provider: string;
-    model: string;
-    parallelization: number;
-};
-
-/**
- * Provider Router
- *
- * Routes generation and fixing requests to the appropriate provider(s)
- * based on complexity analysis.
- */
-
-interface RouteConfig {
-    /** Optional: Override default verbosity */
-    verbose?: boolean;
-}
-interface GenerationResult {
-    orbitals: OrbitalDefinition[];
-    complexity: ComplexityResult;
-    timing: {
-        decomposeMs: number;
-        generateMs: number;
-        totalMs: number;
-    };
-    provider: string;
-}
-interface DecomposedUnit {
-    name: string;
-    entity: string;
-    traits: string[];
-}
-/**
- * Main routing function for generation
- *
- * 1. Decomposes the request
- * 2. Classifies complexity
- * 3. Routes to appropriate provider(s)
- * 4. Returns combined results
- */
-declare function routeGeneration(prompt: string, skillContent: string, config?: RouteConfig): Promise<GenerationResult>;
-/**
- * Quick check if a request is likely complex
- * Useful for UI feedback before full decomposition
- */
-declare function quickComplexityCheck(prompt: string): {
-    likelyComplex: boolean;
-    confidence: 'high' | 'medium' | 'low';
-    estimatedOrbitals: number;
-};
-
-/**
- * CapabilityToken — HMAC-SHA256 signed scoped token with budget + TTL.
- *
- * TypeScript port of saezbaldo/ic-agi `ic_agi/control_plane.py`.
- * See: https://github.com/saezbaldo/ic-agi
- *
- * TLA+ properties verified in CapabilityTokens.tla:
- *   P5 AntiReplay:         uses <= budget (invariant)
- *   P6 TTLEnforcement:     expired tokens produce no log entries
- *   P7 RevocationFinality: revoked = true => uses frozen forever
- *   P8 BudgetMonotonicity: uses never decreases
- *   P9 ForgeryResistance:  invalid signature => uses never incremented
- */
-interface CapabilityToken {
-    tokenId: string;
-    issuedTo: string;
-    /** Sorted alphabetically for determinism. */
-    scope: string[];
-    /** Unix epoch seconds. */
-    issuedAt: number;
-    /** Unix epoch seconds. */
-    expiresAt: number;
-    budget: number;
-    uses: number;
-    revoked: boolean;
-    metadata: Record<string, unknown>;
-    /** HMAC-SHA256 hex digest over the immutable fields. */
-    signature: string;
-}
-interface TokenParams {
-    issuedTo: string;
-    scope: string[];
-    ttlSeconds?: number;
-    budget?: number;
-    criticality?: 'low' | 'medium' | 'high' | 'critical';
-    metadata?: Record<string, unknown>;
-}
-/** Issue a new signed capability token. TTL and budget are policy-capped. */
-declare function issueToken(params: TokenParams, signingKey: Buffer): CapabilityToken;
-/** Verify the token's HMAC signature. Uses constant-time comparison (P9). */
-declare function verifyToken(token: CapabilityToken, signingKey: Buffer): boolean;
-/** Check if the token can be used (not revoked, not expired, has remaining budget). */
-declare function isTokenValid(token: CapabilityToken): boolean;
-/**
- * Consume one use from the token.
- * Returns false without mutating if the token is invalid (P5, P8).
- */
-declare function consumeToken(token: CapabilityToken): boolean;
-/** Permanently revoke a token. Immutable once set (P7). */
-declare function revokeToken(token: CapabilityToken): void;
-
-/**
- * ThresholdAuthorizer — K-of-N approval voting for critical agent actions.
- *
- * TypeScript port of saezbaldo/ic-agi `ic_agi/threshold_auth.py`.
- * See: https://github.com/saezbaldo/ic-agi
- *
- * TLA+ properties verified in ThresholdAuth.tla:
- *   P1 ThresholdSafety:       executed => approvals >= K
- *   P2 NoUnilateralAuthority: K >= 2 enforced in constructor
- *   P3 DenialFinality:        once denied, resolution immutable
- *   P4 ResolutionImmutability: resolved => resolution never changes
- *
- * Early-denial formula: deny_count > (N - K)
- * Once enough denials make threshold mathematically unreachable,
- * the request is immediately resolved as denied.
- */
-
-interface ApprovalRequest {
-    requestId: string;
-    actionDescription: string;
-    criticality: string;
-    requester: string;
-    /** Unix epoch seconds. */
-    createdAt: number;
-    ttlSeconds: number;
-    /** Map of approverId → vote (true = approve, false = deny). */
-    approvals: Map<string, boolean>;
-    resolved: boolean;
-    resolution: 'approved' | 'denied' | 'expired' | null;
-}
-interface VoteResult {
-    status: 'approved' | 'denied' | 'pending';
-    approvals: number;
-    denials: number;
-    threshold: number;
-    /** Remaining approvals needed to reach threshold. */
-    remaining: number;
-}
-declare class ThresholdAuthorizer {
-    private requests;
-    private readonly k;
-    private readonly n;
-    private readonly approverIds;
-    private readonly auditLog?;
-    /**
-     * @param k         Minimum approvals required (must be >= 2, P2)
-     * @param approverIds List of registered approver IDs (length >= k)
-     * @param auditLog  Optional audit chain for all voting events
-     */
-    constructor(k: number, approverIds: string[], auditLog?: AuditLog);
-    /**
-     * Create a new approval request for a critical action.
-     * The request window is 5 minutes (300s).
-     */
-    createRequest(actionDescription: string, requester: string, criticality?: string): ApprovalRequest;
-    /**
-     * Submit a vote for a pending request.
-     * Auto-resolves the request when threshold is reached (approve)
-     * or when threshold becomes mathematically unreachable (deny).
-     *
-     * @throws if request not found, already resolved, expired, approver not registered, or double-vote
-     */
-    submitVote(requestId: string, approverId: string, vote: boolean): VoteResult;
-    /** Returns true iff the request is resolved and approved (P1). */
-    isApproved(requestId: string): boolean;
-    /** Returns true iff the request is resolved and denied (P3). */
-    isDenied(requestId: string): boolean;
-    isExpired(requestId: string): boolean;
-    getRequest(requestId: string): ApprovalRequest | undefined;
-}
-
-/**
- * RateLimiter — Sliding window per-entity rate limiting.
- *
- * TypeScript port of saezbaldo/ic-agi `ic_agi/rate_limiter.py`.
- * See: https://github.com/saezbaldo/ic-agi
- *
- * Two-layer design:
- *   1. Global counter (10x per-entity limit) — system-wide protection
- *   2. Per-(entity, scope) counter — fine-grained per-caller limits
- *
- * Cooldown note: when a per-entity counter is exceeded, a cooldown
- * period is applied. The global counter does not apply cooldown.
- */
-
-interface RateLimitConfig {
-    /** Maximum requests per window. Default: 20 */
-    maxRequests?: number;
-    /** Sliding window duration in seconds. Default: 60 */
-    windowSeconds?: number;
-    /** Cooldown duration in seconds after limit exceeded. Default: 30 */
-    cooldownSeconds?: number;
-}
-declare class RateLimiter {
-    private readonly counters;
-    private readonly global;
-    private readonly config;
-    private readonly auditLog?;
-    constructor(config?: RateLimitConfig, auditLog?: AuditLog);
-    /**
-     * Check whether the (entity, scope) pair is allowed to proceed.
-     * Checks the global counter first, then the per-entity counter.
-     */
-    allow(entity: string, scope?: string): boolean;
-    remaining(entity: string, scope?: string): number;
-    inCooldown(entity: string, scope?: string): boolean;
-    reset(entity: string, scope?: string): void;
-    /** Reset all counters including global (test utility). */
-    resetAll(): void;
-}
-
-/**
- * CircuitBreaker — Fault isolation state machine per worker/session.
- *
- * TypeScript port of saezbaldo/ic-agi `ic_agi/circuit_breaker.py`.
- * See: https://github.com/saezbaldo/ic-agi
- *
- * State machine:
- *   CLOSED → OPEN         when consecutive failures >= threshold OR error rate >= 50%
- *   OPEN   → HALF_OPEN    after recovery timeout (probe request allowed through)
- *   HALF_OPEN → CLOSED    when consecutive successes >= success threshold
- *   HALF_OPEN → OPEN      on any failure (immediate trip)
- *
- * Error rate guard only fires when totalRequests >= 5 to prevent
- * tripping on a single noisy startup failure.
- */
-
-declare enum CircuitState {
-    CLOSED = "CLOSED",
-    OPEN = "OPEN",
-    HALF_OPEN = "HALF_OPEN"
-}
-interface CircuitBreakerConfig {
-    /** Consecutive failures before tripping. Default: 3 */
-    failureThreshold?: number;
-    /** Consecutive successes in HALF_OPEN before closing. Default: 2 */
-    successThreshold?: number;
-    /** Seconds in OPEN before allowing a probe request. Default: 30 */
-    recoveryTimeoutSeconds?: number;
-    /** Window in seconds for error-rate calculation. Default: 120 */
-    errorRateWindow?: number;
-    /** Error rate threshold (0–1) to trigger OPEN. Default: 0.5 */
-    errorRateThreshold?: number;
-}
-interface WorkerCircuit {
-    workerId: string;
-    state: CircuitState;
-    consecutiveFailures: number;
-    consecutiveSuccesses: number;
-    totalRequests: number;
-    totalFailures: number;
-    lastFailureTime: number;
-    openedAt: number;
-    lastTransitionTime: number;
-    /** Sliding window of (timestamp, success) pairs. */
-    recent: Array<{
-        timestamp: number;
-        success: boolean;
-    }>;
-}
-declare class CircuitBreaker {
-    private readonly circuits;
-    private readonly config;
-    private readonly auditLog?;
-    constructor(config?: CircuitBreakerConfig, auditLog?: AuditLog);
-    private getOrCreate;
-    /** Compute error rate for the worker within the configured window. Prunes stale entries. */
-    private errorRate;
-    private transition;
-    /**
-     * Check whether the worker is allowed to proceed.
-     * - CLOSED: always allowed
-     * - OPEN:   blocked until recovery timeout, then transitions to HALF_OPEN
-     * - HALF_OPEN: probe allowed through
-     */
-    allow(workerId: string): boolean;
-    recordSuccess(workerId: string): void;
-    recordFailure(workerId: string): void;
-    getState(workerId: string): CircuitState;
-    getStats(workerId: string): Pick<WorkerCircuit, 'state' | 'consecutiveFailures' | 'totalRequests' | 'totalFailures'>;
-}
-
-/**
- * SandboxExecutor — V8 isolate-based sandboxed code execution.
- *
- * Uses `isolated-vm` to run untrusted code in a separate V8 context
- * with configurable memory and time limits. Stronger isolation than
- * Node.js `vm` module (separate heap, no shared references).
- *
- * This is an Almadar-specific addition to the IC-AGI security layer.
- * It will be contributed to almadar-io/ic-agi as an optional module.
- */
-interface SandboxOptions {
-    /** Execution timeout in milliseconds. Default: 5000 */
-    timeoutMs?: number;
-    /** Memory limit for the isolate in MB. Default: 32 */
-    memoryLimitMb?: number;
-}
-interface SandboxResult {
-    success: boolean;
-    value?: unknown;
-    error?: string;
-    timedOut?: boolean;
-}
-/**
- * Execute a JavaScript code string inside a V8 isolate.
- *
- * The `inputs` object is copied into the isolate as a global `inputs` variable.
- * The code should return a value or assign to a global `result` variable.
- *
- * Falls back gracefully if `isolated-vm` is not available in the environment.
- */
-declare function executeSandboxed(code: string, inputs?: Record<string, unknown>, options?: SandboxOptions): Promise<SandboxResult>;
-
-export { type AccessCheckResult, AgenticSearchEngine, type AgenticSearchParams, type AgenticSearchResponse, type ApprovalRequest, AuditLog, type CapabilityToken, CircuitBreaker, type CircuitBreakerConfig, CircuitState, type ComplexityLevel, type ComplexityResult, type ConflictResolution, type DecomposedUnit, type DeepAgentCompleteEvent, type DeepAgentErrorEvent, type DeepAgentEvent, type DeepAgentExecutionEvent, type DeepAgentSchemaEvent, type DeepAgentStartEvent, type ErrorAlert, type EvalSample, type GenerationMetrics, type GenerationResult, GenerationSession, type HealthCheckResult, type InferredPreference, MemoryManager, MetricsCollector, type MetricsSummary, MultiUserManager, ObservabilityCollector, type ObservableEvent, type ObservableEventType, OnlineEvalSampler, type CombinerOptions as OrbitalCombinerOptions, type CombinerResult as OrbitalCombinerResult, type OrbitalSchemaValidationResult, type ParallelExecutionResult, type PerformanceSnapshot, type PreferenceAnalysis, PreferenceLearner, type PreferenceLearnerOptions, type RateLimitConfig, RateLimiter, type ReviewOptions, type RouteConfig, type SamplingConfig, type SamplingStats, type SandboxOptions, type SandboxResult, type ScopedSessionMetadata, type SearchResult, type SearchStrategy, SessionMetadata, type SessionTelemetry, type StateChangeEvent, type StateChangeType, type StateSyncConfig, StateSyncManager, type StateSyncSnapshot, SubAgent, ThresholdAuthorizer, type TokenParams, type ToolExecutor, type ToolStep, type ToolStepStatus, type UserContext, UserPreference, type UserSessionStats, type VersionVector, type VoteResult, WorkflowBuilder, type WorkflowContext, type WorkflowDefinition, WorkflowEngine, type WorkflowExecutionResult, analyzeFailures, classifyComplexity, combineOrbitals, combineOrbitalsToSchema, consumeToken, createAgenticSearchEngine, createErrorFixerSubagent, createOnlineEvalSampler, createPreferenceLearner, createSchemaGenerationWorkflow, createSchemaGeneratorSubagent, createSubagentConfigs, createSubagents, createTestAnalyzerSubagent, createUserContext, createWorkflowEngine, debounceSync, endObservabilitySession, estimateCacheSavings, estimateCombineComplexity, estimateComplexity, executeSandboxed, formatSummary, generateFullOrbital, getExecutionStrategy, getMultiUserManager, getObservabilityCollector, getPerformanceSnapshot, getStateSyncManager, isAdmin, isCompleteEvent, isErrorEvent, isExecutionEvent, isSchemaEvent, isStartEvent, isTokenValid, issueToken, parseDeepAgentEvent, quickComplexityCheck, recordEvent, requireOwnership, resetMultiUserManager, resetObservabilityCollector, resetStateSyncManager, reviewSamples, revokeToken, routeGeneration, startObservabilitySession, verifyToken, withSync };
+ * @almadar/agent
+ *
+ * AI agent infrastructure for Almadar orbital schema generation.
+ *
+ * Provides everything needed to create, run, checkpoint, and resume
+ * skill-based agents. Uses @almadar/llm for LLM access and
+ * @almadar/skills for prompt sections.
+ *
+ * Key modules:
+ * - Agent factory: createSkillAgent(), resumeSkillAgent()
+ * - Session management: SessionManager with pluggable backends
+ * - Persistence: Memory + Firestore backends for checkpoints & sessions
+ * - Event transformer: Raw LangGraph events → typed SSE events
+ * - Tools: execute, validate, orbital subagent, domain, chunking
+ *
+ * @packageDocumentation
+ */
+export type { AgentDependencies, SubAgent, CombineOrbitalsFn, CombinerOptions, CombinerResult, ConvertDomainToSchemaFn, DomainConversionResult, GenerateFullOrbitalFn, OrbitalGenerationResult, OrbitalGenerationOptions, GenerationLog, } from './types.js';
+export { createSSEEvent, formatSSEEvent, parseSSEEvent, isSSEStartEvent, isSSEMessageEvent, isSSEInterruptEvent, isSSECompleteEvent, isSSEErrorEvent, isSSEToolCallEvent, isSSETodoUpdateEvent, isSSETodoDetailEvent, isSSESubagentEvent, isSSEGenerationLogEvent, ExtractedRequirementsSchema, GenerateRequestSchema, ResumeRequestSchema, ContinueRequestSchema, } from './api-types.js';
+export type { SSEEvent, SSEEventType, GenerateRequest, ResumeRequest, ContinueRequest, ExtractedRequirementsInput, StartEvent, MessageEvent, ToolCallEvent, ToolResultEvent, TodoUpdateEvent, ErrorEvent, CompleteEvent, SubagentEvent, GenerationLogEvent, InterruptEvent, } from './api-types.js';
+export { createAgentTools, createExecuteTool, validateCommandPaths, createValidateSchemaTool, createGenerateSchemaTool, createFinishTaskTool, createCombineSchemasTool, createOrbitalSubagentTool, createSubagentEventWrapper, createTraitSubagentTool, createTraitEventWrapper, createGenerateOrbitalDomainTool, createConstructCombinedDomainTool, createDomainOrbitalTools, createQuerySchemaStructureTool, createExtractChunkTool, createApplyChunkTool, createSchemaChunkingTools, } from './tools/index.js';
+export type { SubagentEventCallback, OrbitalCompleteCallback, OrbitalRequirements, OrbitalSubagentToolOptions, TraitEventCallback, TraitCompleteCallback, TraitSubagentToolOptions, TraitSpec, DomainOrbitalEventCallback, DomainOrbitalCompleteCallback, DomainOrbitalToolOptions, DomainOrbitalSpec, } from './tools/index.js';
+export { combineOrbitals, combineOrbitalsToSchema, estimateCombineComplexity, } from './orbitals/combiner/index.js';
+export type { CombinerOptions as OrbitalCombinerOptions, CombinerResult as OrbitalCombinerResult, OrbitalSchemaValidationResult, } from './orbitals/combiner/index.js';
+export { convertDomainToSchema, applySectionUpdate, deleteSection, convertSchemaToDomain, } from './orbitals/domain-language/index.js';
+export type { DomainToSchemaResult, SchemaToDomainResult, DomainDocument, ParseError, SectionMapping, } from './orbitals/domain-language/index.js';
+export { generateFullOrbital, estimateCacheSavings, } from './orbitals/generation/index.js';
+export { createSubagents, createSubagentConfigs, createSchemaGeneratorSubagent, createErrorFixerSubagent, createTestAnalyzerSubagent, } from './subagents.js';
+export { parseDeepAgentEvent, isStartEvent, isExecutionEvent, isSchemaEvent, isCompleteEvent, isErrorEvent, } from './events.js';
+export type { DeepAgentEvent, DeepAgentStartEvent, DeepAgentExecutionEvent, DeepAgentSchemaEvent, DeepAgentCompleteEvent, DeepAgentErrorEvent, } from './events.js';
+export { needsCompaction, createSummaryPrompt, estimateTokens, DEFAULT_COMPACTION_CONFIG, } from './context-compaction.js';
+export type { ContextCompactionConfig, } from './context-compaction.js';
+export { MetricsCollector, formatSummary, analyzeFailures, } from './metrics.js';
+export type { GenerationMetrics, MetricsSummary, } from './metrics.js';
+export { createSkillAgent, resumeSkillAgent, Command, SessionManager, EVENT_BUDGETS, getEventBudget, getBudgetWarningMessage, getInterruptConfig, } from './agent/index.js';
+export type { Skill, SkillLoader, SkillRefLoader, SkillAgentOptions, SkillAgentResult, SessionMetadata, SessionRecord, PersistenceMode, SessionManagerOptions, SkillMeta, } from './agent/index.js';
+export { MemorySessionBackend, FirestoreCheckpointer, FirestoreSessionStore, FirestoreStore, } from './persistence/index.js';
+export type { FirestoreCheckpointerOptions, FirestoreDb, FirestoreTimestamp, FirestoreSessionStoreOptions, FirestoreStoreOptions, Session, } from './persistence/index.js';
+export { transformAgentEvent, transformAgentEventMulti, hasInterrupt, extractInterruptData, isTodoUpdate, isFileOperation, extractFileOperation, } from './event-transformer/index.js';
+export type { RawAgentEvent, } from './event-transformer/index.js';
+export { MemoryOrbitalSchema, MemoryManager, PreferenceLearner, createPreferenceLearner, AgenticSearchEngine, createAgenticSearchEngine, ObservabilityCollector, getObservabilityCollector, resetObservabilityCollector, recordEvent, startObservabilitySession, endObservabilitySession, getPerformanceSnapshot, MultiUserManager, getMultiUserManager, resetMultiUserManager, createUserContext, isAdmin, requireOwnership, StateSyncManager, getStateSyncManager, resetStateSyncManager, withSync, debounceSync, } from './memory/index.js';
+export type { UserPreference, GenerationSession, ProjectContext, UserFeedback, PatternAffinity, InterruptRecord, ToolApprovalPreference, CheckpointRecord, MemoryManagerOptions, PreferenceLearnerOptions, InferredPreference, PreferenceAnalysis, SearchStrategy, AgenticSearchParams, SearchResult, AgenticSearchResponse, ObservableEventType, ObservableEvent, SessionTelemetry, PerformanceSnapshot, HealthCheckResult, UserContext, ScopedSessionMetadata, AccessCheckResult, UserSessionStats, StateChangeType, StateChangeEvent, VersionVector, StateSyncSnapshot, ConflictResolution, StateSyncConfig, } from './memory/index.js';
+export { OnlineEvalSampler, createOnlineEvalSampler, reviewSamples, } from './evals/online-sampling.js';
+export type { SamplingConfig, EvalSample, ErrorAlert, SamplingStats, ReviewOptions, } from './evals/online-sampling.js';
+export { WorkflowEngine, WorkflowBuilder, createWorkflowEngine, createSchemaGenerationWorkflow, } from './tools/composition.js';
+export type { ToolStep, ToolStepStatus, WorkflowContext, WorkflowDefinition, WorkflowExecutionResult, ParallelExecutionResult, ToolExecutor, } from './tools/composition.js';
+export { createWorkflowToolWrapper, createEvalWorkflowWrapper, } from './agent/workflow-tool-wrapper.js';
+export type { WorkflowToolWrapperOptions, ToolTelemetry, WorkflowToolWrapper, } from './agent/workflow-tool-wrapper.js';
+export { classifyComplexity, estimateComplexity, getExecutionStrategy, routeGeneration, quickComplexityCheck, } from './orchestration/index.js';
+export type { ComplexityLevel, ComplexityResult, RouteConfig, GenerationResult, DecomposedUnit, } from './orchestration/index.js';
+export { AuditLog, issueToken, verifyToken, isTokenValid, consumeToken, revokeToken, ThresholdAuthorizer, RateLimiter, CircuitBreaker, CircuitState, } from './utils/safety/index.js';
+export type { AuditEntry, CapabilityToken, TokenParams, ApprovalRequest, VoteResult, RateLimitConfig, CircuitBreakerConfig, } from './utils/safety/index.js';
+export { WorkspaceManager, SinkManager, GitClient, GitSink, FirestoreSink, WORKSPACE_LAYOUT, createUserOrbTemplate, createProjectOrbTemplate, createSchemaOrbTemplate, serializeOrb, parseOrb, readOrbInstances, readOrb, writeOrbInstances, writeOrb, } from './workspace/index.js';
+export type { WorkspaceSink, WorkspaceConfig, FileMeta, SinkResult, MemorySnapshot, FirestoreSinkConfig, GitLogEntry, GitStatus, } from './workspace/index.js';
+export { executeSandboxed } from './tools/sandbox-executor.js';
+export type { SandboxOptions, SandboxResult } from './tools/sandbox-executor.js';
+export { classifyCommand, TOOL_GATES, CRITICAL_COMMAND_PATTERNS } from './agent/interrupt-config.js';
+export type { ActionGate } from './agent/interrupt-config.js';