import { type ClaudeAgentRow } from "./claude-terminal-agent-adapter.js";
import type { TerminalCompletionEvidence, TerminalDurableCompletionRequest, TerminalThreadLifecycleCandidate, TerminalThreadLifecycleCandidateProvider, TerminalThreadLifecycleCandidateRequest, TerminalThreadLifecycleCandidateToken, TerminalThreadLifecycleCandidateValidation, TerminalThreadFileToken } from "./terminal-agent-adapter.js";
import { type TerminalSubmissionAcceptanceEvidence } from "./terminal-submission-facts.js";
export interface ClaudeTranscriptAnchor {
    schema_version: 1;
    session_id: string;
    cwd: string;
    pid: number;
    agent_started_at_ms: number;
    captured_at: string;
    relative_path: string;
    offset_bytes: number;
    file_existed: boolean;
    device?: string;
    inode?: string;
}
export interface CaptureClaudeTranscriptAnchorOptions {
    sessionId?: string;
    cwd?: string;
    pid?: number;
    claudeHome?: string;
    agentRows: readonly ClaudeAgentRow[];
    now?: Date;
}
/**
 * Durable identity for one already-running root Claude task started by the
 * human in the TUI. The prompt is represented only by its exact SHA-256 digest
 * and native UUID; raw prompt content is never retained in this anchor.
 */
export interface ClaudeHumanStartedActiveTaskAnchor {
    schema: "agent-knock-knock/claude-human-started-active-task-anchor";
    version: 1;
    session_id: string;
    cwd: string;
    pid: number;
    agent_started_at_ms: number;
    captured_at: string;
    relative_path: string;
    device: string;
    inode: string;
    prompt_uuid: string;
    request_hash: string;
    claude_version: string;
    transcript_file_id: string;
    turn_start_offset_bytes: number;
    observed_end_offset_bytes: number;
    anchor_fingerprint: string;
}
export interface CaptureClaudeHumanStartedActiveTaskOptions extends CaptureClaudeTranscriptAnchorOptions {
    maxTurnBytes?: number;
}
export interface ObserveClaudeHumanStartedActiveTaskOptions extends DetectClaudeTranscriptCompletionOptions {
    anchor: ClaudeHumanStartedActiveTaskAnchor;
    /** Last complete, stable JSONL boundary returned by a prior observation. */
    resumeOffsetBytes?: number;
    checkpoint?: ClaudeHumanStartedActiveTaskCheckpoint;
}
export interface ClaudeHumanStartedActiveTaskCheckpointToolUse {
    tool_use_id: string;
    owner_uuid: string;
}
/**
 * Privacy-safe continuation state for streaming one anchored Claude turn.
 * It contains only opaque native IDs, hashes, and bounded redacted output.
 */
