@mxf-dev/core 1.0.0

package/dist/types/NetworkRecoveryTypes.js

@@ -0,0 +1,169 @@
+/**
+ * Copyright 2024 Brad Anderson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author Brad Anderson <BradA1878@pm.me>
+ * @repository https://github.com/mxf-dev/mxf
+ * @documentation https://mxf-dev.github.io/mxf/
+ */
+/**
+ * Network Recovery Types
+ *
+ * Type definitions for network error handling, retry logic,
+ * circuit breaker patterns, and graceful degradation strategies.
+ */
+/**
+ * Classification of network and API errors for proper handling strategies
+ */
+export var NetworkErrorType;
+(function (NetworkErrorType) {
+    // Network connectivity issues
+    NetworkErrorType["NETWORK_TIMEOUT"] = "NETWORK_TIMEOUT";
+    NetworkErrorType["NETWORK_CONNECTION_REFUSED"] = "NETWORK_CONNECTION_REFUSED";
+    NetworkErrorType["NETWORK_DNS_RESOLUTION"] = "NETWORK_DNS_RESOLUTION";
+    NetworkErrorType["NETWORK_SOCKET_ERROR"] = "NETWORK_SOCKET_ERROR";
+    // API service issues
+    NetworkErrorType["API_BAD_GATEWAY"] = "API_BAD_GATEWAY";
+    NetworkErrorType["API_SERVICE_UNAVAILABLE"] = "API_SERVICE_UNAVAILABLE";
+    NetworkErrorType["API_GATEWAY_TIMEOUT"] = "API_GATEWAY_TIMEOUT";
+    NetworkErrorType["API_INTERNAL_ERROR"] = "API_INTERNAL_ERROR";
+    // Authentication and authorization
+    NetworkErrorType["AUTH_UNAUTHORIZED"] = "AUTH_UNAUTHORIZED";
+    NetworkErrorType["AUTH_FORBIDDEN"] = "AUTH_FORBIDDEN";
+    // Rate limiting
+    NetworkErrorType["RATE_LIMITED"] = "RATE_LIMITED";
+    // Client errors
+    NetworkErrorType["CLIENT_BAD_REQUEST"] = "CLIENT_BAD_REQUEST";
+    NetworkErrorType["CLIENT_UNPROCESSABLE"] = "CLIENT_UNPROCESSABLE";
+    NetworkErrorType["CLIENT_NOT_FOUND"] = "CLIENT_NOT_FOUND";
+    // Other errors
+    NetworkErrorType["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+})(NetworkErrorType || (NetworkErrorType = {}));
+/**
+ * Determines if an error is retryable based on its type
+ */
+export function isRetryableError(errorType) {
+    const retryableTypes = [
+        NetworkErrorType.NETWORK_TIMEOUT,
+        NetworkErrorType.NETWORK_CONNECTION_REFUSED,
+        NetworkErrorType.NETWORK_DNS_RESOLUTION,
+        NetworkErrorType.NETWORK_SOCKET_ERROR,
+        NetworkErrorType.API_BAD_GATEWAY,
+        NetworkErrorType.API_SERVICE_UNAVAILABLE,
+        NetworkErrorType.API_GATEWAY_TIMEOUT,
+        NetworkErrorType.API_INTERNAL_ERROR,
+        NetworkErrorType.RATE_LIMITED
+    ];
+    return retryableTypes.includes(errorType);
+}
+/**
+ * Default network recovery configuration
+ */
+export const DEFAULT_NETWORK_RECOVERY_CONFIG = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    retryMultiplier: 2,
+    circuitBreakerThreshold: 5,
+    circuitBreakerCooldownMs: 60000,
+    circuitBreakerHalfOpenRequests: 1,
+    requestTimeoutMs: 30000,
+    enableGracefulDegradation: true,
+    enableDetailedLogging: true
+};
+/**
+ * Circuit breaker states
+ */
+export var CircuitBreakerState;
+(function (CircuitBreakerState) {
+    CircuitBreakerState["CLOSED"] = "CLOSED";
+    CircuitBreakerState["OPEN"] = "OPEN";
+    CircuitBreakerState["HALF_OPEN"] = "HALF_OPEN"; // Testing recovery
+})(CircuitBreakerState || (CircuitBreakerState = {}));
+/**
+ * Classifies an error based on status code and error details
+ */
+export function classifyNetworkError(error, statusCode) {
+    // Check for specific status codes first
+    if (statusCode) {
+        switch (statusCode) {
+            case 400:
+                return NetworkErrorType.CLIENT_BAD_REQUEST;
+            case 401:
+                return NetworkErrorType.AUTH_UNAUTHORIZED;
+            case 403:
+                return NetworkErrorType.AUTH_FORBIDDEN;
+            case 404:
+                return NetworkErrorType.CLIENT_NOT_FOUND;
+            case 422:
+                return NetworkErrorType.CLIENT_UNPROCESSABLE;
+            case 429:
+                return NetworkErrorType.RATE_LIMITED;
+            case 500:
+                return NetworkErrorType.API_INTERNAL_ERROR;
+            case 502:
+                return NetworkErrorType.API_BAD_GATEWAY;
+            case 503:
+                return NetworkErrorType.API_SERVICE_UNAVAILABLE;
+            case 504:
+                return NetworkErrorType.API_GATEWAY_TIMEOUT;
+        }
+    }
+    // Check error message for network issues
+    const errorMessage = error?.message?.toLowerCase() || '';
+    if (errorMessage.includes('timeout')) {
+        return NetworkErrorType.NETWORK_TIMEOUT;
+    }
+    if (errorMessage.includes('econnrefused') || errorMessage.includes('connection refused')) {
+        return NetworkErrorType.NETWORK_CONNECTION_REFUSED;
+    }
+    if (errorMessage.includes('enotfound') || errorMessage.includes('dns')) {
+        return NetworkErrorType.NETWORK_DNS_RESOLUTION;
+    }
+    if (errorMessage.includes('socket') || errorMessage.includes('econnreset')) {
+        return NetworkErrorType.NETWORK_SOCKET_ERROR;
+    }
+    if (errorMessage.includes('fetch failed')) {
+        // Generic fetch failed could be various network issues
+        return NetworkErrorType.NETWORK_CONNECTION_REFUSED;
+    }
+    return NetworkErrorType.UNKNOWN_ERROR;
+}
+/**
+ * Calculates retry delay with exponential backoff and jitter
+ */
+export function calculateRetryDelay(attemptNumber, config) {
+    const exponentialDelay = config.baseDelayMs * Math.pow(config.retryMultiplier, attemptNumber - 1);
+    const clampedDelay = Math.min(exponentialDelay, config.maxDelayMs);
+    // Add jitter (±20%) to prevent thundering herd
+    const jitter = clampedDelay * 0.2 * (Math.random() - 0.5);
+    return Math.round(clampedDelay + jitter);
+}
+/**
+ * Formats an error for logging with appropriate detail level
+ */
+export function formatNetworkError(error, includeStack = false) {
+    const parts = [
+        `[${error.type}]`,
+        error.statusCode ? `Status ${error.statusCode}` : '',
+        error.message,
+        error.retryCount ? `(Retry ${error.retryCount}/${error.maxRetries})` : ''
+    ].filter(Boolean);
+    let formatted = parts.join(' ');
+    if (includeStack && error.originalError?.stack) {
+        formatted += '\n' + error.originalError.stack;
+    }
+    return formatted;
+}
+//# sourceMappingURL=NetworkRecoveryTypes.js.map

package/dist/types/NetworkRecoveryTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkRecoveryTypes.js","sourceRoot":"","sources":["../../src/types/NetworkRecoveryTypes.ts"],"names":[],"mappings":"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"}

package/dist/types/OrparMemoryIntegrationTypes.d.ts

@@ -0,0 +1,463 @@
+/**
+ * Copyright 2024 Brad Anderson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author Brad Anderson <BradA1878@pm.me>
+ * @repository https://github.com/mxf-dev/mxf
+ * @documentation https://mxf-dev.github.io/mxf/
+ */
+/**
+ * ORPAR-Memory Integration Types
+ *
+ * Type definitions for the unified cognitive-memory architecture that tightly couples
+ * ORPAR phases with memory operations. This integration enables:
+ * - Phase-specific memory strata routing
+ * - Surprise-driven ORPAR control decisions
+ * - Phase-weighted reward attribution
+ * - ORPAR cycle-triggered memory consolidation
+ *
+ * Feature flag: ORPAR_MEMORY_INTEGRATION_ENABLED
+ */
+import { MemoryStratum, MemoryEntry, SurpriseDetection } from './MemoryStrataTypes.js';
+import { OrparPhase, MemoryUsageRecord, QValueUpdate } from './MemoryUtilityTypes.js';
+import { AgentId, ChannelId } from './ChannelContext.js';
+/**
+ * Mapping of an ORPAR phase to its preferred memory strata
+ */
+export interface PhaseStrataMapping {
+    /** ORPAR phase */
+    phase: OrparPhase;
+    /** Primary strata to query (higher priority) */
+    primaryStrata: MemoryStratum[];
+    /** Secondary strata to query (lower priority, used as fallback) */
+    secondaryStrata: MemoryStratum[];
+    /** Lambda value for utility weighting in this phase */
+    lambda: number;
+    /** Rationale for this mapping */
+    rationale: string;
+}
+/**
+ * Default phase-strata mappings following the cognitive architecture
+ */
+export declare const DEFAULT_PHASE_STRATA_MAPPINGS: PhaseStrataMapping[];
+/**
+ * Result of phase-aware memory retrieval
+ */
+export interface PhaseStrataRetrievalResult {
+    /** Retrieved memories */
+    memories: MemoryEntry[];
+    /** Which strata were queried */
+    queriedStrata: MemoryStratum[];
+    /** The phase that drove the retrieval */
+    phase: OrparPhase;
+    /** Lambda value used */
+    lambdaUsed: number;
+    /** Retrieval metadata */
+    metadata: {
+        /** Primary strata results count */
+        primaryResultCount: number;
+        /** Secondary strata results count */
+        secondaryResultCount: number;
+        /** Total query time in ms */
+        queryTimeMs: number;
+    };
+}
+/**
+ * Decision made by the SurpriseOrparAdapter based on surprise signals
+ */
+export interface SurpriseOrparDecision {
+    /** Type of decision */
+    type: SurpriseDecisionType;
+    /** Number of additional observation cycles to trigger (for RE_OBSERVE) */
+    additionalObservations?: number;
+    /** Surprise context to inject into reasoning (for INJECT_CONTEXT) */
+    surpriseContext?: SurpriseContext;
+    /** Whether the current plan should be reconsidered (for RECONSIDER_PLAN) */
+    planReconsideration?: PlanReconsiderationInfo;
+    /** Whether to extend reasoning phase (for EXTEND_REASONING) */
+    extendReasoning?: boolean;
+    /** Original surprise detection that triggered this decision */
+    surpriseDetection: SurpriseDetection;
+    /** Confidence in this decision (0-1) */
+    confidence: number;
+}
+/**
+ * Types of decisions the SurpriseOrparAdapter can make
+ */
+export type SurpriseDecisionType = 'NO_ACTION' | 'RE_OBSERVE' | 'INJECT_CONTEXT' | 'RECONSIDER_PLAN' | 'EXTEND_REASONING';
+/**
+ * Context information about surprise to inject into reasoning
+ */
+export interface SurpriseContext {
+    /** The surprising observation */
+    observation: string;
+    /** Why it was surprising */
+    explanation: string;
+    /** The expectation that was violated */
+    violatedExpectation?: string;
+    /** Suggested areas to focus reasoning on */
+    focusAreas: string[];
+    /** Surprise score for weighting */
+    surpriseScore: number;
+}
+/**
+ * Information about why a plan should be reconsidered
+ */
+export interface PlanReconsiderationInfo {
+    /** Reason for reconsideration */
+    reason: string;
+    /** Specific aspects of the plan to review */
+    aspectsToReview: string[];
+    /** Alternative approaches to consider */
+    alternativesToConsider: string[];
+    /** Severity of the reconsideration need */
+    severity: 'low' | 'medium' | 'high';
+}
+/**
+ * Configuration for surprise thresholds
+ */
+export interface SurpriseThresholds {
+    /** Threshold for high surprise (triggers RE_OBSERVE) */
+    high: number;
+    /** Threshold for moderate surprise (triggers INJECT_CONTEXT) */
+    moderate: number;
+    /** Threshold for plan-level surprise (triggers RECONSIDER_PLAN) */
+    plan: number;
+    /** Maximum additional observation cycles for high surprise */
+    maxExtraObservations: number;
+}
+/**
+ * Default surprise thresholds
+ */
+export declare const DEFAULT_SURPRISE_THRESHOLDS: SurpriseThresholds;
+/**
+ * Weights for each ORPAR phase in reward attribution
+ */
+export interface PhaseWeightConfig {
+    /** Weight for observation phase contributions */
+    observation: number;
+    /** Weight for reasoning phase contributions */
+    reasoning: number;
+    /** Weight for planning phase contributions */
+    planning: number;
+    /** Weight for action phase contributions */
+    action: number;
+    /** Weight for reflection phase contributions */
+    reflection: number;
+}
+/**
+ * Default phase weights for reward attribution
+ *
+ * Rationale:
+ * - OBSERVATION (0.15): Context gathering has indirect impact
+ * - REASONING (0.20): Analysis quality affects decisions
+ * - PLANNING (0.30): Strategic decisions are critical
+ * - ACTION (0.25): Execution directly affects outcome
+ * - REFLECTION (0.10): Meta-cognition improves future cycles
+ */
+export declare const DEFAULT_PHASE_WEIGHTS: PhaseWeightConfig;
+/**
+ * Record of memory usage during an ORPAR cycle
+ */
+export interface CycleMemoryUsage {
+    /** Unique cycle identifier */
+    cycleId: string;
+    /** Agent executing the cycle */
+    agentId: AgentId;
+    /** Channel where cycle occurred */
+    channelId: ChannelId;
+    /** Task ID if associated with a task */
+    taskId?: string;
+    /** Memory usage records per phase */
+    phaseUsage: {
+        observation: MemoryUsageRecord[];
+        reasoning: MemoryUsageRecord[];
+        planning: MemoryUsageRecord[];
+        action: MemoryUsageRecord[];
+        reflection: MemoryUsageRecord[];
+    };
+    /** Cycle start timestamp */
+    startedAt: Date;
+    /** Cycle end timestamp */
+    completedAt?: Date;
+    /** Cycle outcome status */
+    outcome?: CycleOutcome;
+}
+/**
+ * Fix #7: Typed metadata interface for CycleOutcome
+ * Provides type safety for common metadata fields while still allowing extension
+ */
+export interface CycleOutcomeMetadata {
+    /** Source that generated this outcome */
+    source?: 'controlLoop' | 'orparTools' | string;
+    /** Learnings extracted from reflection */
+    learnings?: string[];
+    /** Adjustments suggested for future cycles */
+    adjustments?: string[];
+    /** Feedback from the reflection phase */
+    feedback?: string;
+    /** Task-specific metadata */
+    taskMetadata?: Record<string, unknown>;
+    /** Allow additional unknown fields for extensibility */
+    [key: string]: unknown;
+}
+/**
+ * Outcome of an ORPAR cycle
+ */
+export interface CycleOutcome {
+    /** Whether the cycle was successful */
+    success: boolean;
+    /** Quality score (0-1) if available */
+    qualityScore?: number;
+    /** Number of errors encountered */
+    errorCount: number;
+    /** Number of tool calls made */
+    toolCallCount: number;
+    /** Whether task was completed */
+    taskCompleted: boolean;
+    /** Additional outcome metadata - Fix #7: Now uses typed interface */
+    metadata?: CycleOutcomeMetadata;
+}
+/**
+ * Phase-weighted reward calculation result
+ */
+export interface PhaseWeightedRewardResult {
+    /** Memory ID */
+    memoryId: string;
+    /** Calculated reward value */
+    reward: number;
+    /** Breakdown of contribution by phase */
+    phaseContributions: Partial<Record<OrparPhase, number>>;
+    /** Base reward before phase weighting */
+    baseReward: number;
+    /** Sum of phase weights where memory was used */
+    totalPhaseWeight: number;
+    /** Q-value update to apply */
+    qValueUpdate: QValueUpdate;
+}
+/**
+ * Rule for triggering memory consolidation based on cycle outcomes
+ */
+export interface ConsolidationRule {
+    /** Rule identifier */
+    id: string;
+    /** Rule name */
+    name: string;
+    /** Condition function that returns true if rule should trigger */
+    condition: ConsolidationCondition;
+    /** Action to take when rule triggers */
+    action: ConsolidationAction;
+    /** Priority (higher = checked first) */
+    priority: number;
+}
+/**
+ * Condition that can trigger consolidation
+ */
+export interface ConsolidationCondition {
+    /** Minimum Q-value threshold (optional) */
+    minQValue?: number;
+    /** Maximum Q-value threshold (optional) */
+    maxQValue?: number;
+    /** Minimum success count (optional) */
+    minSuccessCount?: number;
+    /** Minimum failure count (optional) */
+    minFailureCount?: number;
+    /** Days since last access (optional) */
+    daysSinceAccess?: number;
+    /** Current stratum must be one of these (optional) */
+    currentStrata?: MemoryStratum[];
+}
+/**
+ * Action to take during consolidation
+ */
+export type ConsolidationAction = {
+    type: 'PROMOTE';
+    targetStratum: MemoryStratum;
+} | {
+    type: 'DEMOTE';
+    targetStratum: MemoryStratum;
+} | {
+    type: 'ARCHIVE';
+} | {
+    type: 'ABSTRACT';
+    targetStratum: MemoryStratum;
+};
+/**
+ * Default consolidation rules following the plan
+ */
+export declare const DEFAULT_CONSOLIDATION_RULES: ConsolidationRule[];
+/**
+ * Result of consolidation rule evaluation
+ */
+export interface ConsolidationTriggerResult {
+    /** Memory ID that triggered */
+    memoryId: string;
+    /** Rule that triggered */
+    rule: ConsolidationRule;
+    /** Action to execute */
+    action: ConsolidationAction;
+    /** Memory's current state */
+    memoryState: {
+        currentStratum: MemoryStratum;
+        qValue: number;
+        successCount: number;
+        failureCount: number;
+        daysSinceAccess: number;
+    };
+    /** Timestamp of trigger */
+    triggeredAt: Date;
+}
+/**
+ * Specification for phase-specific memory storage
+ */
+export interface PhaseStorageSpec {
+    /** Phase this spec applies to */
+    phase: OrparPhase;
+    /** Target stratum for storage */
+    targetStratum: MemoryStratum;
+    /** Default importance level */
+    defaultImportance: 'critical' | 'high' | 'medium' | 'low' | 'trivial';
+    /** Content type */
+    contentType: 'observation' | 'analysis' | 'plan' | 'action_result' | 'learning';
+    /** Auto-tagging rules */
+    autoTags: string[];
+}
+/**
+ * Default phase storage specifications
+ */
+export declare const DEFAULT_PHASE_STORAGE_SPECS: PhaseStorageSpec[];
+/**
+ * Options for phase-aware memory retrieval
+ */
+export interface PhaseRetrievalOptions {
+    /** Query text for semantic search */
+    query: string;
+    /** ORPAR phase driving the retrieval */
+    phase: OrparPhase;
+    /** Agent ID for scoping */
+    agentId: AgentId;
+    /** Channel ID for scoping */
+    channelId?: ChannelId;
+    /** Maximum results to return */
+    maxResults?: number;
+    /** Override default lambda */
+    lambda?: number;
+    /** Include secondary strata in search */
+    includeSecondary?: boolean;
+    /** Additional tags to filter by */
+    tags?: string[];
+    /** Time range filter */
+    timeRange?: {
+        start?: Date;
+        end?: Date;
+    };
+}
+/**
+ * Options for phase-aware memory storage
+ */
+export interface PhaseStorageOptions {
+    /** Content to store */
+    content: string;
+    /** ORPAR phase during storage */
+    phase: OrparPhase;
+    /** Agent ID for attribution */
+    agentId: AgentId;
+    /** Channel ID for scoping */
+    channelId?: ChannelId;
+    /** Task ID if associated */
+    taskId?: string;
+    /** Override target stratum */
+    targetStratum?: MemoryStratum;
+    /** Override importance level */
+    importance?: 'critical' | 'high' | 'medium' | 'low' | 'trivial';
+    /** Additional tags */
+    tags?: string[];
+    /** Related memory IDs */
+    relatedMemories?: string[];
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Complete ORPAR-Memory integration configuration
+ */
+export interface OrparMemoryIntegrationConfig {
+    /** Whether the integration is enabled */
+    enabled: boolean;
+    /** Phase-strata mappings */
+    phaseStrataMappings: PhaseStrataMapping[];
+    /** Surprise thresholds */
+    surpriseThresholds: SurpriseThresholds;
+    /** Phase weights for reward attribution */
+    phaseWeights: PhaseWeightConfig;
+    /** Consolidation rules */
+    consolidationRules: ConsolidationRule[];
+    /** Phase storage specifications */
+    phaseStorageSpecs: PhaseStorageSpec[];
+    /** Debug mode - extra logging */
+    debug: boolean;
+}
+/**
+ * Default ORPAR-Memory integration configuration
+ */
+export declare const DEFAULT_ORPAR_MEMORY_CONFIG: OrparMemoryIntegrationConfig;
+/**
+ * Environment variable names for ORPAR-Memory configuration
+ */
+export declare const ORPAR_MEMORY_ENV_VARS: {
+    readonly ENABLED: "ORPAR_MEMORY_INTEGRATION_ENABLED";
+    readonly PHASE_STRATA_OBSERVATION_PRIMARY: "PHASE_STRATA_OBSERVATION_PRIMARY";
+    readonly PHASE_STRATA_REASONING_PRIMARY: "PHASE_STRATA_REASONING_PRIMARY";
+    readonly PHASE_STRATA_PLANNING_PRIMARY: "PHASE_STRATA_PLANNING_PRIMARY";
+    readonly SURPRISE_HIGH_THRESHOLD: "SURPRISE_HIGH_THRESHOLD";
+    readonly SURPRISE_MODERATE_THRESHOLD: "SURPRISE_MODERATE_THRESHOLD";
+    readonly SURPRISE_MAX_EXTRA_OBSERVATIONS: "SURPRISE_MAX_EXTRA_OBSERVATIONS";
+    readonly PHASE_WEIGHT_OBSERVATION: "PHASE_WEIGHT_OBSERVATION";
+    readonly PHASE_WEIGHT_REASONING: "PHASE_WEIGHT_REASONING";
+    readonly PHASE_WEIGHT_PLANNING: "PHASE_WEIGHT_PLANNING";
+    readonly PHASE_WEIGHT_ACTION: "PHASE_WEIGHT_ACTION";
+    readonly PHASE_WEIGHT_REFLECTION: "PHASE_WEIGHT_REFLECTION";
+    readonly CONSOLIDATION_PROMOTION_QVALUE: "CONSOLIDATION_PROMOTION_QVALUE";
+    readonly CONSOLIDATION_DEMOTION_QVALUE: "CONSOLIDATION_DEMOTION_QVALUE";
+    readonly DEBUG: "ORPAR_MEMORY_DEBUG";
+};
+/**
+ * Get ORPAR-Memory config from environment variables
+ */
+export declare function getOrparMemoryConfigFromEnv(): Partial<OrparMemoryIntegrationConfig>;
+/**
+ * ORPAR cycle state tracked by the coordinator
+ */
+export interface OrparCycleState {
+    /** Unique cycle identifier */
+    cycleId: string;
+    /** Agent executing the cycle */
+    agentId: AgentId;
+    /** Channel where cycle is occurring */
+    channelId: ChannelId;
+    /** Current ORPAR phase */
+    currentPhase: OrparPhase;
+    /** Phase start times */
+    phaseStartTimes: Partial<Record<OrparPhase, Date>>;
+    /** Memory usage during cycle */
+    memoryUsage: CycleMemoryUsage;
+    /** Surprise detections during cycle */
+    surpriseDetections: SurpriseDetection[];
+    /** Additional observations queued */
+    additionalObservationsQueued: number;
+    /** Whether cycle is complete */
+    isComplete: boolean;
+    /** Cycle start timestamp */
+    startedAt: Date;
+}
+//# sourceMappingURL=OrparMemoryIntegrationTypes.d.ts.map

package/dist/types/OrparMemoryIntegrationTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrparMemoryIntegrationTypes.d.ts","sourceRoot":"","sources":["../../src/types/OrparMemoryIntegrationTypes.ts"],"names":[],"mappings":"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"}