import type { CodexAsyncQuestionDurableEvidence } from "./codex-async-question-adapter.js";
import type { CodexOpenRootRolloutInventory } from "./agent-session-provider.js";
import type { TerminalCompletionEvidence } from "./terminal-agent-adapter.js";
import { validateCodexRolloutAcceptanceAnchor, validateTerminalSubmissionAcceptanceEvidence, type CaptureCodexRolloutAcceptanceAnchorOptions, type CodexCandidateSetRolloutAcceptanceAnchor, type CodexCandidateSetRolloutAcceptanceRequest, type CodexCandidateSetRolloutAcceptanceResult, type CodexRolloutAcceptanceAnchor, type CodexRolloutAcceptanceIdentity, type CodexRolloutAcceptanceRequest, type CodexRolloutIdentity, type TerminalSubmissionAcceptanceEvidence } from "./terminal-submission-facts.js";
export { validateCodexRolloutAcceptanceAnchor, validateTerminalSubmissionAcceptanceEvidence };
export type { CodexBoundRolloutAcceptanceAnchor, CodexCandidateRolloutAcceptanceAnchorEntry, CodexCandidateSetRolloutAcceptanceAnchor, CodexRolloutAcceptanceAnchor, CodexCandidateSetRolloutAcceptanceResult, CodexRolloutAcceptanceIdentity, CodexRolloutIdentity, TerminalSubmissionAcceptanceEvidence, CodexVirginRolloutAcceptanceAnchor } from "./terminal-submission-facts.js";
export type CodexBoundRolloutCompletionCode = "completion_found" | "abort_found" | "exact_turn_not_complete" | "partial_rollout_record" | "rollout_changed_during_scan" | "invalid_anchor" | "invalid_acceptance_evidence" | "acceptance_anchor_mismatch" | "acceptance_turn_mismatch" | "binding_identity_mismatch" | "rollout_identity_mismatch" | "rollout_unreadable" | "rollout_truncated" | "scan_limit_exceeded" | "invalid_rollout_jsonl" | "duplicate_exact_completion" | "duplicate_exact_abort" | "conflicting_exact_settlement" | "later_turn_started" | "invalid_exact_completion" | "invalid_exact_abort";
export interface CodexBoundRolloutCompletionDiagnostics {
    detector: "codex_exact_bound_rollout";
    code: CodexBoundRolloutCompletionCode;
    native_thread_id?: string;
    acceptance_id?: string;
    anchor_fingerprint?: string;
    rollout_identity_fingerprint?: string;
    scan_start_offset_bytes?: number;
    observed_end_offset_bytes?: number;
    scanned_records?: number;
    observed_task_complete_records?: number;
    observed_turn_aborted_records?: number;
    detail?: string;
}
export type CodexBoundRolloutCompletionResult = {
    status: "completed";
    completion: TerminalCompletionEvidence;
    diagnostics: CodexBoundRolloutCompletionDiagnostics;
} | {
    status: "pending";
    diagnostics: CodexBoundRolloutCompletionDiagnostics;
} | {
    status: "failure";
    diagnostics: CodexBoundRolloutCompletionDiagnostics;
};
/**
 * Durable identity for one already-running Codex task that was started by the
 * human in the TUI. The prompt itself is deliberately omitted; the exact root
 * user row is represented only by its SHA-256 digest and native turn UUID.
 */
