ai-foreman 1.7.20 → 1.7.21

package/dist/qaPreparationMetrics.d.ts

@@ -0,0 +1,145 @@
+export type FindingCause = "disclosed-builder-miss" | "preparation-omission" | "implementation-defect" | "new-authorized-scope" | "outside-contract" | "unknown";
+export interface FindingAssessmentV1 {
+    version: 1;
+    findingId: string;
+    contractDigest: string;
+    reviewDigest: string;
+    assessor: string;
+    independent: boolean;
+    cause: FindingCause;
+    explanation: string;
+    knowableBeforeImplementation: boolean | null;
+    actionableBeforeImplementation: boolean | null;
+    expectedCheckIds: string[];
+    originalInputEvidence: string[];
+    builderEvidence: string[];
+    scopeAuthorityEvidence: string[];
+}
+export declare function validateFindingAssessment(assessment: FindingAssessmentV1): void;
+export interface QaMetricEvent {
+    version: 1;
+    eventId: string;
+    workKey: string;
+    admissionDigest: string;
+    at: string;
+    mode: "legacy" | "shadow" | "enforce";
+    level?: number;
+    cohort: string;
+    kind: "approved" | "implementation-started" | "preparation-failure" | "substantive-review" | "format-repair" | "provider-retry" | "remediation" | "amendment" | "completed" | "waived" | "cancelled" | "abandoned" | "finding-classification" | "quality-observation" | "sample" | "phase-observation";
+    status?: "passed" | "failed" | "blocked" | "not-run" | "disabled" | "advisory-only";
+    equivalentReviewData?: boolean;
+    phase?: "preparation" | "planning" | "challenge" | "builder" | "review" | "repair" | "remediation";
+    durationMs?: number;
+    costUsd?: number | null;
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    findingId?: string;
+    findingIds?: string[];
+    cause?: FindingCause;
+    outsideContract?: boolean;
+    classifier?: string;
+    evidenceRefs?: string[];
+    assessmentRef?: string;
+    confidence?: "supported" | "unknown";
+    corrects?: string;
+    observationDay?: 7 | 30;
+    reopened?: boolean;
+    escapedDefect?: boolean;
+    sample?: {
+        contractDigest: string;
+        reviewDigest: string;
+        assessor: string;
+        checkUsefulness: Array<{
+            checkId: string;
+            result: string;
+            duplicate?: boolean;
+            irrelevant?: boolean;
+            observation: string;
+        }>;
+        excessiveInvestigation?: string;
+        coverageAdequate: boolean;
+    };
+}
+export declare function validateFindingClassification(event: QaMetricEvent, resolveEvidence: (reference: string) => boolean): void;
+/** Stable identities deduplicate replays; amendments do not reset work's first review. */
+export declare function measureQaPreparation(events: QaMetricEvent[]): {
+    approved: number;
+    started: number;
+    comparableStarted: number;
+    excludedNonEquivalentReviews: number;
+    approvedNeverStarted: number;
+    preparationFailures: number;
+    firstReviews: number;
+    firstReviewPasses: number;
+    firstReviewPassRate: number | null;
+    endToEndFirstAttempt: number;
+    endToEndRate: number | null;
+    omissionWorks: number;
+    omissionRounds: number;
+    omissionIncidence: number | null;
+    omissionRoundsPerStarted: number | null;
+    causes: Record<FindingCause, number>;
+    statuses: Record<string, number>;
+    quality: {
+        day7: {
+            observed: number;
+            reopened: number;
+            escaped: number;
+            unknown: number;
+        };
+        day30: {
+            observed: number;
+            reopened: number;
+            escaped: number;
+            unknown: number;
+        };
+    };
+    phaseCosts: Record<string, {
+        knownUsd: number;
+        knownSamples: number;
+        unknownSamples: number;
+        durationMs: number;
+    }>;
+    outsideContractEvents: number;
+    formatRepairs: number;
+    providerRetries: number;
+    byMode: {
+        [k: string]: {
+            works: number;
+            started: number;
+        };
+    };
+    samples: {
+        eventId: string;
+        workKey: string;
+        mode: "legacy" | "shadow" | "enforce";
+        level: number | undefined;
+        cohort: string;
+        at: string;
+        costUsd: number | null;
+        durationMs: number | null;
+        evidenceRefs: string[];
+        contractDigest?: string | undefined;
+        reviewDigest?: string | undefined;
+        assessor?: string | undefined;
+        checkUsefulness?: {
+            checkId: string;
+            result: string;
+            duplicate?: boolean;
+            irrelevant?: boolean;
+            observation: string;
+        }[] | undefined;
+        excessiveInvestigation?: string;
+        coverageAdequate?: boolean | undefined;
+    }[];
+    cohortSizes: {
+        [k: string]: number;
+    };
+};
+export declare function relativeOmissionReduction(baseline: {
+    incidence: number | null;
+    cohort: string;
+}, current: {
+    incidence: number | null;
+    cohort: string;
+}): number | null;

