ai-foreman 1.7.29 → 2.0.0

package/dist/qaPreparationInputs.js

@@ -45,6 +45,25 @@ export function admittedPlanInput(projectDir, ticket) {
                 requirements.push({ id: `req-plan-${fingerprint.slice(0, 24)}-${occurrence}`, inputRef: input.id, locator: `${location}${field}[${index}]`, statement, digest: contractDigest("statement", statement), obligation: "mandatory", origin: "explicit", authority: "approved" });
             });
         }
+        if (slice.verification_version === 2) {
+            for (const requirement of slice.verification_requirements ?? []) {
+                const statement = requirement.summary;
+                requirements.push({
+                    id: `req-plan-v2-${slice.slice_ref}-${requirement.id}`,
+                    inputRef: input.id,
+                    locator: `slices.${slice.slice_ref}.verification_requirements.${requirement.id}`,
+                    statement,
+                    // A RequirementRef's historical digest domain is its statement.
+                    // Keep that invariant and bind the executable V2 intent separately.
+                    digest: contractDigest("statement", statement),
+                    verificationIntentDigest: contractDigest("verification-intent-v2", requirement),
+                    obligation: "mandatory",
+                    origin: "explicit",
+                    authority: "approved",
+                    verificationIntent: structuredClone(requirement),
+                });
+            }
+        }
         return { input, plan, requirements };
     }
     throw new Error("Exact admitted approved-plan revision unavailable; restore its immutable artifact before preparation");

package/dist/qaPrerequisites.d.ts

