@deksden-com/dd-flow-cli 0.9.0-beta.16 → 0.9.0-beta.161

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

@@ -0,0 +1,126 @@
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { appendAudit } from "./audit.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { runtimeHarness } from "./execution-policy.js";
+import { recoveryGuard } from "./run-recovery-guard.js";
+import { prepareMemoryReviewWorkInput } from "./memory-review-work-input.js";
+import { memoryReviewWorkerSchema } from "./memory-review-registration.js";
+import { validateMemoryReviewWorkResult } from "./memory-review-work-results.js";
+import { readWorkBatchCustody } from "./work-registry.js";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function refuse(reason) {
+    throw new AppError("memory_review_work_custody_invalid", "Reviewer settlement lacks independent Work and Session custody", 1, { reason, effect: "no_effect" });
+}
+/** Current physical settlement proof. All reads are SQL-only; the external
+ * copied workspace is rechecked separately before the settlement writer.
+ */
+function physical(context, work, owner, harness) {
+    const scope = owner.registration().scope;
+    const rows = context.db.all("SELECT ws.id,ws.session_id,ws.hook_event_id,ws.start_receipt_json,s.harness,s.provider_session_id FROM work_sessions ws JOIN sessions s ON s.session_id=ws.session_id AND s.project_id=? JOIN runs r ON r.id=s.run_id AND r.project_id=s.project_id WHERE ws.work_id=? AND ws.status='running' AND s.run_id=? AND s.worker_id=? AND s.harness=? AND s.status='active' AND s.current_stage='work' AND s.project_root=r.project_root AND s.workspace_path=r.workspace_root LIMIT 2", [work.project_id, work.work_id, work.run_id, work.work_id, harness]);
+    if (rows.length !== 1 || !rows[0].provider_session_id || typeof rows[0].start_receipt_json !== "string"
+        || Buffer.byteLength(rows[0].start_receipt_json) > 8 * 1024 * 1024)
+        refuse("active_reviewer_session_required");
+    const selected = rows[0];
+    if (!context.db.get("SELECT 1 FROM works WHERE project_id=? AND run_id=? AND work_id=? AND status='running'", [work.project_id, work.run_id, work.work_id]))
+        refuse("review_work_not_running");
+    if (!context.db.get("SELECT 1 FROM hook_events WHERE project_id=? AND event_key=? AND session_id=? AND harness=? AND provider_session_id=? AND status='claimed' AND event_name='PreToolUse'", [work.project_id, selected.hook_event_id, selected.session_id, selected.harness, selected.provider_session_id]))
+        refuse("review_start_hook_missing");
+    // Check physical identity, not just distinct internal keys or an agent's
+    // assertion that it did not author the documents.
+    if (context.db.get("SELECT 1 FROM work_sessions ws JOIN works w ON w.work_id=ws.work_id JOIN sessions s ON s.session_id=ws.session_id AND s.project_id=w.project_id WHERE w.project_id=? AND w.run_id=? AND w.work_id<>? AND s.harness=? AND s.provider_session_id=? LIMIT 1", [work.project_id, work.run_id, work.work_id, harness, selected.provider_session_id]))
+        refuse("reviewer_session_not_independent");
+    try {
+        const receipt = JSON.parse(selected.start_receipt_json);
+        if (receipt.version !== 2 || typeof receipt.context !== "string" || receipt.context_sha256 !== hash(receipt.context)
+            || receipt.generation !== owner.input.generation)
+            refuse("review_start_receipt_changed");
+        const input = JSON.parse(receipt.context);
+        if (input.run_id !== work.run_id || input.work_id !== work.work_id || input.parent_work_id !== scope.parent_work_id
+            || input.read_only !== true || input.result_schema !== memoryReviewWorkerSchema
+            || hybridDigest(input.review_input) !== hybridDigest(owner.input))
+            refuse("review_start_input_changed");
+    }
+    catch (error) {
+        if (error instanceof AppError && error.code === "memory_review_work_custody_invalid")
+            throw error;
+        return refuse("invalid_review_start_receipt");
+    }
+    return selected;
+}
+/** Registered reviewer result owner. Corrected waves consume their separately
+ * admitted current view and check receipt, never original compose byte custody.
+ * This class writes no files and dispatches no provider.
+ */
+export class PreparedRegisteredMemoryReviewWorkResult {
+    workId;
+    sha256;
+    #bytes;
+    #value;
+    #work;
+    #owner;
+    #allocation;
+    #physical;
+    #harness;
+    constructor(bytes, value, work, owner, allocation, selected, harness) {
+        this.#bytes = Buffer.from(bytes);
+        this.#value = structuredClone(value);
+        this.#work = { ...work };
+        this.#owner = owner;
+        this.#allocation = structuredClone(allocation);
+        this.#physical = { ...selected };
+        this.#harness = harness;
+        this.workId = work.work_id;
+        this.sha256 = hash(bytes);
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        if (!(input.bytes instanceof Uint8Array) || !input.bytes.byteLength || input.bytes.byteLength > 1024 * 1024)
+            refuse("invalid_result_bytes");
+        const work = context.db.get("SELECT * FROM works WHERE work_id=?", [input.workId]);
+        if (!work || work.result_schema !== memoryReviewWorkerSchema)
+            refuse("registered_reviewer_work_required");
+        const run = context.db.get("SELECT project_root FROM runs WHERE project_id=? AND id=?", [work.project_id, work.run_id]);
+        if (!run)
+            refuse("owned_run_required");
+        const generation = recoveryGuard(context, work.project_id, work.run_id)?.generation ?? 0;
+        const owner = prepareMemoryReviewWorkInput(context, work, run, generation, input.progress);
+        const bytes = Buffer.from(input.bytes), value = validateMemoryReviewWorkResult(bytes, owner.bundle.engine(), {
+            workId: work.work_id, packet: owner.packet(), references: owner.input.run_inputs
+        });
+        input.progress?.(`Memory review ${work.work_id}: result validated`);
+        const harness = runtimeHarness(owner.bundle.execution.work("review").worker);
+        const allocation = readWorkBatchCustody(context, work.work_id), selected = physical(context, work, owner, harness);
+        const prepared = new PreparedRegisteredMemoryReviewWorkResult(bytes, value, work, owner, allocation, selected, harness);
+        prepared.assertCustody(context);
+        input.progress?.(`Memory review ${work.work_id}: result custody verified`);
+        return prepared;
+    }
+    bytes() { return Buffer.from(this.#bytes); }
+    value() { return structuredClone(this.#value); }
+    assertCustody(context) {
+        this.#owner.assertCustody(context);
+        if (hybridDigest(readWorkBatchCustody(context, this.workId)) !== hybridDigest(this.#allocation)
+            || hybridDigest(physical(context, this.#work, this.#owner, this.#harness)) !== hybridDigest(this.#physical))
+            refuse("review_work_custody_changed");
+    }
+    revalidate(context) { this.#owner.revalidate(context); this.assertCustody(context); }
+    assertSettlementScope(context, sessionId, workSessionId) {
+        this.assertCustody(context);
+        if (sessionId !== this.#physical.session_id || workSessionId !== this.#physical.id)
+            refuse("foreign_reviewer_session");
+    }
+    recordSettlement(context, sessionId, workSessionId) {
+        this.assertSettlementScope(context, sessionId, workSessionId);
+        const receipt = this.#owner.registration();
+        if (context.db.get("SELECT 1 FROM audit_events WHERE project_id=? AND event_type='memory.review_work_settlement' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? LIMIT 1", [this.#work.project_id, this.#work.run_id, this.workId]))
+            refuse("review_settlement_already_recorded");
+        appendAudit(context, { projectId: this.#work.project_id, eventType: "memory.review_work_settlement", payload: {
+                schema_id: "dd-flow/memory-review-work-settlement@1", run_id: this.#work.run_id, work_id: this.workId,
+                work_session_id: workSessionId, session_id: sessionId, harness: this.#harness, provider_session_id: this.#physical.provider_session_id,
+                scope: receipt.scope, wave: receipt.wave, unit_id: this.#value.unit_id,
+                input_sha256: receipt.input_sha256, registration_sha256: hybridDigest(receipt), allocation_sha256: hybridDigest(this.#allocation),
+                start_receipt_sha256: hash(this.#physical.start_receipt_json), result_sha256: this.sha256
+            } });
+    }
+}

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

@@ -0,0 +1,91 @@
+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, progress) {
+    const bundle = readFlowRunExecutionBundle(context, { projectRoot: run.project_root, runId: work.run_id });
+    if (!bundle || !["mb-init", "mb-upgrade"].includes(bundle.descriptor.descriptor.id))
+        refuse("registered_memory_bundle_required");
+    progress?.(`Memory review ${work.work_id}: bundle verified`);
+    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 owner = corrected ?? PreparedMemoryInitialReviewInputs.prepare(context, { scope, bundle });
+    progress?.(`Memory review ${work.work_id}: inputs prepared`);
+    const checks = corrected ? PreparedMemoryCorrectionCheckReceipt.restore(context, corrected) : null;
+    if (checks)
+        progress?.(`Memory review ${work.work_id}: checks restored`);
+    const registration = corrected && checks ? PreparedRegisteredCorrectedMemoryReview.restore(context, corrected, checks) : null;
+    if (registration)
+        progress?.(`Memory review ${work.work_id}: registration restored`);
+    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) => {
+        if (registration)
+            registration.assertCustody(writer);
+        else {
+            owner.assertCustody(writer);
+            if (hybridDigest(readRegisteredMemoryReview(writer, view.scope, view.wave)) !== receiptSha256)
+                refuse("review_registration_changed");
+        }
+    };
+    assertCustody(context);
+    progress?.(`Memory review ${work.work_id}: assignment verified`);
+    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),
+        // The registered owner already revalidates corrected inputs, checks and
+        // its allocation. Repeating those traversals here adds no new boundary.
+        revalidate: (reader) => {
+            if (registration)
+                registration.revalidate(reader);
+            else {
+                owner.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,95 @@
+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 { parseMemoryWorkResultProposal } from "./memory-work-result-json.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 = parseMemoryWorkResultProposal(input, "memory_review_work_result_invalid");
+        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;
+        // A malformed checksum is a correctable proposal shape, not proof that a
+        // valid foreign packet was selected. Never accept either mismatch.
+        const foreignPacket = typeof value.packet_sha256 === "string" && /^[a-f0-9]{64}$/.test(value.packet_sha256)
+            && value.packet_sha256 !== packet.packet_sha256;
+        if (value.schema_id !== memoryReviewWorkerSchema || value.run_id !== packet.run_id || value.work_id !== binding.workId || foreignPacket
+            || 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}`))
+                    throw new AppError("memory_review_work_result_invalid", "Cite only the retained references assigned to this reviewer", 2, { reason: "unregistered_or_duplicate_evidence", phase: "prepare", effect: "no_effect", recoverable: true,
+                        unit_id: packet.unit.id, reference: structuredClone(ref),
+                        hint: "Correct this citation using assigned packet references, or remove the extra citation. Do not change the packet, accepted inputs or assigned scope.",
+                        result_sha256: createHash("sha256").update(input).digest("hex") });
+            }
+        };
+        const nonblank = (text) => Boolean(text.trim()) && !text.includes("\0");
+        if (!nonblank(value.summary))
+            refuse("missing_assessment");
+        evidence(value.evidence);
+        if ("preservation_invariants" in packet && packet.preservation_invariants) {
+            for (const invariant of packet.preservation_invariants) {
+                const old = invariant.evidence;
+                const refs = old.flatMap(source => {
+                    const path = source.root === "canon" ? `.memory-bank/${source.path}` : source.path;
+                    const retained = packet.historical_inputs?.filter(entry => entry.source.path === path && entry.source.sha256 === source.sha256).map(entry => entry.retained) ?? [];
+                    return retained.length ? retained : packet.unit_inputs.filter(ref => ref.path === path && ref.sha256 === source.sha256);
+                });
+                if (!refs.length || !value.evidence.some(ref => refs.some(old => old.root === ref.root && old.path === ref.path && old.sha256 === ref.sha256)))
+                    throw new AppError("memory_review_work_result_invalid", "Examine and cite the assigned old document evidence as well as current outputs", 2, { reason: "preservation_review_without_old_evidence", phase: "prepare", effect: "no_effect", recoverable: true,
+                        invariant_id: invariant.id, old_references: structuredClone(refs), result_sha256: createHash("sha256").update(input).digest("hex") });
+            }
+        }
+        const outputs = packet.unit.artifacts.map(ref => ({ root: ref.root === "run" ? "run" : "workspace",
+            path: ref.root === "canon" ? `.memory-bank/${ref.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,167 @@
+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";
+import { memoryReviewViewWithinLimit } from "./memory-review-limits.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, initialAssignments: input.first.assignments, 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) || !["mb-init", "mb-upgrade"].includes(input.bundle.descriptor.descriptor.id))
+            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,
+        ...(first.upgrade_baseline ? { upgrade_baseline: structuredClone(first.upgrade_baseline), preservation_invariants: structuredClone(first.preservation_invariants ?? []) } : {}),
+        instruction: structuredClone(first.instruction), repairs: repairs.map(repair => ({ work_id: repair.work_id, authority_sha256: repair.authority_sha256, result: repair.reference })) };
+    if (!memoryReviewViewWithinLimit(view))
+        refuse("unbounded_second_view");
+    return view;
+}

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

@@ -0,0 +1,77 @@
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { PreparedCorrectedMemoryReviewAcceptance } from "./memory-corrected-review-acceptance.js";
+import { validateMemoryReviewCorrectionPlan, memoryRepairCanonicalPaths } 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,
+            canonicalPaths: memoryRepairCanonicalPaths(context, bundle),
+            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); }
+}