/**
 * Session State Manager
 *
 * Manages cross-session state sharing, dependency tracking,
 * and coordination for complex workflows.
 *
 * @since 2026-01-07
 */
import { XrayStateManager } from "../state/state-manager.js";
import { SessionCoordinator } from "../delegation/session-coordinator.js";
export interface SessionDependency {
    sessionId: string;
    dependsOn: string[];
    dependedBy: string[];
    state: "pending" | "active" | "completed" | "failed";
    priority: number;
    metadata: Record<string, unknown>;
}
export interface SessionGroup {
    groupId: string;
    sessionIds: string[];
    coordinatorSession: string;
    state: "forming" | "active" | "completing" | "completed" | "failed";
    sharedState: Map<string, {
        value: unknown;
        fromSessionId: string;
        timestamp: number;
    }>;
    createdAt: number;
    completedAt?: number;
}
export interface MigrationPlan {
    sessionId: string;
    targetCoordinator: string;
    stateTransfer: Map<string, unknown>;
    migrationSteps: string[];
    rollbackSteps: string[];
}
export interface FailoverConfig {
    sessionId: string;
    backupCoordinators: string[];
    failoverThreshold: number;
    autoFailover: boolean;
}
export declare class SessionStateManager {
    private stateManager;
    private sessionCoordinator;
    private dependencies;
    private sessionGroups;
    private failoverConfigs;
    /** Stable store records. A field write patches one key instead of cloning the map. */
    private dependencyRecord;
    private groupRecord;
    private failoverRecord;
    constructor(stateManager: XrayStateManager, sessionCoordinator: SessionCoordinator);
    /**
     * Share state between sessions
     */
    shareState(fromSessionId: string, toSessionId: string, key: string, value: unknown): boolean;
    /**
     * Broadcast state to multiple sessions
     */
    broadcastState(fromSessionId: string, targetSessionIds: string[], key: string, value: unknown): number;
    /**
     * Register session dependency
     */
    registerDependency(sessionId: string, dependsOn: string[], metadata?: Record<string, unknown>): void;
    /**
     * Update dependency state
     */
    updateDependencyState(sessionId: string, state: SessionDependency["state"]): void;
    /**
     * Get dependency chain for a session
     */
    getDependencyChain(sessionId: string): {
        dependencies: string[];
        dependents: string[];
        canStart: boolean;
    };
    /**
     * Create session group for complex workflows
     */
    createSessionGroup(groupId: string, sessionIds: string[], coordinatorSession: string): SessionGroup;
    /**
     * Update session group state
     */
    updateSessionGroupState(groupId: string, state: SessionGroup["state"]): void;
    /**
     * Share state within a session group
     */
    shareGroupState(groupId: string, key: string, value: unknown, fromSessionId: string): boolean;
    /**
     * Get session group state
     */
    getGroupState(groupId: string, key: string): unknown;
    /**
     * Plan session migration
     */
    planMigration(sessionId: string, targetCoordinator: string): MigrationPlan;
    /**
     * Validate migration plan before execution
     */
    validateMigrationPlan(plan: MigrationPlan): Promise<{
        valid: boolean;
        errors: string[];
        warnings: string[];
    }>;
    /**
     * Validate rollback capability for a migration plan
     */
    validateRollbackCapability(plan: MigrationPlan): {
        canRollback: boolean;
        reason?: string;
    };
    /**
     * Find orphaned agents in dependency graph
     */
    findOrphanedAgents(allAgents: string[], dependencies: Record<string, string[]>): string[];
    /**
     * Execute session migration
     */
    executeMigration(plan: MigrationPlan): Promise<boolean>;
    /**
     * Configure failover for a session
     */
    configureFailover(sessionId: string, backupCoordinators: string[], failoverThreshold: number, autoFailover: boolean): void;
    /**
     * Execute failover for a session
     */
    executeFailover(sessionId: string): Promise<boolean>;
    /**
     * Get coordination statistics
     */
    getCoordinationStats(): {
        totalDependencies: number;
        activeDependencies: number;
        totalGroups: number;
        activeGroups: number;
        failoverConfigs: number;
    };
    private propagateDependencyUpdate;
    private rollbackMigration;
    private trackDependency;
    private trackGroup;
    private trackFailover;
    private persistDependencies;
    private persistSessionGroups;
    private persistFailoverConfigs;
    private loadPersistedRecords;
    private readStoreRecord;
    /** Patch the stored object so a pre-seeded key survives the first write. */
    private adoptStoreRecord;
    shutdown(): void;
}
export declare const createSessionStateManager: (stateManager: XrayStateManager, sessionCoordinator: SessionCoordinator) => SessionStateManager;