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

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

@@ -0,0 +1,794 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import fs from "node:fs";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedMemoryRepairWorkBaseline } from "./memory-repair-work-baseline.js";
+import { PreparedBoundMemoryRepairCopy } from "./memory-repair-writer-copy.js";
+import { appendAudit } from "./audit.js";
+import { stageRetainedMemoryRepairFile, verifyRetainedMemoryRepairFile } from "./memory-repair-publication-files.js";
+import { acquireInstallationLock } from "./installation-lock.js";
+import { PreparedMemoryRepairPublicationSource } from "./memory-repair-publication-source.js";
+import { retainedMemoryRepairPublicationPlans } from "./memory-repair-publication-intent.js";
+import { PreparedSecondMemoryRepairLaunch } from "./memory-second-repair-launch.js";
+const token = Symbol("registered-memory-repair-publication");
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function refuse(reason) {
+    throw new AppError("memory_repair_publication_invalid", "Publication intent lacks retained output and physical start custody", 1, { reason, effect: "no_effect" });
+}
+/** Pure expected-view derivation, not SQL or physical observation authority. */
+export function deriveRetainedMemoryRepairViews(start, exported, plan, result, privatePlan = plan) {
+    if (privatePlan.state(0).sha256 !== start.sha256)
+        refuse("foreign_retained_start_view");
+    if (start.exported(exported.entries().filter(entry => entry.kind === "file").map(entry => entry.path)).sha256 !== exported.sha256)
+        refuse("foreign_retained_export_view");
+    const actions = plan.actions();
+    const changes = (retained) => retained.actions().filter(action => action.after?.kind !== "directory").map(action => ({ path: action.path,
+        before_sha256: action.before?.sha256 ?? null, after_sha256: action.after?.sha256 ?? null }));
+    const ordered = (items) => [...items].sort((a, b) => a.path.localeCompare(b.path, "en"));
+    if (hybridDigest(ordered(changes(plan))) !== hybridDigest(ordered(result.changes))
+        || hybridDigest(ordered(changes(privatePlan))) !== hybridDigest(ordered(result.changes)))
+        refuse("reserved_delta_differs_from_result");
+    const after = privatePlan.state(privatePlan.actions().length);
+    const merged = plan.state(0).composeSettledDelta(start, after);
+    if (merged.sha256 !== plan.state(actions.length).sha256)
+        refuse("unexplained_retained_publication_view");
+    const available = new Set(after.entries().filter(entry => entry.kind === "file").map(entry => entry.path));
+    const selected = [...new Set([...exported.entries().filter(entry => entry.kind === "file" && available.has(entry.path)).map(entry => entry.path),
+            ...result.changes.filter(change => change.after_sha256 !== null).map(change => change.path)])];
+    const exportedAfter = after.exported(selected);
+    const deltaSha256 = hybridDigest({ baseline_sha256: exported.sha256,
+        snapshot_sha256: hybridDigest(exportedAfter.entries()), changes: ordered(result.changes) });
+    const transitionSha256 = hybridDigest({ before_sha256: plan.state(0).sha256, start_protected_sha256: start.sha256,
+        delta_sha256: deltaSha256, actions: actions.map(action => ({ path: action.path, before: action.before, after: action.after })) });
+    return { exportedAfter, deltaSha256, transitionSha256 };
+}
+/** SQL-selected intent restored independently from partially published source.
+ * This owner verifies retained output and exact physical prefixes. It does not
+ * apply files, settle Work or claim semantic review/closure.
+ */
+export class PreparedRetainedMemoryRepairPublication {
+    sha256;
+    #baseline;
+    #copy;
+    #second;
+    #secondBinding;
+    #workSessionId;
+    #bytes;
+    #result;
+    #plan;
+    #exportedAfter;
+    #source;
+    constructor(key, baseline, copy, workSessionId, receipt, bytes, result, plan, exportedAfter, source = null, second = null, secondBinding = null) {
+        if (key !== token)
+            refuse("publication_token_required");
+        this.#baseline = baseline;
+        this.#copy = copy;
+        this.#workSessionId = workSessionId;
+        this.#bytes = Buffer.from(bytes);
+        this.#result = structuredClone(result);
+        this.#plan = plan;
+        this.#exportedAfter = exportedAfter;
+        this.#source = source;
+        this.#second = second;
+        this.#secondBinding = secondBinding;
+        this.sha256 = hybridDigest(receipt);
+        Object.freeze(this);
+    }
+    static prepare(context, baseline, copy, workSessionId, source = null) {
+        if (!PreparedMemoryRepairWorkBaseline.isPrepared(baseline) || !PreparedBoundMemoryRepairCopy.isPrepared(copy))
+            refuse("registered_publication_binding_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("publication_preparation_outside_writer_required");
+        const receipt = baseline.registeredPublicationIntent(context, workSessionId);
+        copy.assertCommittedStartCustody(context, workSessionId);
+        try {
+            const { current, plan, privatePlan } = retainedMemoryRepairPublicationPlans(receipt);
+            if (current) {
+                if (!PreparedMemoryRepairPublicationSource.isPrepared(source) || !source.matches(baseline, copy, workSessionId))
+                    refuse("registered_publication_source_required");
+                source.assertRegisteredCustody(context);
+                if (source.sha256 !== receipt.source_view_sha256 || hybridDigest(source.receipt()) !== receipt.source_receipt_sha256
+                    || source.before().sha256 !== receipt.before_sha256 || source.before().bytes().toString("base64") !== receipt.before_base64)
+                    refuse("registered_publication_source_changed");
+            }
+            else if (source)
+                refuse("foreign_legacy_publication_source");
+            if (receipt.private_root !== copy.root()
+                || receipt.source_root !== copy.sourceRoot() || copy.input().baseline_registration_sha256 !== baseline.sha256
+                || receipt.start_receipt_sha256 !== hybridDigest(copy.startedReceipt())
+                || typeof receipt.result_base64 !== "string" || receipt.result_base64.length > Math.ceil(1024 * 1024 / 3) * 4)
+                refuse("publication_scope_or_bytes_changed");
+            const bytes = Buffer.from(receipt.result_base64, "base64");
+            if (bytes.length > 1024 * 1024 || bytes.toString("base64") !== receipt.result_base64 || hash(bytes) !== receipt.result_sha256)
+                refuse("retained_result_changed");
+            const result = baseline.validateResult(context, bytes);
+            if (result.outcome !== "accepted")
+                refuse("accepted_reserved_result_required");
+            const { exportedAfter, deltaSha256, transitionSha256 } = deriveRetainedMemoryRepairViews(baseline.baseline(), baseline.exportedBaseline(), plan, result, privatePlan);
+            const outputSha256 = hybridDigest({ input: copy.input(), start_receipt_sha256: hybridDigest(copy.startedReceipt()), work_session_id: workSessionId,
+                result_sha256: hash(bytes), delta_sha256: deltaSha256, transition_sha256: transitionSha256,
+                ...(current ? { source_view_sha256: source.sha256, source_receipt_sha256: hybridDigest(source.receipt()), private_plan_sha256: privatePlan.sha256 } : {}) });
+            if (receipt.delta_sha256 !== deltaSha256 || receipt.transition_sha256 !== transitionSha256 || receipt.output_sha256 !== outputSha256)
+                refuse("reserved_output_identity_changed");
+            const prepared = new PreparedRetainedMemoryRepairPublication(token, baseline, copy, workSessionId, receipt, bytes, result, plan, exportedAfter, source);
+            prepared.revalidate(context);
+            return prepared;
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            return refuse("invalid_retained_publication");
+        }
+    }
+    static prepareSecond(context, second) {
+        if (!PreparedSecondMemoryRepairLaunch.isPrepared(second))
+            refuse("registered_second_publication_owner_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("publication_preparation_outside_writer_required");
+        const binding = second.restorePublicationBinding(context), retained = binding.publication;
+        const prepared = new PreparedRetainedMemoryRepairPublication(token, null, null, binding.workSessionId, retained.receipt, retained.bytes, retained.result, retained.plan, retained.exportedAfter, null, second, binding);
+        prepared.revalidate(context);
+        return prepared;
+    }
+    #startedReceipt() {
+        if (this.#copy)
+            return this.#copy.startedReceipt();
+        if (!this.#secondBinding)
+            refuse("registered_publication_binding_required");
+        return structuredClone(this.#secondBinding.start);
+    }
+    #sourceRoot() {
+        if (this.#copy)
+            return this.#copy.sourceRoot();
+        if (!this.#secondBinding)
+            refuse("registered_publication_binding_required");
+        return this.#secondBinding.sourceRoot;
+    }
+    #privateRoot() {
+        if (this.#copy)
+            return this.#copy.root();
+        if (!this.#secondBinding)
+            refuse("registered_publication_binding_required");
+        return this.#secondBinding.privateRoot;
+    }
+    result() { return structuredClone(this.#result); }
+    static isPrepared(value) {
+        return value instanceof PreparedRetainedMemoryRepairPublication && #baseline in value;
+    }
+    bytes() { return Buffer.from(this.#bytes); }
+    plan() { return this.#plan; }
+    /** SQL-only current generation/physical start/independent intent fence. */
+    assertCustody(context) {
+        if (this.#second) {
+            this.#second.assertPublicationCustody(context, this.sha256);
+            return;
+        }
+        if (!this.#copy || !this.#baseline)
+            refuse("registered_publication_binding_required");
+        this.#copy.assertCommittedStartCustody(context, this.#workSessionId);
+        this.#source?.assertRegisteredCustody(context);
+        if (hybridDigest(this.#baseline.registeredPublicationIntent(context, this.#workSessionId)) !== this.sha256)
+            refuse("registered_intent_changed");
+    }
+    #actionReceipt(index) {
+        const action = this.#plan.actions()[index];
+        if (!action)
+            refuse("invalid_publication_action_index");
+        const start = this.#startedReceipt();
+        return { schema_id: "dd-flow/memory-repair-publication-action-intent@1", project_id: start.project_id,
+            run_id: start.run_id, work_id: this.#result.work_id, generation: start.generation,
+            work_session_id: this.#workSessionId, publication_intent_sha256: this.sha256, index,
+            source_root: this.#sourceRoot(), staging_directory: path.join(this.#sourceRoot(), ".dd-flow", "memory-repair-publications", this.sha256),
+            staging_slot: action.after ? `action-${index}.tmp` : null,
+            before_sha256: this.#plan.state(index).sha256, after_sha256: this.#plan.state(index + 1).sha256,
+            action_sha256: hybridDigest(action) };
+    }
+    #selectedAction(context, index) {
+        const expected = this.#actionReceipt(index);
+        const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='memory.repair_publication_action_intent' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? AND json_extract(payload_json,'$.generation')=? AND json_extract(payload_json,'$.index')=? LIMIT 2", [expected.project_id, expected.run_id, expected.work_id, expected.generation, index]);
+        if (!rows.length)
+            return null;
+        try {
+            if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 16 * 1024
+                || hybridDigest(JSON.parse(rows[0].payload_json)) !== hybridDigest(expected))
+                refuse("publication_action_intent_changed");
+            return expected;
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            return refuse("invalid_publication_action_intent");
+        }
+    }
+    /** Commit SQL admission before any staging or destination effect. This is
+     * not proof of applied bytes, directory ownership, completion or settlement.
+     */
+    reserveNextAction(context) {
+        const view = this.revalidate(context);
+        if (view.completed === view.total)
+            refuse("publication_has_no_pending_action");
+        const receipt = this.#actionReceipt(view.completed);
+        const reservation = context.db.writeTransaction(() => {
+            if (context.db.isOwnedWriteTransaction?.() !== true)
+                refuse("owned_publication_writer_required");
+            this.assertCustody(context);
+            for (let index = 0; index < view.completed; index++) {
+                if (!this.#selectedAction(context, index))
+                    refuse("unadmitted_publication_prefix");
+            }
+            const prior = this.#selectedAction(context, view.completed);
+            if (!prior)
+                appendAudit(context, { projectId: receipt.project_id,
+                    eventType: "memory.repair_publication_action_intent", payload: receipt });
+            if (!this.#selectedAction(context, view.completed))
+                refuse("publication_action_readback_failed");
+            return { ...receipt, status: "reserved", replayed: Boolean(prior) };
+        });
+        try {
+            const current = this.revalidate(context);
+            if (current.completed !== view.completed)
+                refuse("publication_cursor_changed");
+        }
+        catch (error) {
+            throw new AppError("memory_repair_publication_pending", "Action admission committed; preserve owned publication state for reconciliation", 1, { effect: "committed", publication_intent_sha256: this.sha256, index: view.completed,
+                cause: error instanceof Error ? error.message : String(error) });
+        }
+        return reservation;
+    }
+    /** Reserve directory creation separately from action admission. Existing
+     * roots without this build receipt cannot be adopted. This creates only
+     * CLI service directories, never MB files, and does not apply an action.
+     */
+    prepareStagingDirectory(context) {
+        const view = this.revalidate(context), start = this.#startedReceipt();
+        if (view.completed === view.total)
+            refuse("publication_has_no_pending_action");
+        const directory = path.join(this.#sourceRoot(), ".dd-flow", "memory-repair-publications", this.sha256);
+        const build = { schema_id: "dd-flow/memory-repair-publication-staging@1", project_id: start.project_id,
+            run_id: start.run_id, work_id: this.#result.work_id, generation: start.generation,
+            work_session_id: this.#workSessionId, publication_intent_sha256: this.sha256, directory, mode: 0o700 };
+        const select = (event, expected) => {
+            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')=? AND json_extract(payload_json,'$.generation')=? LIMIT 2", [build.project_id, event, build.run_id, build.work_id, build.generation]);
+            if (!rows.length)
+                return false;
+            try {
+                if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 16 * 1024)
+                    refuse("staging_receipt_changed");
+                const value = JSON.parse(rows[0].payload_json);
+                if (expected ? hybridDigest(value) !== hybridDigest(expected)
+                    : !Number.isSafeInteger(value.dev) || !Number.isSafeInteger(value.ino)
+                        || hybridDigest(value) !== hybridDigest({ ...build, dev: value.dev, ino: value.ino }))
+                    refuse("staging_receipt_changed");
+                return true;
+            }
+            catch (error) {
+                if (error instanceof AppError)
+                    throw error;
+                return refuse("invalid_staging_receipt");
+            }
+        };
+        const buildEvent = "memory.repair_publication_staging_build", readyEvent = "memory.repair_publication_staging_ready";
+        const checkAncestors = () => {
+            for (const relative of ["", ".dd-flow", ".dd-flow/memory-repair-publications", `.dd-flow/memory-repair-publications/${this.sha256}`]) {
+                const named = path.join(this.#sourceRoot(), relative), stat = fs.lstatSync(named, { throwIfNoEntry: false });
+                if (stat && (!stat.isDirectory() || fs.realpathSync(named) !== named))
+                    refuse("unsafe_staging_ancestor");
+            }
+        };
+        checkAncestors();
+        const wasReady = select(readyEvent);
+        if (wasReady && !fs.lstatSync(directory, { throwIfNoEntry: false }))
+            refuse("ready_staging_directory_missing");
+        if (!select(buildEvent, build) && fs.lstatSync(directory, { throwIfNoEntry: false }))
+            refuse("unowned_staging_directory");
+        context.db.writeTransaction(() => {
+            if (context.db.isOwnedWriteTransaction?.() !== true)
+                refuse("owned_publication_writer_required");
+            this.assertCustody(context);
+            for (let index = 0; index < view.completed; index++)
+                if (!this.#selectedAction(context, index))
+                    refuse("unadmitted_publication_prefix");
+            if (view.completed < view.total && !this.#selectedAction(context, view.completed))
+                refuse("reserved_publication_action_required");
+            if (!select(buildEvent, build))
+                appendAudit(context, { projectId: build.project_id, eventType: buildEvent, payload: build });
+            if (!select(buildEvent, build))
+                refuse("staging_build_readback_failed");
+        });
+        try {
+            this.revalidate(context);
+            checkAncestors();
+            for (const relative of [".dd-flow", ".dd-flow/memory-repair-publications", `.dd-flow/memory-repair-publications/${this.sha256}`]) {
+                const named = path.join(this.#sourceRoot(), relative);
+                if (!fs.lstatSync(named, { throwIfNoEntry: false })) {
+                    if (wasReady)
+                        refuse("ready_staging_directory_missing");
+                    fs.mkdirSync(named, { mode: 0o700 });
+                    fs.chmodSync(named, 0o700);
+                    checkAncestors();
+                    for (const durable of [named, path.dirname(named)]) {
+                        const descriptor = fs.openSync(durable, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+                        try {
+                            fs.fsyncSync(descriptor);
+                        }
+                        finally {
+                            fs.closeSync(descriptor);
+                        }
+                    }
+                }
+            }
+            checkAncestors();
+            const stat = fs.lstatSync(directory);
+            if ((stat.mode & 0o7777) !== 0o700 || stat.dev !== fs.lstatSync(this.#sourceRoot()).dev)
+                refuse("unsafe_staging_directory");
+            const ready = { ...build, dev: stat.dev, ino: stat.ino };
+            const replayed = select(readyEvent, ready);
+            if (!replayed && fs.readdirSync(directory).length)
+                refuse("unready_staging_directory_not_empty");
+            if (replayed) {
+                const actions = this.#plan.actions();
+                for (const slot of fs.readdirSync(directory)) {
+                    const match = /^action-([0-9]{1,6})\.tmp$/.exec(slot), index = match ? Number(match[1]) : -1;
+                    if (!match || slot !== `action-${index}.tmp` || !actions[index]?.after
+                        || !this.#selectedAction(context, index))
+                        refuse("unknown_staging_slot");
+                    const entry = fs.lstatSync(path.join(directory, slot));
+                    if (actions[index].after.kind === "file" ? !entry.isFile() || entry.nlink !== 1
+                        : !entry.isDirectory() || fs.readdirSync(path.join(directory, slot)).length !== 0)
+                        refuse("unsafe_staging_slot");
+                }
+            }
+            const fd = fs.openSync(directory, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+            try {
+                const current = fs.fstatSync(fd);
+                if (current.dev !== stat.dev || current.ino !== stat.ino || !current.isDirectory())
+                    refuse("staging_directory_identity_changed");
+                fs.fsyncSync(fd);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            const parent = fs.openSync(path.dirname(directory), fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+            try {
+                fs.fsyncSync(parent);
+            }
+            finally {
+                fs.closeSync(parent);
+            }
+            this.revalidate(context);
+            checkAncestors();
+            const retained = fs.lstatSync(directory);
+            if (retained.dev !== stat.dev || retained.ino !== stat.ino || (retained.mode & 0o7777) !== 0o700)
+                refuse("staging_directory_identity_changed");
+            return context.db.writeTransaction(() => {
+                if (context.db.isOwnedWriteTransaction?.() !== true)
+                    refuse("owned_publication_writer_required");
+                this.assertCustody(context);
+                if (!select(buildEvent, build))
+                    refuse("staging_build_custody_lost");
+                for (let index = 0; index <= view.completed; index++)
+                    if (!this.#selectedAction(context, index))
+                        refuse("publication_action_custody_lost");
+                if (!select(readyEvent, ready))
+                    appendAudit(context, { projectId: build.project_id, eventType: readyEvent, payload: ready });
+                if (!select(readyEvent, ready))
+                    refuse("staging_ready_readback_failed");
+                return { directory, publication_intent_sha256: this.sha256, staging_ready_sha256: hybridDigest(ready), status: "ready", replayed };
+            });
+        }
+        catch (error) {
+            throw new AppError("memory_repair_publication_pending", "Staging build committed; preserve its directory for reconciliation", 1, { effect: "publication_pending", publication_intent_sha256: this.sha256, directory,
+                cause: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    /** Prepare exact retained file bytes behind action and directory admission.
+     * The destination is unchanged; a separate apply owner must consume this
+     * independent readiness receipt before atomic replacement.
+     */
+    stageNextFile(context) {
+        const view = this.revalidate(context), action = this.#plan.actions()[view.completed];
+        if (action?.after?.kind !== "file")
+            refuse("pending_file_action_required");
+        const reservation = this.reserveNextAction(context);
+        const staging = this.prepareStagingDirectory(context);
+        try {
+            if (this.revalidate(context).completed !== view.completed)
+                refuse("publication_cursor_changed");
+            const receipt = { ...this.#actionReceipt(view.completed), schema_id: "dd-flow/memory-repair-publication-file-ready@1",
+                output_sha256: action.after.sha256, mode: action.after.mode };
+            const ready = this.#actionJournal(context, "memory.repair_publication_file_ready", receipt);
+            const file = path.join(staging.directory, `action-${view.completed}.tmp`), bytes = this.#plan.output(action.path);
+            let output;
+            if (ready) {
+                verifyRetainedMemoryRepairFile(file, bytes, action.after.mode);
+                output = { path: file, sha256: action.after.sha256, status: "ready", replayed: true, bytes_appended: 0 };
+            }
+            else
+                output = stageRetainedMemoryRepairFile(staging.directory, `action-${view.completed}.tmp`, bytes, action.after.mode);
+            const verifiedStaging = this.prepareStagingDirectory(context);
+            if (verifiedStaging.staging_ready_sha256 !== staging.staging_ready_sha256)
+                refuse("staging_directory_identity_changed");
+            if (output.sha256 !== action.after.sha256 || this.revalidate(context).completed !== view.completed)
+                refuse("staged_output_changed");
+            return context.db.writeTransaction(() => {
+                if (context.db.isOwnedWriteTransaction?.() !== true)
+                    refuse("owned_publication_writer_required");
+                this.assertCustody(context);
+                if (!this.#selectedAction(context, view.completed))
+                    refuse("publication_action_custody_lost");
+                const directories = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='memory.repair_publication_staging_ready' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? AND json_extract(payload_json,'$.generation')=? LIMIT 2", [receipt.project_id, receipt.run_id, receipt.work_id, receipt.generation]);
+                try {
+                    if (directories.length !== 1 || Buffer.byteLength(directories[0].payload_json) > 16 * 1024
+                        || hybridDigest(JSON.parse(directories[0].payload_json)) !== staging.staging_ready_sha256)
+                        refuse("staging_directory_custody_lost");
+                }
+                catch (error) {
+                    if (error instanceof AppError)
+                        throw error;
+                    refuse("invalid_staging_directory_custody");
+                }
+                const select = () => this.#actionJournal(context, "memory.repair_publication_file_ready", receipt);
+                const replayed = select();
+                if (!replayed)
+                    appendAudit(context, { projectId: receipt.project_id, eventType: "memory.repair_publication_file_ready", payload: receipt });
+                if (!select())
+                    refuse("staged_file_readback_failed");
+                return { ...output, index: view.completed, publication_intent_sha256: this.sha256,
+                    action_intent_replayed: reservation.replayed, readiness_replayed: replayed };
+            });
+        }
+        catch (error) {
+            throw new AppError("memory_repair_publication_pending", "Reserved staging file remains pending; destination has not been applied by this operation", 1, { effect: "publication_pending", publication_intent_sha256: this.sha256, index: view.completed,
+                cause: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    #actionJournal(context, event, receipt) {
+        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')=? AND json_extract(payload_json,'$.generation')=? AND json_extract(payload_json,'$.index')=? LIMIT 2", [receipt.project_id, event, receipt.run_id, receipt.work_id, receipt.generation, receipt.index]);
+        if (!rows.length)
+            return false;
+        try {
+            if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 16 * 1024
+                || hybridDigest(JSON.parse(rows[0].payload_json)) !== hybridDigest(receipt))
+                refuse("publication_action_journal_changed");
+            return true;
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            return refuse("invalid_publication_action_journal");
+        }
+    }
+    #assertActionReady(context, index) {
+        if (!this.#selectedAction(context, index))
+            refuse("publication_action_custody_lost");
+        const action = this.#plan.actions()[index];
+        if (action.after) {
+            this.#registeredStagingReady(context);
+            const file = action.after.kind === "file";
+            const receipt = { ...this.#actionReceipt(index), 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 (!this.#actionJournal(context, file ? "memory.repair_publication_file_ready" : "memory.repair_publication_directory_ready", receipt))
+                refuse("publication_action_readiness_required");
+        }
+    }
+    #registeredStagingReady(context) {
+        const start = this.#startedReceipt();
+        const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='memory.repair_publication_staging_ready' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? AND json_extract(payload_json,'$.generation')=? LIMIT 2", [start.project_id, start.run_id, this.#result.work_id, start.generation]);
+        try {
+            if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 16 * 1024)
+                refuse("staging_directory_custody_lost");
+            const value = JSON.parse(rows[0].payload_json);
+            const expected = { schema_id: "dd-flow/memory-repair-publication-staging@1", project_id: start.project_id,
+                run_id: start.run_id, work_id: this.#result.work_id, generation: start.generation,
+                work_session_id: this.#workSessionId, publication_intent_sha256: this.sha256,
+                directory: path.join(this.#sourceRoot(), ".dd-flow", "memory-repair-publications", this.sha256), mode: 0o700,
+                dev: value.dev, ino: value.ino };
+            if (!Number.isSafeInteger(value.dev) || !Number.isSafeInteger(value.ino) || hybridDigest(value) !== hybridDigest(expected))
+                refuse("staging_directory_custody_changed");
+            return expected;
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            return refuse("invalid_staging_directory_custody");
+        }
+    }
+    #completeAction(context, index) {
+        const receipt = { ...this.#actionReceipt(index), schema_id: "dd-flow/memory-repair-publication-action-complete@1" };
+        const event = "memory.repair_publication_action_complete";
+        return context.db.writeTransaction(() => {
+            if (context.db.isOwnedWriteTransaction?.() !== true)
+                refuse("owned_publication_writer_required");
+            this.assertCustody(context);
+            this.#assertActionReady(context, index);
+            const replayed = this.#actionJournal(context, event, receipt);
+            if (!replayed)
+                appendAudit(context, { projectId: receipt.project_id, eventType: event, payload: receipt });
+            if (!this.#actionJournal(context, event, receipt))
+                refuse("publication_completion_readback_failed");
+            return replayed;
+        });
+    }
+    #completionReceipt() {
+        const start = this.#startedReceipt();
+        const total = this.#plan.actions().length;
+        return { schema_id: "dd-flow/memory-repair-publication-complete@1", project_id: start.project_id,
+            run_id: start.run_id, work_id: this.#result.work_id, generation: start.generation, work_session_id: this.#workSessionId,
+            publication_intent_sha256: this.sha256, result_sha256: hash(this.#bytes), action_count: total,
+            before_sha256: this.#plan.state(0).sha256, after_sha256: this.#plan.state(total).sha256 };
+    }
+    #selectedCompletion(context) {
+        const receipt = this.#completionReceipt();
+        const expected = hybridDigest(receipt), event = "memory.repair_publication_complete";
+        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')=? AND json_extract(payload_json,'$.generation')=? LIMIT 2", [receipt.project_id, event, receipt.run_id, receipt.work_id, receipt.generation]);
+        if (!rows.length)
+            return false;
+        try {
+            if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 16 * 1024
+                || hybridDigest(JSON.parse(rows[0].payload_json)) !== expected)
+                refuse("publication_completion_changed");
+            return true;
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            return refuse("invalid_publication_completion");
+        }
+    }
+    /** SQL-only completion proof for the active physical start. This is not
+     * current filesystem observation or independent semantic review acceptance.
+     */
+    assertAppliedCustody(context) {
+        this.assertCustody(context);
+        if (!this.#selectedCompletion(context))
+            refuse("registered_publication_completion_required");
+        const receipt = this.#completionReceipt();
+        for (let index = 0; index < receipt.action_count; index++) {
+            this.#assertActionReady(context, index);
+            const completed = { ...this.#actionReceipt(index), schema_id: "dd-flow/memory-repair-publication-action-complete@1" };
+            if (!this.#actionJournal(context, "memory.repair_publication_action_complete", completed))
+                refuse("action_completion_required");
+        }
+        return receipt;
+    }
+    revalidateApplied(context) {
+        const view = this.revalidate(context);
+        if (view.completed !== view.total)
+            refuse("complete_publication_view_required");
+        return hybridDigest(this.assertAppliedCustody(context));
+    }
+    settlementBinding(context) {
+        const completion = this.assertAppliedCustody(context), start = this.#startedReceipt();
+        if (typeof start.session_id !== "string" || typeof start.harness !== "string" || typeof start.provider_session_id !== "string")
+            refuse("physical_settlement_identity_required");
+        if (!context.db.get("SELECT 1 FROM works w JOIN works p ON p.work_id=w.parent_work_id AND p.project_id=w.project_id AND p.run_id=w.run_id JOIN runs r ON r.project_id=w.project_id AND r.id=w.run_id WHERE w.work_id=? AND w.project_id=? AND w.run_id=? AND w.status='running' AND p.status='running' AND json_extract(r.index_json,'$.current_stage')='review'", [this.#result.work_id, completion.project_id, completion.run_id]))
+            refuse("active_review_settlement_scope_required");
+        return { project_id: completion.project_id, run_id: completion.run_id, generation: completion.generation,
+            work_id: this.#result.work_id, work_session_id: this.#workSessionId, session_id: start.session_id,
+            harness: start.harness, provider_session_id: start.provider_session_id, private_root: this.#privateRoot(), source_root: this.#sourceRoot(),
+            start_receipt_sha256: hybridDigest(start), publication_intent_sha256: this.sha256,
+            publication_complete_sha256: hybridDigest(completion), result_sha256: completion.result_sha256,
+            before_sha256: completion.before_sha256, after_sha256: completion.after_sha256 };
+    }
+    #completePublication(context) {
+        const view = this.revalidate(context);
+        if (view.completed !== view.total)
+            refuse("complete_publication_view_required");
+        const receipt = this.#completionReceipt(), expected = hybridDigest(receipt), event = "memory.repair_publication_complete";
+        context.db.writeTransaction(() => {
+            if (context.db.isOwnedWriteTransaction?.() !== true)
+                refuse("owned_publication_writer_required");
+            this.assertCustody(context);
+            for (let index = 0; index < view.total; index++) {
+                this.#assertActionReady(context, index);
+                const completed = { ...this.#actionReceipt(index), schema_id: "dd-flow/memory-repair-publication-action-complete@1" };
+                if (!this.#actionJournal(context, "memory.repair_publication_action_complete", completed))
+                    refuse("action_completion_required");
+            }
+            if (!this.#selectedCompletion(context))
+                appendAudit(context, { projectId: receipt.project_id, eventType: event, payload: receipt });
+            if (!this.#selectedCompletion(context))
+                refuse("publication_completion_readback_failed");
+        });
+        if (this.revalidate(context).completed !== view.total)
+            refuse("completed_publication_view_changed");
+        return expected;
+    }
+    /** Apply one ordered action under the same workspace lock used by initial
+     * layer publication. Exact already-applied prefixes reconcile lost completion
+     * receipts only with independently retained admission/readiness. This never
+     * settles Work or treats worker acceptance as independent semantic review.
+     */
+    applyNextAction(context) {
+        const initial = this.revalidate(context);
+        for (let index = 0; index < initial.completed; index++)
+            this.#assertActionReady(context, index);
+        try {
+            if (initial.completed < initial.total) {
+                const action = this.#plan.actions()[initial.completed];
+                if (action.after?.kind === "file")
+                    this.stageNextFile(context);
+                else {
+                    this.reserveNextAction(context);
+                    if (action.after?.kind === "directory") {
+                        const staging = this.prepareStagingDirectory(context), slot = path.join(staging.directory, `action-${initial.completed}.tmp`);
+                        const receipt = { ...this.#actionReceipt(initial.completed), schema_id: "dd-flow/memory-repair-publication-directory-ready@1", mode: action.after.mode };
+                        const ready = this.#actionJournal(context, "memory.repair_publication_directory_ready", receipt);
+                        const prior = fs.lstatSync(slot, { throwIfNoEntry: false });
+                        if (ready && (!prior || !prior.isDirectory() || (prior.mode & 0o7777) !== action.after.mode))
+                            refuse("ready_directory_slot_changed");
+                        if (!prior)
+                            fs.mkdirSync(slot, { mode: 0o700 });
+                        else if (!prior.isDirectory() || fs.readdirSync(slot).length || ![0o700, action.after.mode].includes(prior.mode & 0o7777))
+                            refuse("unsafe_staging_directory_slot");
+                        const fd = fs.openSync(slot, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+                        try {
+                            const opened = fs.fstatSync(fd);
+                            if (!opened.isDirectory() || prior && (opened.dev !== prior.dev || opened.ino !== prior.ino))
+                                refuse("directory_slot_identity_changed");
+                            if (!ready)
+                                fs.fchmodSync(fd, action.after.mode);
+                            fs.fsyncSync(fd);
+                            const named = fs.lstatSync(slot), current = fs.fstatSync(fd);
+                            if (!named.isDirectory() || named.dev !== opened.dev || named.ino !== opened.ino
+                                || current.dev !== opened.dev || current.ino !== opened.ino || (current.mode & 0o7777) !== action.after.mode)
+                                refuse("directory_slot_identity_changed");
+                        }
+                        finally {
+                            fs.closeSync(fd);
+                        }
+                        const verified = this.prepareStagingDirectory(context);
+                        if (verified.staging_ready_sha256 !== staging.staging_ready_sha256)
+                            refuse("staging_directory_identity_changed");
+                        context.db.writeTransaction(() => {
+                            if (context.db.isOwnedWriteTransaction?.() !== true)
+                                refuse("owned_publication_writer_required");
+                            this.assertCustody(context);
+                            if (!this.#selectedAction(context, initial.completed))
+                                refuse("publication_action_custody_lost");
+                            if (hybridDigest(this.#registeredStagingReady(context)) !== staging.staging_ready_sha256)
+                                refuse("staging_directory_custody_changed");
+                            if (!this.#actionJournal(context, "memory.repair_publication_directory_ready", receipt))
+                                appendAudit(context, { projectId: receipt.project_id, eventType: "memory.repair_publication_directory_ready", payload: receipt });
+                            if (!this.#actionJournal(context, "memory.repair_publication_directory_ready", receipt))
+                                refuse("directory_readiness_readback_failed");
+                        });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            throw new AppError("memory_repair_publication_pending", "Publication staging requires reconciliation before shared application", 1, { effect: "publication_pending", publication_intent_sha256: this.sha256, cause: error instanceof Error ? error.message : String(error) });
+        }
+        const namespace = path.join(context.ddFlowHome, "memory-layer-publications");
+        if (fs.realpathSync(context.ddFlowHome) !== path.resolve(context.ddFlowHome))
+            refuse("noncanonical_publication_home");
+        if (!fs.lstatSync(namespace, { throwIfNoEntry: false })) {
+            fs.mkdirSync(namespace, { mode: 0o700 });
+            fs.chmodSync(namespace, 0o700);
+        }
+        if (!fs.lstatSync(namespace).isDirectory() || fs.realpathSync(namespace) !== namespace)
+            refuse("unsafe_publication_lock_namespace");
+        const lock = acquireInstallationLock(path.join(namespace, `${hybridDigest(this.#sourceRoot())}.lock`), this.sha256);
+        let released = false;
+        const release = () => { lock.release(); released = true; };
+        try {
+            lock.assertOwnership();
+            const view = this.revalidate(context);
+            for (let index = 0; index < view.completed; index++) {
+                const action = this.#plan.actions()[index];
+                const directories = [path.dirname(path.join(this.#sourceRoot(), action.path))];
+                if (action.after) {
+                    const retained = this.#registeredStagingReady(context), actual = fs.lstatSync(retained.directory);
+                    if (!actual.isDirectory() || actual.dev !== retained.dev || actual.ino !== retained.ino
+                        || (actual.mode & 0o7777) !== 0o700 || fs.realpathSync(retained.directory) !== retained.directory)
+                        refuse("ready_staging_directory_changed");
+                    directories.push(retained.directory);
+                }
+                for (const directory of directories) {
+                    const fd = fs.openSync(directory, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+                    try {
+                        fs.fsyncSync(fd);
+                    }
+                    finally {
+                        fs.closeSync(fd);
+                    }
+                }
+                lock.assertOwnership();
+                this.#completeAction(context, index);
+            }
+            if (view.completed === view.total) {
+                const publication_complete_sha256 = this.#completePublication(context);
+                release();
+                return { completed: view.completed, total: view.total, status: "applied", replayed: true, publication_complete_sha256 };
+            }
+            if (view.completed !== initial.completed)
+                refuse("publication_cursor_changed");
+            this.#assertActionReady(context, view.completed);
+            const action = this.#plan.actions()[view.completed], destination = path.join(this.#sourceRoot(), action.path);
+            const staged = path.join(this.#sourceRoot(), ".dd-flow", "memory-repair-publications", this.sha256, `action-${view.completed}.tmp`);
+            if (action.after) {
+                const retained = this.#registeredStagingReady(context), directory = path.dirname(staged), actual = fs.lstatSync(directory);
+                if (!actual.isDirectory() || (actual.mode & 0o7777) !== 0o700 || actual.dev !== retained.dev || actual.ino !== retained.ino
+                    || fs.realpathSync(directory) !== directory)
+                    refuse("ready_staging_directory_changed");
+            }
+            if (action.after?.kind === "file")
+                verifyRetainedMemoryRepairFile(staged, this.#plan.output(action.path), action.after.mode);
+            else if (action.after) {
+                const stat = fs.lstatSync(staged);
+                if (!stat.isDirectory() || (stat.mode & 0o7777) !== action.after.mode || fs.readdirSync(staged).length)
+                    refuse("ready_directory_slot_changed");
+            }
+            // Revalidate the entire protected inventory immediately before the effect,
+            // not merely the selected target. Cooperative publications share this lock.
+            if (this.revalidate(context).completed !== view.completed)
+                refuse("publication_cursor_changed");
+            lock.assertOwnership();
+            if (action.after)
+                fs.renameSync(staged, destination);
+            else
+                fs.unlinkSync(destination);
+            const parent = fs.openSync(path.dirname(destination), fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+            try {
+                fs.fsyncSync(parent);
+            }
+            finally {
+                fs.closeSync(parent);
+            }
+            if (action.after) {
+                const stagingParent = fs.openSync(path.dirname(staged), fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+                try {
+                    fs.fsyncSync(stagingParent);
+                }
+                finally {
+                    fs.closeSync(stagingParent);
+                }
+            }
+            const current = this.revalidate(context);
+            if (current.completed !== view.completed + 1)
+                refuse("publication_effect_not_exact");
+            lock.assertOwnership();
+            this.#completeAction(context, view.completed);
+            const completion = current.completed === current.total ? this.#completePublication(context) : null;
+            release();
+            return { ...current, status: current.completed === current.total ? "applied" : "partial", replayed: false,
+                ...(completion ? { publication_complete_sha256: completion } : {}) };
+        }
+        catch (error) {
+            let releaseFailure;
+            if (!released)
+                try {
+                    release();
+                }
+                catch (releaseError) {
+                    releaseFailure = releaseError instanceof Error ? releaseError.message : String(releaseError);
+                }
+            throw new AppError("memory_repair_publication_pending", "Reserved publication must reconcile its exact admitted prefix before settlement", 1, { effect: "publication_pending", publication_intent_sha256: this.sha256, cause: error instanceof Error ? error.message : String(error),
+                ...(releaseFailure ? { release_failure: releaseFailure } : {}) });
+        }
+    }
+    revalidate(context) {
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("publication_verification_outside_writer_required");
+        this.assertCustody(context);
+        if (this.#second) {
+            const view = this.#second.verifyPublicationPrefix(context);
+            if (view.publication_intent_sha256 !== this.sha256 || view.work_session_id !== this.#workSessionId
+                || view.work_id !== this.#result.work_id || view.total !== this.#plan.actions().length)
+                refuse("registered_second_publication_changed");
+            return { completed: view.completed, total: view.total };
+        }
+        if (!this.#baseline || !this.#copy)
+            refuse("registered_publication_binding_required");
+        this.#baseline.validateResult(context, this.#bytes);
+        this.#copy.verifyPublicationPrivateView(context, this.#workSessionId, this.#exportedAfter);
+        const view = this.#plan.classify(this.#sourceRoot());
+        this.#copy.verifyPublicationSourceInputs(context, this.#workSessionId, this.#plan.state(view.completed));
+        const current = this.#plan.classify(this.#sourceRoot());
+        if (current.completed !== view.completed)
+            refuse("publication_cursor_changed");
+        return current;
+    }
+}