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

package/dist/services/memory-flow-user-inputs.js

@@ -0,0 +1,88 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { readFlowRunExecutionBundle, assertPreparedRunBundleSqlAuthority } from "./runs.js";
+import { requireProjectByRoot } from "./projects.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { resolveStagePublicationPath } from "./stage-report-renderer.js";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const inputOwners = {
+    "mb-distill": { code: "distill_user_input_invalid", message: "Distillation needs its original delivered request and answers", bundle: "distill_bundle_required", schema: "dd-flow/distill-user-inputs@1" },
+    "mb-fix": { code: "memory_fix_user_input_invalid", message: "Memory repair needs its original delivered request and answers", bundle: "memory_fix_bundle_required", schema: "dd-flow/mb-fix-user-inputs@1" },
+    "review-fix": { code: "review_fix_user_input_invalid", message: "Review-fix needs its original delivered request and answers", bundle: "review_fix_bundle_required", schema: "dd-flow/review-fix-user-inputs@1" },
+    "interactive": { code: "interactive_user_input_invalid", message: "Interactive needs its original delivered request and answers", bundle: "interactive_bundle_required", schema: "dd-flow/interactive-user-answers@1" },
+    "release": { code: "delivery_user_input_invalid", message: "Release needs its original delivered request and answers", bundle: "delivery_bundle_required", schema: "dd-flow/release-user-inputs@1" },
+    "deploy": { code: "delivery_user_input_invalid", message: "Deploy needs its original delivered request and answers", bundle: "delivery_bundle_required", schema: "dd-flow/deploy-user-inputs@1" },
+    "publish": { code: "delivery_user_input_invalid", message: "Publish needs its original delivered request and answers", bundle: "delivery_bundle_required", schema: "dd-flow/publish-user-inputs@1" }
+};
+/** Read task evidence, not approval semantics. A Stage owner must consider the
+ * full ordered input set, select the actual agreement and fence this same set
+ * again before publication. Agent files and result claims are not user input.
+ * SQL custody survives projection loss and supported RUN relocation. */
+export function readMemoryFlowUserInputs(context, input, flowId, retainedBundle) {
+    const owner = Object.hasOwn(inputOwners, flowId) ? inputOwners[flowId] : inputOwners["mb-fix"];
+    function refuse(reason) {
+        throw new AppError(owner.code, owner.message, 1, { reason, effect: "no_effect" });
+    }
+    if (!Object.hasOwn(inputOwners, flowId))
+        refuse("unsupported_flow");
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const bundle = retainedBundle ?? readFlowRunExecutionBundle(context, input);
+    return readPreparedMemoryFlowUserInputs(context, { projectId: project.id, runId: input.runId }, flowId, bundle);
+}
+/** SQL/in-memory read for an already selected RUN. No root discovery or
+ * filesystem reads occur inside a Stage/publication settlement fence. */
+export function readPreparedMemoryFlowUserInputs(context, scope, flowId, bundle) {
+    const owner = Object.hasOwn(inputOwners, flowId) ? inputOwners[flowId] : inputOwners["mb-fix"];
+    function refuse(reason) {
+        throw new AppError(owner.code, owner.message, 1, { reason, effect: "no_effect" });
+    }
+    if (!Object.hasOwn(inputOwners, flowId))
+        refuse("unsupported_flow");
+    if (!bundle || bundle.manifest.flow_id !== flowId)
+        refuse(owner.bundle);
+    return context.db.readSnapshot(() => {
+        const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle);
+        if (!run.run_root)
+            refuse("run_home_required");
+        const request = bundle.blob("runtime/source-request.md"), reference = bundle.manifest.inventory.find(ref => ref.path === "runtime/source-request.md");
+        if (!request.length || request.length > 64 * 1024 || !reference || hash(request) !== reference.sha256)
+            refuse("original_request_missing");
+        const sources = [{ role: "request", event_id: 0, stage: null, pause_id: null,
+                root: "run", path: "execution-bundle/runtime/source-request.md", sha256: reference.sha256, base64: request.toString("base64") }];
+        const rows = context.db.all("SELECT id,payload_json FROM audit_events WHERE project_id=? AND event_type='flow_run.stage_resumed' AND json_extract(payload_json,'$.run_id')=? ORDER BY id LIMIT 129", [scope.projectId, scope.runId]);
+        if (rows.length > 128)
+            refuse("too_many_answers");
+        const pauses = new Set();
+        let total = request.length;
+        for (const row of rows) {
+            if (Buffer.byteLength(row.payload_json) > 64 * 1024)
+                refuse("unbounded_answer_event");
+            const answer = JSON.parse(row.payload_json);
+            if (typeof answer.stage !== "string" || typeof answer.pause_id !== "string" || !answer.pause_id || pauses.has(answer.pause_id)
+                || typeof answer.answer_path !== "string")
+                refuse("ambiguous_answer");
+            pauses.add(answer.pause_id);
+            for (const [role, locator] of [["question", path.join(path.dirname(answer.answer_path), "question.md")], ["answer", answer.answer_path]]) {
+                const file = resolveStagePublicationPath(context, scope.projectId, scope.runId, locator);
+                const relative = path.relative(run.run_root, file).split(path.sep).join("/");
+                if (!relative || path.isAbsolute(relative) || relative.split("/").some(part => !part || part === ".." || part === "."))
+                    refuse("input_outside_run");
+                const packets = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='flow_run.stage_packet' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.stage')=? AND json_extract(payload_json,'$.file')=? LIMIT 2", [scope.projectId, scope.runId, answer.stage, locator]);
+                if (packets.length !== 1 || Buffer.byteLength(packets[0].payload_json) > 2 * 1024 * 1024)
+                    refuse("answer_custody_missing");
+                const packet = JSON.parse(packets[0].payload_json);
+                if (typeof packet.base64 !== "string")
+                    refuse("answer_custody_changed");
+                const bytes = Buffer.from(packet.base64, "base64");
+                total += bytes.length;
+                if (!bytes.length || bytes.length > 1024 * 1024 || total > 16 * 1024 * 1024 || bytes.toString("base64") !== packet.base64
+                    || hash(bytes) !== packet.sha256)
+                    refuse("answer_custody_changed");
+                sources.push({ role: role, event_id: row.id, stage: answer.stage, pause_id: answer.pause_id,
+                    root: "run", path: relative, sha256: packet.sha256, base64: packet.base64 });
+            }
+        }
+        return { schema_id: owner.schema, run_id: scope.runId, bundle_sha256: bundle.sha256, sources };
+    });
+}