package/dist/qaPreparationMetrics.js

@@ -0,0 +1,120 @@
+export function validateFindingAssessment(assessment) {
+    if (assessment.version !== 1 || !assessment.findingId || !assessment.assessor || !assessment.explanation?.trim() || !assessment.contractDigest || !assessment.reviewDigest)
+        throw new Error("Finding assessment lacks retained scope, identity or explanation");
+    if (assessment.cause === "preparation-omission" && (!assessment.independent || assessment.knowableBeforeImplementation !== true || assessment.actionableBeforeImplementation !== true || !assessment.originalInputEvidence.length))
+        throw new Error("An omission requires independent evidence that the check was knowable and actionable before implementation");
+    if (assessment.cause === "disclosed-builder-miss" && (!assessment.expectedCheckIds.length || !assessment.builderEvidence.length))
+        throw new Error("Disclosed Builder miss requires the delivered check and Builder evidence");
+    if (assessment.cause === "new-authorized-scope" && !assessment.scopeAuthorityEvidence.length)
+        throw new Error("New scope requires retained authorization evidence");
+}
+export function validateFindingClassification(event, resolveEvidence) {
+    if (event.kind !== "finding-classification" || !event.findingId || !event.classifier || !event.cause)
+        throw new Error("Classification requires stable finding and classifier identities");
+    if (!event.evidenceRefs?.length || event.evidenceRefs.some(reference => !resolveEvidence(reference)))
+        throw new Error("Classification requires retained evidence");
+    if (event.cause !== "unknown" && event.confidence !== "supported")
+        throw new Error("Unsupported classification must remain unknown");
+    if (event.cause === "preparation-omission" && (!event.assessmentRef || !resolveEvidence(event.assessmentRef)))
+        throw new Error("Knowability/actionability omission requires independent assessment");
+}
+/** Stable identities deduplicate replays; amendments do not reset work's first review. */
+export function measureQaPreparation(events) {
+    const unique = new Map();
+    for (const event of events) {
+        if (event.version !== 1 || !event.eventId || !event.workKey || !Number.isFinite(Date.parse(event.at)))
+            throw new Error("Invalid metric event");
+        const existing = unique.get(event.eventId);
+        if (existing && JSON.stringify(existing) !== JSON.stringify(event))
+            throw new Error("Conflicting metric replay");
+        unique.set(event.eventId, event);
+    }
+    const ordered = [...unique.values()].sort((left, right) => Date.parse(left.at) - Date.parse(right.at));
+    const works = new Map();
+    for (const event of ordered) {
+        const group = works.get(event.workKey) ?? [];
+        group.push(event);
+        works.set(event.workKey, group);
+    }
+    let approved = 0, started = 0, comparableStarted = 0, excludedNonEquivalentReviews = 0, approvedNeverStarted = 0, preparationFailures = 0, firstReviews = 0, firstReviewPasses = 0, endToEndFirstAttempt = 0, omissionWorks = 0, omissionRounds = 0;
+    const statuses = {}, causes = { "disclosed-builder-miss": 0, "preparation-omission": 0, "implementation-defect": 0, "new-authorized-scope": 0, "outside-contract": 0, unknown: 0 };
+    const quality = { day7: { observed: 0, reopened: 0, escaped: 0, unknown: 0 }, day30: { observed: 0, reopened: 0, escaped: 0, unknown: 0 } };
+    const phaseCosts = {};
+    for (const group of works.values()) {
+        const hasApproved = group.some(event => event.kind === "approved"), hasStarted = group.some(event => event.kind === "implementation-started");
+        if (hasApproved)
+            approved++;
+        if (hasStarted)
+            started++;
+        if (hasApproved && !hasStarted)
+            approvedNeverStarted++;
+        const comparable = group.some(event => event.mode === "enforce" || event.equivalentReviewData === true);
+        if (hasStarted && comparable)
+            comparableStarted++;
+        if (group.some(event => event.kind === "preparation-failure"))
+            preparationFailures++;
+        const firstObserved = group.find(event => event.kind === "substantive-review" && event.status !== "disabled" && event.status !== "advisory-only");
+        if (firstObserved && firstObserved.mode !== "enforce" && firstObserved.equivalentReviewData !== true)
+            excludedNonEquivalentReviews++;
+        const first = firstObserved && (firstObserved.mode === "enforce" || firstObserved.equivalentReviewData === true) ? firstObserved : undefined;
+        if (first) {
+            firstReviews++;
+            statuses[first.status ?? "unknown"] = (statuses[first.status ?? "unknown"] ?? 0) + 1;
+            if (first.status === "passed") {
+                firstReviewPasses++;
+                if (hasStarted && group.some(event => event.kind === "completed"))
+                    endToEndFirstAttempt++;
+            }
+        }
+        const classifications = new Map();
+        for (const event of group)
+            if (event.kind === "finding-classification" && event.findingId)
+                classifications.set(event.findingId, event);
+        for (const event of classifications.values())
+            causes[event.cause ?? "unknown"]++;
+        const omissionFindings = new Set([...classifications].filter(([, event]) => event.cause === "preparation-omission" && event.confidence === "supported" && event.assessmentRef).map(([id]) => id));
+        const omissionCorrections = group.filter(event => event.kind === "remediation" && group.some(review => review.kind === "substantive-review" && Date.parse(review.at) > Date.parse(event.at) && review.status !== "disabled" && review.status !== "advisory-only") && [event.findingId, ...(event.findingIds ?? [])].some(id => id && omissionFindings.has(id)));
+        if (hasStarted && comparable && omissionCorrections.length) {
+            omissionWorks++;
+            omissionRounds += omissionCorrections.length;
+        }
+        const completion = group.find(event => event.kind === "completed");
+        if (completion)
+            for (const [day, field] of [[7, "day7"], [30, "day30"]]) {
+                const observation = group.find(event => event.kind === "quality-observation" && event.observationDay === day && Date.parse(event.at) >= Date.parse(completion.at) + day * 86400000 && typeof event.reopened === "boolean" && typeof event.escapedDefect === "boolean");
+                if (!observation)
+                    quality[field].unknown++;
+                else {
+                    quality[field].observed++;
+                    if (observation.reopened)
+                        quality[field].reopened++;
+                    if (observation.escapedDefect)
+                        quality[field].escaped++;
+                }
+            }
+        for (const event of group) {
+            if (["waived", "cancelled", "abandoned"].includes(event.kind))
+                statuses[event.kind] = (statuses[event.kind] ?? 0) + 1;
+            if (event.phase) {
+                const cost = phaseCosts[event.phase] ??= { knownUsd: 0, knownSamples: 0, unknownSamples: 0, durationMs: 0 };
+                cost.durationMs += event.durationMs ?? 0;
+                if (typeof event.costUsd === "number") {
+                    cost.knownUsd += event.costUsd;
+                    cost.knownSamples++;
+                }
+                else
+                    cost.unknownSamples++;
+            }
+        }
+    }
+    const fraction = (n, d) => d ? n / d : null;
+    return { approved, started, comparableStarted, excludedNonEquivalentReviews, approvedNeverStarted, preparationFailures, firstReviews, firstReviewPasses, firstReviewPassRate: fraction(firstReviewPasses, firstReviews), endToEndFirstAttempt, endToEndRate: fraction(endToEndFirstAttempt, comparableStarted), omissionWorks, omissionRounds, omissionIncidence: fraction(omissionWorks, comparableStarted), omissionRoundsPerStarted: fraction(omissionRounds, comparableStarted), causes, statuses, quality, phaseCosts,
+        outsideContractEvents: [...unique.values()].filter(event => event.kind === "finding-classification" && event.outsideContract).length,
+        formatRepairs: ordered.filter(event => event.kind === "format-repair").length, providerRetries: ordered.filter(event => event.kind === "provider-retry").length,
+        byMode: Object.fromEntries(["legacy", "shadow", "enforce"].map(mode => [mode, { works: new Set(ordered.filter(event => event.mode === mode).map(event => event.workKey)).size, started: new Set(ordered.filter(event => event.mode === mode && event.kind === "implementation-started").map(event => event.workKey)).size }])), samples: ordered.filter(event => event.kind === "sample").map(event => ({ ...event.sample, eventId: event.eventId, workKey: event.workKey, mode: event.mode, level: event.level, cohort: event.cohort, at: event.at, costUsd: event.costUsd ?? null, durationMs: event.durationMs ?? null, evidenceRefs: event.evidenceRefs ?? [] })), cohortSizes: Object.fromEntries([...new Set(ordered.map(event => event.cohort))].map(cohort => [cohort, new Set(ordered.filter(event => event.cohort === cohort).map(event => event.workKey)).size])) };
+}
+export function relativeOmissionReduction(baseline, current) {
+    if (baseline.cohort !== current.cohort || baseline.incidence === null || baseline.incidence === 0 || current.incidence === null)
+        return null;
+    return (baseline.incidence - current.incidence) / baseline.incidence;
+}