export interface CodexHumanStartedActiveTaskAnchor {
    schema: "agent-knock-knock/codex-human-started-active-task-anchor";
    version: 1;
    native_thread_id: string;
    process_uuid: string;
    process_birth: string;
    captured_at: string;
    rollout: CodexRolloutIdentity;
    turn_id: string;
    request_hash: string;
    codex_version: string;
    task_started_offset_bytes: number;
    user_message_offset_bytes: number;
    observed_end_offset_bytes: number;
    anchor_fingerprint: string;
}
export interface CaptureCodexHumanStartedActiveTaskOptions {
    currentIdentity: CodexRolloutAcceptanceIdentity;
    now?: Date;
    maxBytes?: number;
}
export interface ObserveCodexHumanStartedActiveTaskOptions {
    anchor: CodexHumanStartedActiveTaskAnchor;
    currentIdentity: CodexRolloutAcceptanceIdentity;
    maxBytes?: number;
    /** Last complete, stable JSONL boundary returned by a prior observation. */
    resumeOffsetBytes?: number;
}
export type CodexHumanStartedActiveTaskObservation = {
    status: "pending";
    observedEndOffsetBytes: number;
    safeResumeOffsetBytes: number;
} | {
    status: "completed";
    completion: TerminalCompletionEvidence & {
        outcome: "success" | "failure";
    };
} | {
    status: "invalidated";
    reason: string;
} | {
    status: "unavailable";
    reason: string;
    retryable: true;
};
export interface CodexQuestionnaireScreenEvidence {
    currentStep: number;
    totalSteps: number;
    prompt: string;
    responseKind: "single_select" | "multi_select" | "free_text" | "confirm";
    options?: ReadonlyArray<{
        label: string;
        description?: string;
    }>;
    /** Changed/unsupported frames may only use unique pending-call attribution. */
    exactShape: boolean;
}
export type CodexBoundQuestionnaireAttributionResult = {
    status: "matched";
    evidenceFingerprint: string;
} | {
    status: "not_matched";
    code: "accepted_root_missing" | "accepted_call_not_unique" | "screen_signature_not_unique";
} | {
    status: "unavailable";
    code: "invalid_inventory" | "invalid_screen" | "rollout_scan_unavailable";
};
/**
 * Capture the latest active native task in an exact open Codex rollout.
 * This is intentionally separate from the pre-send acceptance anchor: all
 * task-start and root-user evidence already exists when this function runs.
 */
export declare function captureCodexHumanStartedActiveTaskAnchor(options: CaptureCodexHumanStartedActiveTaskOptions): CodexHumanStartedActiveTaskAnchor | undefined;
/** Observe only the exact human-started task named by the persisted anchor. */
export declare function observeCodexHumanStartedActiveTask(options: ObserveCodexHumanStartedActiveTaskOptions): CodexHumanStartedActiveTaskObservation;
export declare function validateCodexHumanStartedActiveTaskAnchor(value: unknown): CodexHumanStartedActiveTaskAnchor;
export declare function captureCodexRolloutAcceptanceAnchor(options: CaptureCodexRolloutAcceptanceAnchorOptions): CodexRolloutAcceptanceAnchor;
export declare function captureCodexCandidateSetRolloutAcceptanceAnchor({ inventory: inventoryValue, now }: {
    inventory: CodexOpenRootRolloutInventory;
    now?: Date;
}): CodexCandidateSetRolloutAcceptanceAnchor;
export declare function detectCodexCandidateSetRolloutAcceptance({ anchor: anchorValue, currentInventory: inventoryValue, requestHash: requestHashValue, recoveryCandidate: recoveryCandidateValue }: CodexCandidateSetRolloutAcceptanceRequest): CodexCandidateSetRolloutAcceptanceResult;
/**
 * Attributes a rendered questionnaire to one exact accepted Codex turn while
 * the process has multiple open root rollouts. No prompt or tool arguments are
 * returned: callers receive only a bounded fingerprint or a typed failure.
 */
export declare function detectCodexBoundQuestionnaireAttribution(options: {
    currentInventory: CodexOpenRootRolloutInventory;
    acceptedIdentity: CodexRolloutAcceptanceIdentity;
    acceptanceId: string;
    screen: CodexQuestionnaireScreenEvidence;
    maxBytesPerRollout?: number;
}): CodexBoundQuestionnaireAttributionResult;
export declare function detectCodexRolloutAcceptance(options: CodexRolloutAcceptanceRequest): TerminalSubmissionAcceptanceEvidence | undefined;
/**
 * Scans the exact rollout and native turn proven by terminal acceptance.
 *
 * Unlike the general Codex context loader, this detector does not retain only
 * a recent-turn window. It starts at the immutable pre-submission byte anchor
 * and matches only the persisted acceptance UUID, so a delayed monitor can
 * recover completion even after later native turns have been appended.
 */
export declare function detectCodexBoundRolloutCompletion(options: {
    anchor: CodexRolloutAcceptanceAnchor;
    acceptanceEvidence: TerminalSubmissionAcceptanceEvidence;
    currentIdentity: CodexRolloutAcceptanceIdentity;
    requestHash: string;
}): CodexBoundRolloutCompletionResult;
/**
 * Read only the bounded, complete tail of one exact rollout and return async
 * questions belonging to its single currently active native turn. A missing
 * task boundary, a partial record, file drift, or an unsupported payload is a
 * hard absence rather than permission to infer from screen text alone.
 */
export declare function readCodexAsyncQuestionDurableEvidence(input: {
    rollout: CodexRolloutIdentity;
    nativeThreadId: string;
    maxBytes?: number;
}): readonly CodexAsyncQuestionDurableEvidence[] | undefined;