package/dist/services/memory-git-integration.js

@@ -0,0 +1,220 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+/** One reviewed inventory for fresh Git observation and historical terminal custody. */
+export function reviewedMemoryGitFiles(refs) {
+    return refs.filter(ref => ref.root === "workspace" && (ref.path.startsWith(".memory-bank/") || ref.path === ".mb-lint.json"))
+        .map(ref => ({ root: "workspace", path: ref.path, sha256: ref.sha256 }))
+        .sort((a, b) => a.path.localeCompare(b.path, "en"));
+}
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+export function isReviewedMemoryGitFile(ref) {
+    return !!ref && ref.root === "workspace" && typeof ref.path === "string"
+        && (ref.path.startsWith(".memory-bank/") || ref.path === ".mb-lint.json") && ref.path.length <= 4096 && !/[\\\0]/.test(ref.path)
+        && !ref.path.split("/").some(segment => !segment || segment === "." || segment === "..")
+        && typeof ref.sha256 === "string" && /^[a-f0-9]{64}$/.test(ref.sha256)
+        && (Object.keys(ref).sort().join() === "path,root,sha256"
+            || Object.keys(ref).sort().join() === "git_mode,path,root,sha256" && ["100644", "100755"].includes(ref.git_mode));
+}
+/** A removed file is absent, not a directory or a path through a symlink. */
+export function assertMemoryGitRemovalSources(directory, removals) {
+    for (const ref of removals) {
+        let current = directory;
+        const segments = ref.path.split("/");
+        for (const [index, segment] of segments.entries()) {
+            current = path.join(current, segment);
+            const stat = fs.lstatSync(current, { throwIfNoEntry: false });
+            if (!stat)
+                break;
+            if (index === segments.length - 1)
+                refuse("removed_memory_file_present");
+            if (!stat.isDirectory())
+                refuse("unsafe_removal_parent");
+        }
+    }
+}
+function refuse(reason) {
+    throw new AppError("memory_git_integration_invalid", "Memory finish lacks observed Git integration", 2, { reason, effect: "no_effect" });
+}
+function root(value) {
+    if (typeof value !== "string" || !path.isAbsolute(value))
+        refuse("absolute_root_required");
+    try {
+        const resolved = fs.realpathSync(value);
+        if (!fs.statSync(resolved).isDirectory())
+            refuse("repository_root_required");
+        return resolved;
+    }
+    catch {
+        return refuse("repository_root_unavailable");
+    }
+}
+/** Read-only physical observation, NOT policy selection, accepted MB content,
+ * full owned-file coverage or SQL/Stage authority. The finish owner must bind
+ * this selection to retained project policy and independently reviewed bytes.
+ * No checkout, commit, merge, push, tool repair or configuration mutation. */
+export function observeMemoryGitIntegration(input, env) {
+    if (!input || typeof input.integrationBranch !== "string" || !input.integrationBranch
+        || input.integrationBranch.length > 1024 || [...input.integrationBranch].some(character => character.charCodeAt(0) <= 32 || character.charCodeAt(0) === 127)
+        || input.integrationBranch.startsWith("-") || typeof input.gitExecutable !== "string"
+        || !path.isAbsolute(input.gitExecutable))
+        refuse("explicit_git_selection_required");
+    const projectRoot = root(input.projectRoot), workspaceRoot = root(input.workspaceRoot);
+    const cleanEnv = { ...Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_"))), GIT_LITERAL_PATHSPECS: "1" };
+    const git = (directory, args, expectedStatus = 0) => {
+        const result = spawnSync(input.gitExecutable, ["-c", "core.fsmonitor=false", "-c", "core.untrackedCache=false",
+            "-C", directory, ...args], { env: { ...cleanEnv, GIT_OPTIONAL_LOCKS: "0" }, encoding: "utf8",
+            timeout: 10000, maxBuffer: 2 * 1024 * 1024, windowsHide: true, shell: false });
+        if (result.error || result.signal || result.status !== expectedStatus)
+            refuse("git_observation_failed");
+        return result.stdout;
+    };
+    const integrationRef = `refs/heads/${input.integrationBranch}`;
+    git(projectRoot, ["check-ref-format", integrationRef]);
+    for (const directory of [projectRoot, workspaceRoot]) {
+        if (git(directory, ["rev-parse", "--is-bare-repository"]).trim() !== "false"
+            || root(git(directory, ["rev-parse", "--show-toplevel"]).trim()) !== directory)
+            refuse("not_repository_root");
+    }
+    const common = (directory) => root(path.resolve(directory, git(directory, ["rev-parse", "--git-common-dir"]).trim()));
+    const repository = common(projectRoot);
+    if (common(workspaceRoot) !== repository)
+        refuse("foreign_workspace_repository");
+    const workspaceBranch = git(workspaceRoot, ["symbolic-ref", "--short", "HEAD"]).trim();
+    const head = git(workspaceRoot, ["rev-parse", "--verify", "HEAD^{commit}"]).trim();
+    const integrationHead = git(projectRoot, ["rev-parse", "--verify", `${integrationRef}^{commit}`]).trim();
+    if (![head, integrationHead].every(value => /^[a-f0-9]{40,64}$/.test(value)))
+        refuse("invalid_commit_identity");
+    // status intentionally trusts index visibility flags. Do not accept that
+    // trust for MB readiness or mutate the user's index to clear those flags.
+    const visibility = git(workspaceRoot, ["ls-files", "-v", "-z", "--", ".memory-bank"]);
+    if (visibility.split("\0").filter(Boolean).some(entry => !entry.startsWith("H ")))
+        refuse("memory_index_visibility_override");
+    const status = git(workspaceRoot, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ".memory-bank"]);
+    if (status)
+        refuse("memory_bank_not_committed");
+    const index = git(workspaceRoot, ["ls-files", "--stage", "-z", "--", ".memory-bank/index.md"]);
+    if (!/^100644 [a-f0-9]{40,64} 0\t\.memory-bank\/index\.md\0$/.test(index))
+        refuse("tracked_memory_bank_index_required");
+    // Failure is a typed refusal; neither an unmerged feature nor an unborn
+    // branch can become an accepted integration by supplying its own hash.
+    git(projectRoot, ["merge-base", "--is-ancestor", head, integrationHead]);
+    const workspaceMemoryTree = git(workspaceRoot, ["rev-parse", "--verify", `${head}:.memory-bank`]).trim();
+    const integrationMemoryTree = git(projectRoot, ["rev-parse", "--verify", `${integrationHead}:.memory-bank`]).trim();
+    if (!/^[a-f0-9]{40,64}$/.test(workspaceMemoryTree) || workspaceMemoryTree !== integrationMemoryTree)
+        refuse("integrated_memory_tree_changed");
+    return { schema_id: "dd-flow/memory-git-integration-observation@1", project_root: projectRoot,
+        workspace_root: workspaceRoot, repository, workspace_branch: workspaceBranch, integration_ref: integrationRef, workspace_head: head,
+        integration_head: integrationHead, memory_tree: workspaceMemoryTree,
+        tracked_index_entry_sha256: hybridDigest(index), memory_index_visibility_sha256: hybridDigest(visibility),
+        memory_status_sha256: hybridDigest(status) };
+}
+/** Exact reviewed MB/owned root lint bytes in the physical workspace and integrated Git
+ * tree. References must be selected by the accepted review owner; this helper
+ * validates physical correspondence only and grants no semantic authority. */
+export function observeReviewedMemoryGitIntegration(input, env, references, removals = []) {
+    if (!Array.isArray(references) || !references.length || references.length > 4096
+        || references.some(ref => !isReviewedMemoryGitFile(ref))
+        || !Array.isArray(removals) || references.length + removals.length > 4096
+        || removals.some(ref => !isReviewedMemoryGitFile(ref) || !ref.path.startsWith(".memory-bank/") || ref.path === ".memory-bank/index.md")
+        || new Set([...references, ...removals].map(ref => ref.path)).size !== references.length + removals.length
+        || !references.some(ref => ref.path === ".memory-bank/index.md"))
+        refuse("invalid_reviewed_memory_inventory");
+    const selected = structuredClone([...references]).sort((a, b) => a.path.localeCompare(b.path, "en"));
+    const removed = structuredClone([...removals]).sort((a, b) => a.path.localeCompare(b.path, "en"));
+    const integration = observeMemoryGitIntegration(input, env);
+    const observed = ObservedMemorySources.capture({ workspace: integration.workspace_root }, selected.map(({ root, path }) => ({ root, path })));
+    const hashes = observed.hashes();
+    const cleanEnv = { ...Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_"))), GIT_LITERAL_PATHSPECS: "1" };
+    const git = (args, directory = integration.workspace_root, stdin) => {
+        const result = spawnSync(input.gitExecutable, ["-c", "core.fsmonitor=false", "-c", "core.untrackedCache=false",
+            "-C", directory, ...args], { env: { ...cleanEnv, GIT_OPTIONAL_LOCKS: "0" },
+            input: stdin, timeout: 10000, maxBuffer: (stdin === undefined ? 16 : 65) * 1024 * 1024, windowsHide: true, shell: false });
+        if (result.error || result.signal || result.status !== 0)
+            refuse("reviewed_git_blob_unavailable");
+        return result.stdout;
+    };
+    let total = 0;
+    const entries = new Map();
+    const listing = git(["ls-tree", "-r", "-t", "-z", integration.workspace_head, "--", ".memory-bank", ".mb-lint.json"]).toString("utf8");
+    if (listing && !listing.endsWith("\0"))
+        refuse("reviewed_regular_git_blob_required");
+    for (const entry of listing.split("\0").filter(Boolean)) {
+        const match = /^([0-7]{6}) (blob|tree|commit) ([a-f0-9]{40,64})\t([\s\S]+)$/.exec(entry);
+        if (!match || entries.has(match[4]))
+            refuse("reviewed_regular_git_blob_required");
+        entries.set(match[4], { mode: match[1], type: match[2], oid: match[3] });
+    }
+    for (const directory of new Set([integration.workspace_root, integration.project_root]))
+        assertMemoryGitRemovalSources(directory, removed);
+    for (const ref of removed) {
+        if (entries.has(ref.path))
+            refuse("removed_memory_file_still_committed");
+    }
+    const oids = [...new Set(selected.map(ref => {
+            const entry = entries.get(ref.path);
+            if (!entry || entry.mode !== (ref.git_mode ?? "100644") || entry.type !== "blob")
+                refuse("reviewed_regular_git_blob_required");
+            return entry.oid;
+        }))];
+    const batch = git(["cat-file", "--batch"], integration.workspace_root, `${oids.join("\n")}\n`);
+    const contents = new Map();
+    let offset = 0;
+    for (const oid of oids) {
+        const end = batch.indexOf(10, offset);
+        if (end < 0)
+            refuse("reviewed_git_blob_unavailable");
+        const header = /^([a-f0-9]{40,64}) blob (0|[1-9][0-9]*)$/.exec(batch.subarray(offset, end).toString("ascii"));
+        const size = Number(header?.[2]);
+        if (!header || header[1] !== oid || !Number.isSafeInteger(size) || size > 16 * 1024 * 1024
+            || end + 1 + size >= batch.length || batch[end + 1 + size] !== 10)
+            refuse("reviewed_git_blob_unavailable");
+        contents.set(oid, batch.subarray(end + 1, end + 1 + size));
+        offset = end + size + 2;
+    }
+    if (offset !== batch.length)
+        refuse("reviewed_git_blob_unavailable");
+    for (const ref of selected) {
+        if (hashes.get(memorySourceKey("workspace", ref.path)) !== ref.sha256)
+            refuse("reviewed_workspace_bytes_changed");
+        const expectedMode = ref.git_mode ?? "100644";
+        // Git may ignore chmod when core.filemode=false. Bytes and clean status
+        // alone do not prove that a preserved executable still is executable.
+        if (process.platform !== "win32") {
+            for (const directory of new Set([integration.workspace_root, integration.project_root])) {
+                const executable = (fs.lstatSync(path.join(directory, ref.path)).mode & 0o111) !== 0;
+                if (executable !== (expectedMode === "100755"))
+                    refuse("reviewed_workspace_mode_changed");
+            }
+        }
+        const content = contents.get(entries.get(ref.path).oid);
+        total += content.length;
+        if (total > 64 * 1024 * 1024)
+            refuse("reviewed_git_bytes_exceed_bound");
+        if (createHash("sha256").update(content).digest("hex") !== ref.sha256)
+            refuse("reviewed_git_bytes_changed");
+        if (ref.path === ".mb-lint.json") {
+            for (const root of new Set([integration.workspace_root, integration.project_root])) {
+                const visibility = git(["ls-files", "-v", "-z", "--", ref.path], root).toString("utf8");
+                if (visibility !== `H ${ref.path}\0`)
+                    refuse("lint_configuration_index_visibility_override");
+                const source = ObservedMemorySources.capture({ workspace: root }, [{ root: "workspace", path: ref.path }]);
+                if (source.hashes().get(memorySourceKey("workspace", ref.path)) !== ref.sha256)
+                    refuse("integrated_lint_configuration_changed");
+                source.revalidate();
+            }
+            const integrated = git(["cat-file", "blob", `${integration.integration_head}:${ref.path}`], integration.project_root);
+            if (createHash("sha256").update(integrated).digest("hex") !== ref.sha256)
+                refuse("integrated_lint_configuration_changed");
+        }
+    }
+    observed.revalidate();
+    if (hybridDigest(observeMemoryGitIntegration(input, env)) !== hybridDigest(integration))
+        refuse("integration_changed_during_observation");
+    return { ...integration, reviewed_files_sha256: hybridDigest(selected),
+        ...(removed.length ? { removed_files_sha256: hybridDigest(removed) } : {}) };
+}

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

@@ -0,0 +1,212 @@
+import { assertMemorySqlCustody } from "./memory-custody-snapshot.js";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedHistoricalOriginalMemoryReview } from "./memory-historical-original-review.js";
+import { PreparedHistoricalMemoryRepairRegistration } from "./memory-historical-repair-registration.js";
+import { PreparedSettledMemoryRepair } from "./memory-repair-history.js";
+import { readRetainedCorrectedMemoryReviewRegistration } from "./memory-corrected-review-registration.js";
+import { PreparedRetainedMemoryCorrectionChecks } from "./memory-correction-check-receipt.js";
+import { readMemoryReviewWorkSettlement } from "./memory-review-acceptance.js";
+import { validateMemoryReviewWorkResult } from "./memory-review-work-results.js";
+import { memoryCorrectedReviewBatch } from "./memory-corrected-review-batch.js";
+import { correctedMemoryReviewAssignments } from "./memory-corrected-review-inputs.js";
+import { memoryCorrectionAffectedUnits } from "./memory-completed-correction-wave.js";
+import { correctedMemoryReviewUnits } from "./memory-corrected-review-projection.js";
+import { correctedMemoryReviewFindings } from "./memory-corrected-review-findings.js";
+import { readAcceptedStageData } from "./stage-report-renderer.js";
+import { runtimeHarness } from "./execution-policy.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+const token = Symbol("historical-corrected-memory-review");
+function refuse(reason) {
+    throw new AppError("memory_historical_corrected_review_invalid", "Historical selective review lacks independent correction and reviewer custody", 2, { reason, effect: "no_effect" });
+}
+/** Retained metadata consistency only, not SQL/Session/Stage authority. */
+export function assertHistoricalMemoryReviewSources(histories, paths, runInputs, anchor) {
+    if (!Array.isArray(histories) || !histories.length || histories.length > 256
+        || !Array.isArray(runInputs) || runInputs.length > 4096)
+        refuse("invalid_historical_source_inventory");
+    const retainedHistories = histories;
+    let baseline = (anchor ?? retainedHistories[0].before()).withWritePaths(paths);
+    const visibleMemory = new Set(retainedHistories[0].workspaceManifest().entries()
+        .filter(entry => entry.kind === "file" && entry.path.startsWith(".memory-bank/")).map(entry => entry.path));
+    const prefixes = new Set([hybridDigest(baseline.entries())]);
+    for (const history of retainedHistories) {
+        if (!prefixes.has(hybridDigest(history.before().entries())))
+            refuse("historical_input_prefix_changed");
+        baseline = baseline.composeSettledDelta(history.before(), history.after(), history.result().outcome);
+        prefixes.add(hybridDigest(baseline.entries()));
+        const before = new Map(history.before().entries().map(entry => [entry.path, entry]));
+        for (const entry of history.after().entries())
+            if (entry.kind === "file" && hybridDigest(before.get(entry.path) ?? null) !== hybridDigest(entry))
+                visibleMemory.add(entry.path);
+    }
+    const memory = (path) => path === ".memory-bank" || path.startsWith(".memory-bank/");
+    const finalFiles = new Map(baseline.entries().filter(entry => entry.kind === "file" && visibleMemory.has(entry.path)).map(entry => [entry.path, entry.sha256]));
+    const nonMemory = retainedHistories[0].workspaceManifest().entries().filter(entry => !memory(entry.path));
+    const files = (entries) => entries.filter(entry => entry.kind === "file").map(entry => ({ path: entry.path, sha256: entry.sha256 }));
+    const sort = (entries) => [...entries].sort((a, b) => a.path.localeCompare(b.path, "en"));
+    const workspace = runInputs.filter(ref => ref.root === "workspace");
+    if (retainedHistories.some(history => hybridDigest(history.workspaceManifest().entries().filter(entry => !memory(entry.path))) !== hybridDigest(nonMemory))
+        || hybridDigest(sort(files(nonMemory))) !== hybridDigest(sort(workspace.filter(ref => !memory(ref.path)).map(ref => ({ path: ref.path, sha256: ref.sha256 }))))
+        || hybridDigest(sort([...finalFiles].map(([path, sha256]) => ({ path, sha256 }))))
+            !== hybridDigest(sort(workspace.filter(ref => memory(ref.path)).map(ref => ({ path: ref.path, sha256: ref.sha256 }))))
+        || new Set(runInputs.map(ref => `${ref.root}:${ref.path}`)).size !== runInputs.length)
+        refuse("historical_workspace_projection_changed");
+}
+/** Historical full projection only, not Stage receipt acceptance. Expected
+ * input/check hashes must be selected from the independent accepted receipt.
+ * Current workspace/copies/policy are never adopted or used for re-admission. */
+export class PreparedHistoricalCorrectedMemoryReview {
+    #custodyKey = {};
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #original in value;
+    }
+    #original;
+    #repairs;
+    #histories;
+    #checks;
+    #registration;
+    #workers;
+    #projection;
+    #observed;
+    #effective;
+    #reviewSha256;
+    constructor(key, original, repairs, histories, checks, registration, workers, projection, observed, effective, results) {
+        if (key !== token)
+            refuse("historical_review_token_required");
+        this.#original = original;
+        this.#repairs = repairs;
+        this.#histories = histories;
+        this.#checks = checks;
+        this.#registration = structuredClone(registration);
+        this.#workers = workers;
+        this.#projection = structuredClone(projection);
+        this.#observed = observed;
+        this.#effective = structuredClone(effective);
+        this.#reviewSha256 = hybridDigest({ registration_sha256: hybridDigest(this.#registration), workers: this.#workers.map(worker => ({
+                work_id: worker.workId, authority_sha256: worker.authority, result: worker.result
+            })), results });
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        if (!PreparedHistoricalOriginalMemoryReview.isPrepared(input.original))
+            refuse("historical_original_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        const original = input.original, initial = original.registration(), scope = initial.scope, bundle = original.bundle();
+        original.revalidate(context);
+        const registration = context.db.readSnapshot(() => readRetainedCorrectedMemoryReviewRegistration(context, scope, input.correctedInputSha256, input.checkReceiptSha256));
+        if (!registration)
+            refuse("historical_registration_required");
+        const view = registration.view, repairs = PreparedHistoricalMemoryRepairRegistration.prepare(context, original);
+        const histories = repairs.completedWorkOrder(context).map(id => PreparedSettledMemoryRepair.prepare(context, repairs, id));
+        const repairReceipt = repairs.receipt(), repairBatch = repairs.batch();
+        const paths = [...new Set(repairBatch.works.flatMap(item => item.payload.memory_repair.write_paths))].sort();
+        assertHistoricalMemoryReviewSources(histories, paths, view.run_inputs);
+        const repairResults = histories.map(history => ({ work_id: history.workId, result: history.result(), reference: history.reference(), authority_sha256: history.sha256,
+            unit_ids: repairBatch.works.find(item => repairReceipt.work_ids[item.key] === history.workId).payload.memory_repair.unit_ids }));
+        const compose = readAcceptedStageData(context, { projectId: scope.project_id, runId: scope.run_id, stage: bundle.descriptor.descriptor.id === "mb-upgrade" ? "upgrade" : "compose" });
+        const affected = memoryCorrectionAffectedUnits(initial.view.unit_inventory, repairResults, JSON.parse(compose.bytes.toString("utf8")).details.works);
+        const assignments = correctedMemoryReviewAssignments({ units: initial.view.unit_inventory, initialAssignments: initial.view.assignments, affected,
+            files: view.run_inputs.filter(ref => ref.root === "workspace"), repairs: repairResults });
+        if (view.schema_id !== "dd-flow/memory-corrected-review-inputs@1" || view.source_policy !== initial.view.source_policy
+            || view.original_review_sha256 !== original.reviewSha256() || view.base !== initial.view.base
+            || hybridDigest(view.unit_inventory) !== hybridDigest(initial.view.unit_inventory)
+            || hybridDigest(view.instruction) !== hybridDigest(initial.view.instruction)
+            || hybridDigest([view.upgrade_baseline, view.preservation_invariants]) !== hybridDigest([initial.view.upgrade_baseline, initial.view.preservation_invariants])
+            || hybridDigest(view.affected_unit_ids) !== hybridDigest(affected) || hybridDigest(view.assignments) !== hybridDigest(assignments)
+            || hybridDigest(view.repairs) !== hybridDigest(repairResults.map(repair => ({ work_id: repair.work_id, authority_sha256: repair.authority_sha256, result: repair.reference }))))
+            refuse("historical_correction_projection_changed");
+        const checks = PreparedRetainedMemoryCorrectionChecks.prepare(context, { projectId: scope.project_id, runId: scope.run_id,
+            correctedInputSha256: registration.input_sha256, receiptSha256: registration.check_receipt_sha256 });
+        if (checks.value(context).completed_correction_sha256 !== view.completed_correction_sha256)
+            refuse("historical_check_wave_changed");
+        const batch = memoryCorrectedReviewBatch(view), harness = runtimeHarness(bundle.execution.work("review").worker);
+        const workers = context.db.readSnapshot(() => batch.works.map(item => readMemoryReviewWorkSettlement(context, registration, registration.work_ids[item.key], harness)));
+        const engine = bundle.engine();
+        const results = workers.map((worker, index) => validateMemoryReviewWorkResult(worker.bytes, engine, {
+            workId: worker.workId, packet: batch.works[index].payload.memory_review, references: view.run_inputs
+        }));
+        const references = workers.map((worker, index) => ({ reviewer_work_id: worker.workId, input_sha256: registration.input_sha256,
+            result: worker.result, unit_ids: [results[index].unit_id] }));
+        const projection = { ...correctedMemoryReviewUnits({ view, original: original.results(), current: results, originalReferences: original.references(),
+                currentReferences: references, repairWorkIds: histories.map(history => history.workId) }),
+            ...correctedMemoryReviewFindings({ original: original.results(), current: results, affected, originalReferences: original.references(), currentReferences: references, repairs: repairResults,
+                diagnostics: original.registration().view.diagnostic_findings, diagnosticReference: original.registration().view.run_inputs.find(ref => ref.root === "run" && ref.path === `${bundle.descriptor.stage("verify").directory}/result.json`) }) };
+        const observed = ObservedMemorySources.capture({ run: workers[0].root }, workers.map(worker => ({ root: "run", path: worker.result.path })));
+        const hashes = observed.hashes();
+        if (workers.some(worker => hashes.get(memorySourceKey("run", worker.result.path)) !== worker.result.sha256))
+            refuse("historical_reviewer_artifact_changed");
+        const originalReferences = original.references();
+        const effectiveResults = original.results().map(old => results.find(result => result.unit_id === old.unit_id) ?? old);
+        const effectiveReferences = effectiveResults.map(result => references.find(reference => reference.reviewer_work_id === result.work_id)
+            ?? originalReferences.find(reference => reference.reviewer_work_id === result.work_id));
+        if (effectiveReferences.some(reference => !reference))
+            refuse("effective_review_reference_missing");
+        const prepared = new PreparedHistoricalCorrectedMemoryReview(token, original, repairs, histories, checks, registration, workers, projection, observed, { results: effectiveResults, references: effectiveReferences, projection }, results);
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    projection() { return structuredClone(this.#projection); }
+    /** Retained complete protected document state after the first repair graph.
+     * Not a physical current-source or write-permission admission. */
+    settledDocumentBaseline() {
+        const paths = [...new Set(this.#repairs.batch().works.flatMap(item => item.payload.memory_repair.write_paths))].sort();
+        let baseline = this.#histories[0].before().withWritePaths(paths);
+        const prefixes = new Set([hybridDigest(baseline.entries())]);
+        for (const history of this.#histories) {
+            if (!prefixes.has(hybridDigest(history.before().entries())))
+                refuse("historical_input_prefix_changed");
+            baseline = baseline.composeSettledDelta(history.before(), history.after(), history.result().outcome);
+            prefixes.add(hybridDigest(baseline.entries()));
+        }
+        return baseline;
+    }
+    retainedInputView() { return structuredClone(this.#registration.view); }
+    finalChecks(context) { this.assertCustody(context); return this.#checks.value(context).checks; }
+    /** Effective full review inventory after selective wave one. Results and
+     * references come from retained settlements, never workspace recapture. */
+    effectiveReviewProof(context) {
+        this.assertCustody(context);
+        return structuredClone(this.#effective);
+    }
+    bundle() { return this.#original.bundle(); }
+    verificationProfileHash(context) { this.assertCustody(context); return this.#checks.value(context).profile_sha256; }
+    /** Exact live fan-in identity reconstructed from retained settlements.
+     * A digest is an identity, not independent plan or Stage acceptance. */
+    reviewSha256() {
+        return this.#reviewSha256;
+    }
+    settlementProof(context) {
+        this.assertCustody(context);
+        return { registration_scope: structuredClone(this.#registration.scope), registration_sha256: hybridDigest(this.#registration), wave: 1,
+            check_receipt_sha256: this.#registration.check_receipt_sha256, workers: this.#workers.map(worker => ({ work_id: worker.workId,
+                authority_sha256: worker.authority, result: { ...worker.result } })) };
+    }
+    assertCustody(context) {
+        const original = this.#original;
+        assertMemorySqlCustody(context, this.#custodyKey, () => {
+            original.assertCustody(context);
+            this.#repairs.assertCustody(context);
+            this.#checks.assertCustody(context);
+            if (hybridDigest(readRetainedCorrectedMemoryReviewRegistration(context, this.#registration.scope, this.#registration.input_sha256, this.#registration.check_receipt_sha256)) !== hybridDigest(this.#registration))
+                refuse("historical_registration_changed");
+            for (const history of this.#histories)
+                history.assertCustody(context);
+            const harness = runtimeHarness(this.#original.bundle().execution.work("review").worker);
+            for (const worker of this.#workers)
+                if (readMemoryReviewWorkSettlement(context, this.#registration, worker.workId, harness).authority !== worker.authority)
+                    refuse("historical_reviewer_settlement_changed");
+        });
+    }
+    revalidate(context) {
+        this.#original.revalidate(context);
+        this.#repairs.revalidate(context);
+        this.#checks.revalidate(context);
+        for (const history of this.#histories)
+            history.revalidate(context);
+        this.#observed.revalidate();
+        this.assertCustody(context);
+    }
+}