@deksden-com/dd-flow-cli 0.9.0-beta.14 → 0.9.0-beta.140

package/dist/services/memory-review-work-input.js

@@ -0,0 +1,72 @@
+import { AppError } from "../shared/errors.js";
+import { readFlowRunExecutionBundle } from "./runs.js";
+import { PreparedMemoryInitialReviewInputs } from "./memory-review-inputs.js";
+import { readRegisteredMemoryReview, memoryReviewBatch, memoryReviewWorkerSchema } from "./memory-review-registration.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedCorrectedMemoryReviewInputs } from "./memory-corrected-review-inputs.js";
+import { PreparedSecondCorrectedMemoryReviewInputs } from "./memory-second-corrected-review-inputs.js";
+import { PreparedMemoryCorrectionCheckReceipt } from "./memory-correction-check-receipt.js";
+import { PreparedRegisteredCorrectedMemoryReview } from "./memory-corrected-review-registration.js";
+const preparedOwners = new WeakMap();
+function workScope(work) { return hybridDigest([work.work_id, work.project_id, work.run_id, work.parent_work_id, work.payload_json, work.result_schema, work.launch_policy]); }
+export function assertPreparedMemoryReviewWorkInput(context, owner, work, run, generation) {
+    const issued = preparedOwners.get(owner);
+    if (!issued || issued.store !== context.db || issued.work !== workScope(work) || issued.root !== run.project_root || issued.generation !== generation || issued.input !== hybridDigest(owner.input))
+        refuse("foreign_prepared_review_input");
+    owner.assertCustody(context);
+}
+function refuse(reason) {
+    throw new AppError("memory_review_input_invalid", "Memory reviewer Work lacks its independently registered input", 2, { reason, effect: "no_effect" });
+}
+/** Physical preparation outside a writer. The SQL-only closure must also be
+ * consumed by Work claim, not just by an external launch/copy precheck.
+ */
+export function prepareMemoryReviewWorkInput(context, work, run, generation) {
+    const bundle = readFlowRunExecutionBundle(context, { projectRoot: run.project_root, runId: work.run_id });
+    if (!bundle || bundle.descriptor.descriptor.id !== "mb-init")
+        refuse("registered_memory_bundle_required");
+    let payload;
+    try {
+        payload = JSON.parse(work.payload_json ?? "null");
+    }
+    catch {
+        return refuse("invalid_review_payload");
+    }
+    const packet = payload?.memory_review;
+    if (!payload || payload.kind !== "memory-review" || payload.read_only !== true
+        || !((packet?.schema_id === "dd-flow/memory-review-work-packet@1" && packet.wave === 0)
+            || (packet?.schema_id === "dd-flow/memory-review-work-packet@2" && (packet.wave === 1 || packet.wave === 2))))
+        refuse("invalid_review_payload");
+    const scope = { projectId: work.project_id, runId: work.run_id };
+    const corrected = packet.wave === 2 ? PreparedSecondCorrectedMemoryReviewInputs.prepareFromBundle(context, { scope, bundle })
+        : packet.wave === 1 ? PreparedCorrectedMemoryReviewInputs.prepareFromBundle(context, { scope, bundle }) : null;
+    const registration = corrected ? PreparedRegisteredCorrectedMemoryReview.restore(context, corrected, PreparedMemoryCorrectionCheckReceipt.restore(context, corrected)) : null;
+    const owner = corrected ?? PreparedMemoryInitialReviewInputs.prepare(context, { scope, bundle });
+    const view = owner.value(), receipt = registration ? registration.receipt() : readRegisteredMemoryReview(context, view.scope, view.wave);
+    if (receipt.input_sha256 !== owner.sha256 || work.parent_work_id !== view.scope.parent_work_id
+        || work.result_schema !== memoryReviewWorkerSchema || work.launch_policy !== "fresh_agent_required")
+        refuse("foreign_review_assignment");
+    const batch = registration ? registration.batch() : memoryReviewBatch(owner.value());
+    const assigned = batch.works.find(item => receipt.work_ids[item.key] === work.work_id);
+    if (!assigned || !payload || payload.kind !== "memory-review" || payload.read_only !== true
+        || hybridDigest(payload.memory_review) !== hybridDigest(assigned.payload.memory_review))
+        refuse("changed_review_assignment");
+    const receiptSha256 = hybridDigest(receipt);
+    const assertCustody = (writer) => {
+        owner.assertCustody(writer);
+        if (registration)
+            registration.assertCustody(writer);
+        else if (hybridDigest(readRegisteredMemoryReview(writer, view.scope, view.wave)) !== receiptSha256)
+            refuse("review_registration_changed");
+    };
+    assertCustody(context);
+    const input = { schema_id: "dd-flow/review-input@3", parent_work_id: view.scope.parent_work_id,
+        kind: "memory-review", cycle: `memory-review-wave-${view.wave}`, generation,
+        workspace_fingerprint: view.source_sha256, source_policy: "review-inputs@1",
+        source_sha256: view.source_sha256, run_inputs: structuredClone(view.run_inputs) };
+    const prepared = Object.freeze({ input, assertCustody, bundle,
+        registration: () => structuredClone(receipt), packet: () => structuredClone(assigned.payload.memory_review),
+        revalidate: (reader) => { owner.revalidate(reader); registration?.revalidate(reader); assertCustody(reader); } });
+    preparedOwners.set(prepared, { store: context.db, work: workScope(work), root: run.project_root, generation, input: hybridDigest(input) });
+    return prepared;
+}