@@ -6,10 +6,11 @@ export interface QaPrerequisiteEvidence {
     checkedAt: string;
     /** Host absence is actionable; host availability never proves provider access. */
     authority: "host-preflight";
+    /** not_applicable: a typed applicability condition is false, so the requirement does not apply (never a missing prerequisite). */
     checks: Array<{
         requirement: string;
         capability: string;
-        outcome: "available" | "not_run";
+        outcome: "available" | "not_run" | "not_applicable";
         evidence: string;
     }>;
     sourceDefects: string[];

package/dist/qaPrerequisites.js

@@ -17,12 +17,32 @@ export async function checkQaPrerequisites(input) {
     catch { /* malformed manifests remain source findings */ }
     const evidence = {
         version: 3, snapshotPath: realpathSync(input.snapshotPath), checkedAt: new Date().toISOString(), authority: "host-preflight",
-        scopeDigest: qaDigest("qa-prerequisites-v3", { sourceDigest: input.sourceDigest, snapshotPath: realpathSync(input.snapshotPath), manifests, node: process.version, path: env.PATH ?? "", runtimeContext: input.runtimeContext ?? null, requirements: input.ticket.required_tests }),
+        scopeDigest: qaDigest("qa-prerequisites-v4", { sourceDigest: input.sourceDigest, snapshotPath: realpathSync(input.snapshotPath), manifests, node: process.version, path: env.PATH ?? "", runtimeContext: input.runtimeContext ?? null, requirements: input.ticket.verification_version === 2 ? input.ticket.verification_requirements : input.ticket.required_tests }),
         checks: [], sourceDefects: [],
     };
     const probe = input.probe ?? ((executable, args) => new Promise(resolve => {
         execFile(executable, args, { cwd: input.snapshotPath, env, timeout: timeoutMs, maxBuffer: 4096, windowsHide: true }, error => resolve(!error));
     }));
+    // V2 never extracts or executes a command from provider prose. Its closed
+    // probe vocabulary is resolved by the host and records availability only.
+    if (input.ticket.verification_version === 2) {
+        for (const requirement of input.ticket.verification_requirements ?? []) {
+            if (requirement.applicability.kind !== "host-executable-available")
+                continue;
+            const executable = resolveExecutablePath(requirement.applicability.executable, env);
+            const available = Boolean(executable);
+            const expected = requirement.applicability.expected;
+            evidence.checks.push({
+                requirement: requirement.id,
+                capability: `host-probe:executable-available:${requirement.applicability.executable}`,
+                outcome: available === expected ? "available" : "not_applicable",
+                evidence: `Host registry resolved executable availability=${available}; expected=${expected}; ${available === expected ? "requirement applies" : "requirement does not apply"}; snapshot=${evidence.snapshotPath}`,
+            });
+        }
+        return evidence;
+    }
+    // V1 compatibility only: historical prose is read conservatively and never
+    // promoted to a typed applicability condition.
     for (const requirement of input.ticket.required_tests) {
         const command = /^\s*`?(pnpm|npm|yarn|bun|node|docker|python3|pytest|cargo|go)\b/.exec(requirement)?.[1];
         if (command) {

package/dist/qaProtocolV2.d.ts

@@ -73,6 +73,13 @@ export interface QaSessionHandleV2 {
     acceptedHandoffReceiptDigest?: string;
 }
 export interface QaTurnIntentV2 {
+    sealedDispatch?: import("./structuredDispatchRecord.js").SealedDispatchRecordV2;
+    outputContract?: {
+        protocolVersion: 2;
+        operation: string;
+        schemaVersion: number;
+        schemaDigest: string;
+    };
     version: 2;
     operationId: string;
     runId: string;
@@ -87,6 +94,14 @@ export interface QaTurnIntentV2 {
     intendedAt: string;
 }
 export interface QaTurnReceiptV2 {
+    retainedEvidence?: {
+        rawOriginalBytes?: number;
+        rawRetainedBytes?: number;
+        cleanedOriginalBytes: number;
+        cleanedRetainedBytes: number;
+    };
+    sealedDispatch?: import("./structuredDispatchRecord.js").SealedDispatchRecordV2;
+    structuredResponseDigest?: string;
     version: 2;
     operationId: string;
     dispatch: "not-dispatched" | "completed" | "uncertain";

package/dist/qaRecovery.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { chmodSync, closeSync, cpSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readlinkSync, readdirSync, realpathSync, renameSync, writeFileSync, } from "node:fs";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
-import { parseProviderContract, parseQaFailureReport, qaRecoveryAcknowledgementV1Schema } from "rafi-spec";
+import { parseProviderContract, parseStrictJson, validateQaFailureReport, QA_FAILURE_REPORT_MAX_BYTES, qaRecoveryAcknowledgementV1Schema } from "rafi-spec";
 import { calculateFrozenQaStateDigest, captureFrozenQaSource } from "./qaSnapshot.js";
 import { WorkflowDb } from "./workflowDb.js";
 export const QA_RECOVERY_ROOT = ".foreman/qa-report-recovery";
@@ -81,6 +81,8 @@ export function canonicalizeQaRecoveryRequirements(packet) {
     return revise(loaded, { resources });
 }
 export function loadQaRecoveryPacket(directory) {
+    if (existsSync(join(directory, ".structured-communication-v2-cutover")))
+        throw new Error("structured-communication-v2-cutover: this recovery packet cannot resume; start a new native dispatch");
     const root = resolve(directory);
     const manifestPath = join(root, "manifest.json");
     if (!existsSync(manifestPath) || lstatSync(manifestPath).isSymbolicLink())
@@ -455,7 +457,22 @@ export function readManualQaReport(packetDirectory) { return JSON.parse(readFile
 export function validateManualQaReport(packet) {
     const path = join(packet.directory, "report.json");
     const raw = existsSync(path) ? readFileSync(path) : Buffer.alloc(0);
-    const parsed = parseQaFailureReport(raw.toString());
+    let value;
+    let errors = [];
+    if (raw.length > QA_FAILURE_REPORT_MAX_BYTES)
+        errors = [`serialized report exceeds ${QA_FAILURE_REPORT_MAX_BYTES} bytes`];
+    else {
+        try {
+            value = parseStrictJson(raw.toString());
+        }
+        catch (error) {
+            errors = [`invalid JSON: ${String(error)}`];
+        }
+        if (!errors.length)
+            errors = validateQaFailureReport(value).errors;
+    }
+    const parsed = { report: errors.length ? undefined : value,
+        validation: { valid: errors.length === 0, errors } };
     let next = appendQaRecoveryResource(packet, `validation/manual-repair-r${packet.manifest.revision + 1}.json`, parsed.validation, { purpose: "Validation result for the latest operator-edited report.json" });
     const editable = writeEditableReport(packet.directory, raw);
     next = revise(next, { resources: next.manifest.resources.filter((resource) => resource.path !== "report.json").concat(editable).sort(resourceOrder) });
@@ -499,8 +516,8 @@ export function renderQaRecoveryAcknowledgementInstruction(packet, relativePath)
         `Packet digest: ${packet.manifest.packetDigest}`,
         `Reviewed-state digest: ${packet.manifest.reviewedStateDigest}`,
         "Required resources:", required,
-        "Reply with exactly the following acknowledgement line, followed by the required RAFI_CONTINUITY_DELTA record:",
-        `RAFI_QA_RECOVERY_ACK packet="${packet.manifest.packetDigest}" reviewed_state="${packet.manifest.reviewedStateDigest}" required_resources_read="all"`,
+        "Return the following payload in the native qa-recovery-acceptance response, with bounded continuity in the same object:",
+        JSON.stringify({ packet: packet.manifest.packetDigest, reviewed_state: packet.manifest.reviewedStateDigest, required_resources_read: "all" }),
     ].join("\n");
 }
 export function validateQaRecoveryAcknowledgement(text, packet, options = {}) {