import type { RuntimeStateHandle } from './runtime-state-handle.js';
import type { RunnerKind, InternalizationChannel } from './internalization/peer-runner-contracts.js';
import { type ActionabilityPolicyInput, type SuppressedDiagnostic } from './internalization/queue-actionability.js';
export interface BlockedSample {
    taskId: string;
    taskKind: RunnerKind;
    blockedBy: string[];
}
export interface DependencyFailedSample {
    taskId: string;
    taskKind: RunnerKind;
    failedDependencies: string[];
}
export interface ReadyTask {
    taskId: string;
    taskKind: RunnerKind;
    channel: InternalizationChannel;
}
export type QueueNoReadyTasksReason = 'no_candidates' | 'all_hydration_failed' | 'all_blocked' | 'all_dependency_failed' | 'all_retry_wait_pending' | 'all_lease_conflict' | 'all_unresolvable';
export interface NoReadyTasksDiagnosis {
    reason: QueueNoReadyTasksReason;
    inspectedCount: number;
}
export interface RetryWaitPendingSample {
    taskId: string;
    taskKind: RunnerKind;
    retryAfter: string;
}
export interface LeaseConflictSample {
    taskId: string;
    taskKind: RunnerKind;
    leaseOwner: string;
    leaseExpiresAt: string;
}
export interface UnresolvableSample {
    taskId: string;
    taskKind: RunnerKind;
    rejectionCount: number;
}
export interface InternalizationQueueSnapshot {
    pendingCount: number;
    retryWaitCount: number;
    countsByTaskKind: Record<string, number>;
    countsByChannel: Record<string, number>;
    invalidMetadataCount: number;
    sampleInvalidTaskIds: string[];
    blockedSummary: {
        count: number;
        samples: BlockedSample[];
    };
    dependencyFailedSummary: {
        count: number;
        samples: DependencyFailedSample[];
    };
    leaseConflictSummary: {
        count: number;
        samples: LeaseConflictSample[];
        sampleTaskIds: string[];
    };
    retryWaitPendingSummary: {
        count: number;
        samples: RetryWaitPendingSample[];
    };
    unresolvableSummary: {
        count: number;
        samples: UnresolvableSample[];
    };
    readyTasks: ReadyTask[];
    noReadyTasks: NoReadyTasksDiagnosis | null;
    /** Tasks suppressed from the actionable queue — disabled channels or non-MVP task kinds */
    suppressedTasks: SuppressedDiagnostic[];
}
export declare class InternalizationQueueReadModel {
    private readonly stateManager;
    private policy;
    constructor(stateManager: RuntimeStateHandle['stateManager']);
    setPolicy(policy: ActionabilityPolicyInput): void;
    getSnapshot(): Promise<InternalizationQueueSnapshot>;
    private resolveDependencies;
    close(): Promise<void>;
}
export interface InternalizationQueueReadModelHandle {
    readModel: InternalizationQueueReadModel;
    close: () => Promise<void>;
}
export interface CreateQueueReadModelOptions {
    workspaceDir: string;
    readonly?: boolean;
    /** Enabled activation channels — loaded from feature flags at CLI boundary */
    enabledChannels?: Set<string>;
}
export declare function createInternalizationQueueReadModel(opts: CreateQueueReadModelOptions): Promise<InternalizationQueueReadModelHandle>;
//# sourceMappingURL=internalization-queue-read-model.d.ts.map