import type { EnqueueWorkInput, LeaseWorkInput, RequestSessionClosureInput, SessionClosureRecord, WorkError, WorkItemRecord, WorkQueueHealth } from './work-queue';
import { type SessionObligationRecord, type SessionObligationState } from './obligation-ledger';
import { type FailHostActionInput, type HostActionRecord, type ReportHostActionInput, type RequestHostActionInput, type StartHostActionInput, type VerifyHostActionInput } from './host-actions';
import { type AppendRetrievalCycleInput, type CreateRetrievalSessionInput, type RetrievalCycleRecord, type RetrievalSessionRecord, type RetrievalSessionState } from './retrieval-sessions';
import { type AddLearningCandidateEvidenceInput, type LearningCandidateEvidenceRecord, type LearningCandidateRecord, type LearningCandidateState, type LearningCandidateVersionRecord, type TransitionLearningCandidateInput, type UpsertLearningCandidateInput } from './learning-candidates';
import { type CreateWorkflowWorkerInput, type EnqueueWorkflowMergeInput, type TransitionWorkflowWorkerInput, type WorkflowMergeRecord, type WorkflowMergeState, type WorkflowWorkerEventRecord, type WorkflowWorkerRecord } from './workflow-workers';
import { type RetrievalLedgerEventRecord, type VerifyReceiptBoundRetrievalInput, type VerifyReceiptBoundRetrievalResult } from './retrieval-ledger';
import { type CanonicalSemanticTaskWrite, type ChannelQueryPlanRecord, type TaskIntentArtifactRecord, type TerminalTransitionRecord, type ToolNameResolutionRecord, type TranscriptCheckpointRecord } from './task-semantic-control';
import { type TaskRuntimeEventRecord, type TaskRuntimeSnapshotRecord } from './task-runtime';
import type { AppendTaskAggregateInput, AppendTaskAggregateResult, LeaseTaskOutboxInput, TaskOutboxRecord } from './task-aggregate';
import { type CanonicalTaskIdentity, type RetrievalCycleReceiptV1, type RuntimeActivationSnapshotV1, type SemanticExecutionContext, type TaskAggregateEventV1, type TaskDefinitionV1, type TaskRuntimeSnapshotV2 } from '@devflow-tools/sdk';
import type { AppendRetrievalCycleV2Input, CreateRetrievalSessionV2Input, RetrievalSessionV2Record } from './retrieval-runtime';
export interface BenchmarkReportRecord {
    runId: string;
    suiteId: string;
    suiteVersion: string;
    projectRoot: string;
    commit: string | null;
    createdAt: number;
    status: 'completed';
    tasks: unknown[];
}
export declare class RuntimeActivationConflictError extends Error {
    readonly previousHash: string;
    readonly nextHash: string;
    readonly conflictingFields: string[];
    readonly code = "ACTIVATION_CONFLICT";
    readonly retryable = false;
    readonly recoveryAction = "Call refresh_activation explicitly and invalidate downstream artifacts.";
    constructor(previousHash: string, nextHash: string, conflictingFields: string[]);
}
export interface BenchmarkReportMetaRecord {
    runId: string;
    suiteId: string;
    suiteVersion: string;
    projectRoot: string;
    commit: string | null;
    taskCount: number;
    createdAt: number;
    status: 'completed';
}
export interface FeedbackRecord {
    id: string;
    projectRoot: string;
    query: string;
    rating: 'hit' | 'partial' | 'miss';
    taskType?: string;
    contextMode?: 'general' | 'task';
    runId?: string;
    tokenCount?: number;
    createdAt: number;
}
export interface TelemetryFailureRecord {
    id: string;
    operation: string;
    payload: unknown;
    error: string;
    createdAt: number;
    resolvedAt?: number;
}
export interface GovernanceRuleRecord {
    id: string;
    name: string;
    gate: 1 | 2 | 3 | 4;
    level: 'constitutional' | 'project' | 'session';
    condition: Record<string, unknown>;
    action: 'deny' | 'warn' | 'allow';
    message: string;
    enabled: boolean;
    createdAt?: number;
    updatedAt?: number;
}
export interface GovernanceAuditRecord {
    seq: number;
    ts: number;
    tool: string;
    argsHash: string;
    decision: 'allow' | 'deny' | 'warn';
    ruleId: string | null;
    sessionId: string;
    prevHash: string;
    signature: string;
}
export interface HookReceiptRecord {
    projectRoot: string;
    lastMcpCall?: number;
    bypassCount?: number;
    updatedAt: number;
}
export interface ContextReceiptRecord {
    projectRoot: string;
    sessionId: string;
    executionId: string;
    contextHash: string;
    issuedAt: number;
    expiresAt: number;
    selectedFiles?: string[];
    memoryIds?: string[];
    canonicalNextAction?: string;
    canonicalAction?: {
        tool: string;
        input: Record<string, unknown>;
        status: 'required' | 'recommended' | 'unsupported' | 'degraded';
        required: boolean;
        reason?: string;
        binding: Record<string, unknown> & {
            requiredContextReceipt: string;
        };
        verificationPlan: Array<Record<string, unknown>>;
    };
    actionAttempts?: Array<{
        id: string;
        tool: string;
        status: 'succeeded' | 'failed' | 'timeout' | 'unavailable';
        attemptedAt: number;
        toolUseId?: string;
        reason?: string;
    }>;
    actionSatisfiedAt?: number;
    actionDegradation?: {
        missedTool: string;
        failedAttemptCount: number;
        reason: string;
        authorizedByContextReceipt: string;
        authorizedAt: number;
    };
    requestId?: string;
}
export interface ContextSelectionEventRecord {
    id: string;
    projectRoot: string;
    sessionId: string;
    executionId: string;
    requestId?: string;
    selectionType: 'code' | 'action';
    candidateId: string;
    toolName: string;
    toolUseId?: string;
    selectedAt: number;
}
export interface PolicyVerificationBaselineRecord {
    projectRoot: string;
    kind: string;
    commandHash: string;
    diagnosticHashes: string[];
    sourceRevision?: string;
    updatedAt: number;
}
export interface MemoryDistillCheckpointRecord {
    id: string;
    projectRoot: string;
    sessionId?: string;
    trigger: 'pre_compact' | 'session_end';
    pendingEvents: number;
    releasedLeases: number;
    details?: Record<string, unknown>;
    createdAt: number;
}
export type MemoryTurnStatus = 'pending' | 'committed' | 'skipped';
export interface MemoryTurnRecord {
    turnId: string;
    projectRoot: string;
    sessionId: string;
    promptHash: string;
    eventId: string;
    status: MemoryTurnStatus;
    receiptId?: string;
    memoryIds: string[];
    source?: string;
    reason?: string;
    stopPromptedAt?: number;
    createdAt: number;
    decidedAt?: number;
}
export interface HookFallbackRecord {
    id: string;
    projectRoot: string;
    sessionId?: string;
    toolUseId?: string;
    requestType: string;
    tool: string;
    reason: 'timeout' | 'unreachable' | 'protocol' | 'unknown';
    durationMs: number;
    attempts: number;
    createdAt: number;
}
export declare function getGlobalDevFlowDbPath(home?: string): string;
export declare function openGlobalDevFlowDatabase(home?: string, options?: {
    busyTimeoutMs?: number;
    readonly?: boolean;
}): DevFlowDatabase;
export declare function openGlobalDevFlowReadOnlyDatabase(home?: string, options?: {
    busyTimeoutMs?: number;
}): DevFlowDatabase;
export declare class DevFlowDatabase {
    private db;
    constructor(projectRoot: string, opts?: {
        dbPath?: string;
        busyTimeoutMs?: number;
        readonly?: boolean;
    });
    private initializeSchema;
    insertRun(run: any): void;
    getRun(id: string): any | null;
    updateRun(id: string, updates: any): void;
    insertRunStep(step: any): void;
    getRunSteps(runId: string): any[];
    insertEvent(event: any): void;
    getEvents(runId: string): any[];
    appendDashboardRunEvent(event: {
        runId: string;
        projectRoot: string;
        sequence: number;
        kind: string;
        payload?: unknown;
        timestamp?: number;
    }): void;
    listDashboardRunEvents(runId: string, projectRoot: string, after?: number): any[];
    getProjectStats(projectRoot: string): any | null;
    upsertProjectStats(stats: any): void;
    getRuns(): any[];
    setSetting(key: string, value: string): void;
    getSetting(key: string): string | null;
    deleteSetting(key: string): void;
    insertSession(params: {
        id: string;
        projectRoot: string;
        label?: string;
        startedAt: number;
    }): void;
    ensureSession(params: {
        id: string;
        projectRoot: string;
        label?: string;
        startedAt?: number;
    }): void;
    getSession(id: string): any | null;
    listSessions(limit: number, offset: number, projectRoot?: string): any[];
    closeSession(id: string, finishedAt?: number): void;
    listToolCallEventsBySession(sessionId: string): any[];
    getToolCallEventByToolUseId(sessionId: string, toolUseId: string): {
        eventId: string;
        executionId: string;
        timestamp: number;
        duration: number;
        input: Record<string, unknown>;
    } | null;
    listToolCallEventsBySessions(sessionIds: string[]): Record<string, any[]>;
    insertSkillExecution(params: {
        executionId: string;
        sessionId?: string;
        skillName: string;
        startedAt: number;
        status: string;
        requiredMcpTools?: string[];
        availableMcpTools?: string[];
    }): void;
    getSkillExecution(executionId: string): any | null;
    getLatestSkillExecutionForSession(sessionId: string): any | null;
    updateSkillExecution(executionId: string, updates: {
        status?: string;
        finishedAt?: number;
        totalDuration?: number;
        mcpComplianceRate?: number;
        missedMcpTools?: string[];
        failedToolCalls?: number;
        blockedToolCalls?: number;
        fallbackCount?: number;
        fallbackReasons?: string[];
        totalToolCalls?: number;
        mcpToolCalls?: number;
        directToolCalls?: number;
        subagentCount?: number;
        metadata?: Record<string, unknown>;
    }): void;
    mergeSkillExecutionMetadata(executionId: string, incoming: Record<string, unknown>): Record<string, unknown> | null;
    listSkillExecutions(limit: number, skillName?: string, projectRoot?: string): any[];
    insertToolCallEvent(params: {
        eventId: string;
        executionId: string;
        sessionId?: string;
        timestamp: number;
        toolName: string;
        toolType: string;
        isMcpTool: boolean;
        mcpToolName?: string;
        mcpEnforced: boolean;
        mcpFallback: boolean;
        kind?: string;
        input: unknown;
        output?: unknown;
        duration: number;
        parentToolCallId?: string;
        subagentId?: string;
        error?: string;
        blocked: boolean;
        blockReason?: string;
        workflowRunId?: string;
        failureCategory?: string;
        tokensUsed?: number;
        toolUseId?: string;
    }): boolean;
    listToolCallEvents(executionId: string): any[];
    updateToolCallEvent(eventId: string, updates: {
        output?: string;
        error?: string;
        failureCategory?: string;
        duration?: number;
    }): boolean;
    markToolCallBlocked(eventId: string, reason: string): boolean;
    reconcileSkillExecution(executionId: string, status: 'completed' | 'failed', finishedAt?: number, metadata?: Record<string, unknown>): void;
    reconcileRunningSkillExecutionsForSession(sessionId: string, finishedAt?: number, metadata?: Record<string, unknown>): any[];
    getExecutionObligationCompliance(executionId: string): {
        rate: number;
        applicable: number;
        satisfied: number;
        missedTools: string[];
        mcpCallShare: number;
    };
    getMcpCompliance(projectRoot?: string): {
        overall: number;
        bySkill: Record<string, number>;
        missedTools: string[];
        applicableObligations: number;
        satisfiedObligations: number;
        mcpCallShare: number;
    };
    cleanupStaleRecords(): void;
    insertToolMetric(metric: {
        id: string;
        toolCallEventId: string;
        sessionId: string;
        toolName: string;
        query?: string;
        status?: string;
        resultCount?: number;
        resultSizeBytes?: number;
        latencyMs?: number;
        engine?: string;
        accuracyQueryId?: string;
        metadata?: string;
        createdAt: number;
    }): void;
    getToolMetrics(sessionId?: string, toolName?: string, limit?: number, offset?: number, projectRoot?: string): any[];
    getToolMetricsSummary(days?: number, projectRoot?: string): any[];
    aggregatePendingToolMetrics(limit?: number): number;
    insertFeedback(feedback: FeedbackRecord): void;
    listFeedback(projectRoot?: string, limit?: number): FeedbackRecord[];
    getFeedbackSummary(projectRoot?: string): {
        total: number;
        hits: number;
        partials: number;
        misses: number;
        hitRate: number;
    };
    insertTelemetryFailure(failure: TelemetryFailureRecord): void;
    resolveTelemetryFailure(id: string, resolvedAt?: number): void;
    listTelemetryFailures(options?: {
        unresolvedOnly?: boolean;
        limit?: number;
    }): TelemetryFailureRecord[];
    countTelemetryFailures(unresolvedOnly?: boolean): number;
    trimTelemetryFailures(maxRows?: number): number;
    insertAccuracyQuery(q: {
        id: string;
        sessionId: string;
        engine: string;
        query: string;
        topKResults: string;
        selectedIds?: string;
        createdAt: number;
    }): void;
    getAccuracyQueries(options: {
        engine?: string;
        status?: string;
        limit?: number;
        offset?: number;
        projectRoot?: string;
    }): any[];
    updateAccuracyFeedback(id: string, feedback: {
        relevance: 'hit' | 'partial' | 'miss';
        note?: string;
    }): void;
    getAccuracyStats(engine?: string, since?: number, projectRoot?: string): any;
    insertBenchmarkReport<T extends BenchmarkReportRecord>(report: T): void;
    getBenchmarkReport<T extends BenchmarkReportRecord = BenchmarkReportRecord>(runId: string): T | null;
    getLatestBenchmarkReport<T extends BenchmarkReportRecord = BenchmarkReportRecord>(suiteId?: string): T | null;
    listBenchmarkReports(limit?: number): BenchmarkReportMetaRecord[];
    listGovernanceRules(includeDisabled?: boolean): GovernanceRuleRecord[];
    getGovernanceRule(id: string): GovernanceRuleRecord | null;
    upsertGovernanceRule(rule: GovernanceRuleRecord): GovernanceRuleRecord;
    deleteGovernanceRule(id: string): boolean;
    listGovernanceAudit(limit?: number, offset?: number): {
        items: GovernanceAuditRecord[];
        total: number;
    };
    upsertLearningCandidate(input: UpsertLearningCandidateInput): LearningCandidateRecord;
    getLearningCandidate(id: string): LearningCandidateRecord | null;
    listLearningCandidates(options?: {
        projectRoot?: string;
        states?: LearningCandidateState[];
        limit?: number;
    }): LearningCandidateRecord[];
    addLearningCandidateEvidence(input: AddLearningCandidateEvidenceInput): LearningCandidateRecord;
    listLearningCandidateEvidence(candidateId: string): LearningCandidateEvidenceRecord[];
    resolveLearningContradiction(candidateId: string, evidenceId: string, resolvedAt?: number): LearningCandidateRecord;
    transitionLearningCandidate(candidateId: string, input: TransitionLearningCandidateInput): LearningCandidateRecord;
    listLearningCandidateVersions(candidateId: string): LearningCandidateVersionRecord[];
    private assertLearningTransition;
    private getLearningEvidenceAggregates;
    private insertLearningCandidateVersion;
    private insertLearningActivation;
    enqueueWork(input: EnqueueWorkInput): WorkItemRecord;
    getWorkByIdempotencyKey(idempotencyKey: string): WorkItemRecord | null;
    getWorkById(id: string): WorkItemRecord | null;
    acquireProjectMutationLease(input: {
        projectRoot: string;
        mutationKind: string;
        owner: string;
        leaseMs: number;
        sourceHash?: string;
        now?: number;
    }): boolean;
    releaseProjectMutationLease(projectRoot: string, mutationKind: string, owner: string): boolean;
    cancelStaleWork(input: {
        id: string;
        owner: string;
        sourceHash?: string;
        taskSpecHash?: string;
        reason?: string;
        now?: number;
    }): boolean;
    replayDeadLetterWork(id: string, input: {
        idempotencyKey: string;
        sourceHash?: string;
        taskSpecHash?: string;
        now?: number;
    }): WorkItemRecord | null;
    requestSessionClosure(input: RequestSessionClosureInput): SessionClosureRecord;
    getSessionClosure(projectRoot: string, sessionId: string): SessionClosureRecord | null;
    completeSessionClosure(projectRoot: string, sessionId: string, excludingWorkItemId?: string, closedAt?: number): SessionClosureRecord;
    listSessionClosures(projectRoot: string, limit?: number): SessionClosureRecord[];
    leaseWork(input: LeaseWorkInput): WorkItemRecord[];
    completeWork(id: string, owner: string, now?: number): boolean;
    heartbeatWork(id: string, owner: string, leaseMs: number, now?: number): boolean;
    retryWork(id: string, owner: string, error: WorkError, nextAttemptAt: number): boolean;
    deferWork(id: string, owner: string, error: WorkError, nextAttemptAt: number): boolean;
    deadLetterWork(id: string, owner: string, error: WorkError): boolean;
    recoverExpiredWork(projectRoot: string, now?: number): number;
    getWorkQueueHealth(projectRoot: string, now?: number): WorkQueueHealth;
    private mapWorkItem;
    private mapSessionClosure;
    private refreshClosedSessionClosure;
    private countSessionLifecyclePending;
    getHookReceipt(projectRoot: string): HookReceiptRecord | null;
    updateHookReceipt(projectRoot: string, updater: (current: HookReceiptRecord | null) => Omit<HookReceiptRecord, 'projectRoot' | 'updatedAt'>): HookReceiptRecord;
    deleteHookReceipt(projectRoot: string): boolean;
    createRetrievalSession(input: CreateRetrievalSessionInput): RetrievalSessionRecord;
    createRetrievalSessionV2(input: CreateRetrievalSessionV2Input): RetrievalSessionV2Record;
    getRetrievalSessionV2(id: string): RetrievalSessionV2Record | null;
    listRetrievalCyclesV2(sessionId: string): RetrievalCycleReceiptV1[];
    appendRetrievalCycleV2(input: AppendRetrievalCycleV2Input): RetrievalSessionV2Record;
    getRetrievalSession(projectRoot: string, sessionId: string, id: string): RetrievalSessionRecord | null;
    getRetrievalSessionByRequest(requestId: string): RetrievalSessionRecord | null;
    listRetrievalCycles(retrievalSessionId: string): RetrievalCycleRecord[];
    appendRetrievalCycle(input: AppendRetrievalCycleInput): RetrievalCycleRecord;
    finalizeRetrievalSession(input: {
        id: string;
        projectRoot: string;
        sessionId: string;
        state: Extract<RetrievalSessionState, 'satisfied' | 'exhausted'>;
        finalReceipt: string;
    }): RetrievalSessionRecord;
    expireRetrievalSessions(now?: number, limit?: number): number;
    private validateRetrievalSessionInput;
    private assertRetrievalIdentity;
    upsertContextReceipt(receipt: ContextReceiptRecord): void;
    getContextReceipt(projectRoot: string, sessionId: string, executionId: string): ContextReceiptRecord | null;
    getActiveContextReceipt(projectRoot: string, sessionId: string, executionId?: string, now?: number): ContextReceiptRecord | null;
    getContextReceiptForRequest(projectRoot: string, sessionId: string, requestId: string): ContextReceiptRecord | null;
    recordContextSelectionEvent(event: ContextSelectionEventRecord): boolean;
    appendRetrievalLedgerEvent(event: RetrievalLedgerEventRecord): boolean;
    verifyReceiptBoundRetrieval(input: VerifyReceiptBoundRetrievalInput): VerifyReceiptBoundRetrievalResult;
    appendTaskIntentArtifact(record: TaskIntentArtifactRecord): TaskIntentArtifactRecord;
    private appendTaskIntentArtifactInTransaction;
    getTaskIntentArtifact(artifactHash: string): TaskIntentArtifactRecord | null;
    getLatestTaskIntentArtifact(input: {
        projectRoot: string;
        sessionId: string;
        turnId?: string;
        requestId?: string;
    }): TaskIntentArtifactRecord | null;
    getTaskIntentArtifactBySource(input: {
        projectRoot: string;
        sessionId: string;
        sourceHash: string;
    }): TaskIntentArtifactRecord | null;
    listLatestTaskIntentArtifacts(projectRoot: string, sessionId: string): TaskIntentArtifactRecord[];
    appendChannelQueryPlan(record: ChannelQueryPlanRecord): ChannelQueryPlanRecord;
    getChannelQueryPlan(planHash: string): ChannelQueryPlanRecord | null;
    getChannelQueryPlanForIntent(input: {
        projectRoot: string;
        sessionId: string;
        turnId: string;
        sourceIntentHash: string;
    }): ChannelQueryPlanRecord | null;
    appendToolNameResolution(record: ToolNameResolutionRecord): boolean;
    listToolNameResolutions(input: {
        projectRoot: string;
        sessionId: string;
        requestId?: string;
    }): ToolNameResolutionRecord[];
    appendTerminalTransition(record: TerminalTransitionRecord): TerminalTransitionRecord;
    appendTaskRuntimeEvent(event: TaskRuntimeEventRecord): TaskRuntimeEventRecord;
    getTaskRuntimeEvent(eventId: string): TaskRuntimeEventRecord | null;
    listTaskRuntimeEvents(projectRoot: string, sessionId: string, turnId: string): TaskRuntimeEventRecord[];
    putTaskRuntimeSnapshot(snapshot: TaskRuntimeSnapshotRecord): TaskRuntimeSnapshotRecord;
    appendTaskRuntimeEventAndSnapshot(event: TaskRuntimeEventRecord, snapshot: TaskRuntimeSnapshotRecord): TaskRuntimeSnapshotRecord;
    getTaskRuntimeSnapshot(projectRoot: string, sessionId: string, turnId: string): TaskRuntimeSnapshotRecord | null;
    deleteTaskRuntimeSnapshot(projectRoot: string, sessionId: string, turnId: string): boolean;
    appendTaskAggregate(input: AppendTaskAggregateInput): AppendTaskAggregateResult;
    bindRuntimeActivation(input: {
        identity: CanonicalTaskIdentity;
        revision: number;
        snapshot: RuntimeActivationSnapshotV1;
    }): {
        snapshot: RuntimeActivationSnapshotV1;
        replayed: boolean;
    };
    getOrCreateRuntimeActivation(input: {
        identity: CanonicalTaskIdentity;
        revision: number;
        snapshot: RuntimeActivationSnapshotV1;
    }): {
        snapshot: RuntimeActivationSnapshotV1;
        replayed: boolean;
    };
    private bindRuntimeActivationInTransaction;
    getRuntimeActivation(projectRoot: string, sessionId: string, turnId: string, revision: number): RuntimeActivationSnapshotV1 | null;
    putSemanticExecutionContext(input: {
        context: SemanticExecutionContext;
        revision: number;
    }): SemanticExecutionContext;
    putCanonicalSemanticTask(input: CanonicalSemanticTaskWrite): SemanticExecutionContext;
    getSemanticExecutionContext(projectRoot: string, sessionId: string, turnId: string, revision: number): SemanticExecutionContext | null;
    getSemanticExecutionContextByHash(contextHash: string): SemanticExecutionContext | null;
    getLatestSemanticExecutionContext(input: {
        projectRoot: string;
        sessionId: string;
        turnId: string;
    }): {
        context: SemanticExecutionContext;
        revision: number;
    } | null;
    listTaskAggregateEvents(projectRoot: string, sessionId: string, turnId: string, revision: number): TaskAggregateEventV1[];
    getTaskAggregateEventByIdempotencyKey(idempotencyKey: string): TaskAggregateEventV1 | null;
    getTaskAggregateSnapshot(projectRoot: string, sessionId: string, turnId: string, revision: number): TaskRuntimeSnapshotV2 | null;
    getTaskDefinitionV2(definitionHash: string): TaskDefinitionV1 | null;
    leaseTaskOutbox(input: LeaseTaskOutboxInput): TaskOutboxRecord[];
    completeTaskOutbox(operationId: string, owner: string, fencingToken: number, now?: number): boolean;
    getTaskOutbox(operationId: string): TaskOutboxRecord | null;
    private putTaskDefinitionV2;
    getTerminalTransition(receiptId: string): TerminalTransitionRecord | null;
    getLatestTerminalTransition(projectRoot: string, sessionId: string, turnId: string): TerminalTransitionRecord | null;
    appendTranscriptCheckpoint(record: TranscriptCheckpointRecord): boolean;
    getLatestTranscriptCheckpoint(input: {
        projectRoot: string;
        hostId: string;
        sessionId: string;
        sourcePath: string;
    }): TranscriptCheckpointRecord | null;
    listRetrievalLedgerEvents(options: {
        projectRoot: string;
        sessionId?: string;
        executionId?: string;
        requestId?: string;
    }): RetrievalLedgerEventRecord[];
    listContextSelectionEvents(options: {
        projectRoot: string;
        sessionId?: string;
        executionId?: string;
        requestId?: string;
    }): ContextSelectionEventRecord[];
    deleteContextReceipt(projectRoot: string, sessionId: string, executionId?: string): number;
    getPolicyVerificationBaseline(projectRoot: string, kind: string, commandHash: string): PolicyVerificationBaselineRecord | null;
    upsertPolicyVerificationBaseline(record: PolicyVerificationBaselineRecord): void;
    purgeExpiredContextReceipts(now?: number): number;
    beginMemoryTurn(input: Omit<MemoryTurnRecord, 'status' | 'memoryIds'>): MemoryTurnRecord;
    upsertSessionObligation(record: SessionObligationRecord): SessionObligationRecord;
    getSessionObligation(projectRoot: string, sessionId: string, obligationId: string): SessionObligationRecord | null;
    listSessionObligations(projectRoot: string, sessionId: string, states?: SessionObligationState[]): SessionObligationRecord[];
    resolveSessionObligation(input: {
        projectRoot: string;
        sessionId: string;
        obligationId: string;
        state: 'satisfied' | 'degraded' | 'cancelled';
        receiptId?: string;
        reason?: string;
        resolvedAt?: number;
    }): SessionObligationRecord;
    countOpenSessionObligations(projectRoot: string, sessionId: string): number;
    getMemoryTurn(turnId: string): MemoryTurnRecord | null;
    getPendingMemoryTurn(projectRoot: string, sessionId: string): MemoryTurnRecord | null;
    commitMemoryTurn(input: {
        turnId: string;
        receiptId: string;
        memoryIds: string[];
        source: string;
        reason?: string;
        decidedAt?: number;
    }): MemoryTurnRecord;
    updateCommittedMemoryTurnProjection(input: {
        turnId: string;
        memoryIds: string[];
        reason?: string;
    }): MemoryTurnRecord;
    skipMemoryTurn(input: {
        turnId: string;
        receiptId: string;
        reason: string;
        source?: string;
        decidedAt?: number;
    }): MemoryTurnRecord;
    markMemoryTurnStopPrompted(turnId: string, promptedAt?: number): boolean;
    private ensureMemoryObligation;
    listMemoryTurns(projectRoot: string, sessionId?: string, limit?: number): MemoryTurnRecord[];
    listSessionMemoryTurnsForReconciliation(projectRoot: string, sessionId: string): MemoryTurnRecord[];
    insertHookFallback(record: HookFallbackRecord): boolean;
    listHookFallbacks(filter?: {
        projectRoot?: string;
        sessionId?: string;
        from?: number;
        to?: number;
        limit?: number;
    }): HookFallbackRecord[];
    private mapMemoryTurn;
    recordMemoryDistillCheckpoint(checkpoint: MemoryDistillCheckpointRecord): void;
    listMemoryDistillCheckpoints(projectRoot: string, limit?: number): MemoryDistillCheckpointRecord[];
    requestHostAction(input: RequestHostActionInput): HostActionRecord;
    startHostAction(input: StartHostActionInput): HostActionRecord;
    reportHostAction(input: ReportHostActionInput): HostActionRecord;
    verifyHostAction(input: VerifyHostActionInput): HostActionRecord;
    failHostAction(input: FailHostActionInput): HostActionRecord;
    getHostAction(projectRoot: string, actionId: string): HostActionRecord | null;
    listHostActionsForRun(projectRoot: string, runId: string): HostActionRecord[];
    listHostActionsForSession(projectRoot: string, sessionId: string, executionId?: string): HostActionRecord[];
    private transitionHostAction;
    private appendHostActionEvent;
    private validateHostActionIdentity;
    private withImmediateTransaction;
    private isTerminalHostActionState;
    private isLegalHostActionTransition;
    createWorkflowWorker(input: CreateWorkflowWorkerInput): WorkflowWorkerRecord;
    getWorkflowWorker(projectRoot: string, workerId: string): WorkflowWorkerRecord | null;
    listWorkflowWorkers(projectRoot: string, options?: {
        states?: WorkflowWorkerRecord['state'][];
        runId?: string;
        limit?: number;
    }): WorkflowWorkerRecord[];
    listWorkflowWorkerEvents(projectRoot: string, workerId: string): WorkflowWorkerEventRecord[];
    leaseWorkflowWorker(projectRoot: string, workerId: string, owner: string, leaseMs: number, now?: number): WorkflowWorkerRecord;
    heartbeatWorkflowWorker(projectRoot: string, workerId: string, owner: string, leaseMs: number, now?: number): WorkflowWorkerRecord;
    transitionWorkflowWorker(input: TransitionWorkflowWorkerInput): WorkflowWorkerRecord;
    recoverExpiredWorkflowWorkers(projectRoot: string, now?: number): WorkflowWorkerRecord[];
    enqueueWorkflowMerge(input: EnqueueWorkflowMergeInput): WorkflowMergeRecord;
    getWorkflowMerge(projectRoot: string, mergeId: string): WorkflowMergeRecord | null;
    getWorkflowMergeByWorker(projectRoot: string, workerId: string): WorkflowMergeRecord | null;
    listWorkflowMerges(projectRoot: string, limit?: number): WorkflowMergeRecord[];
    transitionWorkflowMerge(projectRoot: string, mergeId: string, target: WorkflowMergeState, update?: {
        parentRevision?: string;
        simulationHash?: string;
        mergeCommit?: string;
        reason?: string;
    }, now?: number): WorkflowMergeRecord;
    private appendWorkflowWorkerEvent;
    all(sql: string, ...params: unknown[]): unknown[];
    get(sql: string, ...params: unknown[]): unknown;
    close(): void;
}