package/dist/qaPreparationPolicy.d.ts

@@ -0,0 +1,5 @@
+import { type QaPreparationConfigV1, type QaPreparationDepthDecisionV1, type QaPreparationLevel } from "rafi-spec";
+export declare const DEPTH_OBLIGATIONS: readonly [readonly ["behavior-mapping", "prerequisites", "scope-boundaries"], readonly ["implementation-inspection", "test-inspection", "edge-cases", "verification-sequence"], readonly ["dependency-map", "failure-cases", "state-transitions", "regression-compatibility"], readonly ["consequential-invariants", "adversarial-cases", "concurrency-retry", "rollback-recovery"], readonly ["approach-proposal", "independent-challenge", "coordinated-verification"]];
+export declare function depthObligations(level: QaPreparationLevel): string[];
+export declare function resolveQaPreparationConfig(value: unknown): QaPreparationConfigV1;
+export declare function validateDepthDecision(value: unknown, predecessor?: QaPreparationDepthDecisionV1): string[];

package/dist/qaPreparationPolicy.js

@@ -0,0 +1,51 @@
+import { Ajv } from "ajv";
+import { QA_PREPARATION_POLICY_VERSION, QA_RISK_MINIMUMS, qaPreparationDepthDecisionV1Schema } from "rafi-spec";
+const validateDecision = new Ajv({ allErrors: true }).compile(qaPreparationDepthDecisionV1Schema);
+export const DEPTH_OBLIGATIONS = [
+    ["behavior-mapping", "prerequisites", "scope-boundaries"],
+    ["implementation-inspection", "test-inspection", "edge-cases", "verification-sequence"],
+    ["dependency-map", "failure-cases", "state-transitions", "regression-compatibility"],
+    ["consequential-invariants", "adversarial-cases", "concurrency-retry", "rollback-recovery"],
+    ["approach-proposal", "independent-challenge", "coordinated-verification"],
+];
+export function depthObligations(level) { return DEPTH_OBLIGATIONS.slice(0, level).flat(); }
+export function resolveQaPreparationConfig(value) {
+    const defaults = { mode: "legacy", policyVersion: QA_PREPARATION_POLICY_VERSION, wallTimeMs: [300_000, 600_000, 1_200_000, 1_800_000, 2_700_000] };
+    if (value === undefined)
+        return defaults;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("qa_preparation must be an object");
+    const raw = value;
+    if (Object.keys(raw).some(key => !["mode", "policyVersion", "wallTimeMs"].includes(key)))
+        throw new Error("Unknown QA preparation policy option");
+    if (!["legacy", "shadow", "enforce"].includes(String(raw.mode)))
+        throw new Error("qa_preparation.mode must be legacy, shadow, or enforce");
+    if (raw.policyVersion !== undefined && raw.policyVersion !== defaults.policyVersion)
+        throw new Error("Unsupported QA preparation policy version");
+    if (raw.wallTimeMs !== undefined && (!Array.isArray(raw.wallTimeMs) || raw.wallTimeMs.length !== 5 || raw.wallTimeMs.some((v, i) => !Number.isSafeInteger(v) || v < defaults.wallTimeMs[i])))
+        throw new Error("QA preparation ceilings must specify five integer limits at least as large as policy defaults");
+    return { ...defaults, mode: raw.mode, ...(raw.wallTimeMs ? { wallTimeMs: raw.wallTimeMs } : {}) };
+}
+export function validateDepthDecision(value, predecessor) {
+    if (!validateDecision(value))
+        return (validateDecision.errors ?? []).map(error => `${error.instancePath} ${error.message}`);
+    const decision = value;
+    const issues = [];
+    const minimum = Math.max(2, ...decision.riskFactors.map(risk => QA_RISK_MINIMUMS[risk.category]));
+    if (!Number.isFinite(Date.parse(decision.timestamp)))
+        issues.push("Invalid planner timestamp");
+    if (decision.level === 1 && (!decision.lowRisk || decision.riskFactors.length))
+        issues.push("Focused requires explicit low-risk assessment and no consequential risks");
+    const effectiveMinimum = decision.level === 1 && decision.lowRisk && !decision.riskFactors.length ? 1 : minimum;
+    if (decision.minimumLevel !== effectiveMinimum || decision.level < effectiveMinimum)
+        issues.push(`Planner decision is below or misstates host minimum ${effectiveMinimum}`);
+    if (decision.riskFactors.some(risk => !decision.minimumReasons.includes(risk.category)))
+        issues.push("Minimum reasons must enumerate evidenced risk categories");
+    if (predecessor) {
+        if (decision.predecessorDecisionId !== predecessor.decisionId || decision.decisionId === predecessor.decisionId)
+            issues.push("Depth revision must retain its predecessor identity");
+        if (decision.level < predecessor.level && /(?:budget|cost|expens|provider.*fail|timeout|exhaust)/i.test(decision.rationale))
+            issues.push("Cost or provider failure cannot justify a downgrade");
+    }
+    return issues;
+}

