@deksden-com/dd-flow-cli 0.9.0-beta.15 → 0.9.0-beta.150

package/dist/services/memory-second-repair-launch.js

@@ -0,0 +1,614 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { RetainedExecutionBundle } from "./execution-bundles.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedRetainedSecondMemoryRepairs } from "./memory-retained-second-repairs.js";
+import { PreparedRetainedSecondMemoryBaseline } from "./memory-retained-second-baseline.js";
+import { PreparedMemoryRepairWorkspace } from "./memory-repair-workspace.js";
+import { PreparedDescriptorStageCoordinator } from "./descriptor-stage-coordinator.js";
+import { readDescriptorCoordinatorSession } from "./descriptor-coordinator-session.js";
+import { reviewSourceHash } from "./review-copy.js";
+import { runtimeHarness } from "./execution-policy.js";
+import { appendAudit } from "./audit.js";
+import { isCompletedMemoryRepairClaim, memoryRepairCurrentReferences, validateMemoryRepairWorkResult } from "./memory-repair-work-results.js";
+import { RetainedMemoryRepairPublicationPlan } from "./memory-repair-publication-plan.js";
+import { retainedMemoryRepairPublicationPlans } from "./memory-repair-publication-intent.js";
+import { deriveRetainedMemoryRepairViews } from "./memory-repair-publication.js";
+import { readMemoryRepairPhysicalBinding, recordMemoryRepairNativeBinding, memoryRepairExecutionIdentity } from "./memory-repair-physical-binding.js";
+function publicationAction(scope, plan, publicationSha256, workSessionId, index) {
+    const action = plan.actions()[index];
+    if (!action)
+        refuse("invalid_publication_action_index");
+    return { schema_id: "dd-flow/memory-repair-publication-action-intent@1", project_id: scope.project_id, run_id: scope.run_id,
+        work_id: scope.work_id, generation: scope.generation, work_session_id: workSessionId, publication_intent_sha256: publicationSha256,
+        index, source_root: scope.workspace_root, staging_directory: path.join(scope.workspace_root, ".dd-flow", "memory-repair-publications", publicationSha256),
+        staging_slot: action.after ? `action-${index}.tmp` : null, before_sha256: plan.state(index).sha256,
+        after_sha256: plan.state(index + 1).sha256, action_sha256: hybridDigest(action) };
+}
+const token = Symbol("second-memory-repair-launch");
+function refuse(reason) {
+    throw new AppError("memory_second_repair_launch_invalid", "Second repair launch lacks frozen profile, baseline and owned copy custody", 2, { reason, effect: "no_effect" });
+}
+function launchRow(context, workId, route, operationId) {
+    const row = readMemoryRepairPhysicalBinding(context, workId, route, operationId);
+    if (!row || !row.provider_session_id || !["launching", "start_requested"].includes(row.status)
+        || typeof row.profile_json !== "string" || Buffer.byteLength(row.profile_json) > 1024 * 1024)
+        refuse("registered_physical_launch_required");
+    return row;
+}
+function journal(context, scope, event) {
+    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", [scope.project_id, event, scope.run_id, scope.work_id, scope.generation]);
+    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 12 * 1024 * 1024)
+        refuse("registered_copy_journal_required");
+    try {
+        return JSON.parse(rows[0].payload_json);
+    }
+    catch {
+        return refuse("invalid_copy_journal");
+    }
+}
+/** Read-only pending physical launch proof. No provider dispatch, Hook claim,
+ * WorkSession/start or output/publication rights are granted by preparation. */
+export class PreparedSecondMemoryRepairLaunch {
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #baseline in value;
+    }
+    #baseline;
+    #launch;
+    #root;
+    #runRoot;
+    #workspace;
+    #intent;
+    #build;
+    #bundle;
+    #coordinator;
+    #session;
+    #registration;
+    #claimToken = null;
+    #restoredStart = null;
+    #claim = null;
+    constructor(key, baseline, launch, root, runRoot, workspace, intent, build, bundle, coordinator, session, registration) {
+        if (key !== token)
+            refuse("launch_token_required");
+        this.#baseline = baseline;
+        this.#launch = structuredClone(launch);
+        this.#root = root;
+        this.#runRoot = runRoot;
+        this.#workspace = workspace;
+        this.#intent = structuredClone(intent);
+        this.#build = structuredClone(build);
+        this.#bundle = bundle;
+        this.#coordinator = coordinator;
+        this.#session = session;
+        this.#registration = registration;
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        return this.#prepare(context, input, null);
+    }
+    /** Restore SQL start custody only; mutable private/shared documents are not
+     * recaptured, and this value cannot claim another Session or publish output. */
+    static restoreForStartedWork(context, input) {
+        if (typeof input.workSessionId !== "string" || !input.workSessionId || input.workSessionId.length > 256)
+            refuse("registered_start_session_required");
+        return this.#prepare(context, input, input.workSessionId);
+    }
+    static #prepare(context, input, workSessionId) {
+        if (!PreparedRetainedSecondMemoryRepairs.isPrepared(input.registration) || !PreparedRetainedSecondMemoryBaseline.isPrepared(input.baseline))
+            refuse("retained_second_owners_required");
+        if (!(input.bundle instanceof RetainedExecutionBundle) || !["mb-init", "mb-upgrade"].includes(input.bundle.descriptor.descriptor.id))
+            refuse("registered_memory_bundle_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        const registration = input.registration, baseline = input.baseline, bundle = input.bundle, owner = registration.receipt(), receipt = baseline.receipt();
+        registration.assertCustody(context);
+        if (workSessionId)
+            baseline.revalidate(context);
+        else
+            baseline.assertCustody(context);
+        if (receipt.registration_sha256 !== hybridDigest(owner) || owner.scope.bundle_sha256 !== bundle.sha256
+            || owner.scope.execution_sha256 !== bundle.execution.sha256)
+            refuse("foreign_registered_baseline");
+        const assigned = registration.batch().works.find(item => owner.work_ids[item.key] === receipt.work_id);
+        if (!assigned)
+            refuse("foreign_second_work");
+        const route = bundle.execution.work("review", assigned.payload.execution_override?.agent_profile_id), launch = launchRow(context, receipt.work_id, route);
+        let profile;
+        try {
+            profile = JSON.parse(launch.profile_json);
+        }
+        catch {
+            return refuse("invalid_launch_profile");
+        }
+        if (!profile || typeof profile !== "object" || Array.isArray(profile))
+            refuse("invalid_launch_profile");
+        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");
+        const run = context.db.get("SELECT run_root,run_dir FROM runs WHERE project_id=? AND id=?", [receipt.project_id, receipt.run_id]);
+        if (!run)
+            refuse("owned_run_required");
+        const runRoot = run.run_root ?? run.run_dir, relative = `works/${receipt.work_id}/writer-workspaces/generation-${receipt.generation}`;
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/.test(receipt.work_id))
+            refuse("unsafe_copy_scope");
+        const intent = { schema_id: "dd-flow/memory-repair-writer-copy-intent@1", project_id: receipt.project_id, run_id: receipt.run_id,
+            work_id: receipt.work_id, generation: receipt.generation, baseline_registration_sha256: hybridDigest(receipt),
+            protected_baseline_sha256: receipt.baseline_sha256, exported_baseline_sha256: receipt.exported_baseline_sha256,
+            run_root: runRoot, source_root: receipt.workspace_root, copy_relative: relative, input: baseline.copyInput() };
+        const ready = journal(context, receipt, "memory.repair_writer_copy_ready");
+        if (!ready || typeof ready.workspace_manifest_base64 !== "string")
+            refuse("ready_manifest_required");
+        const bytes = Buffer.from(ready.workspace_manifest_base64, "base64");
+        if (bytes.toString("base64") !== ready.workspace_manifest_base64)
+            refuse("changed_ready_manifest");
+        const workspace = PreparedMemoryRepairWorkspace.restore(bytes, ready.workspace_manifest_sha256, baseline.exportedBaseline());
+        const build = { ...intent, workspace_manifest_sha256: workspace.sha256, workspace_manifest_base64: bytes.toString("base64") };
+        if (hybridDigest(profile.memory_repair_copy) !== hybridDigest({ root: relative, copy_intent_sha256: hybridDigest(intent),
+            workspace_manifest_sha256: workspace.sha256, baseline_registration_sha256: hybridDigest(receipt) }))
+            refuse("launch_copy_changed");
+        const coordinator = PreparedDescriptorStageCoordinator.prepare(context, { projectRoot: bundle.execution.snapshot().scope.projectRoot, runId: receipt.run_id, stage: "review" });
+        coordinator.assertAllocatedCustody(context);
+        const session = readDescriptorCoordinatorSession(context, { scope: { projectId: receipt.project_id, runId: receipt.run_id, stage: "review" }, bundle, workId: owner.scope.parent_work_id }, refuse);
+        const prepared = new PreparedSecondMemoryRepairLaunch(token, baseline, launch, path.join(runRoot, relative), runRoot, workspace, intent, build, bundle, coordinator, session, registration);
+        if (workSessionId) {
+            prepared.#restoredStart = workSessionId;
+            prepared.#restoreStart(context, workSessionId);
+        }
+        else
+            prepared.revalidate(context);
+        return prepared;
+    }
+    root() { return this.#root; }
+    launch() { return structuredClone(this.#launch); }
+    input() {
+        const receipt = this.#baseline.receipt(), current = this.#baseline.currentView();
+        return { schema_id: current ? "dd-flow/memory-repair-work-input@2" : "dd-flow/memory-repair-work-input@1", work_id: receipt.work_id, generation: receipt.generation,
+            packet_sha256: receipt.packet_sha256, baseline_registration_sha256: hybridDigest(receipt),
+            protected_baseline_sha256: receipt.baseline_sha256, exported_baseline_sha256: receipt.exported_baseline_sha256,
+            copy_intent_sha256: hybridDigest(this.#intent), copy_build_sha256: hybridDigest(this.#build),
+            workspace_manifest_sha256: this.#workspace.sha256, workspace_root: this.#root,
+            launch_operation_id: this.#launch.operation_id, provider_session_id: this.#launch.provider_session_id,
+            ...(current ? { current_view_sha256: current.view_sha256, current_view_receipt_sha256: hybridDigest(current),
+                effective_read_inputs: memoryRepairCurrentReferences(this.#registration.batch().works.find(item => this.#registration.receipt().work_ids[item.key] === receipt.work_id).payload.memory_repair, this.#workspace) } : {}) };
+    }
+    /** Observe bounded private output against the actual packet/start manifest.
+     * This grants no shared publication, Work settlement or review acceptance. */
+    observeOutput(context, bytes) {
+        if (!this.#restoredStart)
+            refuse("restored_registered_start_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("output_observation_outside_writer_required");
+        if (!(bytes instanceof Uint8Array) || !bytes.byteLength || bytes.byteLength > 1024 * 1024)
+            refuse("bounded_result_bytes_required");
+        this.assertCustody(context);
+        const receipt = this.#baseline.receipt(), registration = this.#registration.receipt();
+        const assigned = this.#registration.batch().works.find(item => registration.work_ids[item.key] === receipt.work_id);
+        if (!assigned || assigned.payload.memory_repair.packet_sha256 !== receipt.packet_sha256)
+            refuse("repair_packet_changed");
+        const retained = Buffer.from(bytes), packet = assigned.payload.memory_repair;
+        const result = validateMemoryRepairWorkResult(retained, this.#bundle.engine(), { workId: receipt.work_id, packet,
+            effectiveInputs: memoryRepairCurrentReferences(packet, this.#workspace) });
+        this.#workspace.verifyUnchangedInputs(this.#root);
+        const delta = this.#baseline.exportedBaseline().observeResult(this.#root, result);
+        this.#workspace.verifyUnchangedInputs(this.#root);
+        delta.revalidate();
+        this.assertCustody(context);
+        return { bytes: retained, result, delta, work_session_id: this.#restoredStart,
+            start_receipt_sha256: hybridDigest(this.#restoreStart(context, this.#restoredStart)) };
+    }
+    /** Reserve exact second-wave publication bytes before any shared effect.
+     * Initial publication requires the full explained first-wave baseline;
+     * settled peer views and partial publication recovery require other owners. */
+    reservePublication(context, bytes) {
+        const observed = this.observeOutput(context, bytes), receipt = this.#baseline.receipt();
+        if (!isCompletedMemoryRepairClaim(observed.result))
+            refuse("accepted_private_output_required");
+        const before = this.#baseline.baseline(), exported = this.#baseline.exportedBaseline();
+        this.#workspace.verifySelectedSourceInputs(receipt.workspace_root, this.#baseline.copyInput(), before);
+        const transition = before.publicationTransition(exported, observed.delta);
+        const plan = { before_sha256: transition.state(0).sha256, before_base64: transition.state(0).bytes().toString("base64"),
+            after_sha256: transition.after().sha256, after_base64: transition.after().bytes().toString("base64"),
+            actions: transition.actions().map(action => ({ ...action, bytes_base64: action.after?.kind === "file" ? transition.bytes(action.path).toString("base64") : null })) };
+        RetainedMemoryRepairPublicationPlan.restore(Buffer.from(JSON.stringify(plan)), hybridDigest(plan));
+        const resultSha256 = createHash("sha256").update(observed.bytes).digest("hex");
+        const outputSha256 = hybridDigest({ input: this.input(), start_receipt_sha256: observed.start_receipt_sha256,
+            work_session_id: observed.work_session_id, result_sha256: resultSha256, delta_sha256: observed.delta.sha256, transition_sha256: transition.sha256 });
+        const value = { schema_id: "dd-flow/memory-repair-publication-intent@1", project_id: receipt.project_id, run_id: receipt.run_id,
+            work_id: receipt.work_id, generation: receipt.generation, work_session_id: observed.work_session_id,
+            source_root: receipt.workspace_root, private_root: this.#root, output_sha256: outputSha256,
+            start_receipt_sha256: observed.start_receipt_sha256, result_sha256: resultSha256, result_base64: observed.bytes.toString("base64"),
+            delta_sha256: observed.delta.sha256, transition_sha256: transition.sha256, ...plan };
+        if (Buffer.byteLength(JSON.stringify(value)) > 160 * 1024 * 1024)
+            refuse("unbounded_publication_intent");
+        observed.delta.revalidate();
+        this.assertCustody(context);
+        const expected = hybridDigest(value), eventType = "memory.repair_publication_intent";
+        const select = () => {
+            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, eventType, receipt.run_id, receipt.work_id, receipt.generation]);
+            if (!rows.length)
+                return false;
+            try {
+                if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 160 * 1024 * 1024
+                    || hybridDigest(JSON.parse(rows[0].payload_json)) !== expected)
+                    refuse("publication_intent_changed");
+            }
+            catch (error) {
+                if (error instanceof AppError && error.code === "memory_second_repair_launch_invalid")
+                    throw error;
+                refuse("invalid_publication_intent");
+            }
+            return true;
+        };
+        const result = context.db.writeTransaction(() => {
+            if (context.db.isOwnedWriteTransaction?.() !== true)
+                refuse("owned_publication_writer_required");
+            this.assertCustody(context);
+            const replayed = select();
+            if (!replayed)
+                appendAudit(context, { projectId: receipt.project_id, eventType, payload: value });
+            if (!select())
+                refuse("publication_intent_readback_failed");
+            return { work_id: receipt.work_id, work_session_id: observed.work_session_id, publication_intent_sha256: expected, status: "reserved", replayed };
+        });
+        try {
+            this.assertCustody(context);
+            observed.delta.revalidate();
+            this.#workspace.verifySelectedSourceInputs(receipt.workspace_root, this.#baseline.copyInput(), before);
+        }
+        catch (error) {
+            throw new AppError("memory_repair_publication_pending", "Second publication intent committed but physical custody changed before apply", 1, { effect: "committed", publication_intent_sha256: expected, cause: error instanceof Error ? error.message : String(error) });
+        }
+        return result;
+    }
+    /** Restore the independently reserved plan without adopting current shared
+     * or private bytes. Returned metadata does not authorize physical apply. */
+    restorePublication(context) {
+        if (!this.#restoredStart)
+            refuse("restored_registered_start_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("publication_preparation_outside_writer_required");
+        const start = this.#restoreStart(context, this.#restoredStart);
+        const receipt = this.#baseline.receipt();
+        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", [receipt.project_id, receipt.run_id, receipt.work_id, receipt.generation]);
+        if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 160 * 1024 * 1024)
+            refuse("registered_publication_intent_required");
+        try {
+            const value = JSON.parse(rows[0].payload_json);
+            const { current, plan, privatePlan } = retainedMemoryRepairPublicationPlans(value);
+            if (current || value.project_id !== receipt.project_id || value.run_id !== receipt.run_id || value.work_id !== receipt.work_id
+                || value.generation !== receipt.generation || value.work_session_id !== this.#restoredStart
+                || value.source_root !== receipt.workspace_root || value.private_root !== this.#root
+                || value.start_receipt_sha256 !== hybridDigest(start))
+                refuse("publication_scope_changed");
+            if (typeof value.result_base64 !== "string" || value.result_base64.length > Math.ceil(1024 * 1024 / 3) * 4)
+                refuse("bounded_result_bytes_required");
+            const bytes = Buffer.from(value.result_base64, "base64"), resultSha256 = createHash("sha256").update(bytes).digest("hex");
+            if (!bytes.length || bytes.length > 1024 * 1024 || bytes.toString("base64") !== value.result_base64 || resultSha256 !== value.result_sha256)
+                refuse("retained_result_changed");
+            const owner = this.#registration.receipt(), assigned = this.#registration.batch().works.find(item => owner.work_ids[item.key] === receipt.work_id);
+            if (!assigned || assigned.payload.memory_repair.packet_sha256 !== receipt.packet_sha256)
+                refuse("repair_packet_changed");
+            const packet = assigned.payload.memory_repair;
+            const result = validateMemoryRepairWorkResult(bytes, this.#bundle.engine(), { workId: receipt.work_id, packet,
+                effectiveInputs: memoryRepairCurrentReferences(packet, this.#workspace) });
+            if (!isCompletedMemoryRepairClaim(result))
+                refuse("accepted_reserved_result_required");
+            const views = deriveRetainedMemoryRepairViews(this.#baseline.baseline(), this.#baseline.exportedBaseline(), plan, result, privatePlan);
+            const outputSha256 = hybridDigest({ input: this.input(), start_receipt_sha256: value.start_receipt_sha256,
+                work_session_id: this.#restoredStart, result_sha256: resultSha256, delta_sha256: views.deltaSha256, transition_sha256: views.transitionSha256 });
+            if (value.delta_sha256 !== views.deltaSha256 || value.transition_sha256 !== views.transitionSha256
+                || value.output_sha256 !== outputSha256)
+                refuse("reserved_output_identity_changed");
+            this.assertCustody(context);
+            const currentRow = context.db.get("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')=?", [receipt.project_id, receipt.run_id, receipt.work_id, receipt.generation]);
+            if (currentRow?.payload_json !== rows[0].payload_json)
+                refuse("registered_intent_changed");
+            return { receipt: structuredClone(value), sha256: hybridDigest(value), bytes: Buffer.from(bytes), result, plan, exportedAfter: views.exportedAfter };
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            return refuse("invalid_retained_publication");
+        }
+    }
+    /** Outside-writer restoration for the common sealed publication owner.
+     * Returned data alone is not publication authority. */
+    restorePublicationBinding(context) {
+        const publication = this.restorePublication(context);
+        const start = this.#restoreStart(context, this.#restoredStart);
+        this.assertPublicationCustody(context, publication.sha256);
+        return { publication, start, workSessionId: this.#restoredStart, privateRoot: this.#root, sourceRoot: this.#baseline.receipt().workspace_root };
+    }
+    /** SQL-only start and independent intent fence for an owning writer.
+     * The expected digest comes from an outside-writer restoration; this does
+     * not observe files, recreate receipts or grant application permission. */
+    assertPublicationCustody(context, expectedSha256) {
+        if (!this.#restoredStart)
+            refuse("restored_registered_start_required");
+        if (!/^[a-f0-9]{64}$/.test(expectedSha256))
+            refuse("publication_digest_required");
+        this.assertCustody(context);
+        const scope = this.#baseline.receipt();
+        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", [scope.project_id, scope.run_id, scope.work_id, scope.generation]);
+        if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 160 * 1024 * 1024)
+            refuse("registered_publication_intent_required");
+        try {
+            const value = JSON.parse(rows[0].payload_json);
+            if (hybridDigest(value) !== expectedSha256)
+                refuse("registered_intent_changed");
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            refuse("invalid_retained_publication");
+        }
+        this.assertCustody(context);
+    }
+    /** Verify only an explained ordered prefix. A partial shared publication
+     * is never accepted as a replacement baseline or a completed Work. */
+    verifyPublicationPrefix(context) {
+        const publication = this.restorePublication(context), receipt = this.#baseline.receipt();
+        this.#workspace.verifyUnchangedInputs(this.#root);
+        publication.exportedAfter.revalidate(this.#root);
+        const view = publication.plan.classify(receipt.workspace_root);
+        this.#workspace.verifySelectedSourceInputs(receipt.workspace_root, this.#baseline.copyInput(), publication.plan.state(view.completed));
+        this.#workspace.verifyUnchangedInputs(this.#root);
+        publication.exportedAfter.revalidate(this.#root);
+        const current = publication.plan.classify(receipt.workspace_root);
+        if (current.completed !== view.completed || current.total !== view.total)
+            refuse("publication_cursor_changed");
+        this.assertPublicationCustody(context, publication.sha256);
+        return { publication_intent_sha256: publication.sha256, work_id: receipt.work_id,
+            work_session_id: this.#restoredStart, ...current };
+    }
+    /** Journal the actual next action before any staging/destination effect.
+     * Every already applied prefix action must have its own exact admission. */
+    reserveNextPublicationAction(context) {
+        const view = this.verifyPublicationPrefix(context), publication = this.restorePublication(context), scope = this.#baseline.receipt();
+        if (view.publication_intent_sha256 !== publication.sha256)
+            refuse("registered_intent_changed");
+        if (view.completed === view.total)
+            refuse("publication_has_no_pending_action");
+        const expected = (index) => publicationAction(scope, publication.plan, publication.sha256, this.#restoredStart, index);
+        const select = (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", [scope.project_id, scope.run_id, scope.work_id, scope.generation, 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(expected(index)))
+                    refuse("publication_action_intent_changed");
+            }
+            catch (error) {
+                if (error instanceof AppError)
+                    throw error;
+                refuse("invalid_publication_action_intent");
+            }
+            return true;
+        };
+        const receipt = expected(view.completed);
+        const reservation = context.db.writeTransaction(() => {
+            if (context.db.isOwnedWriteTransaction?.() !== true)
+                refuse("owned_publication_writer_required");
+            this.assertCustody(context);
+            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", [scope.project_id, scope.run_id, scope.work_id, scope.generation]);
+            if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 160 * 1024 * 1024 || hybridDigest(JSON.parse(rows[0].payload_json)) !== publication.sha256)
+                refuse("registered_intent_changed");
+            for (let index = 0; index < view.completed; index++)
+                if (!select(index))
+                    refuse("unadmitted_publication_prefix");
+            const replayed = select(view.completed);
+            if (!replayed)
+                appendAudit(context, { projectId: scope.project_id, eventType: "memory.repair_publication_action_intent", payload: receipt });
+            if (!select(view.completed))
+                refuse("publication_action_readback_failed");
+            return { ...receipt, status: "reserved", replayed };
+        });
+        try {
+            const current = this.verifyPublicationPrefix(context);
+            if (current.completed !== view.completed || current.publication_intent_sha256 !== publication.sha256)
+                refuse("publication_cursor_changed");
+        }
+        catch (error) {
+            throw new AppError("memory_repair_publication_pending", "Second action admission committed; retain it for exact reconciliation", 1, { effect: "committed", publication_intent_sha256: publication.sha256, index: view.completed, cause: error instanceof Error ? error.message : String(error) });
+        }
+        return reservation;
+    }
+    /** Read-only admission restoration before staging/apply. A physical prefix
+     * alone never manufactures its missing independent action receipts. */
+    verifyPublicationActionPrefix(context) {
+        const view = this.verifyPublicationPrefix(context), publication = this.restorePublication(context), scope = this.#baseline.receipt();
+        if (publication.sha256 !== view.publication_intent_sha256)
+            refuse("registered_intent_changed");
+        const count = view.completed < view.total ? view.completed + 1 : view.completed;
+        let next = null;
+        for (let index = 0; index < count; index++) {
+            const expected = publicationAction(scope, publication.plan, publication.sha256, this.#restoredStart, 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", [scope.project_id, scope.run_id, scope.work_id, scope.generation, index]);
+            if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 16 * 1024)
+                refuse("registered_publication_action_required");
+            try {
+                if (hybridDigest(JSON.parse(rows[0].payload_json)) !== hybridDigest(expected))
+                    refuse("publication_action_intent_changed");
+            }
+            catch (error) {
+                if (error instanceof AppError)
+                    throw error;
+                refuse("invalid_publication_action_intent");
+            }
+            if (index === view.completed)
+                next = expected;
+        }
+        const current = this.verifyPublicationPrefix(context);
+        if (current.completed !== view.completed || current.publication_intent_sha256 !== publication.sha256)
+            refuse("publication_cursor_changed");
+        return { ...current, next_action: next };
+    }
+    /** SQL-only claimant validation in the owning Work claim transaction.
+     * This does not create a WorkSession or authorize its start by itself. */
+    assertClaimIdentity(context, eventKey, identity) {
+        const receipt = this.#baseline.receipt();
+        if (this.#restoredStart)
+            refuse("restored_start_cannot_claim");
+        if (!context.db.ownedWriteTransactionToken?.() || context.db.isOwnedWriteTransaction?.() !== true)
+            refuse("owned_work_claim_writer_required");
+        this.assertCustody(context);
+        if (typeof eventKey !== "string" || !eventKey || eventKey.length > 1024)
+            refuse("registered_hook_key_required");
+        const actual = memoryRepairExecutionIdentity(context, { projectId: receipt.project_id, runId: receipt.run_id, workId: receipt.work_id, eventKey, root: this.#root }).identity;
+        const selected = { hookEventId: identity.hookEventId, providerSessionId: identity.providerSessionId,
+            sessionId: identity.sessionId, harness: identity.harness, cwd: identity.cwd };
+        if (!context.db.get("SELECT 1 FROM hook_events WHERE project_id=? AND event_key=? AND id=? AND event_name='PreToolUse' AND status IN ('observed','claimed')", [receipt.project_id, eventKey, actual.hookEventId]))
+            refuse("registered_start_hook_required");
+        if (hybridDigest({ hookEventId: actual.hookEventId, providerSessionId: actual.providerSessionId,
+            sessionId: actual.sessionId, harness: actual.harness, cwd: actual.cwd }) !== hybridDigest(selected))
+            refuse("claim_identity_changed");
+        const profile = JSON.parse(this.#launch.profile_json);
+        if (actual.providerSessionId !== this.#launch.provider_session_id || actual.harness !== runtimeHarness(profile.worker)
+            || actual.cwd !== this.#root)
+            refuse("repair_session_or_cwd_mismatch");
+        if (context.db.get("SELECT 1 FROM work_sessions ws JOIN works w ON w.work_id=ws.work_id JOIN sessions s ON s.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 s.harness=? AND s.provider_session_id=? LIMIT 1", [receipt.project_id, receipt.run_id, receipt.work_id, actual.harness, actual.providerSessionId]))
+            refuse("repair_session_not_fresh");
+        this.assertCustody(context);
+        this.#claimToken = context.db.ownedWriteTransactionToken();
+        this.#claim = { eventKey, identity: selected };
+    }
+    assertCustody(context) {
+        if (this.#restoredStart)
+            this.#restoreStart(context, this.#restoredStart);
+        else
+            this.#assertCustody(context);
+    }
+    #assertCustody(context, startedWorkSessionId) {
+        this.#baseline.assertCustody(context);
+        this.#coordinator.assertAllocatedCustody(context);
+        const receipt = this.#baseline.receipt(), run = context.db.get("SELECT run_root,run_dir FROM runs WHERE project_id=? AND id=?", [receipt.project_id, receipt.run_id]);
+        const scope = this.#bundle.execution.snapshot().scope;
+        if (!run || (run.run_root ?? run.run_dir) !== this.#runRoot || scope.workspace !== receipt.workspace_root
+            || hybridDigest(launchRow(context, receipt.work_id, this.#bundle.execution.work("review", this.#registration.batch().works.find(item => this.#registration.receipt().work_ids[item.key] === receipt.work_id).payload.execution_override?.agent_profile_id), this.#launch.operation_id)) !== hybridDigest(this.#launch))
+            refuse("launch_custody_changed");
+        const root = this.#intent;
+        const parent = context.db.get("SELECT parent_work_id,status FROM works WHERE project_id=? AND run_id=? AND work_id=?", [receipt.project_id, receipt.run_id, receipt.work_id]);
+        if (!parent?.parent_work_id)
+            refuse("owned_target_required");
+        if (startedWorkSessionId) {
+            const sessions = context.db.all("SELECT id FROM work_sessions WHERE work_id=? LIMIT 2", [receipt.work_id]);
+            if (parent.status !== "running" || sessions.length !== 1 || sessions[0].id !== startedWorkSessionId)
+                refuse("registered_start_session_required");
+        }
+        else if (parent.status !== "created" || context.db.get("SELECT 1 FROM work_sessions WHERE work_id=? LIMIT 1", [receipt.work_id]))
+            refuse("unstarted_target_required");
+        if (readDescriptorCoordinatorSession(context, { scope: { projectId: receipt.project_id, runId: receipt.run_id, stage: "review" }, bundle: this.#bundle, workId: parent.parent_work_id }, refuse) !== this.#session
+            || hybridDigest(journal(context, receipt, "memory.repair_writer_copy_intent")) !== hybridDigest(root)
+            || hybridDigest(journal(context, receipt, "memory.repair_writer_copy_build")) !== hybridDigest(this.#build)
+            || hybridDigest(journal(context, receipt, "memory.repair_writer_copy_ready")) !== hybridDigest(this.#build))
+            refuse("copy_or_coordinator_custody_changed");
+    }
+    /** Called after generic WorkSession insertion in the very same claim writer.
+     * A rollback removes both Session binding and independent start receipt. */
+    recordStart(context, workSessionId) {
+        const claim = this.#claim;
+        if (this.#restoredStart)
+            refuse("restored_start_cannot_claim");
+        if (!claim || !this.#claimToken || context.db.isOwnedWriteTransaction?.() !== true
+            || context.db.ownedWriteTransactionToken?.() !== this.#claimToken)
+            refuse("same_work_claim_writer_required");
+        if (typeof workSessionId !== "string" || !workSessionId || workSessionId.length > 256)
+            refuse("registered_start_session_required");
+        const receipt = this.#baseline.receipt(), assigned = this.#registration.batch().works.find(item => this.#registration.receipt().work_ids[item.key] === receipt.work_id);
+        recordMemoryRepairNativeBinding(context, receipt.work_id, this.#bundle.execution.work("review", assigned.payload.execution_override?.agent_profile_id), this.#launch, workSessionId);
+        return this.#startValue(context, workSessionId, claim, true);
+    }
+    #restoreStart(context, workSessionId) {
+        const receipt = this.#baseline.receipt();
+        const row = context.db.get("SELECT hook_event_id FROM work_sessions WHERE id=? AND work_id=?", [workSessionId, receipt.work_id]);
+        if (!row || typeof row.hook_event_id !== "string")
+            refuse("registered_start_hook_required");
+        const actual = memoryRepairExecutionIdentity(context, { projectId: receipt.project_id, runId: receipt.run_id, workId: receipt.work_id, eventKey: row.hook_event_id, root: this.#root }).identity;
+        return this.#startValue(context, workSessionId, { eventKey: row.hook_event_id, identity: { hookEventId: actual.hookEventId,
+                providerSessionId: actual.providerSessionId, sessionId: actual.sessionId, harness: actual.harness, cwd: actual.cwd } }, false);
+    }
+    #startValue(context, workSessionId, claim, write) {
+        const receipt = this.#baseline.receipt();
+        if (claim.identity.providerSessionId !== this.#launch.provider_session_id
+            || claim.identity.harness !== runtimeHarness(JSON.parse(this.#launch.profile_json).worker)
+            || claim.identity.cwd !== this.#root)
+            refuse("repair_session_or_cwd_mismatch");
+        this.#assertCustody(context, workSessionId);
+        const rows = context.db.all("SELECT ws.session_id,ws.hook_event_id,ws.start_receipt_json 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 ws.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 AND s.harness=? AND s.provider_session_id=? AND s.cwd=? LIMIT 2", [receipt.project_id, receipt.run_id, receipt.work_id, workSessionId, receipt.workspace_root, claim.identity.harness, this.#launch.provider_session_id, this.#root]);
+        if (rows.length !== 1 || rows[0].session_id !== claim.identity.sessionId || rows[0].hook_event_id !== claim.eventKey)
+            refuse("registered_start_session_required");
+        const actual = memoryRepairExecutionIdentity(context, { projectId: receipt.project_id, runId: receipt.run_id, workId: receipt.work_id, eventKey: claim.eventKey, root: this.#root }).identity;
+        if (hybridDigest({ hookEventId: actual.hookEventId, providerSessionId: actual.providerSessionId,
+            sessionId: actual.sessionId, harness: actual.harness, cwd: actual.cwd }) !== hybridDigest(claim.identity))
+            refuse("repair_claim_identity_changed");
+        if (!context.db.get("SELECT 1 FROM hook_events WHERE project_id=? AND event_key=? AND id=? AND event_name='PreToolUse' AND status='claimed' AND session_id=? AND COALESCE(provider_session_id,session_id)=? AND harness=?", [receipt.project_id, claim.eventKey, claim.identity.hookEventId, claim.identity.sessionId, this.#launch.provider_session_id, claim.identity.harness]))
+            refuse("registered_start_hook_required");
+        try {
+            const bytes = rows[0].start_receipt_json;
+            if (typeof bytes !== "string" || Buffer.byteLength(bytes) > 16 * 1024 * 1024)
+                refuse("bounded_start_receipt_required");
+            const start = JSON.parse(bytes), hash = (value) => createHash("sha256").update(value).digest("hex");
+            if (start.version !== 2 || start.generation !== receipt.generation || typeof start.context !== "string" || typeof start.prompt !== "string"
+                || start.context_sha256 !== hash(start.context) || start.prompt_sha256 !== hash(start.prompt)
+                || start.response?.work_id !== receipt.work_id || start.response?.work_session_id !== workSessionId
+                || start.response?.worker_prompt_markdown !== start.prompt || start.response_sha256 !== hash(JSON.stringify(start.response)))
+                refuse("repair_start_receipt_changed");
+            const input = JSON.parse(start.context);
+            if (input.work_id !== receipt.work_id || input.run_id !== receipt.run_id || input.workspace_root !== this.#root || input.read_only !== false
+                || input.result_schema !== "dd-flow/memory-repair-work-result@1" || hybridDigest(input.memory_repair_input) !== hybridDigest(this.input()))
+                refuse("repair_start_input_changed");
+            const value = { schema_id: "dd-flow/memory-repair-start@1", project_id: receipt.project_id, run_id: receipt.run_id,
+                work_id: receipt.work_id, generation: receipt.generation, work_session_id: workSessionId, session_id: claim.identity.sessionId,
+                hook_event_id: claim.eventKey, harness: claim.identity.harness, provider_session_id: this.#launch.provider_session_id,
+                context_sha256: start.context_sha256, prompt_sha256: start.prompt_sha256, input_sha256: hybridDigest(this.input()) };
+            const prior = 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", [receipt.project_id, receipt.run_id, receipt.work_id, receipt.generation]);
+            if (prior.length > 1 || prior.length && (Buffer.byteLength(prior[0].payload_json) > 1024 * 1024 || hybridDigest(JSON.parse(prior[0].payload_json)) !== hybridDigest(value)))
+                refuse("repair_start_registration_changed");
+            if (!prior.length) {
+                if (!write)
+                    refuse("registered_start_receipt_required");
+                appendAudit(context, { projectId: receipt.project_id, eventType: "memory.repair_work_start", payload: value });
+            }
+            if (hybridDigest(journal(context, receipt, "memory.repair_work_start")) !== hybridDigest(value))
+                refuse("repair_start_readback_failed");
+            this.#assertCustody(context, workSessionId);
+            return structuredClone(value);
+        }
+        catch (error) {
+            if (error instanceof AppError && error.code === "memory_second_repair_launch_invalid")
+                throw error;
+            return refuse("invalid_repair_start_receipt");
+        }
+    }
+    revalidate(context) {
+        if (this.#restoredStart) {
+            this.#baseline.revalidate(context);
+            this.assertCustody(context);
+            return;
+        }
+        this.assertCustody(context);
+        this.#baseline.revalidate(context);
+        this.#workspace.verify(this.#root);
+        const receipt = this.#baseline.receipt(), input = this.#baseline.copyInput();
+        this.#baseline.baseline().revalidate(receipt.workspace_root);
+        if (reviewSourceHash(receipt.workspace_root, input.explicit_inputs, input.base) !== input.source_sha256)
+            refuse("shared_source_changed_before_start");
+        this.assertCustody(context);
+    }
+    revalidateCommittedStart(context, workSessionId) {
+        const restoredStart = this.#restoredStart;
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("start_verification_outside_writer_required");
+        if (restoredStart && restoredStart !== workSessionId)
+            refuse("foreign_registered_start_session");
+        this.#restoreStart(context, workSessionId);
+        this.#baseline.revalidate(context);
+        if (restoredStart)
+            this.#workspace.verifyUnchangedInputs(this.#root);
+        else
+            this.#workspace.verify(this.#root);
+    }
+}