/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
/**
 * Structured completion reports, per-archetype output contracts.
 * Agents include these in their final output. The WrfcController extracts them.
 */
/** Base fields shared by all completion reports. */
export interface BaseCompletionReport {
    version: 1;
    archetype: string;
    summary: string;
    wrfcId?: string | undefined;
}
/**
 * A single constraint extracted from the task prompt.
 */
export interface Constraint {
    id: string;
    text: string;
    source: 'prompt';
}
/**
 * A reviewer's finding about whether a specific constraint was satisfied.
 */
export interface ConstraintFinding {
    constraintId: string;
    satisfied: boolean;
    evidence: string;
    severity?: 'critical' | 'major' | 'minor';
}
/**
 * One item of the reviewer's acceptance checklist: a requirement DERIVED FROM
 * THE ORIGINAL TASK (interface, argument names/count/order, format, path,
 * cardinality, threshold, exit behavior, side effect), whether the reviewer
 * INDEPENDENTLY verified it, the evidence, and how it was exercised. Landed in
 * the review record so a consumer can render exactly what was verified, and so
 * work that is correct but not what was asked (a false interface/cardinality/
 * threshold item) cannot pass.
 */
export interface AcceptanceChecklistItem {
    /** The requirement, in the reviewer's words, derived from the original task. */
    item: string;
    /** Whether the reviewer independently confirmed the deliverable meets it. */
    verified: boolean;
    /** Concrete evidence for the verdict. */
    evidence: string;
    /** How the reviewer INDEPENDENTLY exercised it (real invocation, not the engineer's tests). */
    howExercised?: string | undefined;
}
/** The mechanical acceptance-checklist gate result, shared by every review path. */
export interface AcceptanceChecklistGate {
    /** Checklist items the reviewer recorded as NOT verified, each one blocks a pass. */
    readonly unmet: readonly AcceptanceChecklistItem[];
    /**
     * True when the reviewer emitted NO checklist at all (absent or empty).
     * A review that records nothing about what was verified against the task
     * contract cannot pass: an empty checklist was previously indistinguishable
     * from all-verified, which let contract-blind reviews through the gate.
     */
    readonly missing: boolean;
}
/**
 * Evaluate the acceptance-checklist gate for a reviewer report. Deterministic
 * and shared so the main chain review and the compound-subtask review apply
 * the IDENTICAL mechanics: any `verified:false` item blocks, and an
 * absent/empty checklist blocks (the reviewer must record what was verified,
 * the report contract already demands the field; this makes it mechanical).
 */
export declare function evaluateAcceptanceChecklistGate(review: {
    acceptanceChecklist?: AcceptanceChecklistItem[] | undefined;
}): AcceptanceChecklistGate;
/** Engineer agent completion report. */
export interface EngineerReport extends BaseCompletionReport {
    archetype: 'engineer';
    gatheredContext: string[];
    plannedActions: string[];
    appliedChanges: string[];
    filesCreated: string[];
    filesModified: string[];
    filesDeleted: string[];
    decisions: Array<{
        what: string;
        why: string;
    }>;
    issues: string[];
    uncertainties: string[];
    /** Constraints enumerated from the task prompt. Defaults to [] when absent. */
    constraints?: Constraint[] | undefined;
}
/** Reviewer agent completion report. */
export interface ReviewerReport extends BaseCompletionReport {
    archetype: 'reviewer';
    score: number;
    passed: boolean;
    dimensions: Array<{
        name: string;
        score: number;
        maxScore: number;
        issues: string[];
    }>;
    issues: Array<{
        severity: 'critical' | 'major' | 'minor' | 'suggestion';
        description: string;
        file?: string | undefined;
        line?: number | undefined;
        pointValue: number;
    }>;
    /** Per-constraint satisfaction findings from the reviewer. Defaults to [] when absent. */
    constraintFindings?: ConstraintFinding[] | undefined;
    /**
     * The acceptance checklist the reviewer derived from the original task and
     * scored against, with how each item was independently exercised. The review
     * record of what was verified. Defaults to [] when absent (older reports).
     */
    acceptanceChecklist?: AcceptanceChecklistItem[] | undefined;
}
/** Tester agent completion report. */
export interface TesterReport extends BaseCompletionReport {
    archetype: 'tester';
    testsWritten: string[];
    testsPassed: number;
    testsFailed: number;
    coverage?: {
        lines: number;
        branches: number;
        functions: number;
    };
    failures: Array<{
        test: string;
        error: string;
    }>;
}
/** Generic completion report for other archetypes. */
export interface GenericReport extends BaseCompletionReport {
    /** Archetype name. For non-standard archetypes (not engineer/reviewer/tester). */
    archetype: string;
    result: string;
}
export type CompletionReport = EngineerReport | ReviewerReport | TesterReport | GenericReport;
export declare function parseCompletionReport(rawOutput: string): CompletionReport | null;
//# sourceMappingURL=completion-report.d.ts.map