ai-foreman 1.7.19 → 1.7.21

package/dist/qaContractDelivery.js

@@ -0,0 +1,145 @@
+import { dispatchWithGraphAccess } from "./graph/session.js";
+import { randomUUID } from "node:crypto";
+import { lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { contractDigest, parsePreparationArtifact, renderVerificationContract, verifyContractDigest } from "./qaVerificationContract.js";
+import { OperationDeadline } from "./util/deadline.js";
+// Durable receipts prove historical transport. They cannot prove a freshly
+// constructed adapter has an armed native-compaction barrier.
+const activeDeliveries = new WeakMap();
+function activeDeliveryKey(digest, session) { return JSON.stringify({ digest, session }); }
+export function actualContractSession(adapter, workspace, configRoot) {
+    const ref = adapter.sessionRef?.();
+    if (!ref || ref.role !== "builder" || ref.sessionId !== adapter.sessionId() || ref.cwd !== realpathSync(workspace) || ref.configRoot !== realpathSync(configRoot) || ref.provider !== adapter.agent)
+        throw new Error("Contract delivery requires the actual scoped Builder session/workspace");
+    return { provider: ref.provider, sessionId: ref.sessionId, generation: ref.generation, workspace: ref.cwd, configRoot: ref.configRoot, compactionSequence: adapter.contractCompactionSequence?.() ?? 0 };
+}
+export function materializeContract(contract, workspace) {
+    verifyContractDigest(contract);
+    const root = realpathSync(workspace);
+    // .foreman is already excluded by product-source capture and snapshots.
+    const directory = join(root, ".foreman", "qa-contracts");
+    for (const part of [join(root, ".foreman"), directory]) {
+        try {
+            if (lstatSync(part).isSymbolicLink())
+                throw new Error("Contract projection cannot follow a control-directory symlink");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        mkdirSync(part, { recursive: true });
+    }
+    const json = JSON.stringify(contract, null, 2), markdown = renderVerificationContract(contract);
+    for (const [extension, content] of [["json", json], ["md", markdown]]) {
+        const target = join(directory, `${contract.contentDigest}.${extension}`), temporary = `${target}.${randomUUID()}.tmp`;
+        writeFileSync(temporary, content, { mode: 0o444 });
+        renameSync(temporary, target);
+        if (readFileSync(target, "utf8") !== content)
+            throw new Error("Contract projection digest verification failed");
+    }
+    return { json: join(directory, `${contract.contentDigest}.json`), markdown: join(directory, `${contract.contentDigest}.md`), resourceDigest: contractDigest("delivery-resources", { json, markdown }) };
+}
+/** Complete retained review inputs, accessible inside the confined QA snapshot. */
+export function finalReviewContractContext(contract, store, workspace, builderClaims = []) {
+    const resources = materializeContract(contract, workspace);
+    const baselineEvidence = contract.baseline.map(observation => {
+        const artifact = store.artifact(observation.evidenceDigest, "baseline-observation");
+        return { digest: observation.evidenceDigest, artifact, ...(artifact.providerReceipt ? { providerEvidence: store.artifact(artifact.providerReceipt, "investigation-evidence") } : {}) };
+    });
+    const context = { version: 1, contract, baselineEvidence, builderClaims };
+    const serialized = JSON.stringify(context);
+    const digest = contractDigest("final-review-context", context);
+    const path = join(resolve(resources.json, ".."), `${digest}.review.json`);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(temporary, serialized, { mode: 0o444 });
+    renameSync(temporary, path);
+    if (readFileSync(path, "utf8") !== serialized)
+        throw new Error("Final review context projection verification failed");
+    return `\nComplete retained QA context: ${path}\nFinal review context digest: ${digest}. Contract JSON: ${resources.json}. Read the complete context before reporting coverage. Baseline evidence is historical, bound to its original source; assess relevance and expected transitions independently. Builder claims are untrusted and require independent verification. If any required resource is inaccessible, report blocked coverage rather than pass.\n${Buffer.byteLength(serialized) <= 128 * 1024 ? `Full structured review context:\n${serialized}\n` : "The full context exceeds the inline limit; use the read-only JSON resource without omitting sections.\n"}`;
+}
+export async function deliverVerificationContract(contract, store, adapter, workspace, configRoot, context) {
+    const capabilities = adapter.contractCapabilities?.();
+    if (!capabilities?.sameSessionAcceptance || !capabilities.nativeCompactionBarrier || !adapter.enableContractEnforcement || !adapter.acceptContractDelivery)
+        throw new Error(`unsupported-capability: ${adapter.agent} has no tested same-session acceptance/native compaction barrier`);
+    activeDeliveries.delete(adapter);
+    adapter.enableContractEnforcement();
+    await adapter.prepareSession?.();
+    const session = actualContractSession(adapter, workspace, configRoot);
+    const resources = materializeContract(contract, workspace);
+    const operationId = `contract-acceptance:${randomUUID()}`;
+    const expiresAt = Date.now() + 120_000;
+    const acceptTurn = (text) => new OperationDeadline("Contract acceptance", Math.max(1, expiresAt - Date.now())).run(() => dispatchWithGraphAccess(configRoot, adapter, text, { purpose: "contract-acceptance", responseOnly: true }, (prompt, policy) => adapter.sendTurn(prompt, policy)), () => { void adapter.close(); });
+    const instruction = `${context}\n\n${renderVerificationContract(contract)}\n\nFull structured contract:\n${JSON.stringify(contract)}\n\nDurable artifacts: ${resources.json}, ${resources.markdown}. This is a tools-disabled acceptance turn in the actual Builder conversation. Return RAFI_QA_ACCEPTANCE_START/END containing {"workId":"${contract.workId}","revision":${contract.revision},"digest":"${contract.contentDigest}","missingSections":[]}. This confirms transport/version only. Implementation starts only after host acceptance.`;
+    let finalInstruction = instruction;
+    if (Buffer.byteLength(instruction) > 256 * 1024) {
+        const sections = segmentContractTransport(instruction);
+        if (sections.length > 256)
+            throw new Error("Contract exceeds bounded segmented delivery capacity");
+        const manifest = sections.map((content, index) => ({ index, digest: contractDigest("delivery-section", content), bytes: Buffer.byteLength(content) }));
+        store.event(contract.runId, contract.workId, `${operationId}:manifest`, "delivery-manifest", { session, contractDigest: contract.contentDigest, manifest });
+        for (const section of manifest) {
+            const segmentInstruction = `Contract transport segment ${section.index + 1}/${sections.length}. Tools disabled; retain this entire section in this conversation. Contract digest: ${contract.contentDigest}.\n${sections[section.index]}\nReturn RAFI_QA_SEGMENT_START/END containing ${JSON.stringify({ index: section.index, digest: section.digest, missingSections: [] })}. No implementation is authorized.`;
+            store.event(contract.runId, contract.workId, `${operationId}:segment:${section.index}:intent`, "delivery-segment-intended", { session, section });
+            if (Date.now() >= expiresAt)
+                throw new Error("Bounded contract delivery deadline exhausted");
+            const result = await acceptTurn(segmentInstruction);
+            store.event(contract.runId, contract.workId, `${operationId}:segment:${section.index}:result`, "delivery-segment-result", result);
+            if (result.isError || result.failure || JSON.stringify(actualContractSession(adapter, workspace, configRoot)) !== JSON.stringify(session))
+                throw new Error("Segmented contract transport failed or crossed a session boundary");
+            const acknowledgment = parsePreparationArtifact(result.text, "RAFI_QA_SEGMENT", 64 * 1024);
+            if (acknowledgment.index !== section.index || acknowledgment.digest !== section.digest || !Array.isArray(acknowledgment.missingSections) || acknowledgment.missingSections.length)
+                throw new Error("Segmented contract acknowledgment is incomplete");
+        }
+        finalInstruction = `All ${sections.length} sections of contract ${contract.contentDigest} have been delivered in this actual Builder conversation. Verify the complete section inventory ${JSON.stringify(manifest)}. Tools disabled. Return RAFI_QA_ACCEPTANCE_START/END containing ${JSON.stringify({ workId: contract.workId, revision: contract.revision, digest: contract.contentDigest, missingSections: [] })}. If any content or condition is inaccessible, list the missing sections; do not accept partial context.`;
+    }
+    store.event(contract.runId, contract.workId, operationId, "delivery-intended", { session, contractDigest: contract.contentDigest, instructionDigest: contractDigest("delivery-instruction", instruction) });
+    if (Date.now() >= expiresAt)
+        throw new Error("Bounded contract delivery deadline exhausted");
+    const response = await acceptTurn(finalInstruction);
+    store.event(contract.runId, contract.workId, `${operationId}:result`, "delivery-result", { response, session });
+    if (response.isError || response.failure)
+        throw new Error("Actual Builder contract acceptance failed; inspect retained delivery result");
+    const acceptance = parsePreparationArtifact(response.text, "RAFI_QA_ACCEPTANCE", 64 * 1024);
+    const after = actualContractSession(adapter, workspace, configRoot);
+    if (JSON.stringify(session) !== JSON.stringify(after) || acceptance.workId !== contract.workId || acceptance.revision !== contract.revision || acceptance.digest !== contract.contentDigest || !Array.isArray(acceptance.missingSections) || acceptance.missingSections.length)
+        throw new Error("Missing/foreign/stale contract acceptance");
+    const receipt = { version: 1, operationId, runId: contract.runId, workId: contract.workId, admissionDigest: contract.admissionDigest, revision: contract.revision, contractDigest: contract.contentDigest, resourceDigest: resources.resourceDigest, ...session, responseDigest: contractDigest("acceptance-response", response.rawResponse ?? response.text), deliveredAt: new Date().toISOString() };
+    store.receipt(receipt);
+    adapter.acceptContractDelivery(session.compactionSequence);
+    activeDeliveries.set(adapter, activeDeliveryKey(contract.contentDigest, session));
+    return receipt;
+}
+/** Byte bounded, lossless Unicode transport. Concatenation reconstructs the exact original input. */
+export function segmentContractTransport(content, maximumBytes = 96 * 1024) {
+    if (!Number.isSafeInteger(maximumBytes) || maximumBytes < 4)
+        throw new Error("Invalid contract segment capacity");
+    const result = [];
+    let section = "", bytes = 0;
+    for (const character of content) {
+        const size = Buffer.byteLength(character);
+        if (bytes + size > maximumBytes) {
+            result.push(section);
+            section = "";
+            bytes = 0;
+        }
+        section += character;
+        bytes += size;
+    }
+    if (section)
+        result.push(section);
+    return result;
+}
+export function assertContractReceipt(store, runId, workId, admissionDigest, session, adapter) {
+    const head = store.head(runId, workId, admissionDigest);
+    if (head.state !== "ready" || !head.digest)
+        throw new Error(`Implementation requires ready verification contract: ${head.state}`);
+    const contract = store.contract(head.digest);
+    if (!session || !store.receipts(head.digest).some(receipt => receipt.runId === runId && receipt.workId === workId && receipt.admissionDigest === admissionDigest && receipt.revision === contract.revision && ["provider", "sessionId", "generation", "workspace", "configRoot", "compactionSequence"].every(key => receipt[key] === session[key])))
+        throw new Error("Implementation requires current actual-session contract receipt");
+    if (resolve(session.workspace) !== session.workspace)
+        throw new Error("Contract workspace identity is not canonical");
+    if (adapter && activeDeliveries.get(adapter) !== activeDeliveryKey(contract.contentDigest, session))
+        throw new Error("Implementation requires current adapter contract receipt and armed enforcement barrier");
+    return contract;
+}

package/dist/qaContractFreshness.d.ts

@@ -0,0 +1,15 @@
+import type { ContractInputRef, QaVerificationContractV1 } from "rafi-spec";
+/** Source implementing the contract is not a semantic freshness input. */
+export declare function compareContractInputs(contract: QaVerificationContractV1, current: ContractInputRef[]): {
+    changed: string[];
+    unavailable: string[];
+    targetedBaseline: string[];
+};
+export declare function reconcileContractChecks(before: QaVerificationContractV1, after: QaVerificationContractV1): {
+    unchanged: string[];
+    changed: string[];
+    added: string[];
+    removed: string[];
+    rerun: string[];
+    carryForwardCandidates: string[];
+};

package/dist/qaContractFreshness.js

@@ -0,0 +1,36 @@
+import { contractDigest } from "./qaVerificationContract.js";
+/** Source implementing the contract is not a semantic freshness input. */
+export function compareContractInputs(contract, current) {
+    const changed = [], unavailable = [], targetedBaseline = [];
+    for (const input of contract.inputs) {
+        const next = current.find(ref => ref.id === input.id);
+        if (!next || next.availability !== "available") {
+            unavailable.push(input.id);
+            continue;
+        }
+        if (next.digest !== input.digest || next.authority !== input.authority || next.revision !== input.revision)
+            (input.kind === "baseline" ? targetedBaseline : changed).push(input.id);
+    }
+    for (const input of current)
+        if (!contract.inputs.some(ref => ref.id === input.id) && input.kind !== "baseline")
+            changed.push(input.id);
+    return { changed, unavailable, targetedBaseline };
+}
+export function reconcileContractChecks(before, after) {
+    if (before.runId !== after.runId || before.workId !== after.workId || after.predecessorDigest !== before.contentDigest || after.revision !== before.revision + 1)
+        throw new Error("Amendment must identify its exact predecessor/work");
+    const unchanged = [], changed = [], added = [], removed = [];
+    for (const check of after.checks) {
+        const prior = before.checks.find(row => row.id === check.id);
+        if (!prior)
+            added.push(check.id);
+        else if (contractDigest("check-meaning", prior) === contractDigest("check-meaning", check))
+            unchanged.push(check.id);
+        else
+            throw new Error(`Changed meaning cannot reuse stable check ID ${check.id}; allocate an explicit successor`);
+    }
+    for (const prior of before.checks)
+        if (!after.checks.some(check => check.id === prior.id))
+            removed.push(prior.id);
+    return { unchanged, changed, added, removed, rerun: [...changed, ...added], carryForwardCandidates: unchanged };
+}

package/dist/qaDeliveryJournal.d.ts

@@ -68,3 +68,13 @@ export interface QaDeliveryTurnV3 {
     captureElapsedMs?: number;
     validationElapsedMs?: number;
 }
+/** V4 distinguishes evidence continuations from the one response-only repair. */
+export interface QaDeliveryTurnV4 extends Omit<QaDeliveryTurnV3, "version" | "kind"> {
+    version: 4;
+    kind: "remediation" | "graph-continuation" | "response-repair";
+}
+export type QaDeliveryTurn = QaDeliveryTurnV3 | QaDeliveryTurnV4;
+/** Independent of preparation's schema revision: old writers cannot mutate an
+ * evidence-continuation journal they would interpret as a response-only repair. */
+export declare function registerQaGraphJournalWriter(db: import("better-sqlite3").Database): void;
+export declare function ensureQaGraphJournalGuards(db: import("better-sqlite3").Database): void;

package/dist/qaDeliveryJournal.js

@@ -1 +1,16 @@
-export {};
+/** Independent of preparation's schema revision: old writers cannot mutate an
+ * evidence-continuation journal they would interpret as a response-only repair. */
+export function registerQaGraphJournalWriter(db) {
+    db.function("rafi_graph_delivery_protocol", () => 4);
+}
+export function ensureQaGraphJournalGuards(db) {
+    const tables = ["qa_delivery_turns", "qa_review_attempts", "qa_remediation_attempts", "qa_turns", "qa_ticket_heads", "qa_operation_journal", "qa_pass_certificates", "build_assignments"];
+    db.transaction(() => {
+        for (const table of tables) {
+            if (!db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(table))
+                continue;
+            for (const action of ["INSERT", "UPDATE", "DELETE"])
+                db.exec(`CREATE TRIGGER IF NOT EXISTS graph_delivery_v4_${table}_${action} BEFORE ${action} ON ${table} BEGIN SELECT CASE WHEN rafi_graph_delivery_protocol() <> 4 THEN RAISE(ABORT,'Graph delivery journal requires a compatible Rafi writer') END; END;`);
+        }
+    })();
+}

package/dist/qaEffectiveConfig.d.ts

@@ -0,0 +1,20 @@
+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 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. */
+export declare function resolveEffectiveQaConfiguration(projectDir: string, settings: Pick<ResolvedAgentSettings, "make">): {
+    digest: string;
+    configRoot: string;
+    qaRules: string;
+    builderRules: string;
+    checklist: string[];
+    skills: {
+        name: string;
+        path: string;
+        content: string;
+        digest: string;
+    }[];
+    roleSource: "compiled" | "library" | "fallback";
+    builderRoleSource: "compiled" | "library" | "fallback";
+};

package/dist/qaEffectiveConfig.js

@@ -0,0 +1,40 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+import { loadSkill } from "special-agents";
+import { loadRoleBundle } from "./roles.js";
+import { loadTicketSetupConfigWithDefaults, loadRafiConfigObject } from "./tickets/setupConfig.js";
+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 function loadQaPreparationPolicy(projectDir) {
+    return resolveQaPreparationConfig(loadRafiConfigObject(projectDir)?.qa_preparation);
+}
+/** Resolve only explicit rule/skill content; never project secrets or mutable .rafi state. */
+export function resolveEffectiveQaConfiguration(projectDir, settings) {
+    const root = realpathSync(projectDir);
+    for (const role of ["qa", "builder"])
+        for (const file of ["system.md", "meta.json"]) {
+            const path = join(root, ".rafi", "compiled", role, file);
+            if (existsSync(path) && !realpathSync(path).startsWith(root + sep))
+                throw new Error("Compiled role configuration escapes the canonical root");
+        }
+    const bundle = loadRoleBundle("qa", { projectDir: root });
+    const builder = loadRoleBundle("builder", { projectDir: root });
+    const checklist = [...loadTicketSetupConfigWithDefaults(root).build.validation_checklist];
+    const skills = bundle.skills.map(name => {
+        if (!/^[A-Za-z0-9_-]+$/.test(name))
+            throw new Error(`Unsafe QA skill reference ${name}`);
+        const runtimeRoot = settings.make === "codex" ? ".codex" : ".claude";
+        const path = [join(root, runtimeRoot, "skills", name, "SKILL.md"), join(root, ".agents", "skills", name, "SKILL.md")].find(existsSync);
+        if (path && !realpathSync(path).startsWith(root + sep))
+            throw new Error(`QA skill ${name} escapes the canonical configuration root`);
+        const skill = path ? { name, body: readFileSync(path, "utf8") } : loadSkill(name);
+        if (!skill.body?.trim())
+            throw new Error(`QA skill ${name} has no dispatchable content`);
+        const content = `## ${skill.name}\n${skill.body.trim()}`;
+        return { name, path: path ?? `special-agents:${name}`, content, digest: contractDigest("skill-content", content) };
+    });
+    const common = { configRoot: resolve(root), qaRules: bundle.system, builderRules: builder.system, checklist, skills, roleSource: bundle.source, builderRoleSource: builder.source };
+    return { ...common, digest: contractDigest("effective-qa-config", common) };
+}

package/dist/qaEvidenceReader.d.ts

@@ -0,0 +1,14 @@
+import type { ManagerEvidenceAvailability } from "rafi-spec";
+export type EvidenceRow = Record<string, unknown>;
+export interface QaEvidenceSnapshot {
+    asOf: string;
+    runId: string;
+    availability: ManagerEvidenceAvailability;
+    capabilities: string[];
+    gaps: string[];
+    rows: Record<string, EvidenceRow[]>;
+    blobs: Map<string, Buffer>;
+}
+/** Inspection never registers a writer, runs a migration, or probes packet paths. */
+export declare function readQaEvidenceSnapshot(projectDir: string, runId: string): QaEvidenceSnapshot;
+export declare function evidenceRecord(row: EvidenceRow, field?: string): EvidenceRow | undefined;

package/dist/qaEvidenceReader.js

@@ -0,0 +1,176 @@
+import { graphDerivedAllowed } from "./graph/derived.js";
+import Database from "better-sqlite3";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { WORKFLOW_DB_FILE } from "./workflowDb.js";
+import { evidenceDigest } from "./managerEvidenceArtifacts.js";
+const scopedTables = ["qa_review_attempts", "qa_reports", "qa_remediation_attempts", "qa_turns", "qa_ticket_heads", "qa_recovery_heads", "qa_transitions", "qa_pass_certificates", "qa_finalization_steps", "qa_failure_handoffs", "qa_operation_journal", "qa_packet_projections", "qa_source_states", "qa_review_bases", "qa_remediation_receipts", "qa_remediation_stops", "build_work_scope", "build_work_admissions", "build_assignments", "build_ownership_conflicts", "build_reconciliations", "build_work_events", "build_instructions", "build_instruction_streams"];
+/** Inspection never registers a writer, runs a migration, or probes packet paths. */
+export function readQaEvidenceSnapshot(projectDir, runId) {
+    const result = { runId, asOf: new Date().toISOString(), availability: "missing", capabilities: [], gaps: [], rows: {}, blobs: new Map() };
+    const path = join(resolve(projectDir), WORKFLOW_DB_FILE);
+    if (!existsSync(path)) {
+        result.gaps.push("workflow database is missing");
+        return result;
+    }
+    let db;
+    try {
+        db = new Database(path, { readonly: true, fileMustExist: true });
+        db.pragma("query_only = ON");
+        const connection = db;
+        connection.transaction(() => {
+            const tables = new Set(connection.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map(row => row.name));
+            const read = (name, query, ...args) => {
+                if (!tables.has(name)) {
+                    result.gaps.push(`${name}: unsupported legacy schema`);
+                    return;
+                }
+                try {
+                    result.rows[name] = connection.prepare(query).all(...args);
+                }
+                catch (error) {
+                    if (!/no such column|no such table/i.test(String(error)))
+                        throw error;
+                    result.gaps.push(`${name}: unsupported legacy columns`);
+                    return;
+                }
+                result.capabilities.push(name);
+                // Invalid JSON must remain visible instead of becoming empty history.
+                for (const row of result.rows[name])
+                    for (const [field, value] of Object.entries(row)) {
+                        if (field.endsWith("_json") && typeof value === "string") {
+                            if (!graphDerivedAllowed(connection, projectDir, evidenceDigest(Buffer.from(value)))) {
+                                row[field] = null;
+                                row[`${field}_availability`] = "revoked-graph-evidence";
+                                result.gaps.push(`${name}/${field}: graph-derived evidence withheld by current policy`);
+                                continue;
+                            }
+                            try {
+                                JSON.parse(value);
+                            }
+                            catch {
+                                result.gaps.push(`${name}/${field}: corrupt retained JSON`);
+                                result.availability = "corrupt";
+                            }
+                        }
+                    }
+            };
+            read("workflow_runs", "SELECT * FROM workflow_runs WHERE run_id=?", runId);
+            if (!result.rows.workflow_runs?.length) {
+                result.gaps.push("requested workflow run is missing");
+                return;
+            }
+            if (result.availability !== "corrupt")
+                result.availability = "present";
+            for (const table of scopedTables)
+                read(table, `SELECT * FROM ${table} WHERE run_id=?`, runId);
+            read("qa_remediation_authorizations", "SELECT * FROM qa_remediation_authorizations WHERE run_id=?", runId);
+            read("workflow_events", "SELECT * FROM workflow_events WHERE run_id=? ORDER BY sequence", runId);
+            read("continuity_events", "SELECT * FROM continuity_events WHERE run_id=? ORDER BY sequence", runId);
+            read("operation_journal", "SELECT * FROM operation_journal WHERE run_id=?", runId);
+            read("human_decisions", "SELECT * FROM human_decisions WHERE run_id=?", runId);
+            if (tables.has("qa_delivery_turns") && tables.has("qa_reports")) {
+                const columns = connection.prepare("PRAGMA table_info(qa_reports)").all();
+                if (columns.some(column => column.name === "report_occurrence_id"))
+                    read("qa_delivery_turns", "SELECT d.* FROM qa_delivery_turns d JOIN qa_reports r ON r.report_occurrence_id=d.report_occurrence_id WHERE r.run_id=?", runId);
+                else
+                    result.gaps.push("qa_delivery_turns: occurrence identity unsupported");
+            }
+            else
+                result.gaps.push("qa_delivery_turns: unsupported legacy schema");
+            for (const [name, query] of Object.entries({
+                build_instruction_deliveries: "SELECT d.* FROM build_instruction_deliveries d JOIN build_instructions i USING(instruction_id) WHERE i.run_id=?",
+                build_instruction_events: "SELECT e.* FROM build_instruction_events e JOIN build_instructions i USING(instruction_id) WHERE i.run_id=? ORDER BY e.sequence",
+                qa_report_dispositions: "SELECT d.* FROM qa_report_dispositions d JOIN qa_reports r USING(report_occurrence_id) WHERE r.run_id=? ORDER BY d.sequence",
+                qa_report_chains: "SELECT c.* FROM qa_report_chains c JOIN qa_reports r ON r.report_occurrence_id=c.predecessor_occurrence_id WHERE r.run_id=?",
+            }))
+                read(name, query, runId);
+            for (const report of result.rows.qa_reports ?? []) {
+                if (typeof report.report_occurrence_id !== "string") {
+                    result.gaps.push("qa_reports: legacy digest identity may be ambiguous; use the retained run/work/review scope");
+                    continue;
+                }
+                const parent = (result.rows.qa_review_attempts ?? []).find(row => row.ticket_id === report.ticket_id && row.review_number === report.review_number);
+                if (!parent || parent.source_digest !== report.source_state_digest || parent.report_digest !== report.report_digest) {
+                    result.gaps.push(`qa_reports/${report.report_occurrence_id}: contradictory or missing review parent`);
+                    result.availability = "corrupt";
+                }
+            }
+            for (const [name, rows] of Object.entries(result.rows))
+                if (name.startsWith("qa_"))
+                    for (const row of rows) {
+                        if ("run_id" in row && row.run_id !== runId || "ticket_id" in row && typeof row.ticket_id !== "string") {
+                            result.gaps.push(`${name}: corrupt scoped row identity`);
+                            result.availability = "corrupt";
+                        }
+                        if ("review_number" in row && (!Number.isSafeInteger(row.review_number) || Number(row.review_number) < 1)) {
+                            result.gaps.push(`${name}: corrupt review ordinal`);
+                            result.availability = "corrupt";
+                        }
+                    }
+            // Copy only blobs referenced by scoped rows. Never allow a guessed digest read.
+            const references = new Set();
+            const collect = (value) => {
+                if (typeof value === "string" && /^[a-f0-9]{64}$/.test(value))
+                    references.add(value);
+                else if (Array.isArray(value))
+                    value.forEach(collect);
+                else if (value && typeof value === "object")
+                    Object.values(value).forEach(collect);
+            };
+            for (const rows of Object.values(result.rows))
+                for (const row of rows)
+                    for (const [field, value] of Object.entries(row)) {
+                        if (field.endsWith("_json") && typeof value === "string") {
+                            try {
+                                collect(JSON.parse(value));
+                            }
+                            catch { /* already disclosed */ }
+                        }
+                        else
+                            collect(value);
+                    }
+            if (!tables.has("content_refs"))
+                result.gaps.push("content_refs: unsupported legacy schema");
+            else
+                for (const digest of references) {
+                    if (!graphDerivedAllowed(connection, projectDir, digest)) {
+                        result.gaps.push(`content ${digest}: graph access revoked`);
+                        continue;
+                    }
+                    const row = connection.prepare("SELECT content FROM content_refs WHERE digest=?").get(digest);
+                    if (row) {
+                        const bytes = Buffer.from(row.content);
+                        if (evidenceDigest(bytes) !== digest) {
+                            result.gaps.push(`content ${digest}: corrupt digest`);
+                            result.availability = "corrupt";
+                        }
+                        else
+                            result.blobs.set(digest, bytes);
+                    }
+                }
+            if (!result.capabilities.includes("qa_review_attempts") && result.availability !== "corrupt")
+                result.availability = "unsupported_legacy";
+        })();
+    }
+    catch (error) {
+        result.availability = /malformed|not a database|corrupt/i.test(String(error)) ? "corrupt" : "unreadable";
+        result.gaps.push(`workflow evidence ${result.availability}: ${String(error)}`);
+        // Do not expose a partial transaction as a complete snapshot.
+        result.rows = {};
+        result.blobs.clear();
+    }
+    finally {
+        db?.close();
+    }
+    return result;
+}
+export function evidenceRecord(row, field = "record_json") {
+    try {
+        const parsed = JSON.parse(String(row[field]));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/qaFailureDelivery.d.ts

@@ -105,9 +105,11 @@ export declare class QaFailureDeliveryService {
     private readonly faults;
     constructor(faults?: QaDeliveryFaultHooks);
     deliver(input: QaFailureDeliveryInput, controller: QaFailureDeliveryController): Promise<QaFailureDeliveryResult>;
+    private deliverOwned;
     private deliverAttempt;
     private turnIntent;
     private dispatch;
+    private dispatchOwned;
     private classify;
     private drift;
     private buildHandoff;