export interface ClaudeHumanStartedActiveTaskCheckpoint {
    schema: "agent-knock-knock/claude-human-started-active-task-checkpoint";
    version: 1;
    anchor_fingerprint: string;
    safe_resume_offset_bytes: number;
    last_record_uuid: string;
    record_count: number;
    chain_fingerprint: string;
    unresolved_tool_uses: ClaudeHumanStartedActiveTaskCheckpointToolUse[];
    assistant_message_id?: string;
    assistant_text?: string;
    end_turn_message_id?: string;
    end_turn_assistant_uuid?: string;
    checkpoint_fingerprint: string;
}
export type ClaudeHumanStartedActiveTaskObservation = {
    status: "pending";
    observedEndOffsetBytes: number;
    safeResumeOffsetBytes: number;
    checkpoint: ClaudeHumanStartedActiveTaskCheckpoint;
} | {
    status: "completed";
    completion: TerminalCompletionEvidence & {
        outcome: "success" | "failure";
    };
} | {
    status: "invalidated";
    reason: string;
} | {
    status: "unavailable";
    reason: string;
    retryable: true;
};
export interface DetectClaudeTranscriptCompletionOptions {
    claudeHome?: string;
    agentRows: readonly ClaudeAgentRow[];
    maxTurnBytes?: number;
}
export interface ObserveClaudeDeadProcessCompletionOptions extends DetectClaudeTranscriptCompletionOptions {
    acceptanceEvidence: unknown;
}
export type ClaudeDeadProcessCompletionObservation = {
    status: "present";
    completion: TerminalCompletionEvidence;
} | {
    status: "absent";
} | {
    status: "unverifiable";
    reason: string;
};
export type ClaudeUserExplicitFallbackTranscriptObservation = {
    status: "pending";
    acceptance?: ClaudeTranscriptAcceptanceEvidence;
    observedEndOffsetBytes?: number;
} | {
    status: "completed";
    acceptance: ClaudeTranscriptAcceptanceEvidence;
    completion: TerminalCompletionEvidence;
    observedEndOffsetBytes: number;
} | {
    status: "unavailable";
    reason: string;
};
export interface ObserveClaudeUserExplicitFallbackTranscriptOptions extends Omit<DetectClaudeTranscriptCompletionOptions, "agentRows"> {
    acceptanceEvidence?: unknown;
}
export interface ClaudeHistoricalSessionSummary {
    id: string;
    cwd: string;
    transcriptPath: string;
    updatedAtMs: number;
    claudeVersion: string;
    rootInteractive: true;
    fileToken: TerminalThreadFileToken;
    metadataFingerprint: string;
    candidateToken: TerminalThreadLifecycleCandidateToken;
}
/**
 * Process-local evidence for one pending, foreground Claude Bash permission.
 * `command` is intentionally raw so the caller can apply the exact command
 * policy, but callers must not persist this object or add it to callbacks.
 */
export interface ClaudeTranscriptPendingApprovalEvidence {
    source: "claude_transcript";
    kind: "run_command";
    command: string;
    cwd: string;
    toolName: "Bash";
    toolUseId: string;
    promptUuid: string;
    assistantUuid: string;
    claudeVersion: string;
    transcriptFileId: string;
    commandSha256: string;
    evidenceFingerprint: string;
    observedEndOffsetBytes: number;
}
/**
 * Durable, privacy-preserving proof that the exact managed request became a
 * native root Claude turn. The request text and transcript path are
 * intentionally omitted so this evidence is safe to persist in a receipt.
 */
export type ClaudeTranscriptAcceptanceEvidence = TerminalSubmissionAcceptanceEvidence & {
    source: "claude_transcript";
};
export declare function defaultClaudeHome(): string;
/** List exact, root-interactive Claude sessions from owner-private transcripts. */
export declare function listClaudeHistoricalSessions(options: {
    cwd: string;
    claudeHome?: string;
    agentVersion?: string;
}): ClaudeHistoricalSessionSummary[];
export declare function listClaudeThreadLifecycleCandidates(options: {
    cwd: string;
    claudeHome?: string;
    agentVersion: string;
}): TerminalThreadLifecycleCandidate[];
export declare function createClaudeThreadLifecycleCandidateProvider(options?: {
    claudeHome?: string;
}): TerminalThreadLifecycleCandidateProvider;
export declare function revalidateClaudeThreadLifecycleCandidate(candidate: TerminalThreadLifecycleCandidate | TerminalThreadLifecycleCandidateToken, options: TerminalThreadLifecycleCandidateRequest & {
    claudeHome?: string;
}): TerminalThreadLifecycleCandidateValidation;
/**
 * Records the immutable file boundary immediately before AKK submits a turn.
 * No transcript contents are retained in conversation state.
 */