package/dist/services/memory-review-work-results.js

@@ -0,0 +1,73 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { AdmittedFrozenEngine } from "./frozen-engine.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+import { memoryReviewWorkerSchema } from "./memory-review-registration.js";
+function refuse(reason) {
+    throw new AppError("memory_review_work_result_invalid", "Reviewer result lacks assigned unit and retained input evidence", 2, { reason, effect: "no_effect" });
+}
+/** Frozen schema and claim admission only. The registered Work owner selects
+ * the packet/references and must still prove actual independent Session,
+ * unchanged copy, generation and atomic settlement. This executes no checks.
+ */
+export function validateMemoryReviewWorkResult(input, engine, binding) {
+    try {
+        if (!(input instanceof Uint8Array) || !input.byteLength || input.byteLength > 1024 * 1024
+            || !(engine instanceof AdmittedFrozenEngine) || !binding.workId || binding.packet?.result_schema !== memoryReviewWorkerSchema)
+            refuse("invalid_preparation_binding");
+        const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input));
+        const schema = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(engine.schema("memory-review-work-result")));
+        if (schema.$id !== memoryReviewWorkerSchema)
+            refuse("invalid_result_schema");
+        const packet = binding.packet;
+        if (value.schema_id !== memoryReviewWorkerSchema || value.run_id !== packet.run_id || value.work_id !== binding.workId || value.packet_sha256 !== packet.packet_sha256
+            || value.unit_id !== packet.unit.id || value.wave !== packet.wave)
+            refuse("foreign_result_identity");
+        const validate = new Ajv2020({ strict: true, validateFormats: false }).compile(schema);
+        if (!validate(value))
+            throw new AppError("memory_review_work_result_invalid", "Reviewer result proposal does not match its schema; correct the reported fields using the assigned packet references", 2, { reason: "invalid_result_schema", phase: "prepare", effect: "no_effect", recoverable: true,
+                errors: structuredClone(validate.errors), result_sha256: createHash("sha256").update(input).digest("hex") });
+        const sources = new Set([...binding.references, ...packet.unit.evidence.map(ref => ({ root: ref.root === 'run' ? 'run' : 'workspace',
+                path: ref.root === 'canon' ? `.memory-bank/${ref.path}` : ref.path, sha256: ref.sha256 }))].map(ref => `${memorySourceKey(ref.root, ref.path)}\0${ref.sha256}`));
+        const evidence = (refs) => {
+            for (const ref of refs) {
+                if (!sources.has(`${memorySourceKey(ref.root, ref.path)}\0${ref.sha256}`))
+                    refuse("unregistered_or_duplicate_evidence");
+            }
+        };
+        const nonblank = (text) => Boolean(text.trim()) && !text.includes("\0");
+        if (!nonblank(value.summary))
+            refuse("missing_assessment");
+        evidence(value.evidence);
+        const outputs = packet.unit.artifacts.map(ref => ({ root: "workspace", path: ref.path, sha256: ref.sha256 }));
+        if (!value.evidence.some(ref => outputs.some(output => ref.root === output.root && ref.path === output.path && ref.sha256 === output.sha256))) {
+            const corrected = "deleted_references" in packet;
+            if (!corrected || packet.schema_id !== "dd-flow/memory-review-work-packet@2" || ![1, 2].includes(packet.wave)
+                || outputs.length || value.outcome === "accepted" || !packet.deleted_references.some(deleted => deleted.role === "artifact"
+                && value.evidence.some(ref => ref.root === "run" && deleted.repair_result.root === "run"
+                    && deleted.repair_result.path === ref.path && deleted.repair_result.sha256 === ref.sha256)))
+                refuse("assessment_without_unit_output");
+        }
+        const findingIds = new Set();
+        for (const finding of value.findings) {
+            if (finding.unit_id !== packet.unit.id || findingIds.has(finding.id))
+                refuse("foreign_or_duplicate_finding");
+            findingIds.add(finding.id);
+            if (!nonblank(finding.summary))
+                refuse("missing_finding_problem");
+            evidence(finding.evidence);
+            if (!finding.evidence.some(ref => packet.unit_inputs.some(source => ref.root === source.root && ref.path === source.path && ref.sha256 === source.sha256)))
+                refuse("finding_without_unit_source");
+        }
+        const material = value.findings.some(finding => finding.severity !== "minor");
+        if (value.outcome === "accepted" && material || value.outcome === "needs_repair" && !material)
+            refuse("contradictory_review_outcome");
+        return structuredClone(value);
+    }
+    catch (error) {
+        if (error instanceof AppError && ["memory_review_work_result_invalid", "frozen_engine_invalid"].includes(error.code))
+            throw error;
+        return refuse("invalid_result_or_binding");
+    }
+}

