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

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

@@ -0,0 +1,415 @@
+import { memoryRepairCanonicalPaths } from "./memory-review-correction-plan.js";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { appendAudit } from "./audit.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { assertRunMutationAllowed } from "./run-recovery-guard.js";
+import { readWorkBatchCustody } from "./work-registry.js";
+import { PreparedRegisteredMemoryCorrections } from "./memory-repair-registration.js";
+import { MemoryRepairDocumentBaseline } from "./memory-repair-document-delta.js";
+import { reviewSourceHash, reviewSourcePaths } from "./review-copy.js";
+import { memoryRepairCurrentReferences, validateMemoryRepairWorkResult } from "./memory-repair-work-results.js";
+import { PreparedMemoryRepairCurrentView } from "./memory-repair-current-view.js";
+import { readMemoryRepairPhysicalBinding } from "./memory-repair-physical-binding.js";
+const event = "memory.repair_work_baseline";
+const preparationToken = Symbol("memory-repair-work-baseline-preparation");
+function refuse(reason) {
+    throw new AppError("memory_repair_work_baseline_invalid", "Writer baseline lacks registered repair Work and current source custody", 1, { reason, effect: "no_effect" });
+}
+function select(context, scope) {
+    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')=? LIMIT 2", [scope.project_id, event, scope.run_id, scope.work_id]);
+    if (!rows.length)
+        return null;
+    try {
+        if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 24 * 1024 * 1024)
+            refuse("ambiguous_or_unbounded_baseline");
+        const receipt = JSON.parse(rows[0].payload_json);
+        if (!["dd-flow/memory-repair-work-baseline@2", "dd-flow/memory-repair-work-baseline@3"].includes(receipt.schema_id) || receipt.export_policy !== "memory-repair-export@1"
+            || receipt.project_id !== scope.project_id
+            || receipt.run_id !== scope.run_id || receipt.work_id !== scope.work_id || receipt.generation !== scope.generation
+            || typeof receipt.baseline_base64 !== "string")
+            refuse("foreign_baseline_receipt");
+        if (receipt.schema_id === "dd-flow/memory-repair-work-baseline@3"
+            ? [receipt.current_view_sha256, receipt.current_view_receipt_sha256].some(value => typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value))
+            : Object.hasOwn(receipt, "current_view_sha256") || Object.hasOwn(receipt, "current_view_receipt_sha256"))
+            refuse("invalid_current_view_binding");
+        const bytes = Buffer.from(receipt.baseline_base64, "base64");
+        if (bytes.toString("base64") !== receipt.baseline_base64)
+            refuse("changed_baseline_bytes");
+        MemoryRepairDocumentBaseline.restore(bytes, receipt.baseline_sha256);
+        if (typeof receipt.exported_baseline_base64 !== "string")
+            refuse("exported_baseline_receipt_required");
+        const exportedBytes = Buffer.from(receipt.exported_baseline_base64, "base64");
+        if (exportedBytes.toString("base64") !== receipt.exported_baseline_base64)
+            refuse("changed_exported_baseline_bytes");
+        const exported = MemoryRepairDocumentBaseline.restore(exportedBytes, receipt.exported_baseline_sha256);
+        const source = MemoryRepairDocumentBaseline.restore(bytes, receipt.baseline_sha256);
+        if (source.exported(exported.entries().filter(entry => entry.kind === "file").map(entry => entry.path)).sha256 !== exported.sha256)
+            refuse("foreign_exported_baseline");
+        return receipt;
+    }
+    catch (error) {
+        if (error instanceof AppError && error.code === "memory_repair_work_baseline_invalid")
+            throw error;
+        return refuse("invalid_baseline_receipt");
+    }
+}
+/** Pre-launch original-document admission. Its independent receipt is not a
+ * WorkSession/start/copy or publication receipt. Dependent/previously repaired
+ * document views must come from registered physical repair settlements, never
+ * from current workspace bytes alone. Those views remain a separate owner.
+ */
+export class PreparedMemoryRepairWorkBaseline {
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #receipt in value;
+    }
+    workId;
+    sha256;
+    #registration;
+    #allocation;
+    #scope;
+    #receipt;
+    #baseline;
+    #launch;
+    #startedWorkSessionId;
+    #currentView;
+    constructor(token, registration, allocation, receipt, baseline, launch = null, startedWorkSessionId = null, currentView = null) {
+        if (token !== preparationToken)
+            refuse("prepared_baseline_token_required");
+        this.#registration = registration;
+        this.#allocation = structuredClone(allocation);
+        this.#scope = {
+            project_id: receipt.project_id, run_id: receipt.run_id, work_id: receipt.work_id, generation: receipt.generation
+        };
+        this.#receipt = structuredClone(receipt);
+        this.#baseline = baseline;
+        this.#launch = launch ? structuredClone(launch) : null;
+        this.#startedWorkSessionId = startedWorkSessionId;
+        this.#currentView = currentView;
+        this.workId = receipt.work_id;
+        this.sha256 = hybridDigest(receipt);
+        Object.freeze(this);
+    }
+    static prepare(context, registration, workId) {
+        if (!(registration instanceof PreparedRegisteredMemoryCorrections))
+            refuse("registered_corrections_required");
+        registration.revalidate(context);
+        const owner = registration.receipt(), assigned = registration.batch().works.find(item => owner.work_ids[item.key] === workId);
+        if (!assigned)
+            refuse("foreign_repair_work");
+        const scope = { project_id: owner.scope.project_id, run_id: owner.run_id, work_id: workId,
+            generation: assertRunMutationAllowed(context, owner.scope.project_id, owner.run_id) };
+        const allocation = readWorkBatchCustody(context, workId);
+        // Never rebase original evidence onto an unexplained shared-workspace edit.
+        // The next document-view owner will derive these inputs from settled deltas.
+        if (assigned.depends_on.length)
+            refuse("registered_dependency_document_view_required");
+        const view = registration.review().original().registration().view;
+        const workspace = registration.review().original().bundle().execution.snapshot().scope.workspace;
+        const sourceHash = () => reviewSourceHash(workspace, view.run_inputs.filter(ref => ref.root === "workspace").map(ref => ref.path), view.base);
+        if (sourceHash() !== view.source_sha256)
+            refuse("original_source_changed_before_writer");
+        const baseline = MemoryRepairDocumentBaseline.capture(workspace, assigned.payload.memory_repair.write_paths, memoryRepairCanonicalPaths(context, registration.review().original().bundle()));
+        const selected = reviewSourcePaths(workspace, view.run_inputs.filter(ref => ref.root === "workspace").map(ref => ref.path), view.base);
+        if (selected === null)
+            refuse("export_source_inventory_unavailable");
+        const available = new Set(baseline.entries().filter(entry => entry.kind === "file").map(entry => entry.path));
+        const exported = baseline.exported(selected.filter(logical => logical.startsWith(".memory-bank/") && available.has(logical)));
+        if (sourceHash() !== view.source_sha256)
+            refuse("original_source_changed_during_baseline");
+        baseline.revalidate(workspace);
+        const receipt = { schema_id: "dd-flow/memory-repair-work-baseline@2", ...scope,
+            registration_sha256: registration.sha256, allocation_sha256: hybridDigest(allocation),
+            packet_sha256: assigned.payload.memory_repair.packet_sha256, workspace_root: workspace,
+            baseline_sha256: baseline.sha256, baseline_base64: baseline.bytes().toString("base64"),
+            export_policy: "memory-repair-export@1", exported_baseline_sha256: exported.sha256,
+            exported_baseline_base64: exported.bytes().toString("base64") };
+        const prepared = new PreparedMemoryRepairWorkBaseline(preparationToken, registration, allocation, receipt, baseline);
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    /** Consume a separately registered current-view receipt. Neither a caller
+     * snapshot nor a current filesystem capture can substitute for this owner.
+     */
+    static prepareFromCurrentView(context, registration, workId, view) {
+        if (!(registration instanceof PreparedRegisteredMemoryCorrections))
+            refuse("registered_corrections_required");
+        if (!PreparedMemoryRepairCurrentView.isPrepared(view) || view.workId !== workId)
+            refuse("registered_current_view_required");
+        const retained = PreparedMemoryRepairCurrentView.restore(context, registration, workId);
+        if (retained.sha256 !== view.sha256)
+            refuse("current_view_registration_changed");
+        retained.revalidate(context);
+        const owner = registration.receipt(), assigned = registration.batch().works.find(item => owner.work_ids[item.key] === workId);
+        if (!assigned)
+            refuse("foreign_repair_work");
+        const generation = assertRunMutationAllowed(context, owner.scope.project_id, owner.run_id);
+        const allocation = readWorkBatchCustody(context, workId), baseline = retained.baseline(), exported = retained.exportedBaseline();
+        const receipt = { schema_id: "dd-flow/memory-repair-work-baseline@3", project_id: owner.scope.project_id,
+            run_id: owner.run_id, work_id: workId, generation, registration_sha256: registration.sha256,
+            allocation_sha256: hybridDigest(allocation), packet_sha256: assigned.payload.memory_repair.packet_sha256,
+            workspace_root: registration.review().original().bundle().execution.snapshot().scope.workspace,
+            baseline_sha256: baseline.sha256, baseline_base64: baseline.bytes().toString("base64"), export_policy: "memory-repair-export@1",
+            exported_baseline_sha256: exported.sha256, exported_baseline_base64: exported.bytes().toString("base64"),
+            current_view_sha256: retained.sha256, current_view_receipt_sha256: hybridDigest(retained.receipt()) };
+        const prepared = new PreparedMemoryRepairWorkBaseline(preparationToken, registration, allocation, receipt, baseline, null, null, retained);
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    receipt() { return structuredClone(this.#receipt); }
+    validateResult(context, bytes) {
+        this.assertRegisteredCustody(context);
+        const owner = this.#registration.receipt();
+        const assigned = this.#registration.batch().works.find(item => owner.work_ids[item.key] === this.workId);
+        if (!assigned || assigned.payload.memory_repair.packet_sha256 !== this.#receipt.packet_sha256)
+            refuse("repair_packet_changed");
+        return validateMemoryRepairWorkResult(bytes, this.#registration.review().original().bundle().engine(), { workId: this.workId, packet: assigned.payload.memory_repair,
+            ...(this.#currentView ? { effectiveInputs: memoryRepairCurrentReferences(assigned.payload.memory_repair, this.#currentView.workspaceManifest()) } : {}) });
+    }
+    currentInput() {
+        if (!this.#currentView)
+            return null;
+        const owner = this.#registration.receipt(), assigned = this.#registration.batch().works.find(item => owner.work_ids[item.key] === this.workId);
+        if (!assigned)
+            refuse("repair_packet_changed");
+        return { current_view_sha256: this.#currentView.sha256, current_view_receipt_sha256: hybridDigest(this.#currentView.receipt()),
+            effective_read_inputs: memoryRepairCurrentReferences(assigned.payload.memory_repair, this.#currentView.workspaceManifest()) };
+    }
+    /** Retain the registered original baseline after a physical launch exists;
+     * never capture today's documents as a replacement for its SQL receipt.
+     */
+    static restoreForLaunch(context, registration, workId) {
+        return this.#restoreRegistered(context, registration, workId, null);
+    }
+    /** Restore original registered bytes for an existing physical WorkSession.
+     * This grants neither another claim nor shared-workspace publication.
+     */
+    static restoreForStartedWork(context, registration, workId, workSessionId) {
+        if (typeof workSessionId !== "string" || !workSessionId || workSessionId.length > 256)
+            refuse("registered_start_session_required");
+        return this.#restoreRegistered(context, registration, workId, workSessionId);
+    }
+    /** SQL restoration for an already reserved publication, not new input
+     * observation. Partly published source must be classified by its intent.
+     */
+    static restoreForPublication(context, registration, workId, workSessionId) {
+        if (typeof workSessionId !== "string" || !workSessionId || workSessionId.length > 256)
+            refuse("registered_start_session_required");
+        return this.#restoreRegistered(context, registration, workId, workSessionId, true);
+    }
+    /** Restore only retained start custody for output observation. Shared input
+     * admission belongs to a separate publication source-view owner. */
+    static restoreForOutput(context, registration, workId, workSessionId) {
+        if (typeof workSessionId !== "string" || !workSessionId || workSessionId.length > 256)
+            refuse("registered_start_session_required");
+        return this.#restoreRegistered(context, registration, workId, workSessionId, false, true);
+    }
+    static #restoreRegistered(context, registration, workId, workSessionId, publicationOnly = false, outputOnly = false) {
+        if (!(registration instanceof PreparedRegisteredMemoryCorrections))
+            refuse("registered_corrections_required");
+        registration.assertCustody(context);
+        const owner = registration.receipt(), assigned = registration.batch().works.find(item => owner.work_ids[item.key] === workId);
+        if (!assigned)
+            refuse("foreign_repair_work");
+        const scope = { project_id: owner.scope.project_id, run_id: owner.run_id, work_id: workId,
+            generation: assertRunMutationAllowed(context, owner.scope.project_id, owner.run_id) };
+        const receipt = select(context, scope), allocation = readWorkBatchCustody(context, workId);
+        const route = registration.review().original().bundle().execution.work("review", assigned.payload.execution_override?.agent_profile_id);
+        const launch = readMemoryRepairPhysicalBinding(context, workId, route);
+        if (!receipt || receipt.registration_sha256 !== registration.sha256 || receipt.allocation_sha256 !== hybridDigest(allocation)
+            || receipt.packet_sha256 !== assigned.payload.memory_repair.packet_sha256
+            || receipt.workspace_root !== registration.review().original().bundle().execution.snapshot().scope.workspace)
+            refuse("registered_baseline_receipt_required");
+        if (assigned.depends_on.length && receipt.schema_id !== "dd-flow/memory-repair-work-baseline@3")
+            refuse("registered_dependency_document_view_required");
+        const currentView = receipt.schema_id === "dd-flow/memory-repair-work-baseline@3"
+            ? PreparedMemoryRepairCurrentView.restore(context, registration, workId) : null;
+        if (currentView && (currentView.sha256 !== receipt.current_view_sha256 || hybridDigest(currentView.receipt()) !== receipt.current_view_receipt_sha256
+            || currentView.baseline().sha256 !== receipt.baseline_sha256 || currentView.exportedBaseline().sha256 !== receipt.exported_baseline_sha256))
+            refuse("registered_current_view_changed");
+        if (!launch?.provider_session_id || !["launching", "start_requested"].includes(launch.status))
+            refuse("registered_physical_launch_required");
+        try {
+            if (Buffer.byteLength(launch.profile_json) > 1024 * 1024)
+                refuse("invalid_launch_profile");
+            const profile = JSON.parse(launch.profile_json);
+            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 !== createHash("sha256").update(JSON.stringify(frozen)).digest("hex"))
+                refuse("launch_profile_not_frozen");
+        }
+        catch (error) {
+            if (error instanceof AppError && error.code === "memory_repair_work_baseline_invalid")
+                throw error;
+            return refuse("invalid_launch_profile");
+        }
+        const baseline = MemoryRepairDocumentBaseline.restore(Buffer.from(receipt.baseline_base64, "base64"), receipt.baseline_sha256);
+        const prepared = new PreparedMemoryRepairWorkBaseline(preparationToken, registration, allocation, receipt, baseline, launch, workSessionId, currentView);
+        prepared.assertRegisteredCustody(context);
+        if (publicationOnly)
+            prepared.registeredPublicationIntent(context, workSessionId);
+        else if (outputOnly)
+            prepared.assertRegisteredStartCustody(context, workSessionId);
+        else
+            prepared.revalidate(context);
+        return prepared;
+    }
+    registeredPublicationIntent(context, workSessionId) {
+        this.assertRegisteredStartCustody(context, workSessionId);
+        const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='memory.repair_publication_intent' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? AND json_extract(payload_json,'$.generation')=? LIMIT 2", [this.#scope.project_id, this.#scope.run_id, this.workId, this.#scope.generation]);
+        const starts = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='memory.repair_work_start' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? AND json_extract(payload_json,'$.generation')=? LIMIT 2", [this.#scope.project_id, this.#scope.run_id, this.workId, this.#scope.generation]);
+        try {
+            if (rows.length !== 1 || starts.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 160 * 1024 * 1024
+                || Buffer.byteLength(starts[0].payload_json) > 1024 * 1024)
+                refuse("registered_publication_intent_required");
+            const value = JSON.parse(rows[0].payload_json);
+            const start = JSON.parse(starts[0].payload_json);
+            if (!["dd-flow/memory-repair-publication-intent@1", "dd-flow/memory-repair-publication-intent@2"].includes(value.schema_id) || value.project_id !== this.#scope.project_id
+                || value.run_id !== this.#scope.run_id || value.work_id !== this.workId || value.generation !== this.#scope.generation
+                || value.work_session_id !== workSessionId || start.work_session_id !== workSessionId
+                || value.start_receipt_sha256 !== hybridDigest(start) || value.source_root !== this.#receipt.workspace_root)
+                refuse("publication_baseline_or_start_changed");
+            if (value.schema_id === "dd-flow/memory-repair-publication-intent@1") {
+                if (value.before_sha256 !== this.#baseline.sha256 || value.before_base64 !== this.#baseline.bytes().toString("base64"))
+                    refuse("publication_baseline_or_start_changed");
+            }
+            else {
+                // This SQL binding is not source authority. The publication owner must
+                // independently restore the graph/histories and private/shared plans.
+                const sources = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='memory.repair_publication_source' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? AND json_extract(payload_json,'$.generation')=? LIMIT 2", [this.#scope.project_id, this.#scope.run_id, this.workId, this.#scope.generation]);
+                if (sources.length !== 1 || Buffer.byteLength(sources[0].payload_json) > 40 * 1024 * 1024)
+                    refuse("registered_publication_source_required");
+                const source = JSON.parse(sources[0].payload_json), { source_view_sha256: sourceSha256, ...body } = source;
+                const privatePlan = value.private_plan;
+                if (source.schema_id !== "dd-flow/memory-repair-publication-source@1" || source.project_id !== this.#scope.project_id
+                    || source.run_id !== this.#scope.run_id || source.work_id !== this.workId || source.generation !== this.#scope.generation
+                    || source.work_session_id !== workSessionId || source.registration_sha256 !== this.#registration.sha256
+                    || source.baseline_registration_sha256 !== this.sha256 || source.start_receipt_sha256 !== hybridDigest(start)
+                    || source.source_root !== this.#receipt.workspace_root || sourceSha256 !== hybridDigest(body)
+                    || value.source_view_sha256 !== sourceSha256 || value.source_receipt_sha256 !== hybridDigest(source)
+                    || value.before_sha256 !== source.before_sha256 || value.before_base64 !== source.before_base64
+                    || !privatePlan || privatePlan.before_sha256 !== this.#baseline.sha256
+                    || privatePlan.before_base64 !== this.#baseline.bytes().toString("base64")
+                    || value.private_plan_sha256 !== hybridDigest(privatePlan))
+                    refuse("publication_source_or_private_start_changed");
+            }
+            return structuredClone(value);
+        }
+        catch (error) {
+            if (error instanceof AppError && error.code === "memory_repair_work_baseline_invalid")
+                throw error;
+            return refuse("invalid_publication_intent");
+        }
+    }
+    launch() { return this.#launch ? structuredClone(this.#launch) : null; }
+    workerRoute() {
+        const receipt = this.#registration.receipt();
+        const assigned = this.#registration.batch().works.find(item => receipt.work_ids[item.key] === this.workId);
+        if (!assigned)
+            refuse("foreign_repair_work");
+        return this.#registration.review().original().bundle().execution.work("review", assigned.payload.execution_override?.agent_profile_id);
+    }
+    assertPrelaunchCustody(context) {
+        if (this.#launch)
+            refuse("use_registered_launch_baseline");
+        this.assertCustody(context);
+    }
+    /** SQL-only post-claim fence for the same prepared physical start. No new
+     * baseline can be registered from this phase or from mutable source bytes.
+     */
+    assertRegisteredStartCustody(context, workSessionId) {
+        if (!this.#launch?.provider_session_id)
+            refuse("registered_physical_launch_required");
+        this.#registration.assertCustody(context);
+        this.#assertCurrentView(context);
+        assertRunMutationAllowed(context, this.#scope.project_id, this.#scope.run_id, this.#scope.generation);
+        if (hybridDigest(readWorkBatchCustody(context, this.workId)) !== hybridDigest(this.#allocation))
+            refuse("repair_allocation_changed");
+        const launch = readMemoryRepairPhysicalBinding(context, this.workId, this.workerRoute(), this.#launch.operation_id);
+        const baseline = select(context, this.#scope);
+        if (!launch || hybridDigest(launch) !== hybridDigest(this.#launch) || !baseline || hybridDigest(baseline) !== this.sha256)
+            refuse("registered_start_custody_changed");
+        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,s.cwd FROM work_sessions ws JOIN works w ON w.work_id=ws.work_id JOIN runs r ON r.project_id=w.project_id AND r.id=w.run_id JOIN sessions s ON s.project_id=w.project_id AND s.session_id=ws.session_id WHERE w.project_id=? AND w.run_id=? AND w.work_id=? AND w.status='running' AND r.status='running' AND r.workspace_root=? AND ws.status='running' AND s.status='active' AND s.current_stage='work' AND s.worker_id=w.work_id AND s.run_id=w.run_id AND s.workspace_path=r.workspace_root AND s.project_root=r.project_root LIMIT 2", [this.#scope.project_id, this.#scope.run_id, this.workId, this.#receipt.workspace_root]);
+        if (rows.length !== 1 || rows[0].id !== workSessionId || rows[0].provider_session_id !== this.#launch.provider_session_id)
+            refuse("registered_start_session_required");
+        return { ...rows[0] };
+    }
+    baseline() { return MemoryRepairDocumentBaseline.restore(Buffer.from(this.#receipt.baseline_base64, "base64"), this.#receipt.baseline_sha256); }
+    exportedBaseline() { return MemoryRepairDocumentBaseline.restore(Buffer.from(this.#receipt.exported_baseline_base64, "base64"), this.#receipt.exported_baseline_sha256); }
+    copyInput() {
+        if (this.#currentView)
+            return this.#currentView.copyInput();
+        const view = this.#registration.review().original().registration().view;
+        return { source_sha256: view.source_sha256, base: view.base,
+            explicit_inputs: view.run_inputs.filter(ref => ref.root === "workspace").map(ref => ref.path) };
+    }
+    /** Preparation alone is not an independently committed baseline receipt. */
+    assertRegisteredCustody(context) {
+        this.assertCustody(context);
+        const receipt = select(context, this.#scope);
+        if (!receipt || hybridDigest(receipt) !== this.sha256)
+            refuse("registered_baseline_receipt_required");
+    }
+    assertCustody(context) {
+        if (this.#startedWorkSessionId) {
+            // The registered start owner also rechecks this baseline's current view.
+            this.assertRegisteredStartCustody(context, this.#startedWorkSessionId);
+            return;
+        }
+        this.#assertCurrentView(context);
+        this.#registration.assertCustody(context);
+        assertRunMutationAllowed(context, this.#scope.project_id, this.#scope.run_id, this.#scope.generation);
+        if (hybridDigest(readWorkBatchCustody(context, this.workId)) !== hybridDigest(this.#allocation))
+            refuse("repair_allocation_changed");
+        const work = context.db.get("SELECT * FROM works WHERE work_id=?", [this.workId]);
+        const run = context.db.get("SELECT workspace_root,status FROM runs WHERE project_id=? AND id=?", [this.#scope.project_id, this.#scope.run_id]);
+        if (!work || work.status !== "created" || !run || run.status !== "running" || run.workspace_root !== this.#receipt.workspace_root
+            || context.db.get("SELECT 1 FROM work_sessions WHERE work_id=? LIMIT 1", [this.workId]))
+            refuse("unstarted_repair_work_required");
+        const launch = this.#launch ? readMemoryRepairPhysicalBinding(context, this.workId, this.workerRoute(), this.#launch.operation_id) : context.db.get("SELECT 1 FROM sqlite_master WHERE type='table' AND name='work_launches'")
+            ? context.db.get("SELECT operation_id,status,profile_json,profile_hash,provider_session_id FROM work_launches WHERE work_id=?", [this.workId]) : undefined;
+        if (this.#launch ? !launch || hybridDigest(launch) !== hybridDigest(this.#launch) : Boolean(launch))
+            refuse("use_registered_launch_baseline");
+        const prior = select(context, this.#scope);
+        if (prior && hybridDigest(prior) !== this.sha256)
+            refuse("baseline_registration_changed");
+    }
+    revalidateSource(context) {
+        if (this.#currentView) {
+            this.#currentView.revalidate(context);
+            return;
+        }
+        this.#registration.revalidate(context);
+        this.#baseline.revalidate(this.#receipt.workspace_root);
+        const view = this.#registration.review().original().registration().view;
+        if (reviewSourceHash(this.#receipt.workspace_root, view.run_inputs.filter(ref => ref.root === "workspace").map(ref => ref.path), view.base)
+            !== view.source_sha256)
+            refuse("original_source_changed_before_writer");
+    }
+    revalidate(context) {
+        this.revalidateSource(context);
+        this.assertCustody(context);
+    }
+    register(context) {
+        this.assertPrelaunchCustody(context);
+        this.revalidate(context);
+        return context.db.writeTransaction(() => {
+            this.assertCustody(context);
+            const prior = select(context, this.#scope);
+            if (!prior)
+                appendAudit(context, { projectId: this.#scope.project_id, eventType: event, payload: this.#receipt });
+            if (hybridDigest(select(context, this.#scope)) !== this.sha256)
+                refuse("baseline_registration_readback_failed");
+            return { work_id: this.workId, baseline_sha256: this.#baseline.sha256, registration_sha256: this.sha256, replayed: Boolean(prior) };
+        });
+    }
+    #assertCurrentView(context) {
+        if (this.#receipt.schema_id !== "dd-flow/memory-repair-work-baseline@3")
+            return;
+        if (!this.#currentView || this.#currentView.sha256 !== this.#receipt.current_view_sha256
+            || hybridDigest(this.#currentView.receipt()) !== this.#receipt.current_view_receipt_sha256)
+            refuse("registered_current_view_required");
+        this.#currentView.assertCustody(context);
+    }
+}

package/dist/services/memory-repair-work-completion.js

@@ -0,0 +1,117 @@
+import { AppError } from "../shared/errors.js";
+import { PreparedPublishedMemoryRepairWorkResult } from "./memory-repair-work-custody.js";
+import { prepareMemoryRepairPrivateOutputFromStage, prepareMemoryRepairPublicationSourceFromStage, restoreMemoryRepairPublicationSourceFromStage, reserveMemoryRepairPublicationAgainstSourceFromStage, reserveMemorySecondRepairPublicationFromStage, restoreMemoryRepairPublicationFromStage, prepareMemorySecondRepairPublicationFromStage, restoreStartedMemorySecondRepairLaunchFromStage } from "./memory-review-handler.js";
+function refuse(reason) {
+    throw new AppError("memory_work_result_preparation_required", "Repair completion requires registered private output and physical start custody", 1, { reason, effect: "no_effect" });
+}
+/** Read-only preparation. Existing intents are restored, never reconstructed
+ * from today's partially published shared workspace. */
+export function prepareMemoryRepairWorkCompletion(context, work, result) {
+    if (context.db.isOwnedWriteTransaction?.())
+        refuse("preparation_outside_writer_required");
+    const bytes = Buffer.from(result);
+    if (!bytes.length || bytes.length > 1024 * 1024)
+        refuse("bounded_result_required");
+    const run = context.db.get("SELECT project_root FROM runs WHERE project_id=? AND id=?", [work.project_id, work.run_id]);
+    const links = context.db.all("SELECT id,start_receipt_json FROM work_sessions WHERE work_id=? AND status='running' LIMIT 2", [work.work_id]);
+    if (!run || links.length !== 1)
+        refuse("exact_active_work_session_required");
+    const link = links[0];
+    let wave, workspaceRoot;
+    try {
+        const payload = JSON.parse(work.payload_json ?? "null");
+        if (work.result_schema !== "dd-flow/memory-repair-work-result@1" || payload?.kind !== "memory-repair" || payload.read_only !== false)
+            refuse("registered_repair_required");
+        wave = payload.memory_repair?.wave;
+        if (!link.start_receipt_json || Buffer.byteLength(link.start_receipt_json) > 32 * 1024 * 1024)
+            refuse("bounded_start_required");
+        const receipt = JSON.parse(link.start_receipt_json);
+        if (typeof receipt.context !== "string" || Buffer.byteLength(receipt.context) > 16 * 1024 * 1024)
+            refuse("bounded_context_required");
+        workspaceRoot = JSON.parse(receipt.context).workspace_root;
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        refuse("invalid_start_scope");
+    }
+    if (wave !== 1 && wave !== 2 || typeof workspaceRoot !== "string" || !workspaceRoot)
+        refuse("exact_wave_workspace_required");
+    const scope = { projectRoot: run.project_root, runId: work.run_id, workId: work.work_id, workspaceRoot, workSessionId: link.id };
+    const restore = () => wave === 1 ? restoreMemoryRepairPublicationFromStage(context, scope) : prepareMemorySecondRepairPublicationFromStage(context, scope);
+    // Presence selects only restoration; the real owner admits generation,
+    // exact receipt multiplicity and physical scope. Corrupt intents never
+    // fall back to a fresh reservation.
+    const retained = context.db.get("SELECT 1 FROM audit_events WHERE project_id=? AND event_type='memory.repair_publication_intent' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? LIMIT 1", [work.project_id, work.run_id, work.work_id]);
+    if (retained) {
+        const publication = restore();
+        if (!publication.bytes().equals(bytes))
+            refuse("retained_result_changed");
+        return { scope, bytes, wave, publication, source: null };
+    }
+    const outcome = wave === 1 ? prepareMemoryRepairPrivateOutputFromStage(context, { ...scope, bytes }).result().outcome
+        : restoreStartedMemorySecondRepairLaunchFromStage(context, scope).observeOutput(context, bytes).result.outcome;
+    if (outcome !== "accepted" && outcome !== "reconciled")
+        refuse("accepted_private_output_required_use_managed_fail_for_blocker");
+    let source = null;
+    if (wave === 1) {
+        try {
+            source = restoreMemoryRepairPublicationSourceFromStage(context, scope);
+        }
+        catch (error) {
+            if (!(error instanceof AppError) || error.code !== "memory_repair_publication_source_invalid" || error.details.reason !== "registered_source_required")
+                throw error;
+            source = prepareMemoryRepairPublicationSourceFromStage(context, scope);
+        }
+    }
+    return { scope, bytes, wave, publication: null, source };
+}
+/** Called by managed Work finish after its normal Hook/actor admission.
+ * Sealed owners revalidate before effects; no caller-supplied object grants
+ * authority. Every action is terminal and advances the retained finite cursor. */
+export function publishMemoryRepairWorkCompletion(context, work, result, progress) {
+    progress?.(`Memory repair ${work.work_id}: preparing publication`);
+    const prepared = prepareMemoryRepairWorkCompletion(context, work, result);
+    const { scope, bytes, wave } = prepared;
+    progress?.(`Memory repair ${work.work_id}: publication input verified`);
+    try {
+        if (!prepared.publication) {
+            if (wave === 1) {
+                // Registration revalidates this invocation's source before and after
+                // its SQL effect; do not rebuild the entire same history graph again.
+                prepared.source.register(context);
+                progress?.(`Memory repair ${work.work_id}: publication source registered`);
+                reserveMemoryRepairPublicationAgainstSourceFromStage(context, { ...scope, bytes });
+            }
+            else
+                reserveMemorySecondRepairPublicationFromStage(context, { ...scope, bytes });
+            progress?.(`Memory repair ${work.work_id}: publication reserved`);
+        }
+        const publication = prepared.publication ?? (wave === 1 ? restoreMemoryRepairPublicationFromStage(context, scope) : prepareMemorySecondRepairPublicationFromStage(context, scope));
+        progress?.(`Memory repair ${work.work_id}: publication restored`);
+        const initial = publication.revalidate(context);
+        let completed = initial.completed;
+        progress?.(`Memory repair ${work.work_id}: publication ready (${completed}/${initial.total})`);
+        // The actual retained plan, not agent output or a guessed retry count,
+        // bounds execution. Even an already applied plan reconciles completion.
+        do {
+            const step = publication.applyNextAction(context);
+            if (step.total !== initial.total || step.completed < completed || step.completed > initial.total)
+                refuse("publication_cursor_changed");
+            if (step.status !== "applied" && step.completed !== completed + 1)
+                refuse("publication_did_not_advance");
+            progress?.(`Memory repair ${work.work_id}: publication advanced (${step.completed}/${step.total})`);
+            if (step.status === "applied")
+                break;
+            completed = step.completed;
+        } while (completed < initial.total);
+        const published = PreparedPublishedMemoryRepairWorkResult.prepare(context, publication);
+        progress?.(`Memory repair ${work.work_id}: published result verified`);
+        return published;
+    }
+    catch (error) {
+        throw new AppError("memory_repair_completion_pending", "Repair publication requires exact-request reconciliation before another completion attempt", 1, { effect: error instanceof AppError && error.details.effect === "unknown" ? "unknown" : "partial",
+            run_id: scope.runId, work_id: scope.workId, work_session_id: scope.workSessionId,
+            cause: error instanceof Error ? error.message : String(error), next_action: "Reconcile retained publication and lifecycle invocation; do not start another Session or replace result bytes." });
+    }
+}

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

@@ -0,0 +1,73 @@
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { appendAudit } from "./audit.js";
+import { PreparedRetainedMemoryRepairPublication } from "./memory-repair-publication.js";
+const token = Symbol("published-memory-repair-work-result");
+function refuse(reason) {
+    throw new AppError("memory_repair_work_custody_invalid", "Repair settlement requires independently completed publication and its active physical WorkSession", 1, { reason, effect: "no_effect" });
+}
+/** Publication proves file effects, not semantic review. This sealed owner
+ * bridges that proof to the existing atomic Work/WorkSession settlement writer.
+ * It cannot launch a provider, accept a review finding or close the Stage.
+ */
+export class PreparedPublishedMemoryRepairWorkResult {
+    workId;
+    sha256;
+    #publication;
+    #binding;
+    constructor(key, publication, binding) {
+        if (key !== token)
+            refuse("published_result_token_required");
+        this.#publication = publication;
+        this.#binding = structuredClone(binding);
+        this.workId = binding.work_id;
+        this.sha256 = binding.result_sha256;
+        Object.freeze(this);
+    }
+    static isPrepared(value) {
+        return value instanceof PreparedPublishedMemoryRepairWorkResult && #publication in value;
+    }
+    static prepare(context, publication) {
+        if (!PreparedRetainedMemoryRepairPublication.isPrepared(publication))
+            refuse("registered_publication_required");
+        publication.revalidateApplied(context);
+        const binding = publication.settlementBinding(context);
+        const prepared = new PreparedPublishedMemoryRepairWorkResult(token, publication, binding);
+        prepared.assertSettlementScope(context, binding.session_id, binding.work_session_id);
+        return prepared;
+    }
+    bytes() { return this.#publication.bytes(); }
+    revalidate(context) {
+        this.#publication.revalidateApplied(context);
+        this.assertSettlementScope(context, this.#binding.session_id, this.#binding.work_session_id);
+    }
+    /** SQL-only check. The publication owner checks original review/allocation,
+     * generation, active Session/provider/CWD, start and completion custody.
+     */
+    assertSettlementScope(context, sessionId, workSessionId) {
+        if (sessionId !== this.#binding.session_id || workSessionId !== this.#binding.work_session_id
+            || hybridDigest(this.#publication.settlementBinding(context)) !== hybridDigest(this.#binding))
+            refuse("repair_settlement_scope_changed");
+    }
+    recordSettlement(context, sessionId, workSessionId) {
+        if (context.db.isOwnedWriteTransaction?.() !== true)
+            refuse("owned_settlement_writer_required");
+        this.assertSettlementScope(context, sessionId, workSessionId);
+        const event = "memory.repair_work_settlement", receipt = { schema_id: "dd-flow/memory-repair-work-settlement@1", ...this.#binding };
+        const select = () => 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')=? AND json_extract(payload_json,'$.generation')=? LIMIT 2", [this.#binding.project_id, event, this.#binding.run_id, this.workId, this.#binding.generation]);
+        if (select().length)
+            refuse("repair_settlement_already_recorded");
+        appendAudit(context, { projectId: this.#binding.project_id, eventType: event, payload: receipt });
+        const rows = select();
+        try {
+            if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 16 * 1024
+                || hybridDigest(JSON.parse(rows[0].payload_json)) !== hybridDigest(receipt))
+                refuse("repair_settlement_readback_failed");
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            refuse("invalid_repair_settlement_readback");
+        }
+    }
+}