@deksden-com/dd-flow-cli 0.9.0-beta.137 → 0.9.0-beta.138

package/dist/services/memory-corrected-review-projection.js

@@ -0,0 +1,78 @@
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+function refuse(reason) {
+    throw new AppError("memory_corrected_review_projection_invalid", "Review result differs from retained inventory and independent selective coverage", 2, { reason, effect: "no_effect" });
+}
+/** Pure full-coverage projection, not Stage acceptance. Untouched units retain
+ * their original reviewer and unchanged source identities. Affected units use
+ * the separately admitted current assignment, including explicit deletions. */
+export function correctedMemoryReviewUnits(input) {
+    const { view } = input, inventory = view.unit_inventory;
+    if (!((view.wave === 1 && view.schema_id === "dd-flow/memory-corrected-review-inputs@1")
+        || (view.wave === 2 && view.schema_id === "dd-flow/memory-corrected-review-inputs@2"))
+        || !Array.isArray(inventory) || !inventory.length || inventory.length > 256
+        || new Set(inventory.map(unit => unit.id)).size !== inventory.length
+        || !Array.isArray(view.assignments) || !Array.isArray(view.affected_unit_ids)
+        || new Set(view.affected_unit_ids).size !== view.affected_unit_ids.length
+        || view.assignments.length !== view.affected_unit_ids.length || input.current.length !== view.assignments.length
+        || input.repairWorkIds.length !== view.repairs.length
+        || new Set(input.repairWorkIds).size !== input.repairWorkIds.length
+        || hybridDigest([...input.repairWorkIds].sort()) !== hybridDigest(view.repairs.map(repair => repair.work_id).sort()))
+        refuse("invalid_projection_inventory");
+    const applicable = inventory.filter(unit => unit.applicability === "applicable");
+    const reviews = (results, refs, ids) => {
+        if (results.length !== ids.length || refs.length !== ids.length
+            || new Set(results.map(result => result.unit_id)).size !== ids.length || new Set(results.map(result => result.work_id)).size !== ids.length
+            || new Set(refs.map(reference => reference.reviewer_work_id)).size !== refs.length
+            || results.some(result => !ids.includes(result.unit_id)))
+            refuse("changed_review_coverage");
+        return new Map(results.map(result => {
+            const reference = refs.find(reference => reference.reviewer_work_id === result.work_id);
+            if (!reference || hybridDigest(reference.unit_ids) !== hybridDigest([result.unit_id]))
+                refuse("changed_review_reference");
+            return [result.unit_id, { result, reference: structuredClone(reference) }];
+        }));
+    };
+    const original = reviews(input.original, input.originalReferences, applicable.map(unit => unit.id));
+    const current = reviews(input.current, input.currentReferences, view.affected_unit_ids);
+    if (input.current.some(result => input.original.some(old => old.work_id === result.work_id)))
+        refuse("reused_review_work");
+    const sources = new Map(view.run_inputs.map(ref => [memorySourceKey(ref.root, ref.path), ref.sha256]));
+    const references = [];
+    const units = inventory.map(old => {
+        if (!["applicable", "not-applicable"].includes(old.applicability))
+            refuse("unresolved_unit_applicability");
+        if (old.applicability === "not-applicable") {
+            if (view.affected_unit_ids.includes(old.id))
+                refuse("excluded_unit_reviewed");
+            return { ...structuredClone(old), outcome: "not-applicable" };
+        }
+        const changed = view.affected_unit_ids.includes(old.id), review = changed ? current.get(old.id) : original.get(old.id);
+        if (!review)
+            refuse("missing_unit_review");
+        references.push(review.reference);
+        const assignments = view.assignments.filter(assignment => assignment.unit.id === old.id);
+        if (changed && (assignments.length !== 1 || assignments[0].unit.applicability !== "applicable"
+            || assignments[0].unit.aspect !== old.aspect || assignments[0].original_unit_sha256 !== hybridDigest(old)))
+            refuse("changed_unit_assignment");
+        const effective = changed ? assignments[0].unit : old;
+        if (!["accepted", "needs_repair", "blocked"].includes(review.result.outcome)
+            || (review.result.outcome === "accepted" && !effective.artifacts.length))
+            refuse("invalid_unit_assessment");
+        const normalize = (refs) => refs.map(ref => {
+            const root = ref.root === "run" ? "run" : "workspace", path = ref.root === "canon" ? `.memory-bank/${ref.path}` : ref.path;
+            if (!["workspace", "project", "canon", "run"].includes(ref.root) || sources.get(memorySourceKey(root, path)) !== ref.sha256)
+                refuse("stale_unit_reference");
+            return { root: ref.root === "project" ? "workspace" : ref.root, path: ref.path, sha256: ref.sha256 };
+        });
+        const evidence = effective.evidence.filter(ref => changed || !["project", "workspace", "canon", "run"].includes(ref.root) || !inventory.flatMap(unit => unit.artifacts).some(artifact => (artifact.root === "run" ? "run" : "workspace") === (ref.root === "run" ? "run" : "workspace")
+            && (artifact.root === "canon" ? `.memory-bank/${artifact.path}` : artifact.path) === (ref.root === "canon" ? `.memory-bank/${ref.path}` : ref.path)
+            && artifact.sha256 !== ref.sha256 && sources.get(memorySourceKey(artifact.root === "run" ? "run" : "workspace", artifact.root === "canon" ? `.memory-bank/${artifact.path}` : artifact.path)) === artifact.sha256));
+        return { ...structuredClone(effective), evidence: normalize(evidence), artifacts: normalize(effective.artifacts), outcome: review.result.outcome };
+    });
+    if (view.assignments.some(assignment => !view.affected_unit_ids.includes(assignment.unit.id))
+        || view.affected_unit_ids.some(id => !applicable.some(unit => unit.id === id)))
+        refuse("foreign_assignment");
+    return { units, details: { reviews: references, repair_wave: view.wave, repair_work_ids: [...input.repairWorkIds] } };
+}

