ai-foreman 1.7.28 → 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/qaPreparationStore.js

@@ -9,7 +9,7 @@ export function migrateQaPreparation(db) {
     db.exec(`
     CREATE TABLE IF NOT EXISTS qa_preparation_policy(run_id TEXT PRIMARY KEY REFERENCES workflow_runs(run_id),record_json TEXT NOT NULL);
     CREATE TABLE IF NOT EXISTS qa_preparation_budgets(id TEXT PRIMARY KEY,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),work_id TEXT NOT NULL,admission_digest TEXT NOT NULL,record_json TEXT NOT NULL,UNIQUE(run_id,work_id,admission_digest));
-    CREATE TABLE IF NOT EXISTS qa_depth_decisions(decision_id TEXT PRIMARY KEY,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),work_id TEXT NOT NULL,record_json TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS qa_depth_decisions(decision_id TEXT NOT NULL,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),work_id TEXT NOT NULL,admission_digest TEXT NOT NULL,record_json TEXT NOT NULL,PRIMARY KEY(decision_id,run_id,work_id,admission_digest));
     CREATE TABLE IF NOT EXISTS qa_preparation_attempts(operation_id TEXT PRIMARY KEY,budget_id TEXT NOT NULL REFERENCES qa_preparation_budgets(id),state TEXT NOT NULL,intent_json TEXT NOT NULL,result_json TEXT);
     CREATE TABLE IF NOT EXISTS qa_preparation_progress(budget_id TEXT NOT NULL REFERENCES qa_preparation_budgets(id),stage TEXT NOT NULL,digest TEXT NOT NULL,PRIMARY KEY(budget_id,stage));
     CREATE TABLE IF NOT EXISTS qa_verification_contracts(digest TEXT PRIMARY KEY,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),work_id TEXT NOT NULL,admission_digest TEXT NOT NULL,revision INTEGER NOT NULL,record_json TEXT NOT NULL,UNIQUE(run_id,work_id,admission_digest,revision));
@@ -19,6 +19,7 @@ export function migrateQaPreparation(db) {
     CREATE TABLE IF NOT EXISTS qa_contract_artifacts(digest TEXT PRIMARY KEY,kind TEXT NOT NULL,record_json TEXT NOT NULL);
     CREATE TABLE IF NOT EXISTS qa_preparation_events(event_id TEXT PRIMARY KEY,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),work_id TEXT NOT NULL,kind TEXT NOT NULL,record_json TEXT NOT NULL);
   `);
+    migrateQaDepthDecisions(db);
     for (const table of ["qa_preparation_policy", "qa_depth_decisions", "qa_verification_contracts", "qa_contract_check_history", "qa_contract_receipts", "qa_contract_artifacts", "qa_preparation_events"]) {
         for (const action of ["UPDATE", "DELETE"])
             db.exec(`CREATE TRIGGER IF NOT EXISTS preparation_immutable_${table}_${action} BEFORE ${action} ON ${table} BEGIN SELECT RAISE(ABORT,'Preparation authority and evidence are immutable'); END`);
@@ -33,6 +34,35 @@ export function migrateQaPreparation(db) {
             db.exec(`CREATE TRIGGER IF NOT EXISTS preparation_owner_${table}_${action} BEFORE ${action} ON ${table} BEGIN SELECT CASE WHEN rafi_qa_preparation_owner(${expression})<>1 THEN RAISE(ABORT,'Original preparation owner required') END; END`);
         }
 }
+/** Provider decision ids are scoped to the admitted preparation, not global. */
+function migrateQaDepthDecisions(db) {
+    const columns = db.prepare("PRAGMA table_info(qa_depth_decisions)").all();
+    if (!columns.length || columns.some(column => column.name === "admission_digest"))
+        return;
+    db.transaction(() => {
+        for (const action of ["INSERT", "UPDATE", "DELETE"]) {
+            db.exec(`DROP TRIGGER IF EXISTS preparation_immutable_qa_depth_decisions_${action}`);
+            db.exec(`DROP TRIGGER IF EXISTS preparation_owner_qa_depth_decisions_${action}`);
+            db.exec(`DROP TRIGGER IF EXISTS preparation_lease_qa_depth_decisions_${action}`);
+        }
+        db.exec("CREATE TABLE qa_depth_decisions_scoped(decision_id TEXT NOT NULL,run_id TEXT NOT NULL REFERENCES workflow_runs(run_id),work_id TEXT NOT NULL,admission_digest TEXT NOT NULL,record_json TEXT NOT NULL,PRIMARY KEY(decision_id,run_id,work_id,admission_digest))");
+        db.exec("INSERT INTO qa_depth_decisions_scoped(decision_id,run_id,work_id,admission_digest,record_json) SELECT decision_id,run_id,work_id,COALESCE(NULLIF(json_extract(record_json,'$.admissionDigest'),''),'legacy:' || run_id || ':' || work_id),record_json FROM qa_depth_decisions");
+        db.exec("DROP TABLE qa_depth_decisions");
+        db.exec("ALTER TABLE qa_depth_decisions_scoped RENAME TO qa_depth_decisions");
+        for (const action of ["INSERT", "UPDATE", "DELETE"]) {
+            const row = action === "DELETE" ? "OLD" : "NEW";
+            db.exec(`CREATE TRIGGER preparation_immutable_qa_depth_decisions_${action} BEFORE ${action} ON qa_depth_decisions BEGIN SELECT RAISE(ABORT,'Preparation authority and evidence are immutable'); END`);
+            const ownerRow = action === "DELETE" ? "OLD" : "NEW";
+            db.exec(`CREATE TRIGGER preparation_owner_qa_depth_decisions_${action} BEFORE ${action} ON qa_depth_decisions BEGIN SELECT CASE WHEN rafi_qa_preparation_owner(${ownerRow}.run_id)<>1 THEN RAISE(ABORT,'Original preparation owner required') END; END`);
+            const leaseRun = ownerRow;
+            db.exec(`CREATE TRIGGER preparation_lease_qa_depth_decisions_${action} BEFORE ${action} ON qa_depth_decisions
+        WHEN (EXISTS(SELECT 1 FROM build_admission) OR rafi_build_writer_run()<>'' OR EXISTS(SELECT 1 FROM build_runtime_runs WHERE run_id=${leaseRun}.run_id))
+        AND NOT EXISTS(SELECT 1 FROM build_admission WHERE json_extract(record_json,'$.token')=rafi_build_writer_token() AND (json_extract(record_json,'$.runId')=${leaseRun}.run_id OR EXISTS(SELECT 1 FROM build_child_runs WHERE child=${leaseRun}.run_id AND parent=json_extract(record_json,'$.runId'))))
+        AND NOT (NOT EXISTS(SELECT 1 FROM build_admission) AND EXISTS(SELECT 1 FROM project_lease WHERE owner=rafi_build_lease_owner() AND generation=rafi_build_lease_generation() AND run_id=${leaseRun}.run_id))
+        BEGIN SELECT RAISE(ABORT,'Preparation requires the original durable lease generation'); END`);
+        }
+    })();
+}
 /** Tagged enforcing authority also fences older callers that omit new fields. */
 export function migrateQaPreparationGuards(db) {
     const scopes = {
@@ -242,13 +272,11 @@ export class QaPreparationStore {
             current.level = decision.level;
             current.deadlineMs = Math.max(current.deadlineMs, current.startMs + current.policy.wallTimeMs[decision.level - 1]);
             this.saveBudget(current);
-            const prior = this.read("qa_depth_decisions", "decision_id", decision.decisionId);
-            const priorScope = this.db.prepare("SELECT run_id,work_id FROM qa_depth_decisions WHERE decision_id=?").get(decision.decisionId);
-            if (priorScope && (priorScope.run_id !== budget.runId || priorScope.work_id !== budget.workId))
-                throw new Error("Planner depth identity belongs to another admitted work");
+            const priorRow = this.db.prepare("SELECT record_json FROM qa_depth_decisions WHERE decision_id=? AND run_id=? AND work_id=? AND admission_digest=?").get(decision.decisionId, budget.runId, budget.workId, budget.admissionDigest);
+            const prior = priorRow ? this.decode(priorRow.record_json) : undefined;
             if (prior && this.protectedJson(prior) !== this.protectedJson(decision))
                 throw new Error("Conflicting planner depth identity");
-            this.db.prepare("INSERT INTO qa_depth_decisions VALUES(?,?,?,?) ON CONFLICT(decision_id) DO NOTHING").run(decision.decisionId, budget.runId, budget.workId, this.protectedJson(decision));
+            this.db.prepare("INSERT INTO qa_depth_decisions VALUES(?,?,?,?,?) ON CONFLICT(decision_id,run_id,work_id,admission_digest) DO NOTHING").run(decision.decisionId, budget.runId, budget.workId, budget.admissionDigest, this.protectedJson(decision));
         });
     }
     retainProgress(budget, stage, value) {

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 = {}) {