ai-foreman 1.7.27 → 1.7.28

package/dist/cli/start.d.ts

@@ -5,7 +5,7 @@ import type { AgentRoleDefaultsV1 } from "rafi-spec";
 import type { BranchPlan } from "../branch/types.js";
 import { type DeliveryConfig, type DeliveryStack } from "../tickets/delivery.js";
 import type { QaNonconvergenceContext, QaNonconvergenceDecision, QaReportRecoveryHandler } from "../qaReview.js";
-import { RunObserver } from "../observability.js";
+import { RunObserver, type ObservabilityMode } from "../observability.js";
 export declare function formatStartResumeCommand(executable: "ai-foreman", projectDir: string, steps: number, sessionId: string): string;
 export declare function formatResumeGuidance(executable: "rafi" | "ai-foreman", projectDir: string, steps: number, sessionId?: string, run?: {
     runId: string;
@@ -22,6 +22,7 @@ export declare function formatResumeGuidance(executable: "rafi" | "ai-foreman",
 export declare function savedStartArguments(command: Command, projectDir: string, opts: Record<string, unknown>): string[];
 /** Pure validation shared by interactive start and persisted preparation. */
 export declare function validateStartOptions(opts: Record<string, any>, requireCount: boolean): void;
+export declare function resolveAuditLoggingMode(cli: unknown, configured: unknown, environment?: string | undefined): ObservabilityMode;
 /** Preserve the distinction between a staged handoff and an unattempted acceptance. */
 export declare function recordHandoffAcceptanceNotAttempted(projectDir: string, runId: string, role: "builder" | "qa", generation: number, stage: string, detail: string): void;
 /** Default start selection is deliberately the same eligibility model users see in the ticket queue. */

package/dist/cli/start.js

@@ -426,6 +426,20 @@ export function validateStartOptions(opts, requireCount) {
         throw new Error("Preparation launch requires both run and token");
     if (opts.launchToken && !opts.preparationRun && !opts.recoverRun)
         throw new Error("Launch token requires a preparation or recovery run");
+    if (opts.auditLogging !== undefined && !["off", "summary", "trace"].includes(String(opts.auditLogging)))
+        throw new Error("--audit-logging must be off, summary, or trace");
+}
+export function resolveAuditLoggingMode(cli, configured, environment = process.env.RAFI_AUDIT_LOGGING) {
+    const value = cli ?? configured ?? environment ?? "summary";
+    if (!["off", "summary", "trace"].includes(String(value)))
+        throw new Error("audit logging must be off, summary, or trace");
+    return String(value);
+}
+function configuredAuditLoggingMode(path) {
+    if (!existsSync(path))
+        return undefined;
+    const raw = parseYaml(readFileSync(path, "utf8"));
+    return raw?.observability?.mode === undefined ? undefined : resolveAuditLoggingMode(undefined, raw.observability.mode, undefined);
 }
 /** A current waiver is an already-recorded decision: surface it, never demand a second start-time approval. */
 function warnRiskPlanWaivers(projectDir, ticketIds) {
@@ -545,6 +559,7 @@ export function buildStartCommand(options = {}) {
         .option("--base <ref>", "base ref for root ticket branches (default: current branch or HEAD)")
         .option("--branch-prefix <prefix>", "branch name prefix for ticket branches")
         .option("--show-session-cost", "show authoritative cost or trustworthy cumulative session tokens for Builder and QA")
+        .option("--audit-logging <mode>", "host-owned audit logging (off | summary | trace)", "summary")
         .option("--hide-session-cost", "hide session cost/token usage for Builder and QA")
         .option("--auto-compact-threshold <percent>", "initial Builder context compaction threshold (1-99)")
         .option("--max-branch-depth <n>", "maximum selected branch stack depth", "5")
@@ -676,6 +691,7 @@ export function buildStartCommand(options = {}) {
             const readinessOwner = { project: cwd, runId: supervisedInvocationId, authority: localBuildAuthority(cwd) };
             const autoApprovePlanUpdates = recoveryRecord
                 ? recoveryRecord.recoveryDecision?.planUpdateApproval === "auto"
+                    && (recoveryRecord.recoveryDecision.planUpdateApprovalSource === "explicit-yes" || recoveryRecord.recoveryDecision.planUpdateApprovalSource === "explicit-choice")
                 : Boolean(opts.yes);
             if (opts.recoveryMode) {
                 const allowed = ["exact-session", "fresh-with-handoff", "fresh-recovery-only", "guided-recovery"];
@@ -934,6 +950,8 @@ export function buildStartCommand(options = {}) {
                 ? recoveryExecutionTickets(recoveryRecord, requestedTicketIds, Boolean(opts.recoveryMode))
                 : selectedNewTicket ? [selectedNewTicket] : undefined;
             const config = loadConfig(join(cwd, "foreman.yaml"));
+            const auditLogging = resolveAuditLoggingMode(command.getOptionValueSource("auditLogging") === "cli" ? opts.auditLogging : undefined, configuredAuditLoggingMode(join(cwd, "foreman.yaml")));
+            const observabilityConfig = { ...config.observability, mode: auditLogging, enabled: auditLogging !== "off" };
             const stamp = new Date().toISOString().replace(/[:.]/g, "-");
             const logPath = join(cwd, ".foreman", `${stamp}.jsonl`);
             const log = new Log(logPath);
@@ -948,9 +966,9 @@ export function buildStartCommand(options = {}) {
                 console.error(`rafi: warning: ${qaResolution.deprecationWarning}`);
             const invocationRunId = supervisedInvocationId;
             let observabilityStore;
-            if (config.observability.enabled) {
+            if (observabilityConfig.enabled) {
                 try {
-                    observabilityStore = new ObservabilityStore(cwd, { config: config.observability });
+                    observabilityStore = new ObservabilityStore(cwd, { config: observabilityConfig });
                 }
                 catch (error) {
                     console.error(`rafi: observability unavailable; build will continue: ${String(error).replace(/\s+/g, " ").slice(0, 300)}`);
@@ -2384,7 +2402,7 @@ export function buildStartCommand(options = {}) {
                 observabilityStore?.enforceLimits();
                 observabilityStore?.maintainLogs(cwd);
                 observabilityStore?.close();
-                pruneRecoveryTelemetryAtCompletion(cwd, config.observability.detail_retention_days);
+                pruneRecoveryTelemetryAtCompletion(cwd, observabilityConfig.detail_retention_days);
                 activeObserver = undefined;
                 process.off("exit", finishObservationOnExit);
                 console.log("foreman: branch run summary");
@@ -2831,7 +2849,7 @@ export function buildStartCommand(options = {}) {
                 observabilityStore?.enforceLimits();
                 observabilityStore?.maintainLogs(cwd);
                 observabilityStore?.close();
-                pruneRecoveryTelemetryAtCompletion(cwd, config.observability.detail_retention_days);
+                pruneRecoveryTelemetryAtCompletion(cwd, observabilityConfig.detail_retention_days);
                 activeObserver = undefined;
                 process.off("exit", finishObservationOnExit);
                 console.log(`\n${accent("foreman:")} ${result.completed}/${result.requested} step(s) completed`);

package/dist/config.js

@@ -84,9 +84,16 @@ export function loadConfig(path = "foreman.yaml") {
             ...(raw.notifications ?? {}),
         },
         qa: { ...DEFAULT_CONFIG.qa, ...(raw.qa ?? {}) },
-        observability: { ...DEFAULT_CONFIG.observability, ...(raw.observability ?? {}) },
+        observability: normalizeObservabilityConfig({ ...DEFAULT_CONFIG.observability, ...(raw.observability ?? {}) }),
     };
 }
+function normalizeObservabilityConfig(config) {
+    if (config.enabled === false)
+        return { ...config, mode: "off" };
+    if (config.mode === "off")
+        return { ...config, enabled: false };
+    return config;
+}
 function validateConfig(raw, path) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
         throw new Error(`${path}: expected a YAML object`);
@@ -123,17 +130,19 @@ function validateObservability(value, path) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error(`${path}: observability must be an object`);
     const input = value;
-    const keys = ["enabled", "sample_interval_seconds", "detail_retention_days", "log_retention_days", "detail_soft_limit_mb", "detail_hard_limit_mb", "log_limit_mb"];
+    const keys = ["enabled", "mode", "sample_interval_seconds", "detail_retention_days", "log_retention_days", "detail_soft_limit_mb", "detail_hard_limit_mb", "log_limit_mb"];
     for (const key of Object.keys(input))
         if (!keys.includes(key))
             throw new Error(`${path}: unknown observability setting ${key}`);
     if (input.enabled !== undefined && typeof input.enabled !== "boolean")
         throw new Error(`${path}: observability.enabled must be a boolean`);
-    for (const key of keys.filter((key) => key !== "enabled")) {
+    if (input.mode !== undefined && !["off", "summary", "trace"].includes(String(input.mode)))
+        throw new Error(`${path}: observability.mode must be off, summary, or trace`);
+    for (const key of keys.filter((key) => key !== "enabled" && key !== "mode")) {
         if (input[key] !== undefined && (!Number.isInteger(input[key]) || Number(input[key]) <= 0))
             throw new Error(`${path}: observability.${key} must be a positive integer`);
     }
-    const merged = { ...DEFAULT_OBSERVABILITY_CONFIG, ...input };
+    const merged = { ...DEFAULT_OBSERVABILITY_CONFIG, ...input, ...(input.enabled === false && input.mode === undefined ? { mode: "off" } : {}), ...(input.mode === "off" && input.enabled === undefined ? { enabled: false } : {}) };
     if (merged.detail_soft_limit_mb >= merged.detail_hard_limit_mb)
         throw new Error(`${path}: observability.detail_soft_limit_mb must be less than detail_hard_limit_mb`);
 }

package/dist/hostQaComparison.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import type { QaContractCoverageV1, QaVerificationContractV1 } from "rafi-spec";
+import type { TicketDef } from "./tickets/ticketSchema.js";
+import type { WorkflowDb } from "./workflowDb.js";
+export declare const hostQaComparisonV1Schema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    runId: z.ZodString;
+    ticketId: z.ZodString;
+    assignmentId: z.ZodString;
+    contractDigest: z.ZodString;
+    contractRevision: z.ZodNumber;
+    reviewAttemptId: z.ZodString;
+    reviewBasisDigest: z.ZodString;
+    baselineSourceDigest: z.ZodString;
+    finalSourceDigest: z.ZodString;
+    scopeBasisDigest: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+        blocked: "blocked";
+    }>;
+    changedPaths: z.ZodArray<z.ZodString>;
+    unauthorizedPaths: z.ZodArray<z.ZodString>;
+    deletedPaths: z.ZodArray<z.ZodString>;
+    protectedPaths: z.ZodArray<z.ZodString>;
+    reason: z.ZodString;
+    comparedAt: z.ZodString;
+}, z.core.$strip>;
+export type HostQaComparisonV1 = z.infer<typeof hostQaComparisonV1Schema>;
+export declare function findHostQaCheck(contract: QaVerificationContractV1): QaVerificationContractV1["checks"][number] | undefined;
+/**
+ * Performs the private host comparison and returns the immutable artifact plus
+ * the coverage row replacement. Provider output is never used to decide scope.
+ */
+export declare function createHostQaComparison(input: {
+    db: Pick<WorkflowDb, "operations" | "qaPreparationStore">;
+    projectDir: string;
+    worktree: string;
+    runId: string;
+    ticket: TicketDef;
+    contract: QaVerificationContractV1;
+    reviewAttemptId: string;
+    reviewBasisDigest: string;
+}): {
+    result: HostQaComparisonV1;
+    resultDigest: string;
+    checkId?: string;
+};
+export declare function applyHostQaComparison(coverage: QaContractCoverageV1, contract: QaVerificationContractV1, result: HostQaComparisonV1, resultDigest: string, projectDir: string): QaContractCoverageV1;
+export declare function hostComparisonDigestFromCoverage(coverage: QaContractCoverageV1, checkId: string): string | undefined;

package/dist/hostQaComparison.js

@@ -0,0 +1,195 @@
+import { z } from "zod";
+import { captureBuildSource } from "./buildAssignment.js";
+import { contractDigest } from "./qaVerificationContract.js";
+const digest = z.string().regex(/^[a-f0-9]{64}$/);
+const path = z.string().min(1).max(1024);
+export const hostQaComparisonV1Schema = z.object({
+    version: z.literal(1),
+    runId: z.string().min(1),
+    ticketId: z.string().min(1),
+    assignmentId: z.string().min(1),
+    contractDigest: digest,
+    contractRevision: z.number().int().positive(),
+    reviewAttemptId: z.string().min(1),
+    reviewBasisDigest: digest,
+    baselineSourceDigest: digest,
+    finalSourceDigest: digest,
+    scopeBasisDigest: digest,
+    status: z.enum(["passed", "failed", "blocked"]),
+    changedPaths: z.array(path).max(256),
+    unauthorizedPaths: z.array(path).max(256),
+    deletedPaths: z.array(path).max(256),
+    protectedPaths: z.array(path).max(256),
+    reason: z.string().max(2048),
+    comparedAt: z.string().datetime(),
+});
+function identity(item) {
+    if (!item)
+        return "missing";
+    return JSON.stringify({
+        headObject: item.headObject,
+        indexObject: item.indexObject,
+        worktreeObject: item.worktreeObject,
+        untracked: item.untracked,
+    });
+}
+function matchesScope(candidate, patterns) {
+    return patterns.some(pattern => {
+        const normalized = pattern.replaceAll("\\", "/").replace(/^\.\//, "");
+        if (normalized.endsWith("/**"))
+            return candidate === normalized.slice(0, -3) || candidate.startsWith(normalized.slice(0, -2));
+        if (normalized.includes("*")) {
+            const expression = new RegExp(`^${normalized.split("*").map(part => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`);
+            return expression.test(candidate);
+        }
+        return candidate === normalized;
+    });
+}
+function isHostQaCheck(check) {
+    const text = `${check.expectedBehavior} ${check.expectedEvidence.join(" ")} ${check.applicability.requiredEvidence.join(" ")}`;
+    const hostScopeEvidence = check.applicability.requiredEvidence.some(evidence => /host[- ]owned.*scope comparison/i.test(evidence));
+    const scopeSemantics = /scope/i.test(text) && /comparison/i.test(text) && /baseline|protected|approved scope|product changes/i.test(text);
+    return !/documentation/i.test(text)
+        && (hostScopeEvidence || (check.applicability.decisionOwner === "host" && (/Rafi compares the final product paths/i.test(check.expectedBehavior) || scopeSemantics)));
+}
+export function findHostQaCheck(contract) {
+    return contract.checks.find(isHostQaCheck);
+}
+function findHostQaChecks(contract) {
+    return contract.checks.filter(isHostQaCheck);
+}
+function findHostDocumentationCheck(contract) {
+    return contract.checks.find(check => check.applicability.decisionOwner === "host"
+        && /documentation/i.test(check.expectedBehavior)
+        && /documentation/i.test(check.expectedEvidence.join(" ")));
+}
+function findAssignment(db, runId, ticketId, baselineDigest) {
+    const operations = db.operations(runId);
+    return operations
+        .filter(operation => operation.intent?.ticketId === ticketId && operation.intent?.before?.digest === baselineDigest
+        && Array.isArray(operation.intent.before.pathInventory) && Array.isArray(operation.result?.after?.pathInventory))
+        .at(-1);
+}
+function baselineDigest(contract) {
+    return contract.inputs.find(input => input.id === "preimplementation-source")?.digest;
+}
+function resultEvidence(resultDigest, projectDir, sourceDigest, status, reason) {
+    return {
+        procedure: "Rafi host-owned comparison of the retained preimplementation inventory and final Builder source",
+        cwd: projectDir,
+        runtime: "Rafi host",
+        sourceDigest,
+        reference: `host-qa-comparison:${resultDigest}`,
+        ...(status === "passed" ? {} : { limitation: reason }),
+    };
+}
+/**
+ * Performs the private host comparison and returns the immutable artifact plus
+ * the coverage row replacement. Provider output is never used to decide scope.
+ */
+export function createHostQaComparison(input) {
+    const check = findHostQaCheck(input.contract);
+    if (!check)
+        throw new Error("Host QA comparison contract check is missing");
+    const expectedBaseline = baselineDigest(input.contract);
+    if (!expectedBaseline)
+        throw new Error("Host QA comparison lacks the admitted preimplementation baseline");
+    const assignment = findAssignment(input.db, input.runId, input.ticket.id, expectedBaseline);
+    const finalFirst = captureBuildSource(input.worktree);
+    const finalSecond = captureBuildSource(input.worktree);
+    if (finalFirst.digest !== finalSecond.digest)
+        throw new Error("Host QA comparison source changed during final capture");
+    const final = finalSecond;
+    const before = assignment?.intent.before;
+    const assignmentId = assignment?.idempotencyKey ?? "missing-assignment";
+    const beforePaths = new Map((before?.pathInventory ?? []).map(item => [item.path, item]));
+    const afterPaths = new Map(final.pathInventory.map(item => [item.path, item]));
+    const allPaths = [...new Set([...beforePaths.keys(), ...afterPaths.keys()])].sort();
+    const changedPaths = allPaths.filter(item => identity(beforePaths.get(item)) !== identity(afterPaths.get(item)));
+    const deletedPaths = [...beforePaths.keys()].filter(item => !afterPaths.has(item)).sort();
+    const protectedPaths = changedPaths.filter(item => item === ".git" || item.startsWith(".git/") || item === ".rafi" || item.startsWith(".rafi/") || item === ".foreman" || item.startsWith(".foreman/")).sort();
+    const scopePatterns = input.ticket.likely_files.map(item => item.replaceAll("\\", "/"));
+    const unauthorizedPaths = scopePatterns.length ? changedPaths.filter(item => !matchesScope(item, scopePatterns)) : changedPaths;
+    const scopeBasisDigest = contractDigest("host-qa-scope-basis", { ticketId: input.ticket.id, ticket: input.ticket, contractDigest: input.contract.contentDigest, assignmentId });
+    const missingBaseline = !assignment || !before || before.digest !== expectedBaseline;
+    const status = missingBaseline || protectedPaths.length || deletedPaths.length || unauthorizedPaths.length ? (missingBaseline ? "blocked" : "failed") : "passed";
+    const reason = missingBaseline
+        ? "The admitted Builder assignment baseline was not retained or does not match the contract baseline."
+        : protectedPaths.length
+            ? `Protected paths changed: ${protectedPaths.slice(0, 8).join(", ")}`
+            : deletedPaths.length
+                ? `Product paths were deleted: ${deletedPaths.slice(0, 8).join(", ")}`
+                : unauthorizedPaths.length
+                    ? `Changed paths are outside the host-resolved ticket scope: ${unauthorizedPaths.slice(0, 8).join(", ")}`
+                    : "Host-observed product paths match the retained baseline and host-resolved ticket scope.";
+    const result = hostQaComparisonV1Schema.parse({ version: 1, runId: input.runId, ticketId: input.ticket.id, assignmentId, contractDigest: input.contract.contentDigest, contractRevision: input.contract.revision, reviewAttemptId: input.reviewAttemptId, reviewBasisDigest: input.reviewBasisDigest, baselineSourceDigest: expectedBaseline, finalSourceDigest: final.digest, scopeBasisDigest, status, changedPaths, unauthorizedPaths, deletedPaths, protectedPaths, reason, comparedAt: new Date().toISOString() });
+    const store = input.db.qaPreparationStore();
+    const existing = store.artifacts("host-qa-comparison").find(item => {
+        const candidate = hostQaComparisonV1Schema.safeParse(item.value);
+        if (!candidate.success)
+            return false;
+        const prior = candidate.data;
+        return prior.runId === result.runId && prior.ticketId === result.ticketId && prior.assignmentId === result.assignmentId
+            && prior.contractDigest === result.contractDigest && prior.contractRevision === result.contractRevision
+            && prior.reviewAttemptId === result.reviewAttemptId && prior.reviewBasisDigest === result.reviewBasisDigest
+            && prior.baselineSourceDigest === result.baselineSourceDigest && prior.finalSourceDigest === result.finalSourceDigest
+            && prior.scopeBasisDigest === result.scopeBasisDigest && prior.status === result.status
+            && JSON.stringify(prior.changedPaths) === JSON.stringify(result.changedPaths)
+            && JSON.stringify(prior.unauthorizedPaths) === JSON.stringify(result.unauthorizedPaths)
+            && JSON.stringify(prior.deletedPaths) === JSON.stringify(result.deletedPaths)
+            && JSON.stringify(prior.protectedPaths) === JSON.stringify(result.protectedPaths)
+            && prior.reason === result.reason;
+    });
+    const resultDigest = existing?.digest ?? store.putArtifact("host-qa-comparison", result);
+    return { result: existing ? hostQaComparisonV1Schema.parse(existing.value) : result, resultDigest, checkId: check.id };
+}
+export function applyHostQaComparison(coverage, contract, result, resultDigest, projectDir) {
+    const parsed = hostQaComparisonV1Schema.parse(result);
+    if (parsed.contractDigest !== contract.contentDigest || parsed.contractRevision !== contract.revision || parsed.runId !== contract.runId || parsed.ticketId !== contract.workId || parsed.finalSourceDigest !== coverage.sourceDigest || parsed.reviewAttemptId !== coverage.attemptId || parsed.reviewBasisDigest !== coverage.inputBasisDigest)
+        throw new Error("Host QA comparison is not bound to the current contract, review, or source");
+    const checks = findHostQaChecks(contract);
+    if (!checks.length)
+        throw new Error("Host QA comparison contract check is missing");
+    const copy = structuredClone(coverage);
+    for (const check of checks) {
+        const row = {
+            checkId: check.id,
+            applicability: "applicable",
+            predicateEvidence: ["Rafi host-owned scope comparison executed against the retained baseline."],
+            outcome: parsed.status === "passed" ? "passed" : parsed.status === "failed" ? "failed" : "blocked",
+            evidence: [resultEvidence(resultDigest, projectDir, parsed.finalSourceDigest, parsed.status, parsed.reason)],
+        };
+        const index = copy.checks.findIndex(item => item.checkId === check.id);
+        if (index < 0)
+            copy.checks.push(row);
+        else
+            copy.checks[index] = row;
+    }
+    const documentationCheck = findHostDocumentationCheck(contract);
+    if (documentationCheck && contract.documentation?.required === false) {
+        const documentationRow = {
+            checkId: documentationCheck.id,
+            applicability: "applicable",
+            predicateEvidence: ["The admitted contract explicitly sets documentation.required to false."],
+            outcome: "passed",
+            evidence: [{
+                    procedure: "Rafi host-owned evaluation of the admitted documentation policy",
+                    cwd: projectDir,
+                    runtime: "Rafi host",
+                    sourceDigest: parsed.finalSourceDigest,
+                    reference: `host-qa-documentation:${contract.contentDigest}`,
+                }],
+        };
+        const documentationIndex = copy.checks.findIndex(item => item.checkId === documentationCheck.id);
+        if (documentationIndex < 0)
+            copy.checks.push(documentationRow);
+        else
+            copy.checks[documentationIndex] = documentationRow;
+    }
+    return copy;
+}
+export function hostComparisonDigestFromCoverage(coverage, checkId) {
+    const reference = coverage.checks.find(row => row.checkId === checkId)?.evidence.find(item => item.reference.startsWith("host-qa-comparison:"))?.reference;
+    const value = reference?.slice("host-qa-comparison:".length);
+    return value && /^[a-f0-9]{64}$/.test(value) ? value : undefined;
+}

package/dist/observability.d.ts

@@ -1,8 +1,10 @@
 import type { ConfigurableAgentRole, DiagnosticSourceResultV1, ManagerRunSummaryV1, RunCurrentStateV1, RunRollupV1, RunSpanV1 } from "rafi-spec";
 export declare const OBSERVABILITY_DB_FILE = ".rafi/observability.sqlite3";
 export declare const OBSERVABILITY_SCHEMA_VERSION: 2;
+export type ObservabilityMode = "off" | "summary" | "trace";
 export interface ObservabilityConfig {
     enabled: boolean;
+    mode: ObservabilityMode;
     sample_interval_seconds: number;
     detail_retention_days: number;
     log_retention_days: number;

package/dist/observability.js

@@ -10,6 +10,7 @@ export const OBSERVABILITY_DB_FILE = ".rafi/observability.sqlite3";
 export const OBSERVABILITY_SCHEMA_VERSION = 2;
 export const DEFAULT_OBSERVABILITY_CONFIG = {
     enabled: true,
+    mode: "summary",
     sample_interval_seconds: 60,
     detail_retention_days: 30,
     log_retention_days: 30,
@@ -49,7 +50,7 @@ export class ObservabilityStore {
         this.db.pragma("foreign_keys = ON");
         this.migrate();
         this.backfillBuildSnapshots();
-        this.summaryOnly = this.meta("summary_only") === "1";
+        this.summaryOnly = this.config.mode === "summary" || this.meta("summary_only") === "1";
     }
     close() { if (this.db.open)
         this.db.close(); }

package/dist/permissions/policy.js

@@ -65,6 +65,17 @@ export class PermissionPolicy {
         if (hitEscalate) {
             return { decision: "escalate", reason: `command matches "${hitEscalate}"` };
         }
+        // Permit only the bounded exit-status wrapper needed to retain explicit
+        // evidence for an already allow-listed project test.  The base command is
+        // still parsed by the restricted grammar; this does not grant arbitrary
+        // shell sequencing, expansion, or output redirection.
+        const exitCapture = /^\s*(.+?)\s+2>&1\s*;\s*echo\s+(?:"EXIT_CODE=\$\?"|'EXIT_CODE=\$\?'|EXIT_CODE=\$\?)\s*$/.exec(command);
+        if (exitCapture) {
+            const reason = classifySupportedShellForm(exitCapture[1], this.cwd, executionCwd, this.config.allowBash);
+            return reason
+                ? { decision: "escalate", reason: `exit-code capture base command rejected: ${reason}` }
+                : { decision: "allow", reason: "bounded exit-code capture for an allowed project test" };
+        }
         const entry = process.env.RAFI_REHEARSAL_CLI_ENTRY;
         const shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
         const launchingRehearsal = entry && isAbsolute(entry) && !/[\r\n\0]/.test(entry)

package/dist/qaBuildGate.js

@@ -14,7 +14,7 @@ import { WorkflowDb } from "./workflowDb.js";
 import { createRoleBuilder, readOnlyPermissionConfig } from "./agentRun.js";
 import { captureBuildSource, assertBuildAssignmentReconciled } from "./buildAssignment.js";
 import { createDisposableQaSnapshotAsync } from "./qaSnapshot.js";
-import { allocateStableCheckIds, authoritativeInventory, bindUniqueBaselineCheckIds, contractDigest, mapSnapshotWorkingDirectories, normalizeSnapshotPaths, renderVerificationContract } from "./qaVerificationContract.js";
+import { allocateStableCheckIds, authoritativeInventory, bindUniqueBaselineCheckIds, contractDigest, mapSnapshotWorkingDirectories, normalizeSnapshotPaths, renderVerificationContract, rewriteProviderHostScopeChecks } from "./qaVerificationContract.js";
 import { resolveEffectiveQaConfiguration } from "./qaEffectiveConfig.js";
 import { prepareVerificationContract } from "./qaPreparation.js";
 import { qaHostGraphFact } from "./qaHostFacts.js";
@@ -129,7 +129,7 @@ async function ensureBuilderContractWithProvenance(projectDir, runId, workId, wo
             provider: builder.agent,
             store, now: Date.now, hostFacts: `${qaHostGraphFact(projectDir)}\n${deliveryFact}\nHost-owned baseline fact: Rafi captured the complete preimplementation per-file path manifest and will perform the exact unchanged-file and scope comparison. Its digest is ${preimplementationPathManifestDigest}. Do not require the provider to receive or reproduce the raw manifest; cite the retained host-preimplementation-source observation and assess the host comparison result instead. Do not author a provider-executed check for Rafi's host postimplementation path manifest, complete changed-path inventory, or unchanged-file comparison; Rafi performs that comparison outside the provider snapshot. Ordinary approved product paths, exports, and tests are not a material QA concern merely because the provider cannot prove whether they were present before implementation; Rafi owns that comparison. Do not reconstruct or disclose the full baseline. 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.`,
             normalizeDraft: (draft, response) => {
-                const normalized = bindUniqueBaselineCheckIds(allocateStableCheckIds(draft));
+                const normalized = rewriteProviderHostScopeChecks(bindUniqueBaselineCheckIds(allocateStableCheckIds(draft)), hostBaseline.id);
                 if (!normalized.baseline.some(observation => observation.id === hostBaseline.id))
                     normalized.baseline.unshift(structuredClone(hostBaseline));
                 for (const check of normalized.checks)

package/dist/qaBuilderCoverage.js

@@ -21,7 +21,7 @@ async function collectBuilderContractCoverageOwned(projectDir, runId, workId, wo
         const session = actualContractSession(adapter, workspace, projectDir);
         const contract = assertContractReceipt(store, runId, workId, admission.requirementsDigest, session, adapter);
         const source = captureBuildSource(workspace);
-        const binding = { phase: "builder", sourceDigest: source.digest, inputBasisDigest: contractDigest("builder-input-basis", { operationId, instruction, contractDigest: contract.contentDigest }), attemptId: operationId, sessionId: session.sessionId };
+        let binding = { phase: "builder", sourceDigest: source.digest, inputBasisDigest: contractDigest("builder-input-basis", { operationId, instruction, contractDigest: contract.contentDigest }), attemptId: operationId, sessionId: session.sessionId };
         const eventId = `builder-coverage:${operationId}`;
         const existing = db.operation(eventId);
         if (existing) {
@@ -44,8 +44,17 @@ async function collectBuilderContractCoverageOwned(projectDir, runId, workId, wo
             db.updateOperation(eventId, "uncertain", { result: { responseDigest } });
             if (response.isError || response.failure)
                 throw new Error("Builder coverage provider failed; retained response requires reconciliation");
-            if (JSON.stringify(actualContractSession(adapter, workspace, projectDir)) !== JSON.stringify(session) || captureBuildSource(workspace).digest !== source.digest)
+            const afterSession = actualContractSession(adapter, workspace, projectDir);
+            const sameScopedSession = afterSession.provider === session.provider
+                && afterSession.workspace === session.workspace
+                && afterSession.configRoot === session.configRoot
+                && (afterSession.sessionId === session.sessionId || afterSession.compactionSequence > session.compactionSequence);
+            if (!sameScopedSession || captureBuildSource(workspace).digest !== source.digest)
                 throw new Error("Builder coverage changed session or product source");
+            // A provider may compact while producing this response-only evidence.
+            // Bind the retained coverage to the host-observed post-compaction session
+            // while continuing to reject unscoped session changes and source edits.
+            binding = { ...binding, sessionId: afterSession.sessionId };
             const coverage = bindCoverageHostFields(parseContractCoverage(response.text), contract, binding);
             bindHostOwnedBuilderFacts(db, coverage, contract, hostObservations, initialSourceDigest, source.digest, workId, projectDir);
             const errors = validateContractCoverage(contract, coverage, binding, false);

package/dist/qaContractCoverage.js

@@ -2,7 +2,7 @@ import { Ajv } from "ajv";
 import { qaContractCoverageV1Schema } from "rafi-spec";
 const coverageSchema = new Ajv({ allErrors: true }).compile(qaContractCoverageV1Schema);
 import { parsePreparationArtifact } from "./qaVerificationContract.js";
-export const COVERAGE_INSTRUCTIONS = `Return RAFI_QA_COVERAGE_START, one QaContractCoverageV1 JSON object, RAFI_QA_COVERAGE_END before the final status marker. The exact schema is ${JSON.stringify(qaContractCoverageV1Schema)}. Put every binding field at the TOP LEVEL, not inside a binding object, and copy the host-supplied binding values exactly. For each check use checkId (not id), applicability as applicable/not-applicable/unresolved, predicateEvidence as an array of strings, outcome as passed/failed/blocked/not-run, and evidence as an array of objects with procedure, cwd, runtime, sourceDigest and reference. For postimplementation evidence sourceDigest is the exact host-supplied sourceDigest, not an individual file hash. Unconditional checks cannot be marked not-applicable or unresolved; for an absence or non-impact check, mark it applicable and provide bounded inspection evidence showing that the absent change or impact was assessed. For independent QA coverage of an applicable passed preimplementation-only check, inspect its matching passed contract.baseline observation and set at least one evidence reference to that observation's exact evidenceDigest; the historical observation is bound to its original source, not the current source. Assess its relevance rather than inventing or claiming a new baseline. Before emitting qa_pass, run every applicable mandatory check that is not backed by a passed retained baseline; do not leave such a check as not-run merely because an earlier turn omitted it. If an exact required command is blocked by the provider shell policy, use a semantically equivalent permitted read-only procedure, record the substitution and limitation truthfully, and assess the same predicate; do not mark the check blocked merely because the literal command syntax was denied. If a required command is permitted and read-only, run it now and retain its bounded result. Do not add unsupported fields. Include every check with truthful applicability and concrete evidence. Missing, blocked, not-run, unresolved applicability, or failed mandatory coverage cannot authorize normal completion. Builder coverage is a claim; final QA independently verifies it.`;
+export const COVERAGE_INSTRUCTIONS = `Return RAFI_QA_COVERAGE_START, one QaContractCoverageV1 JSON object, RAFI_QA_COVERAGE_END before the final status marker. The exact schema is ${JSON.stringify(qaContractCoverageV1Schema)}. Put every binding field at the TOP LEVEL, not inside a binding object, and copy the host-supplied binding values exactly. For each check use checkId (not id), applicability as applicable/not-applicable/unresolved, predicateEvidence as an array of strings, outcome as passed/failed/blocked/not-run, and evidence as an array of objects with procedure, cwd, runtime, sourceDigest and reference. For postimplementation evidence sourceDigest is the exact host-supplied sourceDigest, not an individual file hash. Unconditional checks cannot be marked not-applicable or unresolved; for an absence or non-impact check, mark it applicable and provide bounded inspection evidence showing that the absent change or impact was assessed. For independent QA coverage of an applicable passed preimplementation-only check, inspect its matching passed contract.baseline observation and set at least one evidence reference to that observation's exact evidenceDigest; the historical observation is bound to its original source, not the current source. Assess its relevance rather than inventing or claiming a new baseline. Host-owned checks whose applicability decisionOwner is host are the exception to provider execution: include the check truthfully as applicable/not-run with evidence that the host-owned comparison is pending, and do not block or fail QA over it; Rafi will execute the comparison and replace that row before accepting the pass. Before emitting qa_pass, run every other applicable mandatory check that is not backed by a passed retained baseline; do not leave such a provider-owned check as not-run merely because an earlier turn omitted it. If an exact required command is blocked by the provider shell policy, use a semantically equivalent permitted read-only procedure, record the substitution and limitation truthfully, and assess the same predicate; do not mark the check blocked merely because the literal command syntax was denied. If a required command is permitted and read-only, run it now and retain its bounded result. Do not add unsupported fields. Include every check with truthful applicability and concrete evidence. Missing, blocked, not-run, unresolved applicability, or failed provider-owned mandatory coverage cannot authorize normal completion. Builder coverage is a claim; final QA independently verifies it.`;
 // The source and attempt binding do not exist until the implementation turn has finished.
 export const BUILDER_WORK_COVERAGE_INSTRUCTIONS = `Carry out the applicable contract checks and report your work and evidence honestly in your normal final response. When a check requires historical ordering, retain bounded output for each required step and an explicit ordering record while performing it; a later passing test cannot prove an earlier failing step. Do not emit RAFI_QA_COVERAGE JSON during this implementation turn or stop for coverage binding values. After the implementation turn, Rafi will capture the completed source and request a separate response-only coverage record with the exact host-owned bindings.`;
 export function parseContractCoverage(text) { return parsePreparationArtifact(text, "RAFI_QA_COVERAGE"); }

package/dist/qaPreparationStore.d.ts

@@ -140,6 +140,10 @@ export declare class QaPreparationStore {
     extendBudget(budget: LogicalPreparationBudget, decisionId: string): void;
     putArtifact(kind: string, value: unknown): string;
     artifact<T>(digest: string, kind: string): T;
+    artifacts(kind: string): Array<{
+        digest: string;
+        value: unknown;
+    }>;
     head(runId: string, workId: string, admissionDigest: string): {
         digest?: string;
         generation: number;

package/dist/qaPreparationStore.js

@@ -324,6 +324,14 @@ export class QaPreparationStore {
             throw new Error("Corrupt preparation artifact");
         return value;
     }
+    artifacts(kind) {
+        return this.db.prepare("SELECT digest,record_json FROM qa_contract_artifacts WHERE kind=? ORDER BY digest").all(kind).map(row => {
+            const value = this.decode(row.record_json);
+            if (contractDigest(`artifact-${kind}`, value) !== row.digest)
+                throw new Error("Corrupt preparation artifact");
+            return { digest: row.digest, value };
+        });
+    }
     head(runId, workId, admissionDigest) {
         const row = this.db.prepare("SELECT digest,generation,state,detail FROM qa_contract_heads WHERE run_id=? AND work_id=? AND admission_digest=?").get(runId, workId, admissionDigest);
         return row ? { ...row, digest: row.digest ?? undefined, detail: row.detail && this.projectDir && !graphDerivedAllowed(this.db, this.projectDir, bytesDigest(row.detail)) ? "Graph-derived preparation detail withheld; source-based recovery required" : row.detail ?? undefined } : { generation: 0, state: "preparation-required" };

package/dist/qaReview.js

@@ -26,6 +26,7 @@ import { canonicalSessionPath } from "./sessionIdentity.js";
 import { loadProjectAutonomyConfig, resolveAutonomyPolicy } from "./recoveryPolicy.js";
 import { appendQaRecoveryAttempt, appendQaRecoveryResource, appendQaRecoveryReviewedState, compareQaRecoveryReviewedState, createQaRecoveryPacket, ensureQaRecoveryExcluded, loadQaRecoveryPacket, materializeQaRecoveryContext, qaRecoveryInventory, qaReportDigest, renderQaRecoveryAcknowledgementInstruction, updateQaRecoveryPosition, updateQaRecoveryReviewIdentity, validateManualQaReport, validateQaRecoveryAcknowledgement, } from "./qaRecovery.js";
 import { canonicalJson, createQaFindingRefs, qaDigest } from "./qaProtocolV2.js";
+import { applyHostQaComparison, createHostQaComparison, findHostQaCheck } from "./hostQaComparison.js";
 function ensureProtocolPausePacket(opts, head, stage, detail, frozenState) {
     const db = new WorkflowDb(opts.recovery.projectDir);
     try {
@@ -1653,11 +1654,26 @@ function beginV2Review(opts, source, reviewedSnapshotPath, instruction, handle,
             const expected = contract.inputs.find(input => input.kind === "checklist");
             if (expected?.digest !== contractDigest("input-checklist", checklist))
                 throw new Error("Final QA checklist differs from delivered contract");
+            const needsHistoricalEvidence = contract.checks.some(check => /red|test.?first|ordering|historical/i.test(JSON.stringify(check)));
             const builderClaims = db.operations(opts.recovery.runId).flatMap(operation => {
                 const intent = operation.intent;
                 const result = operation.result;
                 return operation.kind === "builder-coverage" && operation.status === "confirmed" && intent.workId === opts.ticket.id && intent.contractDigest === contract.contentDigest && result?.binding?.sourceDigest === source.digest && result.coverageDigest
-                    ? [{ operationId: operation.idempotencyKey, digest: result.coverageDigest, coverage: preparationStore.artifact(result.coverageDigest, "builder-coverage") }] : [];
+                    ? [{
+                            operationId: operation.idempotencyKey,
+                            digest: result.coverageDigest,
+                            coverage: preparationStore.artifact(result.coverageDigest, "builder-coverage"),
+                            ...(needsHistoricalEvidence && result.implementationDigest ? {
+                                // The response is already host-retained by finishBuildAssignment.
+                                // Expose only this bounded, contract-relevant excerpt to the
+                                // independent reviewer; do not retain or disclose all Builder
+                                // output globally.
+                                implementationResponse: {
+                                    digest: result.implementationDigest,
+                                    response: db.getEvidence(result.implementationDigest)?.toString() ?? "unavailable",
+                                },
+                            } : {}),
+                        }] : [];
             });
             const commandObservations = retainedQaCommandObservations(opts.recovery.projectDir, opts.recovery.runId, opts.ticket.id, qaCommandOutputExcerptsAllowed(opts.ticket.id));
             instruction += `\n${qaHostGraphFact(opts.recovery.projectDir)}\n`;
@@ -1990,7 +2006,13 @@ function finishV2Pass(opts, adapter, detail) {
                     throw new Error("Final coverage requires the current ready contract");
                 const contract = db.qaPreparationStore().contract(contractHead.digest);
                 const coverageBinding = { phase: "qa", sourceDigest: binding.sourceStateDigest, inputBasisDigest: binding.reviewBasisDigest, attemptId: binding.reviewAttemptId, sessionId: binding.sessionRef.sessionId };
-                const coverage = bindCoverageHostFields(parseContractCoverage(binding.lastResponse ?? ""), contract, coverageBinding);
+                const providerCoverage = bindCoverageHostFields(parseContractCoverage(binding.lastResponse ?? ""), contract, coverageBinding);
+                const hostComparison = findHostQaCheck(contract)
+                    ? createHostQaComparison({ db, projectDir: binding.projectDir, worktree: opts.builderWorktree, runId: binding.runId, ticket: opts.ticket, contract, reviewAttemptId: binding.reviewAttemptId, reviewBasisDigest: binding.reviewBasisDigest })
+                    : undefined;
+                const coverage = hostComparison
+                    ? applyHostQaComparison(providerCoverage, contract, hostComparison.result, hostComparison.resultDigest, binding.projectDir)
+                    : providerCoverage;
                 const errors = validateContractCoverage(contract, coverage, coverageBinding);
                 if (errors.length)
                     throw new Error(`Final QA coverage incomplete: ${errors.join("; ")}`);

package/dist/qaVerificationContract.d.ts

@@ -10,6 +10,13 @@ export declare function allocateStableCheckIds(candidate: QaContractCandidateV1)
 export declare function inventoryDigest(requirements: RequirementRef[]): string;
 /** Derive a missing baseline binding only from an explicit, unique check prerequisite reference. */
 export declare function bindUniqueBaselineCheckIds(candidate: QaContractCandidateV1): QaContractCandidateV1;
+/**
+ * The host owns the before/after path comparison. Providers may still draft a
+ * check that asks them to enumerate every changed file, which turns host
+ * bookkeeping into a Builder obligation. Replace only that explicit shape;
+ * ordinary product-scope checks remain provider-authored and unchanged.
+ */
+export declare function rewriteProviderHostScopeChecks(candidate: QaContractCandidateV1, baselineId: string): QaContractCandidateV1;
 export declare function authoritativeInventory(ticket: TicketDef, checklist: string[], inputs: ContractInputRef[]): RequirementRef[];
 export declare function parsePreparationArtifact<T>(text: string, tag: string, maximum?: number): T;
 /** Capture safe absolute snapshot paths before the disposable snapshot is removed. */

package/dist/qaVerificationContract.js

@@ -122,6 +122,46 @@ export function bindUniqueBaselineCheckIds(candidate) {
     }
     return draft;
 }
+/**
+ * The host owns the before/after path comparison. Providers may still draft a
+ * check that asks them to enumerate every changed file, which turns host
+ * bookkeeping into a Builder obligation. Replace only that explicit shape;
+ * ordinary product-scope checks remain provider-authored and unchanged.
+ */
+export function rewriteProviderHostScopeChecks(candidate, baselineId) {
+    const draft = structuredClone(candidate);
+    const hostScope = (check) => {
+        const text = [check.expectedBehavior, ...check.expectedEvidence, ...check.verification.flatMap(method => [method.expectedOutcome, ...(method.steps ?? []), ...(method.argv ?? [])])].join(" ").toLowerCase();
+        return /\b(?:complete|full|all|every)\s+(?:changed|modified|touched)[ -](?:path|paths|file|files)\b/.test(text)
+            || /\b(?:changed|modified|touched)[ -](?:path|paths|file|files)\s+(?:inventory|list|manifest)\b/.test(text)
+            || /\bunchanged[- ]files?\s+(?:comparison|check|verification)\b/.test(text)
+            || /\bpath\s+manifest\b.{0,80}\b(?:compare|comparison|unchanged|scope)\b/.test(text);
+    };
+    const matches = draft.checks.filter(hostScope);
+    if (!matches.length)
+        return draft;
+    const primary = matches[0];
+    const mergedRequirements = [...new Set(matches.flatMap(check => check.requirementRefs))];
+    const mergedPrerequisites = [...new Set([...primary.prerequisiteRefs, baselineId])];
+    primary.requirementRefs = mergedRequirements;
+    primary.origin = "invariant";
+    primary.expectedBehavior = "Rafi compares the final product paths with the host-captured preimplementation baseline and rejects unauthorized product changes.";
+    primary.obligation = "mandatory";
+    primary.timing = "postimplementation";
+    primary.applicability = { kind: "unconditional", decisionOwner: "host", requiredEvidence: [baselineId] };
+    primary.verification = [{ kind: "procedure", steps: ["Rafi performs the host-owned before/after product-path comparison, excluding approved bookkeeping and bounded evidence paths."], cwd: ".", fixtures: [], runtime: "Rafi host", timeoutMs: 30_000, expectedOutcome: "Only approved product changes are present; unauthorized, destructive, protected, or requirement-relevant changes are rejected." }];
+    primary.expectedEvidence = ["Rafi host-owned postimplementation scope comparison bound to the retained preimplementation baseline."];
+    primary.prerequisiteRefs = mergedPrerequisites;
+    const removed = new Set(matches.slice(1).map(check => check.id));
+    draft.checks = draft.checks.filter(check => !removed.has(check.id));
+    for (const row of draft.coverage)
+        row.checkIds = row.checkIds.map(id => removed.has(id) ? primary.id : id).filter((id, index, ids) => ids.indexOf(id) === index);
+    for (const check of draft.checks)
+        check.dependsOnChecks = check.dependsOnChecks.map(id => removed.has(id) ? primary.id : id).filter((id, index, ids) => ids.indexOf(id) === index);
+    for (const concern of draft.unresolved)
+        concern.checkIds = concern.checkIds.map(id => removed.has(id) ? primary.id : id).filter((id, index, ids) => ids.indexOf(id) === index);
+    return draft;
+}
 export function authoritativeInventory(ticket, checklist, inputs) {
     const result = [];
     for (const [kind, entries] of [["acceptance", ticket.acceptance], ["required_tests", ticket.required_tests], ["checklist", checklist]]) {

package/dist/supervisedStart.js

@@ -322,6 +322,27 @@ export async function superviseStart(projectDir, runId, policy, selection) {
     const stopTerm = () => { stopRequestSource = "parent-SIGTERM"; supervisor.requestStop(); };
     process.once("SIGINT", stopInt);
     process.once("SIGTERM", stopTerm);
+    let supervisorCompleted = false;
+    const recordUnexpectedSupervisorExit = (code) => {
+        if (supervisorCompleted)
+            return;
+        try {
+            const state = db.supervisorState(runId);
+            const run = db.getRun(runId);
+            if (!state || state.pid !== process.pid || state.status !== "running" || !run || ["completed", "cancelled", "superseded"].includes(run.status))
+                return;
+            db.putSupervisorState(runId, { ...state, status: "failed", pid: undefined, workerPid: undefined, heartbeatAt: new Date().toISOString() });
+            db.transitionSupervisor(runId, state.workerGeneration, {
+                status: "paused",
+                checkpoint: "supervisor-process-exit",
+                event: "supervisor_process_exit",
+                payload: { exitCode: code, lastCheckpoint: run.checkpoint, generation: state.generation },
+            });
+        }
+        catch { /* Exit handlers must not mask the original process termination. */ }
+    };
+    const onProcessExit = (code) => recordUnexpectedSupervisorExit(code);
+    process.once("exit", onProcessExit);
     try {
         const outcome = await supervisor.run();
         if (outcome.kind === "failed") {
@@ -332,8 +353,10 @@ export async function superviseStart(projectDir, runId, policy, selection) {
             exitCode ||= 2;
     }
     finally {
+        supervisorCompleted = true;
         process.off("SIGINT", stopInt);
         process.off("SIGTERM", stopTerm);
+        process.off("exit", onProcessExit);
         db.close();
     }
     process.exitCode = exitCode;

package/dist/ticketPopulation.js

@@ -17,6 +17,8 @@ function additiveAbsenceRequirement(text) {
     return [
         /\bslice alone\b/i,
         /\bwithout\b.*\b(?:present|implemented|enabled)\b/i,
+        /\bwithout\b.*\btest\/\S+/i,
+        /\bwithout\b.*\bthe\s+\S+\s+export\b/i,
         /\bonly\b.*\bown\b.*\btest files?\b/i,
         /\bonly\b.*\btest files?\b.*\bpresent\b/i,
     ].some((pattern) => pattern.test(text));

package/dist/workflowDb.js

@@ -3,6 +3,7 @@ import { canonicalJson } from "./qaProtocolV2.js";
 import { resolveEffectiveQaConfiguration } from "./qaEffectiveConfig.js";
 import { registerGraphDerived, graphDerivedAllowed, currentGraphDerivedAccess } from "./graph/derived.js";
 import { bindCoverageHostFields, parseContractCoverage, validateContractCoverage } from "./qaContractCoverage.js";
+import { applyHostQaComparison, findHostQaCheck, hostComparisonDigestFromCoverage, hostQaComparisonV1Schema } from "./hostQaComparison.js";
 import { QaPreparationStore, migrateQaPreparation, migrateQaPreparationGuards } from "./qaPreparationStore.js";
 import { GraphStore, migrateGraphStore } from "./graph/storage.js";
 import { reconcileWork } from "./buildWorkReconciliation.js";
@@ -2099,7 +2100,7 @@ export class WorkflowDb {
         const receipts = this.db.prepare("SELECT receipt_json FROM qa_turns WHERE run_id=? AND ticket_id=? AND source_state_digest=? AND review_basis_digest=? AND status='completed'").all(input.runId, input.ticketId, input.sourceStateDigest, input.reviewBasisDigest);
         const receipt = receipts.map(row => parseJson(row.receipt_json)).find(row => qaDigest("turn-receipt", row) === input.turnReceiptDigest && row.terminalEventObserved);
         const response = receipt?.cleanedResponseDigest ? this.getEvidence(receipt.cleanedResponseDigest) : undefined;
-        const retainedCoverage = receipt && response
+        const retainedProviderCoverage = receipt && response
             ? bindCoverageHostFields(parseContractCoverage(response.toString()), contract, {
                 phase: "qa",
                 sourceDigest: input.sourceStateDigest,
@@ -2108,8 +2109,19 @@ export class WorkflowDb {
                 sessionId: binding.sessionId,
             })
             : undefined;
+        let retainedCoverage = retainedProviderCoverage;
+        const hostCheck = findHostQaCheck(contract);
+        if (hostCheck) {
+            const hostDigest = hostComparisonDigestFromCoverage(coverage, hostCheck.id);
+            if (!hostDigest)
+                throw new Error("Coverage is missing the host-owned comparison artifact reference");
+            const hostResult = hostQaComparisonV1Schema.parse(store.artifact(hostDigest, "host-qa-comparison"));
+            retainedCoverage = retainedProviderCoverage
+                ? applyHostQaComparison(retainedProviderCoverage, contract, hostResult, hostDigest, this.projectDir)
+                : undefined;
+        }
         if (!receipt || !retainedCoverage || canonicalJson(retainedCoverage) !== canonicalJson(coverage))
-            throw new Error("Coverage is not bound to the retained terminal review receipt");
+            throw new Error("Coverage is not bound to the retained terminal review receipt and authorized host augmentation");
     }
     issueQaPassCertificate(input, now = new Date()) {
         this.assertContractCertificate(input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-foreman",
-  "version": "1.7.27",
+  "version": "1.7.28",
   "description": "An orchestrator that keeps Codex CLI / Claude Code builders moving through their step list unattended. Part of Rafi.",
   "license": "Apache-2.0",
   "type": "module",
@@ -311,8 +311,8 @@
     "luxon": "^3.7.2",
     "parse5": "7.2.1",
     "pdfjs-dist": "4.10.38",
-    "rafi-spec": "0.8.16",
-    "special-agents": "0.8.16",
+    "rafi-spec": "0.8.17",
+    "special-agents": "0.8.17",
     "yaml": "^2.5.1",
     "zod": "4.4.3"
   },