export declare function captureClaudeTranscriptAnchor(options: CaptureClaudeTranscriptAnchorOptions): ClaudeTranscriptAnchor | undefined;
/** Capture the latest exact, unfinished root prompt in a live Claude process. */
export declare function captureClaudeHumanStartedActiveTaskAnchor(options: CaptureClaudeHumanStartedActiveTaskOptions): ClaudeHumanStartedActiveTaskAnchor | undefined;
/** Observe only the exact root prompt named by a human-started task anchor. */
export declare function observeClaudeHumanStartedActiveTask(options: ObserveClaudeHumanStartedActiveTaskOptions): ClaudeHumanStartedActiveTaskObservation;
export declare function validateClaudeHumanStartedActiveTaskAnchor(value: unknown): ClaudeHumanStartedActiveTaskAnchor;
export declare function initialClaudeHumanStartedActiveTaskCheckpoint(value: ClaudeHumanStartedActiveTaskAnchor): ClaudeHumanStartedActiveTaskCheckpoint;
export declare function validateClaudeHumanStartedActiveTaskCheckpoint(value: unknown, anchorValue: ClaudeHumanStartedActiveTaskAnchor): ClaudeHumanStartedActiveTaskCheckpoint;
/**
 * Detects one completed Claude Code turn from the append-only local transcript.
 * The detector intentionally fails closed on identity, schema, rotation, prompt,
 * background-work, and chain ambiguity.
 */
export declare function detectClaudeTranscriptCompletion(request: TerminalDurableCompletionRequest, options: DetectClaudeTranscriptCompletionOptions): TerminalCompletionEvidence | undefined;
/**
 * Observes completion after the exact bound Claude process is independently
 * proven dead. Unlike the ordinary live monitor detector, this API separates
 * a stable, fully inspected transcript with no completion from a transcript
 * that cannot be inspected or tied back to the durable native-acceptance
 * receipt. Callers may treat only `absent` as authority for orphan cleanup.
 */
export declare function observeClaudeDeadProcessTranscriptCompletion(request: TerminalDurableCompletionRequest, options: ObserveClaudeDeadProcessCompletionOptions): ClaudeDeadProcessCompletionObservation;
/**
 * Detects native acceptance as soon as Claude appends the unique root user
 * row matching the managed request after the immutable pre-send byte anchor.
 * Unlike completion detection, acceptance does not require the agent to be
 * idle because the row is normally written while Claude is working.
 */
export declare function detectClaudeTranscriptAcceptance(request: TerminalDurableCompletionRequest, options: DetectClaudeTranscriptCompletionOptions): ClaudeTranscriptAcceptanceEvidence | undefined;
/**
 * Observe one user-explicit fallback request without persisting its raw text.
 * The immutable pre-send transcript byte anchor plus the SHA-256 request hash
 * must identify exactly one post-anchor root prompt.
 */
export declare function detectClaudeTranscriptAcceptanceByHash(request: TerminalDurableCompletionRequest, options: DetectClaudeTranscriptCompletionOptions): ClaudeTranscriptAcceptanceEvidence | undefined;
export declare function detectClaudeTranscriptCompletionByHash(request: TerminalDurableCompletionRequest, options: DetectClaudeTranscriptCompletionOptions): TerminalCompletionEvidence | undefined;
/**
 * Observe a fallback Watch from its immutable pre-send transcript anchor.
 * Once acceptance has been persisted, the native prompt UUID becomes the
 * sole prompt selector so a later identical request cannot redirect the
 * Watch. This path intentionally requires only the durable transcript: a
 * completed callback remains recoverable after the pane or agent row exits.
 */
export declare function observeClaudeUserExplicitFallbackTranscript(request: TerminalDurableCompletionRequest, options: ObserveClaudeUserExplicitFallbackTranscriptOptions): ClaudeUserExplicitFallbackTranscriptObservation;
/**
 * Detects exactly one unresolved foreground Bash tool use for the current
 * AKK-managed Claude turn. It uses the same anchored, owner-private,
 * no-follow, bounded, stable transcript read as durable completion and fails
 * closed on identity changes, completed turns, background work, or ambiguity.
 */
export declare function detectClaudeTranscriptPendingApproval(request: TerminalDurableCompletionRequest, options: DetectClaudeTranscriptCompletionOptions): ClaudeTranscriptPendingApprovalEvidence | undefined;
export declare function claudeTranscriptAnchorFingerprint(anchor: ClaudeTranscriptAnchor): string;