agentwrangler 0.1.0

package/dist/evidence/r3/packet.js

@@ -0,0 +1,162 @@
+import { createHmac, randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { publishApprovedOutput } from "../common/approved-input.js";
+import { canonicalJson, sha256Bytes, sha256Canonical } from "../common/canonical.js";
+import { redactEvidenceExcerpt } from "../common/redaction.js";
+import { evaluateR3Private } from "./evaluate.js";
+import { R3_PACKET_VERSION, R3_SCORER_VERSION, } from "./types.js";
+const SHA256_RE = /^[0-9a-f]{64}$/u;
+function refuse(code) {
+    throw new Error(code);
+}
+function retainedFailure(error, artifacts) {
+    const message = error instanceof Error && /^[a-z0-9_]+$/u.test(error.message)
+        ? error.message
+        : "r3_packet_failure";
+    return new Error(`${message}_${artifacts.join("_and_")}_retained`);
+}
+function directFile(state, value) {
+    const statePath = fs.realpathSync.native(state);
+    const filePath = fs.realpathSync.native(value);
+    if (path.dirname(filePath) !== statePath)
+        refuse("r3_aggregate_path_invalid");
+    return filePath;
+}
+function rank(seed, domain, value) {
+    return createHmac("sha256", seed).update(domain).update("\0").update(value).digest("hex");
+}
+function stableIdentity(candidate) {
+    return `${candidate.repoAlias}\0${candidate.sessionId}\0${candidate.candidateWorkItemId ?? ""}`;
+}
+function backtestSample(candidates, seed) {
+    const byAlias = new Map();
+    for (const candidate of candidates) {
+        const rows = byAlias.get(candidate.repoAlias) ?? [];
+        rows.push(candidate);
+        byAlias.set(candidate.repoAlias, rows);
+    }
+    for (const rows of byAlias.values()) {
+        rows.sort((a, b) => rank(seed, "backtest", stableIdentity(a)).localeCompare(rank(seed, "backtest", stableIdentity(b))));
+    }
+    const result = [];
+    const aliases = [...byAlias.keys()].sort();
+    for (let index = 0; result.length < 100; index += 1) {
+        let added = false;
+        for (const alias of aliases) {
+            const row = byAlias.get(alias)?.[index];
+            if (row !== undefined && result.length < 100) {
+                result.push(row);
+                added = true;
+            }
+        }
+        if (!added)
+            break;
+    }
+    return result;
+}
+function day(value) {
+    return value !== null && Number.isFinite(Date.parse(value))
+        ? new Date(value).toISOString().slice(0, 10)
+        : "UNKNOWN";
+}
+/** Build a mixed, blinded packet and a separately published private join key. */
+export async function packetR3(request, dependencies = {}) {
+    if (!SHA256_RE.test(request.aggregateSha256))
+        refuse("r3_aggregate_digest_invalid");
+    const evaluated = await evaluateR3Private({ ...request, out: request.packetOut });
+    const retainedArtifacts = ["scratch_verification"];
+    try {
+        const aggregateBytes = fs.readFileSync(directFile(evaluated.approved.scratchStatePath, request.aggregatePath));
+        if (sha256Bytes(aggregateBytes) !== request.aggregateSha256)
+            refuse("r3_aggregate_digest_mismatch");
+        let aggregate;
+        try {
+            aggregate = JSON.parse(aggregateBytes.toString("utf8"));
+        }
+        catch {
+            refuse("r3_aggregate_json_invalid");
+        }
+        if (canonicalJson(aggregate) !== canonicalJson(evaluated.report))
+            refuse("r3_aggregate_content_mismatch");
+        const seed = dependencies.randomSeed?.() ?? randomBytes(32);
+        if (!Buffer.isBuffer(seed) || seed.length < 32)
+            refuse("r3_random_seed_invalid");
+        const commitment = sha256Bytes(seed);
+        const campaignId = sha256Canonical({
+            identity: evaluated.report.identity,
+            aggregate: request.aggregateSha256,
+        }).slice(0, 32);
+        const uplift = evaluated.candidates.filter((candidate) => candidate.candidateReason === "UNIQUE_CANDIDATE" &&
+            candidate.disposition !== "HIGHER_PRECEDENCE" &&
+            candidate.candidateWorkItemId !== null);
+        const backtest = backtestSample(evaluated.candidates.filter((candidate) => candidate.candidateReason === "UNIQUE_CANDIDATE" &&
+            candidate.disposition === "HIGHER_PRECEDENCE" &&
+            candidate.candidateWorkItemId !== null), seed);
+        const selected = [
+            ...uplift.map((candidate) => ({ candidate, cohort: "UPLIFT" })),
+            ...backtest.map((candidate) => ({ candidate, cohort: "BACKTEST" })),
+        ];
+        selected.sort((a, b) => rank(seed, "order", stableIdentity(a.candidate)).localeCompare(rank(seed, "order", stableIdentity(b.candidate))));
+        const keyEntries = [];
+        const entries = selected.map(({ candidate, cohort }) => {
+            const stable = stableIdentity(candidate);
+            const candidateId = rank(seed, "candidate", stable).slice(0, 32);
+            const proposedPrAlias = `pr-${rank(seed, "pr", candidate.candidateWorkItemId).slice(0, 16)}`;
+            const rawExcerpt = dependencies.intentExcerpt?.(candidate);
+            const redacted = rawExcerpt === undefined ? undefined : redactEvidenceExcerpt(rawExcerpt);
+            const redactionFailed = rawExcerpt !== undefined && redacted === null;
+            keyEntries.push({
+                candidateId,
+                sessionId: candidate.sessionId,
+                candidateWorkItemId: candidate.candidateWorkItemId,
+                repoAlias: candidate.repoAlias,
+                cohort,
+                backtestCorrect: candidate.backtestCorrect,
+                redactionFailed,
+            });
+            return {
+                candidateId,
+                repoAlias: candidate.repoAlias,
+                sessionWindow: {
+                    startedBucket: day(candidate.firstTurnAt),
+                    endedBucket: day(candidate.lastTurnAt),
+                },
+                proposedPrAlias,
+                structuredEvidence: {
+                    sessionCommitSignalN: candidate.commitSignalN,
+                    prLifecycleOverlap: candidate.lifecycleOverlap,
+                    acceptedHigherPrecedenceSignal: candidate.excludedBy === null ? "ABSENT" : "PRESENT",
+                    ...(redacted === undefined || redacted === null
+                        ? {}
+                        : { redactedIntentExcerpt: redacted }),
+                },
+                question: "SAME_WORK_ITEM",
+            };
+        });
+        const packet = {
+            campaignId,
+            packetVersion: R3_PACKET_VERSION,
+            randomizationSeedCommitment: commitment,
+            aggregateSha256: request.aggregateSha256,
+            entries,
+        };
+        const key = {
+            campaignId,
+            packetVersion: R3_PACKET_VERSION,
+            scorerVersion: R3_SCORER_VERSION,
+            randomizationSeed: seed.toString("hex"),
+            randomizationSeedCommitment: commitment,
+            aggregateSha256: request.aggregateSha256,
+            entries: keyEntries,
+        };
+        publishApprovedOutput(evaluated.approved, request.packetOut, canonicalJson(packet));
+        retainedArtifacts.push("packet");
+        publishApprovedOutput(evaluated.approved, request.keyOut, canonicalJson(key));
+        retainedArtifacts.push("sealed_key");
+        return { packet, key };
+    }
+    catch (error) {
+        throw retainedFailure(error, retainedArtifacts);
+    }
+}

package/dist/evidence/r3/prepare.js

@@ -0,0 +1,405 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import Database from "better-sqlite3";
+import { runMigrations } from "../../db/migrate.js";
+import { snapshotSessionWorkLinks } from "../../outcomes/linker.js";
+import { backfillMissingWorkItemBranchKeys } from "../../outcomes/sync.js";
+import { loadApprovedEvidenceInput, publishApprovedOutput, } from "../common/approved-input.js";
+import { canonicalJson, sha256Canonical, sha256File } from "../common/canonical.js";
+import { assertDatabaseIntegrity } from "../common/sqlite.js";
+import { R3_REASON_VOCABULARY_VERSION, R3_RUNNER_VERSION, } from "./types.js";
+const REQUIRED_SCHEMA_6 = [
+    "001_observe",
+    "002_indexes",
+    "003_context_inventory_history",
+    "004_apply_jobs",
+    "005_tool_event_metadata",
+    "006_d7_query_indexes",
+];
+const REQUIRED_SCHEMA_7 = [...REQUIRED_SCHEMA_6, "007_work_item_branch_keys"];
+const SHA256_RE = /^[0-9a-f]{64}$/u;
+const COMMIT_RE = /^[0-9a-f]{40}$/u;
+const STRICT_UTC = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/u;
+const EVALUATOR_MODULE_PATH = fileURLToPath(new URL("../../outcomes/linker.ts", import.meta.url));
+function refuse(code) {
+    throw new Error(code);
+}
+function retainedFailure(error, artifacts) {
+    const message = error instanceof Error && /^[a-z0-9_]+$/u.test(error.message)
+        ? error.message
+        : "r3_prepare_failure";
+    return new Error(`${message}_${artifacts.join("_and_")}_retained`);
+}
+function validateRequest(request) {
+    if (!COMMIT_RE.test(request.evaluatorCommit))
+        refuse("r3_evaluator_commit_invalid");
+    if (!SHA256_RE.test(request.evaluatorModuleSha256))
+        refuse("r3_evaluator_digest_invalid");
+    if (!STRICT_UTC.test(request.asOf) || !Number.isFinite(Date.parse(request.asOf))) {
+        refuse("r3_as_of_invalid");
+    }
+    if (!Number.isSafeInteger(request.backfillPageSize) ||
+        request.backfillPageSize < 1 ||
+        request.backfillPageSize > 1_000) {
+        refuse("r3_backfill_page_size_invalid");
+    }
+    if (!Number.isSafeInteger(request.githubConcurrency) ||
+        request.githubConcurrency < 1 ||
+        request.githubConcurrency > 32) {
+        refuse("r3_github_concurrency_invalid");
+    }
+    if (request.resume !== (request.workingDbSha256 !== null)) {
+        refuse("r3_working_db_resume_binding_invalid");
+    }
+    if (request.workingDbSha256 !== null && !SHA256_RE.test(request.workingDbSha256)) {
+        refuse("r3_working_db_digest_invalid");
+    }
+}
+function directWorkingPath(approved, candidate) {
+    const parent = fs.realpathSync.native(path.dirname(path.resolve(candidate)));
+    if (parent !== approved.scratchStatePath)
+        refuse("r3_working_db_not_direct_state_child");
+    return path.join(parent, path.basename(candidate));
+}
+function initializeCheckpoint(db, request, approved) {
+    db.exec(`
+    CREATE TABLE r3_prepare_checkpoint (
+      singleton INTEGER PRIMARY KEY CHECK (singleton=1),
+      approved_input_db_sha256 TEXT NOT NULL,
+      evaluator_commit TEXT NOT NULL,
+      evaluator_module_sha256 TEXT NOT NULL,
+      repo_map_sha256 TEXT NOT NULL,
+      as_of TEXT NOT NULL,
+      link_snapshot_sha256 TEXT NOT NULL,
+      ineligible_n INTEGER NOT NULL,
+      failed_n INTEGER NOT NULL,
+      failure_reason_json TEXT NOT NULL,
+      completed INTEGER NOT NULL
+    );
+    CREATE TABLE r3_prepare_initial_keys (
+      work_item_id TEXT PRIMARY KEY
+    );
+    INSERT INTO r3_prepare_initial_keys(work_item_id)
+      SELECT work_item_id FROM work_item_branch_keys;
+  `);
+    db.prepare(`INSERT INTO r3_prepare_checkpoint
+      (singleton,approved_input_db_sha256,evaluator_commit,evaluator_module_sha256,
+       repo_map_sha256,as_of,link_snapshot_sha256,ineligible_n,failed_n,failure_reason_json,completed)
+     VALUES (1,?,?,?,?,?,?,0,0,'{}',0)`).run(approved.scratchDbSha256, request.evaluatorCommit, request.evaluatorModuleSha256, approved.repoMapSha256, request.asOf, sha256Canonical(JSON.parse(snapshotSessionWorkLinks(db))));
+}
+function verifyAndResetCheckpoint(db, request, approved) {
+    if (!exactStrings(schemaVersions(db), REQUIRED_SCHEMA_7)) {
+        refuse("r3_working_db_schema_invalid");
+    }
+    assertDatabaseIntegrity(db);
+    const row = db.prepare("SELECT * FROM r3_prepare_checkpoint WHERE singleton=1").get();
+    if (row === undefined ||
+        row.approved_input_db_sha256 !== approved.scratchDbSha256 ||
+        row.evaluator_commit !== request.evaluatorCommit ||
+        row.evaluator_module_sha256 !== request.evaluatorModuleSha256 ||
+        row.repo_map_sha256 !== approved.repoMapSha256 ||
+        row.as_of !== request.asOf ||
+        row.link_snapshot_sha256 !==
+            sha256Canonical(JSON.parse(snapshotSessionWorkLinks(db))) ||
+        (row.completed !== 0 && row.completed !== 1))
+        refuse("r3_working_db_checkpoint_binding_mismatch");
+    db.prepare("UPDATE r3_prepare_checkpoint SET ineligible_n=0, failed_n=0, failure_reason_json='{}', completed=0 WHERE singleton=1").run();
+}
+function schemaVersions(db) {
+    const table = db
+        .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='schema_migrations'")
+        .get();
+    if (table === undefined)
+        refuse("r3_schema_missing");
+    return db
+        .prepare("SELECT version FROM schema_migrations ORDER BY version COLLATE BINARY")
+        .all().map((row) => {
+        if (typeof row.version !== "string")
+            refuse("r3_schema_invalid");
+        return row.version;
+    });
+}
+function exactStrings(actual, expected) {
+    return (actual.length === expected.length && actual.every((value, index) => value === expected[index]));
+}
+function migrateExactlyToSeven(db) {
+    const before = schemaVersions(db);
+    if (exactStrings(before, REQUIRED_SCHEMA_6)) {
+        // R3 is an exact historical schema-6-to-7 transition. Newer application
+        // migrations (for example the reports artifact) must not enter this gate.
+        const applied = runMigrations(db, "007_work_item_branch_keys");
+        if (!exactStrings(applied, ["007_work_item_branch_keys"])) {
+            refuse("r3_schema_transition_invalid");
+        }
+    }
+    else if (!exactStrings(before, REQUIRED_SCHEMA_7)) {
+        refuse("r3_schema_version_refused");
+    }
+    if (!exactStrings(schemaVersions(db), REQUIRED_SCHEMA_7))
+        refuse("r3_schema_seven_invalid");
+}
+function assertCorpusWorkspaceScope(db, approvedWorkspaceIds) {
+    const rows = db
+        .prepare(`SELECT DISTINCT s.workspace_id
+         FROM sessions s
+        WHERE s.state = 'RECONCILED'
+          AND EXISTS (SELECT 1 FROM tool_events te
+                       WHERE te.session_id = s.session_id AND te.tool_name = 'Bash')
+          -- R3 corpus: evidence-bearing workspaces only (see plan §5G). Keep this
+          -- predicate byte-identical across all six corpus queries.
+          AND EXISTS (SELECT 1 FROM work_items wi WHERE wi.workspace_id = s.workspace_id)
+        ORDER BY s.workspace_id COLLATE BINARY`)
+        .all();
+    for (const row of rows) {
+        if (typeof row.workspace_id !== "string" || !approvedWorkspaceIds.has(row.workspace_id)) {
+            refuse("r3_corpus_workspace_not_allowlisted");
+        }
+    }
+}
+async function freezeCorpus(db, approvedWorkspaceIds) {
+    assertCorpusWorkspaceScope(db, approvedWorkspaceIds);
+    const rows = db
+        .prepare(`SELECT s.session_id, s.file_path
+         FROM sessions s
+        WHERE s.state = 'RECONCILED'
+          AND EXISTS (SELECT 1 FROM tool_events te
+                       WHERE te.session_id = s.session_id AND te.tool_name = 'Bash')
+          -- R3 corpus: evidence-bearing workspaces only (see plan §5G). Keep this
+          -- predicate byte-identical across all six corpus queries.
+          AND EXISTS (SELECT 1 FROM work_items wi WHERE wi.workspace_id = s.workspace_id)
+        ORDER BY s.session_id COLLATE BINARY`)
+        .all();
+    const entries = [];
+    for (const row of rows) {
+        if (typeof row.session_id !== "string" ||
+            row.session_id.length === 0 ||
+            typeof row.file_path !== "string" ||
+            row.file_path.length === 0) {
+            refuse("r3_corpus_row_invalid");
+        }
+        const resolvedPath = fs.realpathSync.native(row.file_path);
+        const handle = await fs.promises.open(resolvedPath, "r");
+        try {
+            const before = await handle.stat({ bigint: true });
+            const pathnameBefore = await fs.promises.stat(resolvedPath, { bigint: true });
+            const identity = {
+                device: before.dev.toString(),
+                inode: before.ino.toString(),
+                size: before.size.toString(),
+            };
+            const sameIdentity = (stat) => stat.isFile() &&
+                stat.dev.toString() === identity.device &&
+                stat.ino.toString() === identity.inode &&
+                stat.size.toString() === identity.size &&
+                identity.inode !== "0";
+            if (!sameIdentity(pathnameBefore))
+                refuse("r3_corpus_path_replaced_before_hash");
+            const digest = createHash("sha256");
+            const buffer = Buffer.alloc(64 * 1024);
+            const size = Number(before.size);
+            if (!Number.isSafeInteger(size) || size < 0)
+                refuse("r3_corpus_size_invalid");
+            let position = 0;
+            while (position < size) {
+                const remaining = size - position;
+                const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, remaining), position);
+                if (bytesRead === 0)
+                    refuse("r3_corpus_short_read");
+                digest.update(buffer.subarray(0, bytesRead));
+                position += bytesRead;
+            }
+            const after = await handle.stat({ bigint: true });
+            const pathnameAfter = await fs.promises.stat(resolvedPath, { bigint: true });
+            if (!sameIdentity(after) ||
+                !sameIdentity(pathnameAfter) ||
+                after.mtimeNs !== before.mtimeNs ||
+                after.ctimeNs !== before.ctimeNs)
+                refuse("r3_corpus_changed_during_hash");
+            entries.push({
+                sessionId: row.session_id,
+                path: resolvedPath,
+                identity,
+                sha256: digest.digest("hex"),
+            });
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    return { version: "r3-u4-private-corpus-v1", entries };
+}
+function identity(request) {
+    return {
+        sourceCommit: request.evaluatorCommit,
+        runnerVersion: R3_RUNNER_VERSION,
+        evaluatorModuleSha256: request.evaluatorModuleSha256,
+        normalizationVersion: "branch-v1",
+        schemaVersion: 7,
+        reasonVocabularyVersion: R3_REASON_VOCABULARY_VERSION,
+    };
+}
+/** Prepare a sealed, hydrated clone. The attested Stage-0 database is never reopened or mutated. */
+export async function prepareR3(request, dependencies) {
+    validateRequest(request);
+    if ((await sha256File(EVALUATOR_MODULE_PATH)) !== request.evaluatorModuleSha256) {
+        refuse("r3_evaluator_module_digest_mismatch");
+    }
+    if (!dependencies.github.enabled)
+        refuse("r3_github_disabled");
+    const approved = await (dependencies.loadApproved ?? loadApprovedEvidenceInput)(request.approvedInput);
+    const retainedArtifacts = ["scratch_verification"];
+    let source;
+    let working;
+    try {
+        const workingPath = directWorkingPath(approved, request.workingDbPath);
+        if (request.resume) {
+            let existing;
+            try {
+                existing = fs.realpathSync.native(workingPath);
+            }
+            catch {
+                refuse("r3_working_db_missing");
+            }
+            retainedArtifacts.push("working_db");
+            if ((await sha256File(existing)) !== request.workingDbSha256)
+                refuse("r3_working_db_digest_mismatch");
+            working = new Database(existing, { fileMustExist: true });
+            if ((await sha256File(existing)) !== request.workingDbSha256)
+                refuse("r3_working_db_changed_during_open");
+            verifyAndResetCheckpoint(working, request, approved);
+        }
+        else {
+            source = approved.openVerifiedScratchDb();
+            const initial = new Database(source.serialize());
+            source.close();
+            source = undefined;
+            try {
+                migrateExactlyToSeven(initial);
+                initializeCheckpoint(initial, request, approved);
+                const publication = publishApprovedOutput(approved, workingPath, initial.serialize());
+                retainedArtifacts.push("working_db");
+                fs.chmodSync(publication.path, 0o600);
+            }
+            finally {
+                initial.close();
+            }
+            working = new Database(workingPath, { fileMustExist: true });
+        }
+        const beforeLinks = snapshotSessionWorkLinks(working);
+        const totals = {
+            completed: false,
+            selectedN: 0,
+            keyedN: 0,
+            ineligibleN: 0,
+            failedN: 0,
+            missingN: 0,
+            failureReasonN: {},
+        };
+        let cursor = "";
+        do {
+            const page = await backfillMissingWorkItemBranchKeys(working, dependencies.github, {
+                cursor,
+                limit: request.backfillPageSize,
+                concurrency: request.githubConcurrency,
+                evidence: {
+                    repositories: approved.repositories.map(({ workspaceId, owner, repo }) => ({
+                        workspaceId,
+                        owner,
+                        repo,
+                    })),
+                    asOf: request.asOf,
+                    syncedAt: (dependencies.now?.() ?? new Date(request.asOf)).toISOString(),
+                    ...(dependencies.onBackfillCheckpoint === undefined
+                        ? {}
+                        : { onPageCheckpoint: dependencies.onBackfillCheckpoint }),
+                },
+            });
+            totals.selectedN += page.selected;
+            totals.keyedN += page.keyed;
+            totals.ineligibleN += page.ineligible;
+            totals.failedN += page.failed;
+            totals.missingN += page.missing;
+            for (const [reason, count] of Object.entries(page.failureReasonCounts ?? {})) {
+                totals.failureReasonN[reason] = (totals.failureReasonN[reason] ?? 0) + count;
+            }
+            const checkpointRow = working
+                .prepare("SELECT ineligible_n,failed_n,failure_reason_json FROM r3_prepare_checkpoint WHERE singleton=1")
+                .get();
+            const checkpointReasons = JSON.parse(checkpointRow.failure_reason_json);
+            for (const [reason, count] of Object.entries(page.failureReasonCounts ?? {})) {
+                checkpointReasons[reason] = (checkpointReasons[reason] ?? 0) + count;
+            }
+            working
+                .prepare(`UPDATE r3_prepare_checkpoint
+              SET ineligible_n=?, failed_n=?, failure_reason_json=?
+            WHERE singleton=1`)
+                .run(checkpointRow.ineligible_n + page.ineligible, checkpointRow.failed_n + page.failed, canonicalJson(checkpointReasons));
+            cursor = page.nextCursor;
+        } while (cursor !== null);
+        totals.completed = true;
+        const checkpoint = working
+            .prepare(`SELECT ineligible_n,failed_n,failure_reason_json,
+                (SELECT COUNT(*) FROM work_item_branch_keys bk
+                  WHERE NOT EXISTS (SELECT 1 FROM r3_prepare_initial_keys i WHERE i.work_item_id=bk.work_item_id)) keyed_n
+           FROM r3_prepare_checkpoint WHERE singleton=1`)
+            .get();
+        totals.keyedN = checkpoint.keyed_n;
+        totals.ineligibleN = checkpoint.ineligible_n;
+        totals.failedN = checkpoint.failed_n;
+        totals.missingN = checkpoint.ineligible_n + checkpoint.failed_n;
+        totals.selectedN = totals.keyedN + totals.missingN;
+        totals.failureReasonN = JSON.parse(checkpoint.failure_reason_json);
+        working.prepare("UPDATE r3_prepare_checkpoint SET completed=1 WHERE singleton=1").run();
+        if (snapshotSessionWorkLinks(working) !== beforeLinks)
+            refuse("r3_link_snapshot_changed_prepare");
+        const corpus = await freezeCorpus(working, new Set(approved.repositories.map((repository) => repository.workspaceId)));
+        assertDatabaseIntegrity(working);
+        working.pragma("wal_checkpoint(TRUNCATE)");
+        const sealedBytes = working.serialize();
+        working.close();
+        working = undefined;
+        const sealedPublication = publishApprovedOutput(approved, request.sealedDbOut, sealedBytes);
+        retainedArtifacts.push("sealed_db");
+        const corpusPublication = publishApprovedOutput(approved, request.privateCorpusOut, canonicalJson(corpus));
+        retainedArtifacts.push("private_corpus");
+        try {
+            fs.chmodSync(sealedPublication.path, 0o444);
+        }
+        catch {
+            refuse("r3_sealed_db_readonly_failed_sealed_and_corpus_retained");
+        }
+        const manifest = {
+            campaign: "R3_U4_BRANCH_LINKAGE",
+            status: totals.completed && totals.failedN === 0 && totals.ineligibleN === 0
+                ? "PREPARED"
+                : "DATA_INSUFFICIENT",
+            identity: {
+                ...identity(request),
+                approvedInputDbSha256: approved.scratchDbSha256,
+                sealedHydratedDbSha256: sealedPublication.sha256,
+                repoMapSha256: approved.repoMapSha256,
+                privateCorpusSha256: corpusPublication.sha256,
+                linkSnapshotSha256: sha256Canonical(JSON.parse(beforeLinks)),
+                asOf: request.asOf,
+            },
+            backfill: totals,
+            corpus: { outcomeBearingSessionsN: corpus.entries.length },
+            privacy: { rawRefN: 0, transcriptPathN: 0, tokenN: 0 },
+        };
+        publishApprovedOutput(approved, request.manifestOut, canonicalJson(manifest));
+        retainedArtifacts.push("manifest");
+        return manifest;
+    }
+    catch (error) {
+        throw retainedFailure(error, retainedArtifacts);
+    }
+    finally {
+        source?.close();
+        working?.close();
+    }
+}
+export function approvedState(approved) {
+    return { scratchStatePath: approved.scratchStatePath };
+}