export type ProcessState = 'creating' | 'running' | 'stopping' | 'orphaned' | 'terminated' | 'unknown';

export interface HealthStatus {
    cpu: number;
    memoryMB: number;
    status: string;
}

export interface ProcessRecord {
    agentId: string;
    sessionId: string;
    pid: number;
    mode: 'sdk';
    state: ProcessState;
    workspacePath: string;
    command: string;
    createdAt: string;
    lastHeartbeat?: string;
    healthStatus?: HealthStatus;
    orphanedAt?: string;
    metadata?: Record<string, unknown>;
}

export interface PersistedSessionInput {
    agentId: string;
    sessionId: string;
    pid?: number;
    workspacePath?: string;
    command?: string;
    mode?: 'sdk';
}

export declare function getProcessRegistryFile(): string;

export declare class ProcessRegistry {
    private static instance;
    private readonly records;
    private readonly pidToAgentId;
    
    private constructor();
    
    static getInstance(): ProcessRegistry;
    
    private persist;
    private mutate;
    
    register(record: Omit<ProcessRecord, 'createdAt'>): Promise<void>;
    
    update(agentId: string, updates: Partial<ProcessRecord>): Promise<boolean>;
    
    get(agentId: string): ProcessRecord | undefined;
    
    getByPid(pid: number): ProcessRecord | undefined;
    
    getAll(): ProcessRecord[];
    
    getByState(state: ProcessState): ProcessRecord[];
    
    isManaged(agentId: string): boolean;
    
    isManagedByPid(pid: number): boolean;
    
    markOrphaned(agentId: string): Promise<boolean>;
    
    markTerminated(agentId: string): Promise<boolean>;
    
    remove(agentId: string): Promise<boolean>;
    
    updateHeartbeat(agentId: string): Promise<boolean>;
    
    updateHealth(agentId: string, health: HealthStatus): Promise<boolean>;
    
    rebuildFromPersisted(sessions: PersistedSessionInput[]): Promise<void>;
    
    exportState(): ProcessRecord[];
    
    getStats(): Record<ProcessState | 'total', number>;
    
    clear(): Promise<void>;
}

export declare function getProcessRegistry(): ProcessRegistry;

export declare function loadPersistedProcessRegistry(): Promise<ProcessRecord[]>;

export declare function savePersistedProcessRegistry(records: ProcessRecord[]): Promise<void>;