import * as z from 'zod/v4';
export declare const CHECKPOINT_RUN_NOT_ACTIVE_CODE: "CHECKPOINT_RUN_NOT_ACTIVE";
export declare const CHECKPOINT_INTAKE_ERROR_MESSAGE = "Checkpoint is blocked while the run awaits intake answers. Complete task_answer before retrying.";
export declare const CHECKPOINT_TERMINAL_ERROR_MESSAGE = "Checkpoint is blocked because the run is terminal.";
export declare const TASK_ANSWER_CONTRACT_FRAGMENT = "Use the exact current question. If question.options is non-null, value must be exactly one returned option. If options is null, provide grounded non-empty text. Inspect the latest intake.question after every response. Repeat until intake.status is ready or exhausted; do not checkpoint while needs_answer. Not every intake question is a one-word enum: target and expected require grounded free text.";
export declare const CHECKPOINT_CONTRACT_FRAGMENT = "For a run-bound checkpoint, `runId` and `outcome` are required, the run must be active, and at least one of memories, feedback, or non-empty evidence must be supplied. outcome alone is an invalid empty checkpoint. Do not invent evidence fields such as checks; use commands and/or tests. Without `runId`, provide at least one memory. Do not supply `outcome`, `deliveryId`, `feedback`, or `evidence`. When `runId` is supplied, the run must be active. Do not call `memory_checkpoint` while `task_prepare` or `task_answer` reports `needs_answer` or `nextAction=answer_from_evidence_or_ask_user`; complete the required `task_answer` loop first. A successful terminal checkpoint is allowed at most once per logical request. A rejected precondition does not count as that successful checkpoint and may be retried only after the indicated run-state change.";
export declare const CHECKPOINT_TOOL_DESCRIPTION = "Store one final batch of durable facts, decisions, lessons, preferences, or references as untrusted candidate memory. For a run-bound checkpoint, `runId` and `outcome` are required, the run must be active, and at least one of memories, feedback, or non-empty evidence must be supplied. outcome alone is an invalid empty checkpoint. Do not invent evidence fields such as checks; use commands and/or tests. Without `runId`, provide at least one memory. Do not supply `outcome`, `deliveryId`, `feedback`, or `evidence`. When `runId` is supplied, the run must be active. Do not call `memory_checkpoint` while `task_prepare` or `task_answer` reports `needs_answer` or `nextAction=answer_from_evidence_or_ask_user`; complete the required `task_answer` loop first. A successful terminal checkpoint is allowed at most once per logical request. A rejected precondition does not count as that successful checkpoint and may be retried only after the indicated run-state change. After a successful terminal checkpoint, call no more tools and return the final response. Defaults to the current project. Use Curator for learned knowledge that may become global; choose direct global scope only when the user explicitly requested it. Secret-like content is rejected.";
export declare const CHECKPOINT_RUN_ID_DESCRIPTION = "Exact run.runId returned by task_prepare. The run must have reached active; intake/needs_answer runs must complete task_answer first.";
export declare const CHECKPOINT_OUTCOMES: readonly ["completed", "failed", "cancelled", "interrupted"];
export type CheckpointOutcome = (typeof CHECKPOINT_OUTCOMES)[number];
export declare const CHECKPOINT_RESULT_OUTCOMES: readonly ["passed", "failed", "unknown"];
export type CheckpointResultOutcome = (typeof CHECKPOINT_RESULT_OUTCOMES)[number];
export declare const CHECKPOINT_VERIFICATION_OUTCOMES: readonly ["fresh", "stale", "failed", "unknown"];
export type CheckpointVerificationOutcome = (typeof CHECKPOINT_VERIFICATION_OUTCOMES)[number];
export declare const CONTEXT_FEEDBACK_VERDICTS: readonly ["helpful", "irrelevant", "stale", "conflicting"];
export type ContextFeedbackVerdict = (typeof CONTEXT_FEEDBACK_VERDICTS)[number];
export declare const CHECKPOINT_EVIDENCE_FIELD_NAMES: readonly ["changedPaths", "errorSignatures", "commands", "tests", "verification"];
export declare const CHECKPOINT_COMMAND_FIELD_NAMES: readonly ["executable", "classification", "exitCode", "outcome", "digest"];
export declare const CHECKPOINT_TEST_FIELD_NAMES: readonly ["runner", "target", "outcome", "digest"];
export declare const CHECKPOINT_VERIFICATION_FIELD_NAMES: readonly ["outcome"];
export declare const CHECKPOINT_FEEDBACK_FIELD_NAMES: readonly ["entryId", "entryRevision", "verdict", "comment"];
export declare const MAX_CHECKPOINT_MEMORY_ITEMS = 20;
export declare const MAX_CHECKPOINT_EVIDENCE_ITEMS = 100;
export declare const MAX_CHECKPOINT_PATHS = 200;
export declare const MAX_CHECKPOINT_SIGNALS = 200;
export declare const MAX_CHECKPOINT_SHORT_TEXT_CHARS = 500;
export declare const MAX_CHECKPOINT_EXECUTABLE_CHARS = 200;
export declare const MAX_CHECKPOINT_FEEDBACK_ITEMS = 100;
export declare const MAX_FEEDBACK_COMMENT_BYTES: number;
export declare const MAX_FEEDBACK_IDENTIFIER_LENGTH = 256;
export interface CheckpointCommandEvidence {
    executable: string;
    classification?: string | undefined;
    exitCode?: number | undefined;
    outcome: CheckpointResultOutcome;
    digest?: string | undefined;
}
export interface CheckpointTestEvidence {
    runner: string;
    target?: string | undefined;
    outcome: CheckpointResultOutcome;
    digest?: string | undefined;
}
export interface CheckpointEvidence {
    changedPaths?: string[] | undefined;
    errorSignatures?: string[] | undefined;
    commands?: CheckpointCommandEvidence[] | undefined;
    tests?: CheckpointTestEvidence[] | undefined;
    verification?: {
        outcome: CheckpointVerificationOutcome;
    } | undefined;
}
export interface NormalizedCheckpointEvidence {
    changedPaths: string[];
    errorSignatures: string[];
    commands: CheckpointCommandEvidence[];
    tests: CheckpointTestEvidence[];
    verification?: {
        outcome: CheckpointVerificationOutcome;
    };
}
export interface CheckpointFeedback {
    entryId: string;
    entryRevision: number;
    verdict: ContextFeedbackVerdict;
    comment?: string | undefined;
}
export declare function hasCheckpointEvidenceContent(evidence: CheckpointEvidence | undefined): boolean;
export declare const checkpointPathSchema: z.ZodString;
export declare const checkpointSignalSchema: z.ZodString;
export declare const checkpointCommandEvidenceSchema: z.ZodObject<{
    executable: z.ZodString;
    classification: z.ZodOptional<z.ZodString>;
    exitCode: z.ZodOptional<z.ZodNumber>;
    outcome: z.ZodEnum<{
        failed: "failed";
        unknown: "unknown";
        passed: "passed";
    }>;
    digest: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
export declare const checkpointTestEvidenceSchema: z.ZodObject<{
    runner: z.ZodString;
    target: z.ZodOptional<z.ZodString>;
    outcome: z.ZodEnum<{
        failed: "failed";
        unknown: "unknown";
        passed: "passed";
    }>;
    digest: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
export declare const checkpointVerificationSchema: z.ZodObject<{
    outcome: z.ZodEnum<{
        failed: "failed";
        unknown: "unknown";
        stale: "stale";
        fresh: "fresh";
    }>;
}, z.core.$strict>;
export declare const checkpointEvidenceSchema: z.ZodObject<{
    changedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
    errorSignatures: z.ZodOptional<z.ZodArray<z.ZodString>>;
    commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
        executable: z.ZodString;
        classification: z.ZodOptional<z.ZodString>;
        exitCode: z.ZodOptional<z.ZodNumber>;
        outcome: z.ZodEnum<{
            failed: "failed";
            unknown: "unknown";
            passed: "passed";
        }>;
        digest: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>>;
    tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
        runner: z.ZodString;
        target: z.ZodOptional<z.ZodString>;
        outcome: z.ZodEnum<{
            failed: "failed";
            unknown: "unknown";
            passed: "passed";
        }>;
        digest: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>>;
    verification: z.ZodOptional<z.ZodObject<{
        outcome: z.ZodEnum<{
            failed: "failed";
            unknown: "unknown";
            stale: "stale";
            fresh: "fresh";
        }>;
    }, z.core.$strict>>;
}, z.core.$strict>;
export declare const checkpointFeedbackSchema: z.ZodObject<{
    entryId: z.ZodString;
    entryRevision: z.ZodNumber;
    verdict: z.ZodEnum<{
        stale: "stale";
        helpful: "helpful";
        irrelevant: "irrelevant";
        conflicting: "conflicting";
    }>;
    comment: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
//# sourceMappingURL=checkpoint-contract.d.ts.map