package/dist/services/memory-second-corrected-review-inputs.js

@@ -0,0 +1,165 @@
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedCompletedMemoryCorrectionWave, memoryCorrectionCurrentUnits } from "./memory-completed-correction-wave.js";
+import { PreparedRetainedSecondMemoryRepairs } from "./memory-retained-second-repairs.js";
+import { correctedMemoryReviewAssignments } from "./memory-corrected-review-inputs.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+import { assertPreparedRunBundleSqlAuthority } from "./runs.js";
+import { reviewSourceHash } from "./review-copy.js";
+import { RetainedExecutionBundle } from "./execution-bundles.js";
+const token = Symbol("second-corrected-memory-review-inputs");
+function refuse(reason) {
+    throw new AppError("memory_second_corrected_review_input_invalid", "Final re-review lacks settled second repairs and independent first-review custody", 2, { reason, effect: "no_effect" });
+}
+/** Metadata projection only; caller must establish first/second custody. */
+export function secondCorrectedMemoryReviewAssignments(input) {
+    if (!input.first || !Array.isArray(input.first.unit_inventory) || !input.first.unit_inventory.length || input.first.unit_inventory.length > 256
+        || !Array.isArray(input.first.assignments) || !input.first.assignments.length || input.first.assignments.length > 256
+        || input.first.assignments.some(assignment => !assignment?.unit?.id || !Array.isArray(assignment.deleted_references))
+        || new Set(input.first.assignments.map(assignment => assignment.unit.id)).size !== input.first.assignments.length
+        || input.first.assignments.some(assignment => !input.first.unit_inventory.some(unit => unit.id === assignment.unit.id)))
+        refuse("invalid_first_unit_projection");
+    const firstAssignments = new Map(input.first.assignments.map(assignment => [assignment.unit.id, assignment]));
+    const units = memoryCorrectionCurrentUnits(input.first.unit_inventory, input.first.assignments);
+    const assignments = correctedMemoryReviewAssignments({ units, affected: input.affected, files: input.files, repairs: input.repairs });
+    const available = new Map(input.files.map(file => [file.path, file]));
+    for (const assignment of assignments) {
+        for (const deleted of firstAssignments.get(assignment.unit.id)?.deleted_references ?? []) {
+            const recreated = available.get(deleted.path);
+            if (recreated) {
+                const ref = { root: "workspace", path: recreated.path, sha256: recreated.sha256 };
+                const role = deleted.role === "artifact" ? assignment.unit.artifacts : assignment.unit.evidence;
+                if (!role.some(item => item.path === ref.path))
+                    role.push({ ...ref });
+                if (!assignment.inputs.some(item => item.root === ref.root && item.path === ref.path))
+                    assignment.inputs.push({ ...ref });
+                continue;
+            }
+            if (assignment.deleted_references.some(item => item.role === deleted.role && item.path === deleted.path))
+                continue;
+            assignment.deleted_references.push(structuredClone(deleted));
+            const proof = deleted.repair_result, prior = assignment.inputs.find(ref => ref.root === proof.root && ref.path === proof.path);
+            if (prior && prior.sha256 !== proof.sha256)
+                refuse("conflicting_first_deletion_proof");
+            if (!prior)
+                assignment.inputs.push(structuredClone(proof));
+        }
+        assignment.inputs.sort((a, b) => `${a.root}:${a.path}`.localeCompare(`${b.root}:${b.path}`, "en"));
+    }
+    return { units, assignments };
+}
+/** Pure reference projection shared by live admission and historical replay.
+ * The caller must independently establish all first/second settlement proofs. */
+export function secondCorrectedMemoryReviewReferences(input) {
+    for (const items of [input.firstInputs, input.firstWorkers, input.repairs, input.files])
+        if (!Array.isArray(items) || items.length > 4096)
+            refuse("unbounded_second_inputs");
+    if (input.firstWorkers.some(worker => !worker || !worker.result) || input.repairs.some(repair => !repair || !repair.reference)
+        || input.files.some(file => !file))
+        refuse("invalid_second_input_reference");
+    const inputs = new Map();
+    const valid = (ref) => {
+        if (!ref || !["run", "workspace"].includes(ref.root) || typeof ref.path !== "string" || !ref.path
+            || ref.path.startsWith("/") || ref.path.includes("\\") || ref.path.includes("\0") || ref.path.length > 4096
+            || ref.path.split("/").some(part => !part || part === "." || part === "..")
+            || typeof ref.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(ref.sha256))
+            refuse("invalid_second_input_reference");
+    };
+    for (const ref of input.firstInputs)
+        valid(ref);
+    const references = [...input.firstInputs.filter(ref => ref.root === "run"),
+        ...input.firstWorkers.map(worker => ({ root: "run", ...worker.result })),
+        ...input.repairs.map(repair => ({ root: "run", ...repair.reference })),
+        ...input.files.map(file => ({ root: "workspace", ...file }))];
+    for (const ref of references) {
+        valid(ref);
+        const key = memorySourceKey(ref.root, ref.path), prior = inputs.get(key);
+        if (prior && prior.sha256 !== ref.sha256)
+            refuse("conflicting_second_input");
+        inputs.set(key, { root: ref.root, path: ref.path, sha256: ref.sha256 });
+    }
+    if (inputs.size > 4096)
+        refuse("unbounded_second_inputs");
+    return [...inputs.values()].sort((a, b) => `${a.root}:${a.path}`.localeCompare(`${b.root}:${b.path}`, "en"));
+}
+/** Second selective input custody only. Fresh checks and independently
+ * registered read-only reviewers must consume it before semantic closure. */
+export class PreparedSecondCorrectedMemoryReviewInputs {
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #wave in value;
+    }
+    sha256;
+    #wave;
+    #view;
+    #observed;
+    constructor(key, wave, view, observed) {
+        if (key !== token)
+            refuse("second_input_token_required");
+        this.#wave = wave;
+        this.#view = structuredClone(view);
+        this.#observed = observed;
+        this.sha256 = hybridDigest(view);
+        Object.freeze(this);
+    }
+    static prepare(context, wave) {
+        if (!PreparedCompletedMemoryCorrectionWave.isPrepared(wave))
+            refuse("completed_second_wave_required");
+        if (!PreparedRetainedSecondMemoryRepairs.isPrepared(wave.registration()))
+            refuse("second_registration_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        wave.revalidate(context);
+        const view = prepareView(context, wave), bundle = wave.registration().bundle(), workspace = bundle.execution.snapshot().scope.workspace;
+        const run = assertPreparedRunBundleSqlAuthority(context, { projectId: view.scope.project_id, runId: view.scope.run_id }, bundle);
+        const observed = ObservedMemorySources.capture({ workspace, run: run.run_root ?? run.run_dir }, view.run_inputs.map(ref => ({ root: ref.root, path: ref.path })));
+        const hashes = observed.hashes();
+        if (view.run_inputs.some(ref => hashes.get(memorySourceKey(ref.root, ref.path)) !== ref.sha256))
+            refuse("second_input_bytes_changed");
+        const prepared = new PreparedSecondCorrectedMemoryReviewInputs(token, wave, view, observed);
+        prepared.revalidate(context);
+        return prepared;
+    }
+    static prepareFromBundle(context, input) {
+        if (!(input.bundle instanceof RetainedExecutionBundle) || input.bundle.descriptor.descriptor.id !== "mb-init")
+            refuse("registered_memory_bundle_required");
+        const registration = PreparedRetainedSecondMemoryRepairs.prepare(context, input);
+        return this.prepare(context, PreparedCompletedMemoryCorrectionWave.prepare(context, registration));
+    }
+    value() { return structuredClone(this.#view); }
+    bundle() { return this.#wave.registration().bundle(); }
+    completedWave() { return this.#wave; }
+    verificationProfileHash(context) { this.assertCustody(context); return this.#wave.registration().verificationProfileHash(context); }
+    assertCustody(context) { this.#wave.assertCustody(context); }
+    assertAllocationAllowed(context) { this.#wave.assertAllocationAllowed(context); }
+    revalidate(context) {
+        this.#wave.revalidate(context);
+        this.#observed.revalidate();
+        const view = this.#view, workspace = this.bundle().execution.snapshot().scope.workspace;
+        if (reviewSourceHash(workspace, view.run_inputs.filter(ref => ref.root === "workspace").map(ref => ref.path), view.base) !== view.source_sha256)
+            refuse("second_copy_source_changed");
+        this.assertCustody(context);
+    }
+}
+function prepareView(context, wave) {
+    const registration = wave.registration(), receipt = registration.receipt(), first = registration.initialInputView(), batch = registration.batch();
+    const files = wave.workspaceManifest().entries().filter(entry => entry.kind === "file").map(entry => ({ path: entry.path, sha256: entry.sha256 }));
+    const repairs = wave.repairResults().map(repair => ({ ...repair,
+        unit_ids: batch.works.find(work => receipt.work_ids[work.key] === repair.work_id).payload.memory_repair.unit_ids }));
+    // The first re-review's current unit definitions, not obsolete compose-era
+    // byte identities, form the baseline for the second delta projection.
+    const { units, assignments } = secondCorrectedMemoryReviewAssignments({ first, affected: wave.affectedUnitIds(), files, repairs });
+    const proof = registration.firstReviewProof(context);
+    const runInputs = secondCorrectedMemoryReviewReferences({ firstInputs: first.run_inputs, firstWorkers: proof.workers, repairs, files });
+    const workspace = registration.bundle().execution.snapshot().scope.workspace;
+    const view = { schema_id: "dd-flow/memory-corrected-review-inputs@2", wave: 2, scope: first.scope,
+        completed_correction_sha256: wave.sha256, original_review_sha256: receipt.review_sha256,
+        first_review_input_sha256: receipt.first_review_input_sha256, first_check_receipt_sha256: receipt.first_check_receipt_sha256,
+        first_review_registration_sha256: receipt.first_review_registration_sha256,
+        source_policy: "review-inputs@1", source_sha256: reviewSourceHash(workspace, runInputs.filter(ref => ref.root === "workspace").map(ref => ref.path), first.base),
+        base: first.base, run_inputs: runInputs, unit_inventory: units, affected_unit_ids: wave.affectedUnitIds(), assignments,
+        instruction: structuredClone(first.instruction), repairs: repairs.map(repair => ({ work_id: repair.work_id, authority_sha256: repair.authority_sha256, result: repair.reference })) };
+    if (Buffer.byteLength(JSON.stringify(view)) > 1024 * 1024)
+        refuse("unbounded_second_view");
+    return view;
+}

package/dist/services/memory-second-correction-plan.js

@@ -0,0 +1,76 @@
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { PreparedCorrectedMemoryReviewAcceptance } from "./memory-corrected-review-acceptance.js";
+import { validateMemoryReviewCorrectionPlan } from "./memory-review-correction-plan.js";
+import { PreparedHistoricalOriginalMemoryReview } from "./memory-historical-original-review.js";
+import { PreparedHistoricalCorrectedMemoryReview } from "./memory-historical-corrected-review.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+const token = Symbol("memory-second-correction-plan");
+function refuse(reason) {
+    throw new AppError("memory_second_correction_invalid", "Second correction requires independent settled first-wave review", 2, { reason, effect: "no_effect" });
+}
+/** Admission only. Does not allocate repair Works, mutate documents or close
+ * review. Wave two binds the effective first-wave findings and source units,
+ * not obsolete initial findings or caller-supplied coverage. */
+export class PreparedMemorySecondCorrectionPlan {
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #review in value;
+    }
+    sha256;
+    #review;
+    #bytes;
+    #value;
+    constructor(key, review, bytes, value) {
+        if (key !== token)
+            refuse("prepared_plan_token_required");
+        this.#review = review;
+        this.#bytes = bytes;
+        this.#value = structuredClone(value);
+        this.sha256 = createHash("sha256").update(bytes).digest("hex");
+        Object.freeze(this);
+    }
+    static prepare(context, review, bytes) {
+        if (!PreparedCorrectedMemoryReviewAcceptance.isPrepared(review))
+            refuse("prepared_first_wave_review_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        review.revalidate(context);
+        const registration = review.registration(), view = registration.receipt().view;
+        if (view.wave !== 1)
+            refuse("correction_wave_limit");
+        const projection = review.resultProjection();
+        if (projection.outcome === "blocked")
+            refuse("blocked_review_requires_resolution");
+        const assignments = new Map(view.assignments.map(assignment => [assignment.unit.id, assignment.unit]));
+        const units = view.unit_inventory.map(unit => assignments.get(unit.id) ?? unit);
+        const bundle = registration.inputs().bundle();
+        const value = validateMemoryReviewCorrectionPlan(bytes, bundle.engine(), { runId: view.scope.run_id, wave: 2,
+            reviewSha256: review.sha256, units, findings: projection.findings });
+        for (const work of value.works)
+            bundle.execution.work("review", work.profile_id ?? undefined);
+        const prepared = new PreparedMemorySecondCorrectionPlan(token, review, Buffer.from(bytes), value);
+        prepared.historicalReview(context);
+        return prepared;
+    }
+    bytes() { return Buffer.from(this.#bytes); }
+    value() { return structuredClone(this.#value); }
+    review() { return this.#review; }
+    /** Prepare retained proof before second-wave mutation. Expected identities
+     * come only from this genuine live admission; no caller-selected receipt
+     * hash can substitute for the independently registered first review. */
+    historicalReview(context) {
+        this.revalidate(context);
+        const registration = this.#review.registration(), receipt = registration.receipt(), scope = receipt.scope;
+        const original = PreparedHistoricalOriginalMemoryReview.prepareWhileReviewOpen(context, {
+            scope: { projectId: scope.project_id, runId: scope.run_id }, bundle: registration.inputs().bundle()
+        });
+        const historical = PreparedHistoricalCorrectedMemoryReview.prepare(context, { original,
+            correctedInputSha256: receipt.input_sha256, checkReceiptSha256: receipt.check_receipt_sha256 });
+        if (historical.reviewSha256() !== this.#review.sha256
+            || hybridDigest(historical.projection()) !== hybridDigest(this.#review.resultProjection()))
+            refuse("historical_first_wave_changed");
+        return historical;
+    }
+    assertCustody(context) { this.#review.assertCustody(context); }
+    revalidate(context) { this.#review.revalidate(context); }
+}

package/dist/services/memory-second-repair-baseline.js

@@ -0,0 +1,91 @@
+import { AppError } from "../shared/errors.js";
+import { appendAudit } from "./audit.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedSecondMemoryRepairSource } from "./memory-second-repair-source.js";
+import { MemoryRepairDocumentBaseline } from "./memory-repair-document-delta.js";
+const token = Symbol("second-memory-repair-baseline");
+function refuse(reason) {
+    throw new AppError("memory_second_repair_baseline_invalid", "Second writer baseline lacks independently admitted current source", 2, { reason, effect: "no_effect" });
+}
+function selected(context, receipt) {
+    const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='memory.repair_work_baseline' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? LIMIT 2", [receipt.project_id, receipt.run_id, receipt.work_id]);
+    if (!rows.length)
+        return null;
+    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 24 * 1024 * 1024)
+        refuse("ambiguous_or_unbounded_baseline");
+    try {
+        return JSON.parse(rows[0].payload_json);
+    }
+    catch {
+        return refuse("invalid_baseline");
+    }
+}
+/** Second-wave pre-launch receipt only. It grants no private copy,
+ * Session/start, publication or historical post-write re-admission rights. */
+export class PreparedSecondMemoryRepairBaseline {
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #source in value;
+    }
+    sha256;
+    #source;
+    #receipt;
+    constructor(key, source, receipt) {
+        if (key !== token)
+            refuse("baseline_token_required");
+        this.#source = source;
+        this.#receipt = structuredClone(receipt);
+        this.sha256 = hybridDigest(receipt);
+        Object.freeze(this);
+    }
+    static prepare(context, source) {
+        if (!PreparedSecondMemoryRepairSource.isPrepared(source))
+            refuse("prepared_second_source_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        source.revalidate(context);
+        const baseline = source.baseline(), exported = source.exportedBaseline();
+        const binding = source.baselineBinding(context);
+        const receipt = { schema_id: binding.current_view_sha256 ? "dd-flow/memory-repair-work-baseline@5" : "dd-flow/memory-repair-work-baseline@4", wave: 2, ...binding,
+            baseline_sha256: baseline.sha256, baseline_base64: baseline.bytes().toString("base64"), export_policy: "memory-repair-export@1",
+            exported_baseline_sha256: exported.sha256, exported_baseline_base64: exported.bytes().toString("base64") };
+        if (Buffer.byteLength(JSON.stringify(receipt)) > 24 * 1024 * 1024)
+            refuse("unbounded_baseline");
+        source.revalidate(context);
+        return new PreparedSecondMemoryRepairBaseline(token, source, receipt);
+    }
+    receipt() { return structuredClone(this.#receipt); }
+    baseline() {
+        return MemoryRepairDocumentBaseline.restore(Buffer.from(this.#receipt.baseline_base64, "base64"), this.#receipt.baseline_sha256);
+    }
+    exportedBaseline() {
+        return MemoryRepairDocumentBaseline.restore(Buffer.from(this.#receipt.exported_baseline_base64, "base64"), this.#receipt.exported_baseline_sha256);
+    }
+    copyInput() { return this.#source.copyInput(); }
+    workerRoute() { return this.#source.workerRoute(); }
+    assertPrelaunchCustody(context) { this.assertCustody(context); }
+    assertRegisteredCustody(context) {
+        this.assertCustody(context);
+        if (hybridDigest(selected(context, this.#receipt)) !== this.sha256)
+            refuse("registered_baseline_required");
+    }
+    revalidate(context) { this.#source.revalidate(context); this.assertCustody(context); }
+    assertCustody(context) {
+        this.#source.assertCustody(context);
+        if (hybridDigest({ ...this.#receipt, ...this.#source.baselineBinding(context) }) !== this.sha256)
+            refuse("source_binding_changed");
+    }
+    register(context) {
+        this.#source.revalidate(context);
+        return context.db.writeTransaction(() => {
+            this.assertCustody(context);
+            const prior = selected(context, this.#receipt);
+            if (prior !== null && hybridDigest(prior) !== this.sha256)
+                refuse("baseline_replay_conflict");
+            if (prior === null)
+                appendAudit(context, { projectId: this.#receipt.project_id, eventType: "memory.repair_work_baseline", payload: this.#receipt });
+            if (hybridDigest(selected(context, this.#receipt)) !== this.sha256)
+                refuse("baseline_receipt_missing");
+            return { work_id: this.#receipt.work_id, baseline_sha256: this.#receipt.baseline_sha256, receipt_sha256: this.sha256, replayed: prior !== null };
+        });
+    }
+}