import { z } from "zod";
import type { Board } from "./model.js";
import { type WorkflowExport } from "./export.js";
import type { WalkthroughCase } from "./walkthrough.js";
export declare const assessmentOptionsSchema: z.ZodObject<{
    id: z.ZodString;
    capturedBy: z.ZodString;
    capturedAt: z.ZodEffects<z.ZodString, string, string>;
    intent: z.ZodDefault<z.ZodEnum<["assess", "implement", "discuss"]>>;
    jobIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    includeSources: z.ZodDefault<z.ZodBoolean>;
    rationale: z.ZodDefault<z.ZodString>;
    constraints: z.ZodDefault<z.ZodString>;
    cases: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        initialArtifacts: z.ZodArray<z.ZodString, "many">;
        conditions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
        exitChoices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        loopChoices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
        assumptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            note: z.ZodString;
            status: z.ZodEnum<["active", "retracted"]>;
            condition: z.ZodOptional<z.ZodString>;
            value: z.ZodOptional<z.ZodBoolean>;
        }, "strict", z.ZodTypeAny, {
            id: string;
            status: "active" | "retracted";
            note: string;
            condition?: string | undefined;
            value?: boolean | undefined;
        }, {
            id: string;
            status: "active" | "retracted";
            note: string;
            condition?: string | undefined;
            value?: boolean | undefined;
        }>, "many">>;
    }, "strict", z.ZodTypeAny, {
        name: string;
        initialArtifacts: string[];
        conditions?: Record<string, boolean> | undefined;
        exitChoices?: Record<string, string> | undefined;
        loopChoices?: Record<string, boolean> | undefined;
        assumptions?: {
            id: string;
            status: "active" | "retracted";
            note: string;
            condition?: string | undefined;
            value?: boolean | undefined;
        }[] | undefined;
    }, {
        name: string;
        initialArtifacts: string[];
        conditions?: Record<string, boolean> | undefined;
        exitChoices?: Record<string, string> | undefined;
        loopChoices?: Record<string, boolean> | undefined;
        assumptions?: {
            id: string;
            status: "active" | "retracted";
            note: string;
            condition?: string | undefined;
            value?: boolean | undefined;
        }[] | undefined;
    }>, "many">>;
}, "strict", z.ZodTypeAny, {
    id: string;
    intent: "assess" | "implement" | "discuss";
    rationale: string;
    constraints: string;
    capturedBy: string;
    capturedAt: string;
    includeSources: boolean;
    cases?: {
        name: string;
        initialArtifacts: string[];
        conditions?: Record<string, boolean> | undefined;
        exitChoices?: Record<string, string> | undefined;
        loopChoices?: Record<string, boolean> | undefined;
        assumptions?: {
            id: string;
            status: "active" | "retracted";
            note: string;
            condition?: string | undefined;
            value?: boolean | undefined;
        }[] | undefined;
    }[] | undefined;
    jobIds?: string[] | undefined;
}, {
    id: string;
    capturedBy: string;
    capturedAt: string;
    intent?: "assess" | "implement" | "discuss" | undefined;
    rationale?: string | undefined;
    cases?: {
        name: string;
        initialArtifacts: string[];
        conditions?: Record<string, boolean> | undefined;
        exitChoices?: Record<string, string> | undefined;
        loopChoices?: Record<string, boolean> | undefined;
        assumptions?: {
            id: string;
            status: "active" | "retracted";
            note: string;
            condition?: string | undefined;
            value?: boolean | undefined;
        }[] | undefined;
    }[] | undefined;
    constraints?: string | undefined;
    jobIds?: string[] | undefined;
    includeSources?: boolean | undefined;
}>;
export interface AssessmentRequest {
    schema: "staves.assessment-request";
    schemaVersion: 1;
    id: string;
    intent: "assess" | "implement" | "discuss";
    capturedBy: string;
    capturedAt: string;
    source: {
        boardId: string;
        revision: number;
        baseline?: Board["baseline"];
        base?: string;
    };
    /** Canonical semantic content, not a security hash. Revision and reports are excluded. */
    basis: string;
    packet: WorkflowExport;
    cases?: WalkthroughCase[];
    rationale: string;
    constraints: string;
    changes?: ReturnType<typeof import("./derive.js").diff>;
}
export declare const agentReturnSchema: z.ZodEffects<z.ZodObject<{
    requestId: z.ZodString;
    reportedBy: z.ZodString;
    reportedAt: z.ZodEffects<z.ZodString, string, string>;
    repositoryAccess: z.ZodEnum<["available", "unavailable"]>;
    jobs: z.ZodArray<z.ZodObject<{
        jobId: z.ZodString;
        conclusion: z.ZodEnum<["feasible", "conditional", "blocked", "unknown", "reported-implemented"]>;
        reason: z.ZodString;
        references: z.ZodOptional<z.ZodArray<z.ZodObject<{
            kind: z.ZodEnum<["file", "commit", "pr", "execution"]>;
            ref: z.ZodString;
        }, "strict", z.ZodTypeAny, {
            kind: "commit" | "file" | "pr" | "execution";
            ref: string;
        }, {
            kind: "commit" | "file" | "pr" | "execution";
            ref: string;
        }>, "many">>;
    }, "strict", z.ZodTypeAny, {
        jobId: string;
        reason: string;
        conclusion: "unknown" | "conditional" | "feasible" | "blocked" | "reported-implemented";
        references?: {
            kind: "commit" | "file" | "pr" | "execution";
            ref: string;
        }[] | undefined;
    }, {
        jobId: string;
        reason: string;
        conclusion: "unknown" | "conditional" | "feasible" | "blocked" | "reported-implemented";
        references?: {
            kind: "commit" | "file" | "pr" | "execution";
            ref: string;
        }[] | undefined;
    }>, "many">;
    tests: z.ZodDefault<z.ZodArray<z.ZodObject<{
        jobIds: z.ZodArray<z.ZodString, "many">;
        scope: z.ZodString;
        status: z.ZodEnum<["pass", "fail", "not-run"]>;
        reference: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        status: "pass" | "fail" | "not-run";
        scope: string;
        jobIds: string[];
        reference?: string | undefined;
    }, {
        status: "pass" | "fail" | "not-run";
        scope: string;
        jobIds: string[];
        reference?: string | undefined;
    }>, "many">>;
    limitations: z.ZodArray<z.ZodString, "many">;
    counterproposal: z.ZodOptional<z.ZodString>;
}, "strict", z.ZodTypeAny, {
    jobs: {
        jobId: string;
        reason: string;
        conclusion: "unknown" | "conditional" | "feasible" | "blocked" | "reported-implemented";
        references?: {
            kind: "commit" | "file" | "pr" | "execution";
            ref: string;
        }[] | undefined;
    }[];
    requestId: string;
    reportedBy: string;
    reportedAt: string;
    repositoryAccess: "available" | "unavailable";
    tests: {
        status: "pass" | "fail" | "not-run";
        scope: string;
        jobIds: string[];
        reference?: string | undefined;
    }[];
    limitations: string[];
    counterproposal?: string | undefined;
}, {
    jobs: {
        jobId: string;
        reason: string;
        conclusion: "unknown" | "conditional" | "feasible" | "blocked" | "reported-implemented";
        references?: {
            kind: "commit" | "file" | "pr" | "execution";
            ref: string;
        }[] | undefined;
    }[];
    requestId: string;
    reportedBy: string;
    reportedAt: string;
    repositoryAccess: "available" | "unavailable";
    limitations: string[];
    tests?: {
        status: "pass" | "fail" | "not-run";
        scope: string;
        jobIds: string[];
        reference?: string | undefined;
    }[] | undefined;
    counterproposal?: string | undefined;
}>, {
    jobs: {
        jobId: string;
        reason: string;
        conclusion: "unknown" | "conditional" | "feasible" | "blocked" | "reported-implemented";
        references?: {
            kind: "commit" | "file" | "pr" | "execution";
            ref: string;
        }[] | undefined;
    }[];
    requestId: string;
    reportedBy: string;
    reportedAt: string;
    repositoryAccess: "available" | "unavailable";
    tests: {
        status: "pass" | "fail" | "not-run";
        scope: string;
        jobIds: string[];
        reference?: string | undefined;
    }[];
    limitations: string[];
    counterproposal?: string | undefined;
}, {
    jobs: {
        jobId: string;
        reason: string;
        conclusion: "unknown" | "conditional" | "feasible" | "blocked" | "reported-implemented";
        references?: {
            kind: "commit" | "file" | "pr" | "execution";
            ref: string;
        }[] | undefined;
    }[];
    requestId: string;
    reportedBy: string;
    reportedAt: string;
    repositoryAccess: "available" | "unavailable";
    limitations: string[];
    tests?: {
        status: "pass" | "fail" | "not-run";
        scope: string;
        jobIds: string[];
        reference?: string | undefined;
    }[] | undefined;
    counterproposal?: string | undefined;
}>;
export type AgentReturn = z.output<typeof agentReturnSchema>;
/** Capture a read-only scoped packet. Intent is a request, never an executable action. */
export declare function createAssessmentRequest(board: Board, revision: number, input: z.input<typeof assessmentOptionsSchema>): AssessmentRequest;
export interface AssessedReturn {
    request: AssessmentRequest;
    result: AgentReturn;
    status: "current" | "stale";
    requiresReconciliation: boolean;
    evidence: "agent-report";
    verifiedExecution: false;
}
/** Validate the agent report against its original snapshot; never alter board authority. */
export declare function assessReturn(request: AssessmentRequest, currentBoard: Board, input: unknown): AssessedReturn;