import { type ReleaseDomain, type DomainResult } from '@enterprise-skills/core';
import { type TestsVerification } from '../lib/test-report';
/**
 * `enterprise-skills orchestrate score` — deterministic release-confidence score.
 *
 * Reads each domain's evidence from `.project-ai/skill-outputs/<skill-id>.yaml`
 * (Skill Coordination Protocol) and applies the pure `scoreRelease` rubric, so the
 * 0–100 score + go/no-go is reproducible rather than LLM-estimated. Web and mobile are
 * scored as separate surfaces. Exit 1 on any NO-GO.
 */
/** Domain → the skill-output file(s) that feed it. (Shared with `govern`.) */
export declare const DOMAIN_FEEDERS: Record<ReleaseDomain, string[]>;
/**
 * One resolution contract for a file that has two writers (PB-008).
 *
 * `.project-ai/skill-outputs/<skill>.yaml` is written by the orchestrator's
 * StateMachine, whose `Finding` carries a REQUIRED `resolved: boolean`, and
 * read here, where scoring keys on `status: open | fixed`. Same file, two
 * spellings, and only one of them was ever read — so a skill that found a
 * defect and fixed it in the same change recorded `resolved: true` and scored
 * exactly as if it had left the defect open (measured: 80/100 CONDITIONAL,
 * against 100/100 PASS for `status: fixed`).
 *
 * `status` is canonical: the Governor is the decision-maker (§9), the enum has
 * room to grow where a boolean does not, and core owns the scoring contract.
 * `resolved` is retired for producers but still READ, because files carrying it
 * already exist in customer repos and continuing to ignore them is the defect
 * itself, not a clean deprecation.
 *
 * Fail-closed throughout: only the literal `fixed` (or `resolved: true`) clears
 * a finding, anything unrecognised stays open, and when both fields are present
 * and DISAGREE the finding stays open — a producer asserting both "fixed" and
 * "not resolved" has not evidenced a fix.
 */
export declare function resolveFindingStatus(finding: {
    status?: unknown;
    resolved?: unknown;
    tracked_as?: unknown;
}): 'open' | 'fixed' | 'accepted';
/** One present evidence file and what it says about its own provenance. */
export interface EvidenceFileFacts {
    skill: string;
    /** Verified-shape `commit:` value, or null when absent/unusable (→ unbound). */
    declaredCommit: string | null;
    /** Verified-shape `source_digest:` value; the squash-durable binding (§8). */
    declaredSourceDigest: string | null;
    malformed: boolean;
}
export interface DomainEvidence {
    result: DomainResult;
    /** Only the feeders that were actually present, in feeder order. */
    files: EvidenceFileFacts[];
    /**
     * §5 — one recomputation verdict per present feeder, so a caller can report
     * `self-reported` counts distinctly from recomputed ones. A mismatch is
     * ALSO a finding on `result`, because that is what makes it block; this array
     * exists so the degraded case, which deliberately costs nothing, still has
     * somewhere to be seen.
     */
    testsChecks: Array<{
        skill: string;
    } & TestsVerification>;
}
/**
 * Read a domain's evidence AND the binding facts of each file behind it. The
 * scoring result and the freshness question are answered from a single read so
 * they can never disagree about which files were involved.
 */
export declare function collectDomainEvidence(dir: string, domain: ReleaseDomain, now?: Date, decidingCommit?: string): DomainEvidence;
/** Scoring-only view — used where no commit context exists (`orchestrate score`). */
export declare function buildDomain(dir: string, domain: ReleaseDomain, now?: Date): DomainResult;
export interface ReleaseScoreOptions {
    json?: boolean;
}
export declare function releaseScoreCommand(options?: ReleaseScoreOptions): void;
/**
 * §5, acceptance 10 — a self-reported count is rendered as such, never silently.
 *
 * It costs no points on purpose (charging for it would price honest declaration
 * above silent omission, which is PB-006), so PRINTING it is the entire
 * mechanism. `^3.11.0` sat stale in published copy for months precisely because
 * a degradation nobody looks at is indistinguishable from a verification.
 */
export declare function printTestsProvenance(checks: Array<{
    skill: string;
} & TestsVerification>): void;
//# sourceMappingURL=release-score.d.ts.map