package/dist/services/memory-corrected-review-receipt.js

@@ -0,0 +1,170 @@
+import { AppError } from "../shared/errors.js";
+import { appendAudit } from "./audit.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedCorrectedMemoryReviewAcceptance } from "./memory-corrected-review-acceptance.js";
+import { PreparedSecondMemoryReviewAcceptance } from "./memory-second-review-acceptance.js";
+import { PreparedMemoryStageResult } from "./memory-stage-results.js";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { RetainedExecutionBundle } from "./execution-bundles.js";
+import { readAcceptedStageData } from "./stage-report-renderer.js";
+import { PreparedHistoricalOriginalMemoryReview } from "./memory-historical-original-review.js";
+import { PreparedHistoricalCorrectedMemoryReview } from "./memory-historical-corrected-review.js";
+import { PreparedHistoricalSecondMemoryReview } from "./memory-historical-second-review.js";
+const token = Symbol("memory-corrected-review-receipt"), event = "memory.corrected_review_acceptance";
+function refuse(reason) {
+    throw new AppError("memory_corrected_review_receipt_invalid", "Corrected review lacks independently accepted selective-wave custody", 2, { reason, effect: "no_effect" });
+}
+function selected(context, scope) {
+    const run = context.db.get("SELECT index_json FROM runs WHERE project_id=? AND id=?", [scope.projectId, scope.runId]);
+    if (!run)
+        refuse("run_missing");
+    const index = JSON.parse(run.index_json), stage = index.stage_runs?.find((item) => item.stage === "review");
+    if (index.current_stage !== "review" || stage?.status !== "running" || typeof stage.attempt !== "string"
+        || !/^try-[0-9]{3,}$/.test(stage.attempt) || typeof stage.input_sha256 !== "string"
+        || !/^[a-f0-9]{64}$/.test(stage.input_sha256))
+        refuse("active_review_required");
+    return { attempt: stage.attempt, input_sha256: stage.input_sha256 };
+}
+function records(context, scope) {
+    return context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type=? AND json_extract(payload_json,'$.run_id')=? LIMIT 2", [scope.projectId, event, scope.runId]);
+}
+function receipt(context, scope, wave, result) {
+    wave.assertResult(result);
+    const proof = wave.settlementProof(context), stage = selected(context, scope), value = result.value();
+    const expectedWave = PreparedSecondMemoryReviewAcceptance.isPrepared(wave) ? 2 : 1;
+    if (proof.wave !== expectedWave || proof.registration_scope.project_id !== scope.projectId || proof.registration_scope.run_id !== scope.runId
+        || proof.registration_scope.stage !== "review" || proof.registration_scope.attempt !== stage.attempt
+        || proof.registration_scope.input_sha256 !== stage.input_sha256 || value.outcome !== "accepted")
+        refuse("accepted_owned_wave_required");
+    const retained = { schema_id: "dd-flow/memory-corrected-review-acceptance@1", project_id: scope.projectId, run_id: scope.runId,
+        stage: "review", ...stage, result_sha256: result.sha256, projection_sha256: hybridDigest(wave.resultProjection()),
+        corrected_input_sha256: wave.registration().receipt().input_sha256, ...proof };
+    if (Buffer.byteLength(JSON.stringify(retained)) > 2 * 1024 * 1024)
+        refuse("unbounded_receipt");
+    return retained;
+}
+/** Fresh receipt only: the generic Stage acceptance writer must record this
+ * atomically. It does not close a Stage or authorize historical replay. */
+export class PreparedMemoryCorrectedReviewReceipt {
+    #scope;
+    #wave;
+    #result;
+    #receipt;
+    constructor(key, scope, wave, result, value) {
+        if (key !== token)
+            refuse("receipt_token_required");
+        this.#scope = { ...scope };
+        this.#wave = wave;
+        this.#result = result;
+        this.#receipt = structuredClone(value);
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        if ((!PreparedCorrectedMemoryReviewAcceptance.isPrepared(input.wave) && !PreparedSecondMemoryReviewAcceptance.isPrepared(input.wave))
+            || !(input.result instanceof PreparedMemoryStageResult))
+            refuse("prepared_wave_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        input.wave.revalidate(context);
+        if (records(context, input.scope).length)
+            refuse("fresh_receipt_already_exists");
+        return new PreparedMemoryCorrectedReviewReceipt(token, input.scope, input.wave, input.result, receipt(context, input.scope, input.wave, input.result));
+    }
+    record(context) {
+        if (!context.db.isOwnedWriteTransaction?.())
+            refuse("owned_acceptance_writer_required");
+        if (records(context, this.#scope).length || hybridDigest(receipt(context, this.#scope, this.#wave, this.#result)) !== hybridDigest(this.#receipt))
+            refuse("fresh_review_custody_changed");
+        appendAudit(context, { projectId: this.#scope.projectId, eventType: event, payload: this.#receipt });
+        const rows = records(context, this.#scope);
+        if (rows.length !== 1 || hybridDigest(JSON.parse(rows[0].payload_json)) !== hybridDigest(this.#receipt))
+            refuse("receipt_readback_failed");
+    }
+}
+function acceptedReceipt(context, scope) {
+    const data = readAcceptedStageData(context, { ...scope, stage: "review" }), rows = records(context, scope);
+    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 2 * 1024 * 1024)
+        refuse("accepted_receipt_missing");
+    let retained;
+    try {
+        retained = JSON.parse(rows[0].payload_json);
+    }
+    catch {
+        return refuse("invalid_accepted_receipt");
+    }
+    if (!retained || typeof retained !== "object" || Array.isArray(retained)
+        || retained.schema_id !== "dd-flow/memory-corrected-review-acceptance@1" || retained.project_id !== scope.projectId
+        || retained.run_id !== scope.runId || retained.stage !== "review" || ![1, 2].includes(retained.wave)
+        || (retained.wave === 2 && (typeof retained.first_review_proof_sha256 !== "string"
+            || !/^[a-f0-9]{64}$/.test(retained.first_review_proof_sha256)))
+        || typeof retained.corrected_input_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(retained.corrected_input_sha256)
+        || typeof retained.check_receipt_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(retained.check_receipt_sha256)
+        || data.data_schema_id !== "dd-flow/mb-init-review-result@1" || retained.result_sha256 !== data.result.sha256
+        || retained.input_sha256 !== data.input_sha256)
+        refuse("accepted_receipt_changed");
+    return { data, retained, authority: hybridDigest({ data: data.authority_sha256, receipt: retained }) };
+}
+/** Closed Stage replay proves exact independently accepted bytes and rebuilt
+ * historical coverage/findings. Own Stage projection may be missing after
+ * commit: generic settlement restores it; reviewers/checks/repairs may not be
+ * substituted or re-admitted from today's project policy or documents. */
+export class PreparedAcceptedMemoryCorrectedReview {
+    #scope;
+    #authority;
+    #history;
+    constructor(key, scope, authority, history) {
+        if (key !== token)
+            refuse("receipt_token_required");
+        this.#scope = { ...scope };
+        this.#authority = authority;
+        this.#history = history;
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        if (!(input.bundle instanceof RetainedExecutionBundle) || input.bundle.descriptor.descriptor.id !== "mb-init"
+            || !(input.bytes instanceof Uint8Array) || !input.bytes.length || input.bytes.length > 1024 * 1024)
+            refuse("registered_memory_result_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        const accepted = context.db.readSnapshot(() => acceptedReceipt(context, input.scope));
+        if (!accepted.data.bytes.equals(Buffer.from(input.bytes)))
+            refuse("accepted_result_bytes_changed");
+        const hashes = { correctedInputSha256: accepted.retained.corrected_input_sha256, checkReceiptSha256: accepted.retained.check_receipt_sha256 };
+        const history = accepted.retained.wave === 2
+            ? PreparedHistoricalSecondMemoryReview.prepare(context, { scope: input.scope, bundle: input.bundle, ...hashes })
+            : PreparedHistoricalCorrectedMemoryReview.prepare(context, {
+                original: PreparedHistoricalOriginalMemoryReview.prepare(context, { scope: input.scope, bundle: input.bundle }), ...hashes
+            });
+        const projection = history.projection(), proof = history.settlementProof(context), scope = proof.registration_scope;
+        const expected = { schema_id: "dd-flow/memory-corrected-review-acceptance@1", project_id: input.scope.projectId, run_id: input.scope.runId,
+            stage: "review", attempt: scope.attempt, input_sha256: scope.input_sha256, result_sha256: accepted.data.result.sha256,
+            projection_sha256: hybridDigest(projection), corrected_input_sha256: accepted.retained.corrected_input_sha256, ...proof };
+        if (hybridDigest(expected) !== hybridDigest(accepted.retained))
+            refuse("accepted_review_custody_changed");
+        const value = JSON.parse(accepted.data.bytes.toString("utf8"));
+        const verify = readAcceptedStageData(context, { ...input.scope, stage: "verify" });
+        if (value.run_id !== input.scope.runId || value.stage !== "review" || value.schema_id !== accepted.data.data_schema_id
+            || value.input_sha256 !== scope.input_sha256 || projection.outcome !== "accepted"
+            || hybridDigest(value.predecessors) !== hybridDigest([{ stage: "verify", result: verify.result, input_sha256: verify.input_sha256 }])
+            || hybridDigest({ units: value.units, findings: value.findings, outcome: value.outcome, details: value.details }) !== hybridDigest(projection))
+            refuse("accepted_result_projection_changed");
+        const schema = JSON.parse(input.bundle.descriptor.stageBlob("review", "result_schema").toString("utf8"));
+        if (!new Ajv2020({ strict: true, strictRequired: false, validateFormats: false }).compile(schema)(value))
+            refuse("accepted_result_schema_changed");
+        const prepared = new PreparedAcceptedMemoryCorrectedReview(token, input.scope, accepted.authority, history);
+        prepared.revalidate(context);
+        return prepared;
+    }
+    assertCustody(context) {
+        this.#history.assertCustody(context);
+        if (acceptedReceipt(context, this.#scope).authority !== this.#authority)
+            refuse("accepted_review_custody_changed");
+    }
+    /** Final wave inputs selected by the independently accepted receipt. */
+    reviewedSources(context) {
+        this.assertCustody(context);
+        return this.#history.retainedInputView().run_inputs;
+    }
+    finalChecks(context) { this.assertCustody(context); return this.#history.finalChecks(context); }
+    revalidate(context) { this.#history.revalidate(context); this.assertCustody(context); }
+}

package/dist/services/memory-corrected-review-registration.js

@@ -0,0 +1,191 @@
+import { Buffer } from "node:buffer";
+import { AppError } from "../shared/errors.js";
+import { appendAudit } from "./audit.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { isMemoryCorrectionInputOwner } from "./memory-correction-input-owner.js";
+import { PreparedMemoryCorrectionCheckReceipt } from "./memory-correction-check-receipt.js";
+import { memoryCorrectedReviewBatch } from "./memory-corrected-review-batch.js";
+import { addWorkBatch, prepareWorkBatch, readWorkBatchCustody } from "./work-registry.js";
+const token = Symbol("registered-corrected-memory-review");
+const event = "memory.corrected_review_registration";
+function refuse(reason) {
+    throw new AppError("memory_corrected_review_registration_invalid", "Corrected reviewers lack independent current-view, checks and allocation custody", 2, { reason, effect: "no_effect" });
+}
+function batchScope(view) {
+    return { project_id: view.scope.project_id, run_id: view.scope.run_id, stage: "review", attempt: view.scope.attempt,
+        cycle: "", parent_work_id: view.scope.parent_work_id, request_key: `memory-review-wave-${view.wave}` };
+}
+function selected(context, inputs, checks) {
+    inputs.assertCustody(context);
+    checks.assertOwner(inputs);
+    checks.assertRegisteredCustody(context);
+    const view = inputs.value(), scope = view.scope;
+    const receipt = readRetainedRegistration(context, scope, inputs.sha256, checks.sha256, view.wave);
+    if (receipt && hybridDigest(receipt.view) !== hybridDigest(view))
+        refuse("changed_registration");
+    return receipt;
+}
+/** SQL-only retained allocation proof. Expected identities must be pinned by
+ * an independent accepted receipt. This reader never grants current-view or
+ * new allocation rights and does not inspect an obsolete private copy. */
+export function readRetainedCorrectedMemoryReviewRegistration(context, scope, inputSha256, checkReceiptSha256) {
+    return readRetainedRegistration(context, scope, inputSha256, checkReceiptSha256, 1);
+}
+/** Second historical metadata only, pinned by independent accepted hashes.
+ * This is not a current input owner or allocation admission. */
+export function readRetainedSecondCorrectedMemoryReviewRegistration(context, scope, inputSha256, checkReceiptSha256) {
+    return readRetainedRegistration(context, scope, inputSha256, checkReceiptSha256, 2);
+}
+function readRetainedRegistration(context, scope, inputSha256, checkReceiptSha256, wave) {
+    const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type=? AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.scope.attempt')=? AND json_extract(payload_json,'$.scope.parent_work_id')=? AND json_extract(payload_json,'$.wave')=? LIMIT 2", [scope.project_id, event, scope.run_id, scope.attempt, scope.parent_work_id, wave]);
+    if (!rows.length)
+        return null;
+    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 2 * 1024 * 1024)
+        refuse("ambiguous_or_unbounded_registration");
+    let receipt;
+    try {
+        receipt = JSON.parse(rows[0].payload_json);
+    }
+    catch {
+        return refuse("invalid_registration");
+    }
+    const view = receipt?.view;
+    if (!view || hybridDigest(view.scope) !== hybridDigest(scope) || view.wave !== wave
+        || hybridDigest(view) !== inputSha256 || !/^[a-f0-9]{64}$/.test(inputSha256)
+        || !/^[a-f0-9]{64}$/.test(checkReceiptSha256))
+        refuse("changed_retained_view");
+    const batch = memoryCorrectedReviewBatch(view), ids = receipt?.work_ids;
+    if (!ids || typeof ids !== "object" || Array.isArray(ids)
+        || Object.keys(ids).length !== batch.works.length || Object.values(ids).some(id => typeof id !== "string" || !id)
+        || new Set(Object.values(ids)).size !== batch.works.length)
+        refuse("invalid_work_ids");
+    const expected = { schema_id: "dd-flow/memory-corrected-review-registration@1", run_id: scope.run_id, scope, wave: view.wave,
+        input_sha256: inputSha256, view, check_receipt_sha256: checkReceiptSha256, batch_sha256: hybridDigest(batch.works), work_ids: ids };
+    if (hybridDigest(receipt) !== hybridDigest(expected))
+        refuse("changed_registration");
+    for (const item of batch.works) {
+        const id = ids[item.key];
+        if (!id)
+            refuse("missing_review_work");
+        const custody = readWorkBatchCustody(context, id);
+        if (custody.item_key !== item.key || custody.batch_sha256 !== expected.batch_sha256
+            || hybridDigest(custody.scope) !== hybridDigest(batchScope(view))
+            || hybridDigest(custody.work_ids) !== hybridDigest(ids))
+            refuse("changed_work_custody");
+        const work = context.db.get("SELECT parent_work_id,task,launch_policy,result_schema,payload_json,depends_on_json FROM works WHERE project_id=? AND run_id=? AND work_id=?", [scope.project_id, scope.run_id, id]);
+        let payload, dependencies;
+        try {
+            payload = JSON.parse(work?.payload_json ?? "null");
+            dependencies = JSON.parse(work?.depends_on_json ?? "null");
+        }
+        catch {
+            return refuse("invalid_review_work");
+        }
+        if (!work || work.parent_work_id !== scope.parent_work_id || work.task !== item.task
+            || work.launch_policy !== item.launch_policy || work.result_schema !== item.result_schema
+            || hybridDigest(dependencies) !== hybridDigest([])
+            || hybridDigest(payload) !== hybridDigest({ ...item.payload, _dd_flow_batch_request: {
+                    request_sha256: custody.request_sha256, batch_sha256: custody.batch_sha256, item_key: item.key
+                } }))
+            refuse("changed_review_work");
+    }
+    return structuredClone(receipt);
+}
+/** A selective wave is allocated only after independent current-view checks.
+ * The generic batch and this receipt commit together. Replay never allocates
+ * replacements after receipt loss and never grants provider or Session scope. */
+export class PreparedRegisteredCorrectedMemoryReview {
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #inputs in value;
+    }
+    sha256;
+    #inputs;
+    #checks;
+    #receipt;
+    constructor(key, inputs, checks, receipt) {
+        if (key !== token)
+            refuse("registration_token_required");
+        this.#inputs = inputs;
+        this.#checks = checks;
+        this.#receipt = structuredClone(receipt);
+        this.sha256 = hybridDigest(receipt);
+        Object.freeze(this);
+    }
+    static restore(context, inputs, checks) {
+        if (!isMemoryCorrectionInputOwner(inputs) || !PreparedMemoryCorrectionCheckReceipt.isPrepared(checks))
+            refuse("prepared_registration_owners_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        checks.assertOwner(inputs);
+        checks.revalidate(context);
+        checks.assertRegisteredCustody(context);
+        const receipt = context.db.readSnapshot(() => selected(context, inputs, checks));
+        if (!receipt)
+            refuse("registered_corrected_review_required");
+        const prepared = new PreparedRegisteredCorrectedMemoryReview(token, inputs, checks, receipt);
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    receipt() { return structuredClone(this.#receipt); }
+    inputs() { return this.#inputs; }
+    batch() { return memoryCorrectedReviewBatch(this.#inputs.value()); }
+    assertCustody(context) {
+        if (hybridDigest(selected(context, this.#inputs, this.#checks)) !== this.sha256)
+            refuse("registered_review_custody_changed");
+    }
+    revalidate(context) {
+        this.#checks.revalidate(context);
+        this.assertCustody(context);
+    }
+}
+export function registerCorrectedMemoryReview(context, inputs, checks) {
+    if (!isMemoryCorrectionInputOwner(inputs) || !PreparedMemoryCorrectionCheckReceipt.isPrepared(checks))
+        refuse("prepared_registration_owners_required");
+    if (context.db.isOwnedWriteTransaction?.())
+        refuse("preparation_outside_writer_required");
+    checks.assertOwner(inputs);
+    checks.assertRegisteredCustody(context);
+    const view = inputs.value(), batch = memoryCorrectedReviewBatch(view), scope = batchScope(view);
+    const batchInput = { parentWorkId: scope.parent_work_id, requestKey: scope.request_key, stage: "review", value: batch };
+    const prepared = prepareWorkBatch(context, batchInput);
+    inputs.revalidate(context);
+    checks.revalidate(context);
+    const result = context.db.writeTransaction(() => {
+        if (!context.db.isOwnedWriteTransaction?.())
+            refuse("owned_registration_writer_required");
+        const prior = selected(context, inputs, checks);
+        if (!prior) {
+            // If allocation committed without this receipt, do not manufacture a
+            // new wave or adopt an orphaned Work graph from its status alone.
+            if (context.db.get("SELECT 1 FROM works w JOIN stage_work_memberships m ON m.work_id=w.work_id AND m.project_id=w.project_id AND m.run_id=w.run_id WHERE w.project_id=? AND w.run_id=? AND w.parent_work_id=? AND m.stage='review' AND m.attempt=? AND json_extract(w.payload_json,'$.kind')='memory-review' AND json_extract(w.payload_json,'$.memory_review.wave')=? LIMIT 1", [scope.project_id, scope.run_id, scope.parent_work_id, scope.attempt, view.wave]))
+                refuse("review_registration_missing");
+            inputs.assertAllocationAllowed(context);
+        }
+        const allocated = addWorkBatch(context, { ...batchInput, prepared }), ids = allocated.work_ids;
+        if (prior) {
+            if (!allocated.replayed || hybridDigest(ids) !== hybridDigest(prior.work_ids))
+                refuse("changed_allocation");
+        }
+        else {
+            if (allocated.replayed)
+                refuse("review_registration_missing");
+            const receipt = { schema_id: "dd-flow/memory-corrected-review-registration@1", run_id: scope.run_id, scope: view.scope, wave: view.wave,
+                input_sha256: inputs.sha256, view, check_receipt_sha256: checks.sha256, batch_sha256: hybridDigest(batch.works), work_ids: ids };
+            if (Buffer.byteLength(JSON.stringify(receipt)) > 2 * 1024 * 1024)
+                refuse("unbounded_registration");
+            appendAudit(context, { projectId: scope.project_id, eventType: event, payload: receipt });
+        }
+        const retained = selected(context, inputs, checks);
+        if (!retained)
+            refuse("registration_readback_missing");
+        return { input_sha256: retained.input_sha256, wave: view.wave, work_ids: { ...retained.work_ids }, replayed: Boolean(prior) };
+    }, "memory.registerCorrectedReview");
+    try {
+        inputs.revalidate(context);
+        checks.revalidate(context);
+    }
+    catch (error) {
+        throw new AppError("memory_corrected_review_registration_pending", "Reviewer allocation committed but current-view revalidation needs recovery", 1, { effect: "committed", input_sha256: inputs.sha256, work_ids: result.work_ids, cause: error instanceof Error ? error.message : String(error) });
+    }
+    return result;
+}