ai-foreman 1.7.27 → 1.7.29

package/dist/hostQaAugmentation.js

@@ -0,0 +1,64 @@
+import { applyHostQaComparison } from "./hostQaComparison.js";
+import { applyHostGraphApplicability } from "./hostGraphApplicability.js";
+function commandObservationFor(check, observations) {
+    const command = check.verification.find(method => method.kind === "command");
+    const argv = command?.argv ?? [];
+    const kind = argv[0] === "npm" && argv[1] === "test" ? "npm-test" : argv[0] === "node" && argv[1] === "--test" ? "node-test" : undefined;
+    if (!kind)
+        return undefined;
+    return observations.find(observation => observation.kind === kind && observation.outcome === "completed" && observation.exitCode === 0 && typeof observation.spanId === "string");
+}
+function applyHostCommandObservations(coverage, contract, observations) {
+    const parsed = observations.filter((observation) => Boolean(observation && typeof observation === "object"));
+    const copy = structuredClone(coverage);
+    for (const check of contract.checks) {
+        const observation = commandObservationFor(check, parsed);
+        if (!observation)
+            continue;
+        const row = copy.checks.find(item => item.checkId === check.id);
+        if (!row || row.outcome === "failed")
+            continue;
+        row.outcome = "passed";
+        row.evidence = [...(row.evidence ?? []), {
+                procedure: "Rafi host-retained command observation",
+                cwd: ".",
+                runtime: "Rafi host",
+                sourceDigest: copy.sourceDigest,
+                reference: `host-command-span:${observation.spanId}`,
+            }];
+    }
+    return copy;
+}
+function applyBaselineAuthorities(coverage, contract) {
+    const copy = structuredClone(coverage);
+    for (const check of contract.checks) {
+        if (check.timing !== "preimplementation")
+            continue;
+        const baseline = contract.baseline.find(observation => observation.checkId === check.id && observation.status === "passed");
+        const row = copy.checks.find(item => item.checkId === check.id);
+        if (!baseline || !row || row.applicability !== "applicable" || row.outcome !== "passed")
+            continue;
+        if (row.evidence?.some(evidence => evidence.reference === baseline.evidenceDigest))
+            continue;
+        row.evidence = [...(row.evidence ?? []), {
+                procedure: "Rafi host-retained preimplementation baseline authority",
+                cwd: ".",
+                runtime: "Rafi host",
+                sourceDigest: copy.sourceDigest,
+                reference: baseline.evidenceDigest,
+            }];
+    }
+    return copy;
+}
+/** Applies every host-owned coverage decision in one canonical order. */
+export function applyHostQaAugmentations(input) {
+    let coverage = input.coverage;
+    coverage = applyBaselineAuthorities(coverage, input.contract);
+    if (input.commandObservations?.length)
+        coverage = applyHostCommandObservations(coverage, input.contract, input.commandObservations);
+    if (input.hostComparison)
+        coverage = applyHostQaComparison(coverage, input.contract, input.hostComparison.result, input.hostComparison.resultDigest, input.projectDir);
+    if (input.hostGraph)
+        coverage = applyHostGraphApplicability(coverage, input.contract, input.hostGraph.result, input.hostGraph.resultDigest, input.projectDir);
+    return coverage;
+}

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,196 @@
+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);
+    const changedProductPaths = /changed product paths/i.test(text) && /host[- ]retained|baseline|bookkeeping|evidence exclusions/i.test(text);
+    return !/documentation/i.test(text)
+        && (hostScopeEvidence || changedProductPaths || (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, ensureHostScopeCheck, mapSnapshotWorkingDirectories, normalizeSnapshotPaths, renderVerificationContract, rewriteProviderHostScopeChecks } from "./qaVerificationContract.js";
 import { resolveEffectiveQaConfiguration } from "./qaEffectiveConfig.js";
 import { prepareVerificationContract } from "./qaPreparation.js";
 import { qaHostGraphFact } from "./qaHostFacts.js";
@@ -23,6 +23,7 @@ import { BUILDER_WORK_COVERAGE_INSTRUCTIONS } from "./qaContractCoverage.js";
 import { renderBuildWorkContext } from "./buildWorkContext.js";
 import { compareContractInputs } from "./qaContractFreshness.js";
 import { readBuildRuns } from "./buildRuns.js";
+import { normalizeGraphQaChecks } from "./hostGraphApplicability.js";
 /** A received response missing only continuity metadata is a bounded format defect. */
 export function preparationTurnPayload(turn) {
     const formatErrors = turn.continuityErrors ?? [];
@@ -129,7 +130,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 = allocateStableCheckIds(bindUniqueBaselineCheckIds(rewriteProviderHostScopeChecks(normalizeGraphQaChecks(ensureHostScopeCheck(draft, hostBaseline.id)), 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. Graphify is optional evidence: do not install, refresh, scan, or claim Graphify execution unless the host says Rafi-managed Graphify is adopted and enabled. Host-owned Graphify applicability is authoritative; disabled, unadopted, or unavailable Graphify is not a QA blocker, while adopted-enabled Graphify is applicable and cannot be waived by provider output. Other 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. For command exit status, use the host-retained tool event's exitCode and bounded output when available; that is authoritative evidence, and you must not create an echo wrapper, compound command, or other shell scaffold solely to print a numeric status. 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"); }
@@ -20,10 +20,15 @@ export function bindCoverageHostFields(coverage, contract, binding) {
     // Optional schema fields may be emitted as JSON null by providers. Null is
     // not a meaningful limitation, so omit only that representation variant;
     // non-string values elsewhere remain validation errors.
-    for (const check of copy.checks ?? [])
+    for (const check of copy.checks ?? []) {
+        // Some providers mirror the applicability token into outcome. Canonicalize
+        // that harmless representation mistake at the host boundary.
+        if (check.outcome === "not-applicable")
+            check.outcome = "not-run";
         for (const evidence of check.evidence ?? [])
             if (evidence.limitation === null)
                 delete evidence.limitation;
+    }
     copy.version = 1;
     copy.runId = contract.runId;
     copy.workId = contract.workId;
@@ -61,7 +66,11 @@ export function validateContractCoverage(contract, coverage, binding, requirePas
             issues.push(`Unconditional applicability cannot be waived ${row.checkId}`);
         if (row.applicability === "not-applicable" && !row.predicateEvidence?.length)
             issues.push(`Not-applicable requires predicate evidence ${row.checkId}`);
-        if (check.applicability.kind === "conditional" && row.applicability === "applicable" && !row.predicateEvidence?.length)
+        // Host-owned conditional predicates are resolved by the host augmentation
+        // after provider coverage is collected (for example Graphify adoption).
+        // Requiring provider predicate evidence here would make the host-owned,
+        // fail-open path block before the authoritative host observation exists.
+        if (check.applicability.kind === "conditional" && check.applicability.decisionOwner !== "host" && row.applicability === "applicable" && !row.predicateEvidence?.length)
             issues.push(`Conditional applicability requires predicate evidence ${row.checkId}`);
         if (requirePass && check.obligation === "mandatory" && (row.applicability === "unresolved" || row.applicability === "applicable" && row.outcome !== "passed"))
             issues.push(`Mandatory check incomplete ${row.checkId}: run its permitted verification now and resubmit passed evidence, or report a truthful blocked result for host recovery`);

package/dist/qaEffectiveConfig.d.ts

@@ -1,5 +1,6 @@
 import type { ResolvedAgentSettings } from "rafi-spec";
 export declare const FINAL_QA_ROLE_SUFFIX = "You are an independent QA reviewer. Do not edit source, tickets, configuration, or project documentation. You may run tests and create only harmless ignored caches or coverage output.";
+export declare const QA_COMMAND_DISCIPLINE: string;
 export declare function finalQaRoleInstructions(rules: string): string;
 export declare function loadQaPreparationPolicy(projectDir: string): import("special-agents").QaPreparationConfigV1;
 /** Resolve only explicit rule/skill content; never project secrets or mutable .rafi state. */

package/dist/qaEffectiveConfig.js

@@ -6,7 +6,12 @@ import { loadTicketSetupConfigWithDefaults, loadRafiConfigObject } from "./ticke
 import { resolveQaPreparationConfig } from "./qaPreparationPolicy.js";
 import { contractDigest } from "./qaVerificationContract.js";
 export const FINAL_QA_ROLE_SUFFIX = "You are an independent QA reviewer. Do not edit source, tickets, configuration, or project documentation. You may run tests and create only harmless ignored caches or coverage output.";
-export function finalQaRoleInstructions(rules) { return `${rules}\n\n${FINAL_QA_ROLE_SUFFIX}`; }
+export const QA_COMMAND_DISCIPLINE = [
+    "QA command discipline: issue one shell command per Bash call. Prefer the Read tool for source inspection and the configured project test command for verification.",
+    "Do not use shell sequencing or scaffolding such as ;, ||, redirects, command substitution, echo exit markers, temporary baseline copies, cp, cmp, or mkdir. Do not reconstruct or compare preimplementation files; Rafi owns baseline, path-scope, unchanged-file, and byte-identity comparisons.",
+    "If a command is denied by policy, do not retry the same denied command or wrap it in another compound command. Use a permitted equivalent that tests the same product behavior and record any limitation truthfully.",
+].join(" ");
+export function finalQaRoleInstructions(rules) { return `${rules}\n\n${QA_COMMAND_DISCIPLINE}\n\n${FINAL_QA_ROLE_SUFFIX}`; }
 export function loadQaPreparationPolicy(projectDir) {
     const config = loadRafiConfigObject(projectDir);
     return resolveQaPreparationConfig(config?.qa_preparation, config?.qa_preparation_shadow === true, config?.qa_preparation_wall_time_ms);

package/dist/qaPreparation.js

@@ -44,12 +44,26 @@ export function normalizeExpectedFutureAssessment(assessment, candidate) {
     const copy = structuredClone(assessment);
     const checks = new Map(candidate.checks.map(check => [check.id, check]));
     copy.concerns = copy.concerns.map(concern => {
+        // A provider can report a stale check identity copied into descriptive
+        // prose from an earlier draft.  The host has already validated the
+        // structured check/coverage/dependency references; when the assessor also
+        // says the referenced acceptance item is already covered, this is a
+        // non-material labeling defect rather than an unresolved contract gap.
+        // Keep the concern in the retained assessment, but do not block Builder.
+        const staleCoveredReference = /not in the declared check IDs or its dependsOnChecks/i.test(concern.reason)
+            && /reference can be removed|already covered/i.test(`${concern.reason} ${concern.nextAction}`)
+            && concern.checkIds.length > 0
+            && concern.checkIds.every(id => checks.has(id));
+        if (concern.material && staleCoveredReference)
+            return { ...concern, material: false };
         if (!concern.material || !concern.checkIds.length || !concern.checkIds.every(id => checks.get(id)?.timing === "postimplementation"))
             return concern;
         const expectedFutureAbsence = /\b(absent|missing|not (?:yet )?(?:implemented|present|available)|could not find|not found|does not exist|fails? with)\b/i.test(concern.reason)
             && /\b(?:before|pre[- ]?builder|not yet)\b/i.test(concern.reason)
             && /\b(?:implement|add|create|rerun|re-?run|builder|after implementation)\b/i.test(concern.nextAction);
-        return expectedFutureAbsence ? { ...concern, material: false } : concern;
+        const inventedSiblingAbsence = /\b(?:no|without|absen[ct]|missing)\s+(?:the\s+)?[a-z0-9_-]+\s+export\b|\b(?:sibling|other)\s+(?:feature|slice)\s+(?:absen[ct]|removed|present)\b/i.test(concern.reason)
+            && /\b(?:own|imports? only|no [a-z0-9_-]+ symbol|drop|remove)\b/i.test(concern.nextAction);
+        return expectedFutureAbsence || inventedSiblingAbsence ? { ...concern, material: false } : concern;
     });
     return copy;
 }
@@ -411,7 +425,7 @@ export async function prepareVerificationContract(initial, inventory, deps) {
                 normalized.assessedRequirementIds = [...fallback.assessedRequirementIds];
             return normalized;
         };
-        let assessmentResponse = retainedAssessment?.draftPayloadDigest === draftDigest(candidate) ? undefined : await run("assess", "assessment", `Independent semantic assessment in a fresh conversation. Assess each original requirement and selected-depth obligation; identify omissions, conflicts, practical verification gaps, accidental scope, and unsupported dispositions. Treat Rafi-owned bookkeeping paths (.tickets, .rafi, generated docs/configuration, and agent instructions) as expected host changes. Scope concerns must be evaluated against approved product paths and ticket requirements; do not require an exact full-worktree status listing. Future Builder actions are not preparation failures: when an approved requirement specifies test-first ordering, a migration, rollback rehearsal, or other implementation-time sequence, represent it as a mandatory postimplementation check requiring retained Builder evidence. Do not mark the absence of that future evidence before Builder starts as a material concern, and do not demand that preparation reproduce historical order. Only report a material concern when the contract cannot state an actionable postimplementation check or when an already-required preimplementation fact is missing. Return RAFI_QA_ASSESSMENT_START/END with QaSemanticAssessmentV1 (schema: ${JSON.stringify(qaPreparationDepthDecisionV1Schema)}). The concerns field is an array of objects, never strings; every concern object must have exactly these six fields and no others: {reason:string, requirementIds:string[], checkIds:string[], material:boolean, owner:string, nextAction:string}. Do not use legacy fields such as severity, evidence, title, message, category, or resolution. Use concerns: [] only when all issues are resolved. assessedRequirementIds MUST contain every ID in this exact list, even when a requirement is host-owned or has no concern: ${JSON.stringify(candidate.requirements.map(requirement => requirement.id))}. Put every individually assessed required obligation label in assessedObligations, using the exact labels below; do not combine labels or claim to have assessed anything you did not assess. Required obligation labels: ${JSON.stringify(depthObligations(candidate.depthDecision.level))}. Bind exactly ${JSON.stringify(binding)}.\nPrior independent concerns requiring concrete resolution evidence: ${JSON.stringify(targetedConcerns)}\nOriginal inventory:\n${JSON.stringify(inventory)}\nDraft:\n${JSON.stringify(candidate)}`);
+        let assessmentResponse = retainedAssessment?.draftPayloadDigest === draftDigest(candidate) ? undefined : await run("assess", "assessment", `Independent semantic assessment in a fresh conversation. Assess each original requirement and selected-depth obligation; identify omissions, conflicts, practical verification gaps, accidental scope, and unsupported dispositions. Treat Rafi-owned bookkeeping paths (.tickets, .rafi, generated docs/configuration, and agent instructions) as expected host changes. Scope concerns must be evaluated against approved product paths and ticket requirements; do not require an exact full-worktree status listing. Future Builder actions are not preparation failures: when an approved requirement specifies test-first ordering, a migration, rollback rehearsal, or other implementation-time sequence, represent it as a mandatory postimplementation check requiring retained Builder evidence. Do not mark the absence of that future evidence before Builder starts as a material concern, and do not demand that preparation reproduce historical order. If a concern's only next action is to inspect, compare, run, or otherwise produce evidence for a check that is already declared with postimplementation timing, set that concern material:false; it is an actionable future check, not a preparation blocker. Only report a material concern when the contract cannot state an actionable postimplementation check or when an already-required preimplementation fact is missing. Return RAFI_QA_ASSESSMENT_START/END with QaSemanticAssessmentV1 (schema: ${JSON.stringify(qaPreparationDepthDecisionV1Schema)}). The concerns field is an array of objects, never strings; every concern object must have exactly these six fields and no others: {reason:string, requirementIds:string[], checkIds:string[], material:boolean, owner:string, nextAction:string}. Do not use legacy fields such as severity, evidence, title, message, category, or resolution. Use concerns: [] only when all issues are resolved. assessedRequirementIds MUST contain every ID in this exact list, even when a requirement is host-owned or has no concern: ${JSON.stringify(candidate.requirements.map(requirement => requirement.id))}. Put every individually assessed required obligation label in assessedObligations, using the exact labels below; do not combine labels or claim to have assessed anything you did not assess. Required obligation labels: ${JSON.stringify(depthObligations(candidate.depthDecision.level))}. Bind exactly ${JSON.stringify(binding)}.\nPrior independent concerns requiring concrete resolution evidence: ${JSON.stringify(targetedConcerns)}\nOriginal inventory:\n${JSON.stringify(inventory)}\nDraft:\n${JSON.stringify(candidate)}`);
         let assessed = assessmentResponse
             ? await parsedContract(assessmentResponse, "RAFI_QA_ASSESSMENT", validateAssessmentContract, "QA semantic assessment", (value, response) => normalizeAssessment(value, response))
             : { value: retainedAssessment, response: undefined };
@@ -419,6 +433,11 @@ export async function prepareVerificationContract(initial, inventory, deps) {
         // session identity, but it cannot prove or safely author the builder's ID.
         assessed.value.authorSessionId = binding.authorSessionId;
         for (let repair = 0; assessmentResponse && repair < 3; repair++) {
+            // Apply host-owned current-branch applicability normalization before
+            // semantic validation. Otherwise an assessor's material sibling-absence
+            // concern is rejected before the host can downgrade that non-binding
+            // concern to an auditable, non-material observation.
+            assessed.value = normalizeExpectedFutureAssessment(assessed.value, candidate);
             const semanticIssues = validateAssessment(candidate, assessed.value, authorSessionId);
             if (!semanticIssues.length)
                 break;

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;