package/dist/qaPreparationStore.d.ts

@@ -0,0 +1,157 @@
+import { type FindingAssessmentV1, type QaMetricEvent } from "./qaPreparationMetrics.js";
+import type Database from "better-sqlite3";
+import type { QaPreparationConfigV1, QaPreparationDepthDecisionV1, QaPreparationLevel, QaVerificationContractV1, QaContractDeliveryReceiptV1 } from "rafi-spec";
+export type PreparationState = "preparation-required" | "preparing" | "validating" | "ready" | "incomplete" | "blocked" | "uncertain" | "amendment-required" | "reconciling";
+export interface LogicalPreparationBudget {
+    id: string;
+    runId: string;
+    workId: string;
+    admissionDigest: string;
+    policy: QaPreparationConfigV1;
+    startMs: number;
+    deadlineMs: number;
+    level: QaPreparationLevel;
+    reservations: Array<{
+        operationId: string;
+        kind: "planning" | "investigation" | "assessment" | "challenge" | "escalation" | "repair";
+        resultId?: string;
+        resultDigest?: string;
+    }>;
+    usage: {
+        inputTokens: number | null;
+        outputTokens: number | null;
+        costUsd: number | null;
+    };
+    extensions: Array<{
+        authorityId: string;
+        actor: string;
+        reason: string;
+        previousDeadlineMs: number;
+        deadlineMs: number;
+    }>;
+    caps?: Partial<Record<LogicalPreparationBudget["reservations"][number]["kind"], number>>;
+}
+export declare function migrateQaPreparation(db: Database.Database): void;
+/** Tagged enforcing authority also fences older callers that omit new fields. */
+export declare function migrateQaPreparationGuards(db: Database.Database): void;
+/** Uses the existing workflow connection and caller's original lease fences. */
+export declare class QaPreparationStore {
+    private readonly db;
+    private readonly assertOwner;
+    private readonly projectDir?;
+    constructor(db: Database.Database, assertOwner: (runId: string) => void, projectDir?: string | undefined);
+    private protectedJson;
+    private decode;
+    private atomic;
+    equivalentResolver(): import("./qaAuthorizedDisposition.js").EquivalentAuthorityResolver;
+    metric(runId: string, workId: string, admissionDigest: string, eventId: string, kind: QaMetricEvent["kind"], details?: Partial<QaMetricEvent>): void;
+    findingAssessment(runId: string, workId: string, admissionDigest: string, assessment: FindingAssessmentV1, evidenceRefs: string[]): string;
+    eventRecord<T>(eventId: string): T | undefined;
+    metrics(runId: string): {
+        approved: number;
+        started: number;
+        comparableStarted: number;
+        excludedNonEquivalentReviews: number;
+        approvedNeverStarted: number;
+        preparationFailures: number;
+        firstReviews: number;
+        firstReviewPasses: number;
+        firstReviewPassRate: number | null;
+        endToEndFirstAttempt: number;
+        endToEndRate: number | null;
+        omissionWorks: number;
+        omissionRounds: number;
+        omissionIncidence: number | null;
+        omissionRoundsPerStarted: number | null;
+        causes: Record<import("./qaPreparationMetrics.js").FindingCause, number>;
+        statuses: Record<string, number>;
+        quality: {
+            day7: {
+                observed: number;
+                reopened: number;
+                escaped: number;
+                unknown: number;
+            };
+            day30: {
+                observed: number;
+                reopened: number;
+                escaped: number;
+                unknown: number;
+            };
+        };
+        phaseCosts: Record<string, {
+            knownUsd: number;
+            knownSamples: number;
+            unknownSamples: number;
+            durationMs: number;
+        }>;
+        outsideContractEvents: number;
+        formatRepairs: number;
+        providerRetries: number;
+        byMode: {
+            [k: string]: {
+                works: number;
+                started: number;
+            };
+        };
+        samples: {
+            eventId: string;
+            workKey: string;
+            mode: "legacy" | "shadow" | "enforce";
+            level: number | undefined;
+            cohort: string;
+            at: string;
+            costUsd: number | null;
+            durationMs: number | null;
+            evidenceRefs: string[];
+            contractDigest?: string | undefined;
+            reviewDigest?: string | undefined;
+            assessor?: string | undefined;
+            checkUsefulness?: {
+                checkId: string;
+                result: string;
+                duplicate?: boolean;
+                irrelevant?: boolean;
+                observation: string;
+            }[] | undefined;
+            excessiveInvestigation?: string;
+            coverageAdequate?: boolean | undefined;
+        }[];
+        cohortSizes: {
+            [k: string]: number;
+        };
+    };
+    policy(runId: string): QaPreparationConfigV1 | undefined;
+    freezePolicy(runId: string, policy: QaPreparationConfigV1): QaPreparationConfigV1;
+    budget(runId: string, workId: string, admissionDigest: string): LogicalPreparationBudget | undefined;
+    ensureBudget(runId: string, workId: string, admissionDigest: string, level: QaPreparationLevel, nowMs: number): LogicalPreparationBudget;
+    reserve(budget: LogicalPreparationBudget, operationId: string, kind: LogicalPreparationBudget["reservations"][number]["kind"], intent: unknown, nowMs: number, resultId?: string): void;
+    retainResult(budget: LogicalPreparationBudget, operationId: string, result: unknown, usage?: Partial<LogicalPreparationBudget["usage"]>): string;
+    reviseDepth(budget: LogicalPreparationBudget, decision: QaPreparationDepthDecisionV1): void;
+    retainProgress(budget: LogicalPreparationBudget, stage: string, value: unknown): void;
+    beginAmendment(budget: LogicalPreparationBudget, inventory: import("rafi-spec").RequirementRef[], authority: {
+        reason: string;
+        inputDigest: string;
+        predecessorDigest: string;
+    }): void;
+    progress<T>(budget: LogicalPreparationBudget, stage: string): T | undefined;
+    /** Explicit operator action against an answered, exactly scoped durable decision. */
+    applyAnsweredExtensions(budget: LogicalPreparationBudget): void;
+    extendBudget(budget: LogicalPreparationBudget, decisionId: string): void;
+    putArtifact(kind: string, value: unknown): string;
+    artifact<T>(digest: string, kind: string): T;
+    head(runId: string, workId: string, admissionDigest: string): {
+        digest?: string;
+        generation: number;
+        state: PreparationState;
+        detail?: string;
+    };
+    contract(digest: string): QaVerificationContractV1;
+    setState(runId: string, workId: string, admissionDigest: string, state: PreparationState, detail: string, expectedGeneration: number): void;
+    publish(contract: QaVerificationContractV1, expectedGeneration: number, nowMs: number): void;
+    receipt(receipt: QaContractDeliveryReceiptV1): void;
+    receipts(digest: string): QaContractDeliveryReceiptV1[];
+    event(runId: string, workId: string, eventId: string, kind: string, value: unknown): void;
+    private saveBudget;
+    private read;
+}