ai-foreman 1.7.26 → 1.7.27

package/dist/qaFailureDelivery.d.ts

@@ -13,6 +13,8 @@ export interface QaFailureDeliveryInput {
     reviewNumber: number;
     reviewedSourceStateDigest: string;
     reviewBasisDigest: string;
+    /** Frozen published contract identity when contract enforcement is active. */
+    contractDigest?: string;
     remediationGeneration: number;
     latestBuilderResult: string;
     history: unknown[];
@@ -24,6 +26,12 @@ export interface QaFailureDeliveryInput {
         answer: string;
     };
 }
+/**
+ * Remediation is deliberately smaller than review.  The initial and every
+ * subsequent QA review still sees the complete ticket; only the Builder's
+ * follow-up work is limited to a bounded set of current findings.
+ */
+export declare const QA_REMEDIATION_CHUNK_SIZE = 2;
 export interface QaFailureDeliveryController {
     adapter(): BuilderAdapter | undefined;
     setAdapter?(adapter: BuilderAdapter): void;
@@ -74,6 +82,20 @@ interface QaFailureHandoffV3 {
         value: QaFailureReportV1;
         findingRefs: QaFindingRefV2[];
     };
+    remediationChunk: {
+        version: 1;
+        ordinal: number;
+        findingIds: string[];
+        findingKeys: string[];
+        sourceDigest: string;
+        contractBinding: {
+            kind: "published-contract" | "review-basis";
+            digest: string;
+        };
+        reviewBasisDigest: string;
+        reviewAttemptId: string;
+        finalIndependentReviewRequired: true;
+    };
     latestBuilderResult: {
         rawResponseDigest: string;
         summaryDigest: string;
@@ -115,4 +137,5 @@ export declare class QaFailureDeliveryService {
     private buildHandoff;
 }
 export declare function renderQaFailureHandoff(handoff: QaFailureHandoffV3): string;
+export declare function selectQaRemediationFindingIds(report: QaFailureReportV1): string[];
 export {};

package/dist/qaFailureDelivery.js

@@ -14,6 +14,12 @@ import { withActivityPhase } from "./activity.js";
 import { captureFrozenQaSourceAsync } from "./qaSnapshot.js";
 import { canonicalJson, createQaFindingRefs, qaDigest } from "./qaProtocolV2.js";
 import { WorkflowDb } from "./workflowDb.js";
+/**
+ * Remediation is deliberately smaller than review.  The initial and every
+ * subsequent QA review still sees the complete ticket; only the Builder's
+ * follow-up work is limited to a bounded set of current findings.
+ */
+export const QA_REMEDIATION_CHUNK_SIZE = 2;
 export class QaFailureDeliveryService {
     faults;
     constructor(faults = {}) {
@@ -93,6 +99,7 @@ export class QaFailureDeliveryService {
                 prior = read.atomic(() => read.transitionQaFailureHandoff(handoffId, "recheck-required", { receiptDigest, responseDigest: historical.responseDigest, providerTurnId: historical.providerTurnId, detail: "Linked confirmed historical remediation idempotently; fresh source-bound QA required" }));
             }
             if (prior && prior.state !== "prepared") {
+                validateReplayBinding(read, input, prior);
                 const raw = prior.receiptDigest ? read.getEvidence(prior.receiptDigest) : undefined;
                 const receipt = raw ? JSON.parse(raw.toString()) : undefined;
                 const accepted = prior.state === "recheck-required" && read.qaRemediationAttempt(prior.operationId)?.status === "succeeded";
@@ -120,7 +127,8 @@ export class QaFailureDeliveryService {
         const preBoundary = await phase("source-before-preparation", () => captureFrozenQaSourceAsync(input.builderWorktree));
         if (preBoundary.digest !== input.reviewedSourceStateDigest)
             return this.drift(input, "source-drift-before-delivery", preBoundary.digest);
-        const findingRefs = createQaFindingRefs({ runId: input.runId, ticketId: input.ticket.id, reviewAttemptId: input.reviewAttemptId, reportDigest: input.reportDigest, rawFindingIds: input.report.findings.map(f => f.id) });
+        const chunkFindingIds = selectRemediationChunk(input);
+        const findingRefs = createQaFindingRefs({ runId: input.runId, ticketId: input.ticket.id, reviewAttemptId: input.reviewAttemptId, reportDigest: input.reportDigest, rawFindingIds: chunkFindingIds });
         const handoff = this.buildHandoff(input, preBoundary, findingRefs);
         let instruction = renderQaFailureHandoff(handoff) + (input.operatorAnswer ? `\nAuthorized operator answer (${input.operatorAnswer.decisionId}): ${JSON.stringify(input.operatorAnswer.answer)}` : "");
         enforceMandatoryPromptLimit(Buffer.from(instruction));
@@ -435,7 +443,7 @@ export class QaFailureDeliveryService {
             catch (caught) {
                 errors.push(String(caught));
             }
-            const contract = turn && !graphRequest ? parseBuilderQaRemediationContract(turn.cleanedResponse ?? turn.text, { handoffId: qaDigest("qa-failure-handoff", { runId: input.runId, ticketId: input.ticket.id, reviewAttemptId: input.reviewAttemptId, reportDigest: input.reportDigest, remediationGeneration: input.remediationGeneration + 1 }), findings: createQaFindingRefs({ runId: input.runId, ticketId: input.ticket.id, reviewAttemptId: input.reviewAttemptId, reportDigest: input.reportDigest, rawFindingIds: input.report.findings.map(f => f.id) }) }) : undefined;
+            const contract = turn && !graphRequest ? parseBuilderQaRemediationContract(turn.cleanedResponse ?? turn.text, { handoffId: qaDigest("qa-failure-handoff", { runId: input.runId, ticketId: input.ticket.id, reviewAttemptId: input.reviewAttemptId, reportDigest: input.reportDigest, remediationGeneration: input.remediationGeneration + 1 }), findings: createQaFindingRefs({ runId: input.runId, ticketId: input.ticket.id, reviewAttemptId: input.reviewAttemptId, reportDigest: input.reportDigest, rawFindingIds: selectRemediationChunk(input) }) }) : undefined;
             record.parserErrors = [...(contract?.errors ?? []), ...(turn?.continuityErrors ?? [])];
             record.validationErrors = errors;
             if (contract?.report)
@@ -524,9 +532,24 @@ export class QaFailureDeliveryService {
                 occurrenceId: reportOccurrenceId(input.runId, input.ticket.id, input.reviewNumber),
                 digest: input.reportDigest,
                 rawEvidenceDigest: input.reportDigest,
-                value: input.report,
+                // The complete report remains host-retained under rawEvidenceDigest.
+                // Builder receives only the bounded remediation chunk.
+                value: { ...input.report, findings: input.report.findings.filter((finding) => findingRefs.some((ref) => ref.rawId === finding.id)) },
                 findingRefs,
             },
+            remediationChunk: {
+                version: 1,
+                ordinal: input.remediationGeneration + 1,
+                findingIds: findingRefs.map((finding) => finding.rawId),
+                findingKeys: findingRefs.map((finding) => finding.findingKey),
+                sourceDigest: input.reviewedSourceStateDigest,
+                contractBinding: input.contractDigest
+                    ? { kind: "published-contract", digest: input.contractDigest }
+                    : { kind: "review-basis", digest: input.reviewBasisDigest },
+                reviewBasisDigest: input.reviewBasisDigest,
+                reviewAttemptId: input.reviewAttemptId,
+                finalIndependentReviewRequired: true,
+            },
             latestBuilderResult: {
                 rawResponseDigest: evidenceDigest(input.latestBuilderResult),
                 summaryDigest: evidenceDigest(latestSummary.text),
@@ -562,6 +585,8 @@ export function renderQaFailureHandoff(handoff) {
         `Remediation generation: ${handoff.scope.remediationGeneration}`,
         `Reviewed source digest: ${handoff.source.reviewedContentDigest}`,
         `Review basis digest: ${handoff.source.reviewBasisDigest}`,
+        `Contract binding: ${JSON.stringify(handoff.remediationChunk.contractBinding)}`,
+        `Remediation chunk: ${JSON.stringify(handoff.remediationChunk)}`,
         `Captured at: ${handoff.source.capturedAt}`,
         `Builder worktree: ${handoff.source.worktreePath}`,
         `Git directory: ${handoff.source.gitDir}`,
@@ -571,7 +596,7 @@ export function renderQaFailureHandoff(handoff) {
         `Latest Builder result digest: ${handoff.latestBuilderResult.rawResponseDigest}`,
         `Latest Builder result summary${handoff.latestBuilderResult.summaryTruncated ? " (truncated)" : ""}:\n${handoff.latestBuilderResult.summary}`,
         `Current validated QA failure report digest: ${handoff.report.digest}`,
-        `Current validated QA failure report:\n${JSON.stringify(handoff.report.value, null, 2)}`,
+        `Current validated QA remediation chunk:\n${JSON.stringify(handoff.report.value, null, 2)}`,
         `Raw QA finding ID to host finding key mapping:\n${findingMap}`,
         `Prior QA/report/remediation history:\n${handoff.history.length ? JSON.stringify(handoff.history, null, 2) : "(none)"}`,
         ...(handoff.plannerRemediation ? [
@@ -626,8 +651,9 @@ function boundedUtf8(text, maximumBytes) {
 function responseInstructions(handoff) {
     return [
         `QA failure handoff ID: ${handoff.handoffId}`,
-        `Required finding identities: ${JSON.stringify(handoff.report.findingRefs.map(f => ({ finding_key: f.findingKey, raw_id: f.rawId })))}`,
-        "Address, dispute with evidence, or mark blocked every current finding. A Builder claim never approves QA findings.",
+        `Required finding identities for this remediation chunk: ${JSON.stringify(handoff.report.findingRefs.map(f => ({ finding_key: f.findingKey, raw_id: f.rawId })))}`,
+        "Address, dispute with evidence, or mark blocked every finding in this remediation chunk. Do not address findings outside the chunk. A Builder claim never approves QA findings.",
+        "This is only a bounded remediation chunk. It does not approve the ticket. Any source change invalidates this chunk's source binding, and Rafi must perform a fresh full independent QA review afterward.",
         "The envelope must be the first non-empty content of the cleaned response. STEP_STATUS must be the final non-empty line. No prologue, trailing prose, duplicate keys, unknown or missing findings.",
         "In raw output, put the required RAFI_CONTINUITY_DELTA record between the envelope end and STEP_STATUS. The continuity wrapper removes only that record before contract validation.",
         `${BUILDER_QA_REMEDIATION_START}\n${JSON.stringify({ version: 3, handoff_id: handoff.handoffId, summary: "Truthful result", findings: handoff.report.findingRefs.map(f => ({ finding_key: f.findingKey, raw_id: f.rawId, disposition: "disputed", changes: ["Explain actual changes or why none were needed"], evidence: "Actual evidence", verification: [{ check: "Actual verification", outcome: "not_run", evidence: "Actual reason" }] })), observations: [] })}\n${BUILDER_QA_REMEDIATION_END}\nSTEP_STATUS: done | summary="short truthful summary"`,
@@ -636,6 +662,56 @@ function responseInstructions(handoff) {
         `Authoritative V3 schema: ${JSON.stringify(builderQaRemediationReportV3Schema)}`,
     ].join("\n\n");
 }
+export function selectQaRemediationFindingIds(report) {
+    const ids = report.findings.slice(0, QA_REMEDIATION_CHUNK_SIZE).map((finding) => finding.id);
+    if (!ids.length)
+        throw new Error("QA remediation cannot create a chunk without a validated finding");
+    return ids;
+}
+function selectRemediationChunk(input) {
+    return selectQaRemediationFindingIds(input.report);
+}
+function currentPublishedContractDigest(db, input) {
+    if (!input.contractDigest)
+        return undefined;
+    const admission = db.assertAdmittedWork(input.runId, input.ticket.id);
+    const preparation = db.qaPreparationStore();
+    const contractHead = preparation.head(input.runId, input.ticket.id, admission.requirementsDigest);
+    return contractHead.state === "ready" && contractHead.digest ? preparation.contract(contractHead.digest).contentDigest : undefined;
+}
+function validateReplayBinding(db, input, prior) {
+    if (!prior || prior.runId !== input.runId || prior.ticketId !== input.ticket.id || prior.reviewAttemptId !== input.reviewAttemptId
+        || prior.reportDigest !== input.reportDigest || prior.generation !== input.remediationGeneration + 1
+        || prior.reviewedContentDigest !== input.reviewedSourceStateDigest || prior.reviewBasisDigest !== input.reviewBasisDigest) {
+        throw new Error("Replayed QA remediation handoff does not match the current review, source, or review basis");
+    }
+    if (input.contractDigest && currentPublishedContractDigest(db, input) !== input.contractDigest) {
+        throw new Error("Replayed QA remediation handoff has a stale or changed host-published contract binding");
+    }
+    if (prior.handoffDigest) {
+        const raw = db.getEvidence(prior.handoffDigest);
+        if (!raw)
+            throw new Error("Replayed QA remediation handoff is missing its durable request evidence");
+        const handoff = JSON.parse(raw.toString());
+        const chunk = handoff.remediationChunk;
+        const expectedBinding = input.contractDigest
+            ? { kind: "published-contract", digest: input.contractDigest }
+            : { kind: "review-basis", digest: input.reviewBasisDigest };
+        // Older durable handoffs predate chunk metadata. Their review/source/basis
+        // bindings were checked above; preserve idempotent recovery for those
+        // records, while requiring complete chunk metadata for new handoffs.
+        if (!chunk)
+            return;
+        const legacyChunk = chunk;
+        const storedBinding = chunk.contractBinding ?? (typeof legacyChunk.contractDigest === "string"
+            ? { kind: input.contractDigest ? "published-contract" : "review-basis", digest: legacyChunk.contractDigest }
+            : undefined);
+        if (chunk.sourceDigest !== input.reviewedSourceStateDigest || chunk.reviewBasisDigest !== input.reviewBasisDigest
+            || chunk.reviewAttemptId !== input.reviewAttemptId || storedBinding?.kind !== expectedBinding.kind || storedBinding?.digest !== expectedBinding.digest) {
+            throw new Error("Replayed QA remediation chunk binding is stale or incomplete");
+        }
+    }
+}
 function validateReviewBinding(db, input) {
     const report = db.qaReport(input.reportDigest, { runId: input.runId, ticketId: input.ticket.id, reviewNumber: input.reviewNumber });
     const attempt = db.qaReviewAttempt(input.reviewAttemptId);
@@ -649,6 +725,11 @@ function validateReviewBinding(db, input) {
         || head.reviewBasisDigest !== input.reviewBasisDigest || !head.openReportDigests.includes(input.reportDigest)) {
         throw new Error("Builder remediation binding does not match the current failed review and open report occurrence");
     }
+    if (input.contractDigest) {
+        const currentContractDigest = currentPublishedContractDigest(db, input);
+        if (currentContractDigest !== input.contractDigest)
+            throw new Error("Builder remediation contract binding is stale or does not match the host-published QA contract");
+    }
     return head;
 }
 function canonicalEvidence(value) { return canonicalJson(JSON.parse(JSON.stringify(value))); }

package/dist/qaHostFacts.d.ts

@@ -0,0 +1,2 @@
+/** A read-only configuration observation, not a graph scan or proof about external Graphify installations. */
+export declare function qaHostGraphFact(projectDir: string): string;

package/dist/qaHostFacts.js

@@ -0,0 +1,11 @@
+import { loadGraphConfig } from "./graph/config.js";
+/** A read-only configuration observation, not a graph scan or proof about external Graphify installations. */
+export function qaHostGraphFact(projectDir) {
+    try {
+        const graph = loadGraphConfig(projectDir);
+        return `Host observation of Rafi-managed graph configuration: ${JSON.stringify({ adoption: graph.adoption ? "recorded" : "not-recorded", enabled: graph.enabled, reason: graph.reason })}. This describes only Rafi-managed graph adoption at observation time, not any external Graphify installation; assess applicable project rules and any evidence of external adoption separately.`;
+    }
+    catch {
+        return "Host observation of Rafi-managed graph configuration is unavailable; do not assume it is adopted or unadopted.";
+    }
+}

package/dist/qaPreparation.d.ts

@@ -1,19 +1,23 @@
-import type { QaContractCandidateV1, RequirementRef, QaVerificationContractV1 } from "rafi-spec";
+import type { QaContractCandidateV1, QaSemanticAssessmentV1, RequirementRef, QaVerificationContractV1 } from "rafi-spec";
 import type { QaPreparationStore, LogicalPreparationBudget } from "./qaPreparationStore.js";
 export interface PreparationProviderResult {
     operationId?: string;
     text: string;
     sessionId: string;
     graphReceiptRefs?: string[];
+    workspacePaths?: Record<string, string>;
     usage?: Partial<LogicalPreparationBudget["usage"]>;
 }
 export interface PreparationDependencies {
     store: QaPreparationStore;
     now(): number;
+    /** Provider-specific wording is allowed; contract ownership is not. */
+    provider?: "claude" | "codex";
     /** Each dispatch is a fresh, confined conversation, with a persisted reservation. */
     dispatch(phase: "planner" | "prepare" | "assess" | "challenge" | "repair", instruction: string, operationId: string, remainingMs: number): Promise<PreparationProviderResult>;
     inputsCurrent(candidate: QaContractCandidateV1): boolean;
     normalizeDraft?(draft: QaContractCandidateV1, response: PreparationProviderResult): QaContractCandidateV1;
+    hostFacts?: string;
 }
 export type PreparationOutcome = {
     status: "ready";
@@ -23,4 +27,37 @@ export type PreparationOutcome = {
     detail: string;
     nextAction: string;
 };
+export declare const FILE_SCOPE_GUIDANCE = "File lists in plans and tickets, including likely_files and generated file-only diff expectations, are estimates of implementation, not exhaustive boundaries. Different named files or an extra relevant file do not by themselves create a material conflict or block the build. Retain and assess every original requirement; for file-list checks verify that changes serve the approved work rather than requiring an exact file list or a pre-edit snapshot proving no other files changed. Rafi owns tracker lifecycle updates. Generated instructions to mark a ticket done in a document are bookkeeping, not a Builder acceptance criterion or a material conflict; do not require the Builder to perform them, and do not require the host to amend the plan before building. Do not disregard explicit user-established security, privacy, access, or other safety restrictions, or expand the approved product functionality. Report genuine substantive or safety conflicts.";
+export declare const ROLLBACK_VERIFICATION_GUIDANCE = "When an original requirement explicitly asks to verify that rollback restores behavior, specify concrete future verification evidence rather than only inspecting rollback prose. A rollback plan alone does not require a rollback execution or mutation-testing rehearsal. For an npm test project where current uncommitted product changes represent the change to rehearse, the Builder may run rafi qa-rehearse-rollback alone from the project root; it runs npm test before and after reverting a synthetic commit of all uncommitted product changes in an independent temporary repository. It also runs git diff --exit-code against the captured pre-change HEAD after the revert and tests; success proves the tracked files match that baseline. For a requirement that a particular string be absent after rollback, inspecting its absence in the captured baseline plus that successful whole-tree comparison is concrete evidence of absence in the reverted tracked file. The rehearsal cannot use installed dependencies or symbolic links and does not prove ticket isolation or that an actual existing ticket commit was reverted. Assess whether this evidence satisfies the original requirement; do not claim it does when the original explicitly requires the actual ticket commit. Do not assume copying files to external scratch, arbitrary scripts or mutation experiments are allowed. If actual rollback execution is explicitly required but no permitted method satisfies it, report the limitation. Never perform destructive rollback in the source workspace or claim a rehearsal has already happened.";
+export declare const EXECUTABLE_CHECK_GUIDANCE = "Choose verification procedures compatible with the Builder's project permissions and workspace. Documentation is disabled unless the host-bound contract documentation.required is true. When it is false, do not invent documentation checks merely because a docs directory or API-looking path exists; an absent documentation surface is not a failure. When it is true, use only the contract's exact targets and criteria, and define an actionable absent-target outcome. Do not invent mandatory inline node -e or node --eval commands: the Builder policy may refuse them. For a JavaScript behavior or export check, prefer a project-local test file executed with the project's existing test command, or a permitted node --test invocation. Do not invent a mandatory test-first RED phase or other historical sequence merely because a plan requires tests before and after implementation: a passing baseline test is not a failing new test. When an original requirement actually requires a historical sequence, preserve it and specify concrete independently reviewable evidence paths or retained host events for each required step; a generic statement that sequencing evidence exists is not actionable, and a later passing test does not prove past events. If the project policy makes raw stdout redirection or scratch-log creation unavailable, do not turn log-file capture into a blocker: use the retained bounded tool output and host events instead, and never cite a scratch path unless that exact file was successfully created and inspected. The independent QA snapshot may have a detached HEAD even when the Builder source workspace is on a branch; do not use its branch name to infer the Builder source branch. Diff and scope checks must compare the current snapshot with the captured pre-implementation baseline, not blindly with repository HEAD: previously approved or completed ticket changes are part of that baseline and must not be reported as new work. A scope check must first enumerate every changed path outside the explicit bookkeeping/evidence exclusions, then compare that complete host-observed set with the approved product/ticket scope; do not pre-filter the list to expected filenames, because that would hide accidental extra product edits. Bounded evidence-only paths such as scratch/ are not product scope and must be excluded from product-path scope checks while their retained evidence remains subject to QA review. For a current-branch multi-ticket build, do not invent a mandatory branch-alone execution check merely to prove ticket independence; use baseline-aware source/test inspection and the permitted project tests unless the original requirement explicitly requires an actual isolated execution. For additive tickets in a current-branch multi-ticket build, \u201Cacceptable on its own\u201D is satisfied by showing that each ticket's own tests import and exercise only its own feature, pass with the shared baseline and required project tests, and do not depend on the sibling feature; do not require removing another additive feature or perform a destructive rollback experiment unless the approved requirement explicitly requires absence testing or an isolated branch. Preserve explicitly requested procedures and substantive requirements; if a required procedure cannot be run, identify the limitation rather than claiming it was executed. Independently assess whether proposed evidence actually tests the required behavior.";
+/** Baseline bookkeeping must not block ordinary approved implementation work. */
+export declare const APPROVED_PATH_BASELINE_GUIDANCE = "Baseline membership is host-owned bookkeeping, not a Builder requirement. An approved product path, export, or test file is not a material QA concern merely because the provider cannot prove whether it was present before implementation. Do not reconstruct or disclose the full baseline, and do not turn that uncertainty into an unresolved concern. Rafi performs the exact host comparison. Do not author a provider-executed check that asks for Rafi's host postimplementation path manifest, complete changed-path inventory, or unchanged-file comparison; that host-owned comparison is already performed outside the provider snapshot and must be represented by the retained host observation, not by raw manifest disclosure or a provider check. For current-branch additive tickets, a provider-authored or inferred request to test the branch with an already-completed sibling feature removed is not an applicable requirement when the approved scope says not to remove or reconstruct that sibling; verify the ticket's own behavior and tests against the shared baseline instead. Treat sibling-absence testing as binding only when the user explicitly approved that absence requirement. Escalate only an actual host-observed out-of-scope, destructive, protected-file, or requirement-relevant change.";
+/** Ignore known non-authoritative annotations; the original provider response remains retained. */
+export declare function normalizeAssessmentMetadata<T extends QaSemanticAssessmentV1>(assessment: T): T;
+/** Accept only an exact known obligation label when a provider wraps it in a
+ * descriptive object. This is a representation repair, not a host decision:
+ * unknown or ambiguous objects remain unchanged and fail schema validation. */
+export declare function normalizeAssessmentObligations<T extends QaSemanticAssessmentV1>(assessment: T, allowed: string[]): T;
+/** A preparation assessor must not block on the expected absence of future
+ * Builder work. Keep the concern for auditability, but make it non-material
+ * only when every referenced check is postimplementation and the concern is
+ * explicitly asking the Builder to implement/rerun that check. Concerns tied
+ * to preimplementation checks, missing procedures, or other semantic gaps
+ * remain blocking. */
+export declare function normalizeExpectedFutureAssessment<T extends QaSemanticAssessmentV1>(assessment: T, candidate: QaContractCandidateV1): T;
+/**
+ * A mandatory requirement must have at least one mandatory verification check.
+ * Providers occasionally return a concrete check with the weaker advisory
+ * label. Promote the existing covering check at the host boundary; never
+ * invent a check, evidence, or requirement, and let the normal validator still
+ * enforce readiness and independent-QA requirements for the promoted check.
+ */
+export declare function enforceMandatoryCoverage(candidate: QaContractCandidateV1): QaContractCandidateV1;
+/**
+ * Codex occasionally appends a made-up requirement ID to an otherwise valid
+ * check. Remove only those extraneous annotations when the check still has an
+ * exact authoritative reference. Never invent or remap an ID, and leave a
+ * check with no valid references untouched so normal validation fails closed.
+ */
+export declare function removeExtraneousRequirementReferences(candidate: QaContractCandidateV1, inventory: RequirementRef[]): QaContractCandidateV1;
 export declare function prepareVerificationContract(initial: QaContractCandidateV1, inventory: RequirementRef[], deps: PreparationDependencies): Promise<PreparationOutcome>;