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

package/dist/services/memory-repair-history.js

@@ -0,0 +1,491 @@
+import path from "node:path";
+import { readMemoryRepairPhysicalBinding } from "./memory-repair-physical-binding.js";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedRegisteredMemoryCorrections, memoryRepairWorkerSchema } from "./memory-repair-registration.js";
+import { PreparedHistoricalMemoryRepairRegistration } from "./memory-historical-repair-registration.js";
+import { PreparedRetainedSecondMemoryRepairs } from "./memory-retained-second-repairs.js";
+import { readWorkBatchCustody } from "./work-registry.js";
+import { MemoryRepairDocumentBaseline } from "./memory-repair-document-delta.js";
+import { RetainedMemoryRepairPublicationPlan } from "./memory-repair-publication-plan.js";
+import { deriveRetainedMemoryRepairViews } from "./memory-repair-publication.js";
+import { retainedMemoryRepairPublicationPlans } from "./memory-repair-publication-intent.js";
+import { PreparedMemoryRepairWorkspace } from "./memory-repair-workspace.js";
+import { memoryRepairCurrentReferences, validateMemoryRepairWorkResult } from "./memory-repair-work-results.js";
+import { readMemoryRepairCurrentViewReceipt } from "./memory-repair-current-view.js";
+import { runtimeHarness } from "./execution-policy.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+const token = Symbol("settled-memory-repair-history");
+function historyView(registration) {
+    return PreparedRetainedSecondMemoryRepairs.isPrepared(registration) ? registration.initialInputView()
+        : registration.review().original().registration().view;
+}
+function historyBundle(registration) {
+    return PreparedRetainedSecondMemoryRepairs.isPrepared(registration) ? registration.bundle()
+        : registration.review().original().bundle();
+}
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+function refuse(reason) {
+    throw new AppError("memory_repair_history_invalid", "Historical repair lacks independently settled original publication custody", 1, { reason, effect: "no_effect" });
+}
+function json(value, limit) {
+    if (typeof value !== "string" || !value.length || Buffer.byteLength(value) > limit)
+        refuse("unbounded_receipt");
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            refuse("invalid_receipt");
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        return refuse("invalid_receipt");
+    }
+}
+function bytes(value, limit) {
+    if (typeof value !== "string" || value.length > Math.ceil(limit / 3) * 4)
+        refuse("unbounded_retained_bytes");
+    const decoded = Buffer.from(value, "base64");
+    if (decoded.length > limit || decoded.toString("base64") !== value)
+        refuse("changed_retained_bytes");
+    return decoded;
+}
+function selected(context, projectId, runId, workId, event, limit, generation) {
+    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,'$.work_id')=?${generation === undefined ? "" : " AND json_extract(payload_json,'$.generation')=?"} LIMIT 2`, [projectId, event, runId, workId, ...(generation === undefined ? [] : [generation])]);
+    if (rows.length !== 1)
+        refuse("missing_or_ambiguous_historical_receipt");
+    return json(rows[0].payload_json, limit);
+}
+/** SQL/retained-metadata selection only. No current Session activity, source
+ * recapture or obsolete private workspace is used to manufacture this proof.
+ */
+function snapshot(context, registration, workId, validateReferencedViews = true) {
+    registration.assertCustody(context);
+    const owner = registration.receipt(), scope = owner.scope;
+    const second = PreparedRetainedSecondMemoryRepairs.isPrepared(registration);
+    const assigned = registration.batch().works.find(item => owner.work_ids[item.key] === workId);
+    if (!assigned || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/.test(workId))
+        refuse("foreign_repair_work");
+    const allocation = readWorkBatchCustody(context, workId);
+    const work = context.db.get("SELECT status,result,result_schema,parent_work_id FROM works WHERE project_id=? AND run_id=? AND work_id=?", [scope.project_id, scope.run_id, workId]);
+    const run = context.db.get("SELECT run_root,run_dir,workspace_root FROM runs WHERE project_id=? AND id=?", [scope.project_id, scope.run_id]);
+    if (!work || work.status !== "completed" || work.result_schema !== memoryRepairWorkerSchema || work.parent_work_id !== scope.parent_work_id
+        || typeof work.result !== "string" || !work.result.length || Buffer.byteLength(work.result) > 1024 * 1024
+        || !run || !path.isAbsolute(run.run_root ?? run.run_dir))
+        refuse("settled_repair_required");
+    const settlement = selected(context, scope.project_id, scope.run_id, workId, "memory.repair_work_settlement", 16 * 1024);
+    if (!Number.isSafeInteger(settlement.generation) || settlement.generation < 0)
+        refuse("invalid_settlement_generation");
+    const generation = settlement.generation;
+    const links = context.db.all("SELECT id,session_id,hook_event_id,result_path,result_receipt_json,start_receipt_json,start_publication_status FROM work_sessions WHERE work_id=? AND status='completed' LIMIT 2", [workId]);
+    if (links.length !== 1 || context.db.get("SELECT 1 FROM work_sessions WHERE work_id=? AND status='running' LIMIT 1", [workId]))
+        refuse("completed_work_session_required");
+    const link = links[0], root = run.run_root ?? run.run_dir;
+    if (link.start_publication_status !== "published" || link.result_path !== path.join(root, "works", workId, "result.json"))
+        refuse("historical_result_path_changed");
+    const read = (event, limit) => selected(context, scope.project_id, scope.run_id, workId, event, limit, generation);
+    const baseline = read("memory.repair_work_baseline", 24 * 1024 * 1024), copy = read("memory.repair_writer_copy_intent", 1024 * 1024);
+    const build = read("memory.repair_writer_copy_build", 12 * 1024 * 1024), ready = read("memory.repair_writer_copy_ready", 12 * 1024 * 1024);
+    const start = read("memory.repair_work_start", 1024 * 1024), intent = read("memory.repair_publication_intent", 160 * 1024 * 1024);
+    const complete = read("memory.repair_publication_complete", 16 * 1024);
+    const capsule = json(link.start_receipt_json, 16 * 1024 * 1024), resultReceipt = json(link.result_receipt_json, 32768);
+    if (!(second ? ["dd-flow/memory-repair-work-baseline@4", "dd-flow/memory-repair-work-baseline@5"] : ["dd-flow/memory-repair-work-baseline@2", "dd-flow/memory-repair-work-baseline@3"]).includes(baseline.schema_id) || baseline.project_id !== scope.project_id
+        || baseline.run_id !== scope.run_id || baseline.work_id !== workId || baseline.generation !== generation || baseline.registration_sha256 !== registration.sha256
+        || baseline.allocation_sha256 !== hybridDigest(allocation) || baseline.packet_sha256 !== assigned.payload.memory_repair.packet_sha256
+        || baseline.workspace_root !== run.workspace_root || baseline.export_policy !== "memory-repair-export@1")
+        refuse("historical_baseline_changed");
+    const currentView = baseline.schema_id === "dd-flow/memory-repair-work-baseline@3" || second && baseline.schema_id === "dd-flow/memory-repair-work-baseline@5"
+        ? readMemoryRepairCurrentViewReceipt(context, registration, workId) : null;
+    if (PreparedRetainedSecondMemoryRepairs.isPrepared(registration)) {
+        // The initial second baseline must be exactly the explained first-wave
+        // settlement. Receipt-shaped current bytes are never a substitute.
+        const initial = currentView ? MemoryRepairDocumentBaseline.restore(bytes(currentView.baseline_base64, 8 * 1024 * 1024), currentView.baseline_sha256)
+            : registration.initialDocumentBaseline().withWritePaths(assigned.payload.memory_repair.write_paths);
+        const files = new Set(initial.entries().filter(entry => entry.kind === "file").map(entry => entry.path));
+        const exported = currentView ? MemoryRepairDocumentBaseline.restore(bytes(currentView.exported_baseline_base64, 8 * 1024 * 1024), currentView.exported_baseline_sha256)
+            : initial.exported(registration.initialInputView().run_inputs.filter(ref => ref.root === "workspace"
+                && ref.path.startsWith(".memory-bank/") && files.has(ref.path)).map(ref => ref.path));
+        const secondOwner = registration.receipt();
+        const expected = { schema_id: currentView ? "dd-flow/memory-repair-work-baseline@5" : "dd-flow/memory-repair-work-baseline@4", wave: 2, project_id: scope.project_id, run_id: scope.run_id,
+            work_id: workId, generation, registration_sha256: registration.sha256, allocation_sha256: hybridDigest(allocation),
+            packet_sha256: assigned.payload.memory_repair.packet_sha256, workspace_root: run.workspace_root,
+            first_review_input_sha256: secondOwner.first_review_input_sha256, first_check_receipt_sha256: secondOwner.first_check_receipt_sha256,
+            baseline_sha256: initial.sha256, baseline_base64: initial.bytes().toString("base64"), export_policy: "memory-repair-export@1",
+            exported_baseline_sha256: exported.sha256, exported_baseline_base64: exported.bytes().toString("base64"),
+            ...(currentView ? { current_view_sha256: currentView.view_sha256, current_view_receipt_sha256: hybridDigest(currentView) } : {}) };
+        if (hybridDigest(baseline) !== hybridDigest(expected))
+            refuse("historical_second_baseline_changed");
+    }
+    if (assigned.depends_on.length && !currentView)
+        refuse("historical_dependency_view_required");
+    if (currentView) {
+        if (currentView.schema_id !== "dd-flow/memory-repair-current-view@1" || currentView.project_id !== scope.project_id
+            || currentView.run_id !== scope.run_id || currentView.work_id !== workId || currentView.generation !== generation
+            || currentView.registration_sha256 !== registration.sha256 || hybridDigest(currentView) !== baseline.current_view_receipt_sha256
+            || currentView.view_sha256 !== baseline.current_view_sha256 || currentView.baseline_sha256 !== baseline.baseline_sha256
+            || currentView.baseline_base64 !== baseline.baseline_base64 || currentView.exported_baseline_sha256 !== baseline.exported_baseline_sha256
+            || currentView.exported_baseline_base64 !== baseline.exported_baseline_base64
+            || currentView.workspace_manifest_sha256 !== build.workspace_manifest_sha256 || currentView.workspace_manifest_base64 !== build.workspace_manifest_base64
+            || !Array.isArray(currentView.histories) || !currentView.histories.length || currentView.histories.length > 256)
+            refuse("historical_current_view_changed");
+        const graph = currentView.selected;
+        const batch = registration.batch();
+        if (!graph || graph.generation !== generation || hybridDigest(graph.target) !== hybridDigest(assigned)
+            || !Array.isArray(graph.states) || graph.states.length !== batch.works.length || !Array.isArray(graph.settlements))
+            refuse("historical_current_view_graph_changed");
+        const completedKeys = new Set();
+        for (const [index, item] of batch.works.entries()) {
+            const state = graph.states[index];
+            if (!state || state.key !== item.key || state.work_id !== owner.work_ids[item.key]
+                || !["created", "running", "paused", "completed", "failed", "cancelled"].includes(state.status)
+                || state.work_id === workId && state.status !== "created")
+                refuse("historical_current_view_graph_changed");
+            if (state.status === "completed")
+                completedKeys.add(item.key);
+        }
+        for (const item of batch.works) {
+            if ((item.key === assigned.key || completedKeys.has(item.key)) && item.depends_on.some(key => !completedKeys.has(key)))
+                refuse("historical_current_view_dependency_changed");
+        }
+        const expectedIds = new Set([...completedKeys].map(key => owner.work_ids[key]));
+        if (expectedIds.size !== currentView.histories.length)
+            refuse("historical_current_view_reference_changed");
+        const originalInput = viewInput(registration);
+        const retainedInput = currentView.input;
+        if (!retainedInput || typeof retainedInput.source_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(retainedInput.source_sha256)
+            || retainedInput.base !== originalInput.base || hybridDigest(retainedInput.explicit_inputs) !== hybridDigest(originalInput.explicit_inputs))
+            refuse("historical_current_view_input_changed");
+        const actualSettlements = context.db.all(`SELECT id,json_extract(payload_json,'$.work_id') AS work_id FROM audit_events WHERE project_id=? AND event_type='memory.repair_work_settlement' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id') IN (${[...expectedIds].map(() => "?").join(",")}) ORDER BY id LIMIT 257`, [scope.project_id, scope.run_id, ...expectedIds]);
+        if (actualSettlements.length !== expectedIds.size || hybridDigest(actualSettlements) !== hybridDigest(graph.settlements))
+            refuse("historical_current_view_reference_changed");
+        const viewEvents = context.db.all("SELECT id FROM audit_events WHERE project_id=? AND event_type='memory.repair_current_view' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? LIMIT 2", [scope.project_id, scope.run_id, workId]);
+        if (viewEvents.length !== 1 || !Number.isSafeInteger(viewEvents[0].id) || viewEvents[0].id <= 0
+            || actualSettlements.some(item => !Number.isSafeInteger(item.id) || item.id <= 0 || item.id >= viewEvents[0].id))
+            refuse("historical_current_view_order_changed");
+        const seen = new Set();
+        let composed = PreparedRetainedSecondMemoryRepairs.isPrepared(registration)
+            ? registration.initialDocumentBaseline().withWritePaths(assigned.payload.memory_repair.write_paths) : null;
+        const prefixes = new Set(composed ? [hybridDigest(composed.entries())] : []);
+        const immutableInputs = hybridDigest(JSON.parse(bytes(build.workspace_manifest_base64, 8 * 1024 * 1024).toString("utf8")).entries
+            .filter((entry) => entry.path !== ".memory-bank" && !entry.path.startsWith(".memory-bank/")));
+        for (const [index, reference] of currentView.histories.entries()) {
+            if (!reference || typeof reference.work_id !== "string" || !expectedIds.has(reference.work_id) || reference.work_id === workId || seen.has(reference.work_id)
+                || typeof reference.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(reference.sha256))
+                refuse("historical_current_view_reference_changed");
+            seen.add(reference.work_id);
+            // Every retained current view names the whole previously settled set.
+            // Verify that set directly rather than recursively expanding shared DAG
+            // ancestors exponentially. Each snapshot still checks its own receipt.
+            if (validateReferencedViews) {
+                const peer = snapshot(context, registration, reference.work_id, false);
+                if (hybridDigest(peer) !== reference.sha256)
+                    refuse("historical_current_view_reference_changed");
+                if (composed) {
+                    if (reference.work_id !== actualSettlements[index].work_id)
+                        refuse("historical_second_current_view_order_changed");
+                    const before = MemoryRepairDocumentBaseline.restore(bytes(peer.intent.before_base64, 8 * 1024 * 1024), peer.intent.before_sha256);
+                    const after = MemoryRepairDocumentBaseline.restore(bytes(peer.intent.after_base64, 8 * 1024 * 1024), peer.intent.after_sha256);
+                    if (!prefixes.has(hybridDigest(before.entries())))
+                        refuse("historical_second_current_view_prefix_changed");
+                    composed = composed.composeSettledDelta(before, after);
+                    prefixes.add(hybridDigest(composed.entries()));
+                    const peerInputs = JSON.parse(bytes(peer.build.workspace_manifest_base64, 8 * 1024 * 1024).toString("utf8")).entries
+                        .filter((entry) => entry.path !== ".memory-bank" && !entry.path.startsWith(".memory-bank/"));
+                    if (hybridDigest(peerInputs) !== immutableInputs)
+                        refuse("historical_second_current_view_non_memory_changed");
+                }
+            }
+        }
+        if (validateReferencedViews && composed && (composed.sha256 !== baseline.baseline_sha256
+            || composed.bytes().toString("base64") !== baseline.baseline_base64))
+            refuse("historical_second_current_view_changed");
+    }
+    else if (Object.hasOwn(baseline, "current_view_sha256") || Object.hasOwn(baseline, "current_view_receipt_sha256"))
+        refuse("historical_current_view_changed");
+    const privateRoot = path.join(root, "works", workId, "writer-workspaces", `generation-${generation}`);
+    const view = historyView(registration);
+    const expectedCopy = { schema_id: "dd-flow/memory-repair-writer-copy-intent@1", project_id: scope.project_id, run_id: scope.run_id,
+        work_id: workId, generation, baseline_registration_sha256: hybridDigest(baseline), protected_baseline_sha256: baseline.baseline_sha256,
+        exported_baseline_sha256: baseline.exported_baseline_sha256, run_root: root, source_root: run.workspace_root,
+        copy_relative: `works/${workId}/writer-workspaces/generation-${generation}`,
+        input: currentView ? currentView.input : { source_sha256: view.source_sha256, base: view.base, explicit_inputs: view.run_inputs.filter(ref => ref.root === "workspace").map(ref => ref.path) } };
+    if (hybridDigest(copy) !== hybridDigest(expectedCopy) || hybridDigest(ready) !== hybridDigest(build)
+        || hybridDigest(build) !== hybridDigest({ ...copy, workspace_manifest_sha256: build.workspace_manifest_sha256, workspace_manifest_base64: build.workspace_manifest_base64 }))
+        refuse("historical_copy_changed");
+    if (capsule.version !== 2 || capsule.generation !== generation || typeof capsule.context !== "string" || typeof capsule.prompt !== "string"
+        || capsule.context_sha256 !== hash(capsule.context) || capsule.prompt_sha256 !== hash(capsule.prompt)
+        || !capsule.response || typeof capsule.response !== "object" || Array.isArray(capsule.response))
+        refuse("historical_start_capsule_changed");
+    const response = capsule.response, input = json(capsule.context, 4 * 1024 * 1024);
+    const route = historyBundle(registration).execution.work("review", assigned.payload.execution_override?.agent_profile_id);
+    const harness = runtimeHarness(route.worker);
+    const launch = readMemoryRepairPhysicalBinding(context, workId, route);
+    if (!launch || !["launching", "start_requested"].includes(launch.status) || typeof launch.operation_id !== "string" || !launch.operation_id
+        || launch.provider_session_id !== start.provider_session_id)
+        refuse("historical_launch_identity_changed");
+    const profile = json(launch.profile_json, 1024 * 1024);
+    const frozen = { coordinator: route.coordinator, worker: route.worker,
+        delegation: { mode: route.delegation.mode, max_parallel: route.delegation.mode === "external" ? route.delegation.max_parallel : null } };
+    if (hybridDigest({ coordinator: profile.coordinator, worker: profile.worker, delegation: profile.delegation }) !== hybridDigest(frozen)
+        || launch.profile_hash !== hash(JSON.stringify(frozen)))
+        refuse("historical_launch_profile_changed");
+    if (second && hybridDigest(profile.memory_repair_copy) !== hybridDigest({ root: expectedCopy.copy_relative,
+        copy_intent_sha256: hybridDigest(copy), workspace_manifest_sha256: build.workspace_manifest_sha256,
+        baseline_registration_sha256: hybridDigest(baseline) }))
+        refuse("historical_second_launch_copy_changed");
+    const exportedView = currentView ? MemoryRepairDocumentBaseline.restore(bytes(baseline.exported_baseline_base64, 8 * 1024 * 1024), baseline.exported_baseline_sha256) : null;
+    const currentWorkspace = exportedView ? PreparedMemoryRepairWorkspace.restore(bytes(build.workspace_manifest_base64, 8 * 1024 * 1024), build.workspace_manifest_sha256, exportedView) : null;
+    const expectedInput = { schema_id: currentView ? "dd-flow/memory-repair-work-input@2" : "dd-flow/memory-repair-work-input@1", work_id: workId, generation,
+        packet_sha256: baseline.packet_sha256, baseline_registration_sha256: hybridDigest(baseline), protected_baseline_sha256: baseline.baseline_sha256,
+        exported_baseline_sha256: baseline.exported_baseline_sha256, copy_intent_sha256: hybridDigest(copy), copy_build_sha256: hybridDigest(build),
+        workspace_manifest_sha256: build.workspace_manifest_sha256, workspace_root: privateRoot,
+        launch_operation_id: launch.operation_id, provider_session_id: launch.provider_session_id,
+        ...(currentView ? { current_view_sha256: currentView.view_sha256, current_view_receipt_sha256: hybridDigest(currentView),
+            effective_read_inputs: memoryRepairCurrentReferences(assigned.payload.memory_repair, currentWorkspace) } : {}) };
+    if (typeof expectedInput.launch_operation_id !== "string" || !expectedInput.launch_operation_id || typeof start.provider_session_id !== "string" || !start.provider_session_id
+        || input.work_id !== workId || input.run_id !== scope.run_id || input.workspace_root !== privateRoot || input.read_only !== false || input.result_schema !== memoryRepairWorkerSchema
+        || hybridDigest(input.memory_repair_input) !== hybridDigest(expectedInput) || response.work_session_id !== link.id || response.worker_prompt_markdown !== capsule.prompt
+        || capsule.response_sha256 !== hash(JSON.stringify(response)))
+        refuse("historical_work_input_changed");
+    const expectedStart = { schema_id: "dd-flow/memory-repair-start@1", project_id: scope.project_id, run_id: scope.run_id, work_id: workId,
+        generation, work_session_id: link.id, session_id: link.session_id, hook_event_id: link.hook_event_id, harness,
+        provider_session_id: start.provider_session_id, context_sha256: capsule.context_sha256, prompt_sha256: capsule.prompt_sha256, input_sha256: hybridDigest(expectedInput) };
+    if (hybridDigest(start) !== hybridDigest(expectedStart)
+        || !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'", [scope.project_id, link.hook_event_id, link.session_id, harness, start.provider_session_id])
+        || 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", [scope.project_id, scope.run_id, workId, harness, start.provider_session_id]))
+        refuse("historical_start_identity_changed");
+    const resultSha256 = hash(work.result);
+    if (second && intent.schema_id !== "dd-flow/memory-repair-publication-intent@1")
+        refuse("historical_second_publication_source_required");
+    const publicationSource = intent.schema_id === "dd-flow/memory-repair-publication-intent@2"
+        ? read("memory.repair_publication_source", 40 * 1024 * 1024) : null;
+    const fields = ["schema_id", "project_id", "run_id", "work_id", "generation", "work_session_id",
+        "source_root", "private_root", "output_sha256", "start_receipt_sha256", "result_sha256", "result_base64", "delta_sha256",
+        "transition_sha256", "before_sha256", "before_base64", "after_sha256", "after_base64", "actions"];
+    if (publicationSource)
+        fields.push("source_view_sha256", "source_receipt_sha256", "private_plan_sha256", "private_plan");
+    if (!["dd-flow/memory-repair-publication-intent@1", "dd-flow/memory-repair-publication-intent@2"].includes(intent.schema_id) || intent.project_id !== scope.project_id || intent.run_id !== scope.run_id
+        || intent.work_id !== workId || intent.generation !== generation || intent.work_session_id !== link.id || intent.private_root !== privateRoot
+        || intent.source_root !== run.workspace_root || intent.start_receipt_sha256 !== hybridDigest(start)
+        || !publicationSource && (intent.before_sha256 !== baseline.baseline_sha256 || intent.before_base64 !== baseline.baseline_base64)
+        || intent.result_sha256 !== resultSha256 || !bytes(intent.result_base64, 1024 * 1024).equals(Buffer.from(work.result))
+        || Object.keys(intent).sort().join(",") !== fields.sort().join(","))
+        refuse("historical_publication_changed");
+    if (publicationSource) {
+        const graph = publicationSource.selected;
+        const references = publicationSource.histories;
+        const batch = registration.batch();
+        if (!graph || graph.generation !== generation || hybridDigest(graph.target) !== hybridDigest(assigned)
+            || !Array.isArray(graph.states) || graph.states.length !== batch.works.length || !Array.isArray(graph.settlements)
+            || !Array.isArray(references) || references.length > 256)
+            refuse("historical_publication_source_graph_changed");
+        const completedKeys = new Set();
+        for (const [index, item] of batch.works.entries()) {
+            const state = graph.states[index];
+            if (!state || state.key !== item.key || state.work_id !== owner.work_ids[item.key]
+                || !["created", "running", "paused", "completed", "failed", "cancelled"].includes(state.status)
+                || state.work_id === workId && state.status !== "running")
+                refuse("historical_publication_source_graph_changed");
+            if (state.status === "completed")
+                completedKeys.add(item.key);
+        }
+        for (const item of batch.works) {
+            if ((item.key === assigned.key || completedKeys.has(item.key)) && item.depends_on.some(key => !completedKeys.has(key)))
+                refuse("historical_publication_source_dependency_changed");
+        }
+        const ids = new Set([...completedKeys].map(key => owner.work_ids[key]));
+        const settlements = ids.size ? context.db.all(`SELECT id,json_extract(payload_json,'$.work_id') AS work_id FROM audit_events WHERE project_id=? AND event_type='memory.repair_work_settlement' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id') IN (${[...ids].map(() => "?").join(",")}) ORDER BY id LIMIT 257`, [scope.project_id, scope.run_id, ...ids]) : [];
+        if (settlements.length !== ids.size || new Set(settlements.map(item => item.work_id)).size !== ids.size
+            || hybridDigest(settlements) !== hybridDigest(graph.settlements) || references.length !== settlements.length)
+            refuse("historical_publication_source_reference_changed");
+        const events = context.db.all("SELECT id,event_type FROM audit_events WHERE project_id=? AND event_type IN ('memory.repair_work_start','memory.repair_publication_source','memory.repair_publication_intent') AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? AND json_extract(payload_json,'$.generation')=? ORDER BY id LIMIT 4", [scope.project_id, scope.run_id, workId, generation]);
+        if (events.length !== 3 || events[0].event_type !== "memory.repair_work_start" || events[1].event_type !== "memory.repair_publication_source"
+            || events[2].event_type !== "memory.repair_publication_intent" || settlements.some(item => item.id >= events[1].id))
+            refuse("historical_publication_source_order_changed");
+        const sourceBody = { schema_id: "dd-flow/memory-repair-publication-source@1", project_id: scope.project_id, run_id: scope.run_id,
+            work_id: workId, generation, work_session_id: link.id, registration_sha256: registration.sha256,
+            baseline_registration_sha256: hybridDigest(baseline), start_receipt_sha256: hybridDigest(start), copy_input_sha256: hybridDigest(expectedInput),
+            source_root: run.workspace_root, selected: graph, histories: references, before_sha256: intent.before_sha256, before_base64: intent.before_base64 };
+        if (hybridDigest(publicationSource) !== hybridDigest({ ...sourceBody, source_view_sha256: hybridDigest(sourceBody) })
+            || intent.source_view_sha256 !== hybridDigest(sourceBody) || intent.source_receipt_sha256 !== hybridDigest(publicationSource))
+            refuse("historical_publication_source_changed");
+        const original = MemoryRepairDocumentBaseline.restore(bytes(baseline.baseline_base64, 8 * 1024 * 1024), baseline.baseline_sha256);
+        let composed = original;
+        const versions = new Set();
+        const immutableInputs = hybridDigest(JSON.parse(bytes(build.workspace_manifest_base64, 8 * 1024 * 1024).toString("utf8")).entries.filter((entry) => entry.path !== ".memory-bank" && !entry.path.startsWith(".memory-bank/")));
+        for (const [index, reference] of references.entries()) {
+            if (!reference || reference.work_id !== settlements[index].work_id || reference.work_id === workId
+                || typeof reference.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(reference.sha256))
+                refuse("historical_publication_source_reference_changed");
+            if (validateReferencedViews) {
+                const peer = snapshot(context, registration, reference.work_id, false);
+                if (hybridDigest(peer) !== reference.sha256)
+                    refuse("historical_publication_source_reference_changed");
+                const peerBefore = MemoryRepairDocumentBaseline.restore(bytes(peer.intent.before_base64, 8 * 1024 * 1024), peer.intent.before_sha256);
+                const peerAfter = MemoryRepairDocumentBaseline.restore(bytes(peer.intent.after_base64, 8 * 1024 * 1024), peer.intent.after_sha256);
+                if (!index) {
+                    composed = peerBefore.withWritePaths(assigned.payload.memory_repair.write_paths);
+                    versions.add(hybridDigest(composed.entries()));
+                }
+                if (!versions.has(hybridDigest(peerBefore.entries())))
+                    refuse("historical_publication_source_prefix_changed");
+                composed = composed.composeSettledDelta(peerBefore, peerAfter);
+                versions.add(hybridDigest(composed.entries()));
+                const peerInputs = JSON.parse(bytes(peer.build.workspace_manifest_base64, 8 * 1024 * 1024).toString("utf8")).entries.filter((entry) => entry.path !== ".memory-bank" && !entry.path.startsWith(".memory-bank/"));
+                if (hybridDigest(peerInputs) !== immutableInputs)
+                    refuse("historical_publication_source_non_memory_changed");
+            }
+        }
+        if (validateReferencedViews && (references.length && !versions.has(hybridDigest(original.entries()))
+            || composed.sha256 !== intent.before_sha256 || composed.bytes().toString("base64") !== intent.before_base64))
+            refuse("historical_publication_source_view_changed");
+        const privatePlan = RetainedMemoryRepairPublicationPlan.restore(Buffer.from(JSON.stringify(intent.private_plan)), intent.private_plan_sha256);
+        if (privatePlan.state(0).sha256 !== original.sha256)
+            refuse("historical_private_start_changed");
+    }
+    const expectedComplete = { schema_id: "dd-flow/memory-repair-publication-complete@1", project_id: scope.project_id, run_id: scope.run_id,
+        work_id: workId, generation, work_session_id: link.id, publication_intent_sha256: hybridDigest(intent), result_sha256: resultSha256,
+        action_count: Array.isArray(intent.actions) ? intent.actions.length : -1, before_sha256: intent.before_sha256, after_sha256: intent.after_sha256 };
+    const expectedSettlement = { schema_id: "dd-flow/memory-repair-work-settlement@1", project_id: scope.project_id, run_id: scope.run_id, generation,
+        work_id: workId, work_session_id: link.id, session_id: link.session_id, harness, provider_session_id: start.provider_session_id,
+        private_root: privateRoot, source_root: run.workspace_root, start_receipt_sha256: hybridDigest(start), publication_intent_sha256: hybridDigest(intent),
+        publication_complete_sha256: hybridDigest(complete), result_sha256: resultSha256, before_sha256: intent.before_sha256, after_sha256: intent.after_sha256 };
+    if (hybridDigest(complete) !== hybridDigest(expectedComplete) || hybridDigest(settlement) !== hybridDigest(expectedSettlement)
+        || resultReceipt.work_id !== workId || resultReceipt.work_session_id !== link.id || resultReceipt.status !== "completed" || resultReceipt.result_sha256 !== resultSha256
+        || resultReceipt.previous_sha256 !== null && (typeof resultReceipt.previous_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(resultReceipt.previous_sha256)))
+        refuse("historical_settlement_changed");
+    const { plan } = retainedMemoryRepairPublicationPlans(intent);
+    const publicationSha256 = hybridDigest(intent);
+    const stagingDirectory = path.join(run.workspace_root, ".dd-flow", "memory-repair-publications", publicationSha256);
+    const actions = plan.actions();
+    const journal = context.db.all("SELECT event_type,payload_json FROM audit_events WHERE project_id=? AND event_type IN ('memory.repair_publication_action_intent','memory.repair_publication_action_complete','memory.repair_publication_file_ready','memory.repair_publication_directory_ready') AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? AND json_extract(payload_json,'$.generation')=? ORDER BY event_type,payload_json LIMIT 60001", [scope.project_id, scope.run_id, workId, generation]);
+    const expectedJournal = new Map();
+    for (let index = 0; index < actions.length; index++) {
+        const action = actions[index];
+        const receipt = { schema_id: "dd-flow/memory-repair-publication-action-intent@1", project_id: scope.project_id,
+            run_id: scope.run_id, work_id: workId, generation, work_session_id: link.id, publication_intent_sha256: publicationSha256,
+            index, source_root: run.workspace_root, staging_directory: stagingDirectory, staging_slot: action.after ? `action-${index}.tmp` : null,
+            before_sha256: plan.state(index).sha256, after_sha256: plan.state(index + 1).sha256, action_sha256: hybridDigest(action) };
+        expectedJournal.set(`memory.repair_publication_action_intent:${index}`, hybridDigest(receipt));
+        expectedJournal.set(`memory.repair_publication_action_complete:${index}`, hybridDigest({ ...receipt, schema_id: "dd-flow/memory-repair-publication-action-complete@1" }));
+        if (action.after) {
+            const file = action.after.kind === "file";
+            expectedJournal.set(`memory.repair_publication_${file ? "file" : "directory"}_ready:${index}`, hybridDigest({ ...receipt,
+                schema_id: file ? "dd-flow/memory-repair-publication-file-ready@1" : "dd-flow/memory-repair-publication-directory-ready@1",
+                ...(file ? { output_sha256: action.after.sha256 } : {}), mode: action.after.mode }));
+        }
+    }
+    if (journal.length !== expectedJournal.size)
+        refuse("historical_action_receipts_missing_or_ambiguous");
+    for (const row of journal) {
+        const value = json(row.payload_json, 16 * 1024), key = `${row.event_type}:${value.index}`;
+        if (expectedJournal.get(key) !== hybridDigest(value))
+            refuse("historical_action_receipt_changed");
+        expectedJournal.delete(key);
+    }
+    if (expectedJournal.size)
+        refuse("historical_action_receipts_missing_or_ambiguous");
+    const staging = actions.some(action => action.after)
+        ? read("memory.repair_publication_staging_ready", 16 * 1024) : null;
+    if (staging && (!Number.isSafeInteger(staging.dev) || !Number.isSafeInteger(staging.ino)
+        || hybridDigest(staging) !== hybridDigest({ schema_id: "dd-flow/memory-repair-publication-staging@1", project_id: scope.project_id,
+            run_id: scope.run_id, work_id: workId, generation, work_session_id: link.id, publication_intent_sha256: publicationSha256,
+            directory: stagingDirectory, mode: 0o700, dev: staging.dev, ino: staging.ino })))
+        refuse("historical_staging_receipt_changed");
+    return { workId, root, work, link, launch, baseline, build, start, intent, complete, settlement, expectedInput, assigned, journal, staging, currentView,
+        ...(publicationSource ? { publicationSource } : {}) };
+}
+function viewInput(registration) {
+    const view = historyView(registration);
+    return { base: view.base, explicit_inputs: view.run_inputs.filter(ref => ref.root === "workspace").map(ref => ref.path) };
+}
+/** Historical proof only: neither fresh writer admission nor semantic repair
+ * acceptance. Current/dependency views must separately compose settled deltas
+ * and compare the physical shared inventory before admitting new work.
+ */
+export class PreparedSettledMemoryRepair {
+    sha256;
+    workId;
+    #registration;
+    #result;
+    #before;
+    #after;
+    #observed;
+    #workspace;
+    #reference;
+    constructor(key, registration, selected, result, before, after, observed, workspace) {
+        if (key !== token)
+            refuse("historical_result_token_required");
+        this.#registration = registration;
+        this.workId = selected.workId;
+        this.sha256 = hybridDigest(selected);
+        this.#result = structuredClone(result);
+        this.#before = before;
+        this.#after = after;
+        this.#observed = observed;
+        this.#workspace = workspace;
+        this.#reference = { path: path.relative(selected.root, selected.link.result_path).split(path.sep).join("/"), sha256: hash(selected.work.result) };
+        Object.freeze(this);
+    }
+    static prepare(context, registration, workId) {
+        if (!PreparedRegisteredMemoryCorrections.isPrepared(registration)
+            && !PreparedHistoricalMemoryRepairRegistration.isPrepared(registration)
+            && !PreparedRetainedSecondMemoryRepairs.isPrepared(registration))
+            refuse("registered_corrections_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("historical_preparation_outside_writer_required");
+        const value = context.db.readSnapshot(() => snapshot(context, registration, workId));
+        const before = MemoryRepairDocumentBaseline.restore(bytes(value.baseline.baseline_base64, 8 * 1024 * 1024), value.baseline.baseline_sha256);
+        const exported = MemoryRepairDocumentBaseline.restore(bytes(value.baseline.exported_baseline_base64, 8 * 1024 * 1024), value.baseline.exported_baseline_sha256);
+        for (const baseline of [before, exported]) {
+            if (hybridDigest(JSON.parse(baseline.bytes().toString("utf8")).write_paths) !== hybridDigest(value.assigned.payload.memory_repair.write_paths))
+                refuse("historical_write_paths_changed");
+        }
+        const workspace = PreparedMemoryRepairWorkspace.restore(bytes(value.build.workspace_manifest_base64, 8 * 1024 * 1024), value.build.workspace_manifest_sha256, exported);
+        const result = validateMemoryRepairWorkResult(Buffer.from(value.work.result), historyBundle(registration).engine(), { workId, packet: value.assigned.payload.memory_repair,
+            ...(value.currentView || PreparedRetainedSecondMemoryRepairs.isPrepared(registration)
+                ? { effectiveInputs: memoryRepairCurrentReferences(value.assigned.payload.memory_repair, workspace) } : {}) });
+        if (result.outcome !== "accepted")
+            refuse("accepted_settled_repair_required");
+        const { plan, privatePlan } = retainedMemoryRepairPublicationPlans(value.intent);
+        const derived = deriveRetainedMemoryRepairViews(before, exported, plan, result, privatePlan);
+        const output = hybridDigest({ input: value.expectedInput, start_receipt_sha256: hybridDigest(value.start), work_session_id: value.link.id,
+            result_sha256: hash(value.work.result), delta_sha256: derived.deltaSha256, transition_sha256: derived.transitionSha256,
+            ...(value.publicationSource ? { source_view_sha256: value.publicationSource.source_view_sha256,
+                source_receipt_sha256: hybridDigest(value.publicationSource), private_plan_sha256: privatePlan.sha256 } : {}) });
+        if (value.intent.delta_sha256 !== derived.deltaSha256 || value.intent.transition_sha256 !== derived.transitionSha256 || value.intent.output_sha256 !== output)
+            refuse("historical_output_identity_changed");
+        const logical = path.relative(value.root, value.link.result_path).split(path.sep).join("/");
+        const observed = ObservedMemorySources.capture({ run: value.root }, [{ root: "run", path: logical }]);
+        if (observed.hashes().get(memorySourceKey("run", logical)) !== hash(value.work.result))
+            refuse("historical_result_artifact_changed");
+        const prepared = new PreparedSettledMemoryRepair(token, registration, value, result, plan.state(0), plan.state(plan.actions().length), observed, workspace);
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    result() { return structuredClone(this.#result); }
+    before() { return this.#before; }
+    after() { return this.#after; }
+    workspaceManifest() { return this.#workspace; }
+    /** Consume only this independently settled transition. The returned
+     * metadata still needs graph/current-view admission and physical comparison
+     * before a dependent writer can launch; this method grants neither.
+     */
+    composeInto(context, current) {
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("historical_preparation_outside_writer_required");
+        this.revalidate(context);
+        const composed = current.composeSettledDelta(this.#before, this.#after);
+        this.assertCustody(context);
+        return composed;
+    }
+    reference() { return { ...this.#reference }; }
+    assertCustody(context) {
+        if (hybridDigest(snapshot(context, this.#registration, this.workId)) !== this.sha256)
+            refuse("historical_custody_changed");
+    }
+    revalidate(context) { this.assertCustody(context); this.#observed.revalidate(); }
+}