@deksden-com/dd-flow-cli 0.9.0-beta.152 → 0.9.0-beta.156

package/dist/services/memory-fix-run-bundle.js

@@ -0,0 +1,83 @@
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { PreparedInstalledFlowSource } from "./installed-flow-source.js";
+import { FrozenGenericExecution } from "./generic-execution.js";
+import { AdmittedFrozenEngine } from "./frozen-engine.js";
+import { RetainedExecutionBundle } from "./execution-bundles.js";
+import { nextDescriptorRunId } from "./descriptor-run-start.js";
+import { bundledHandlerContext } from "./stage-handlers.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { prepareMemoryFixSourceIntake } from "./memory-fix-intake-custody.js";
+import { prepareMemoryFixGitPolicy } from "./memory-fix-finish-integration.js";
+import { readMemoryFixRequestArtifacts } from "./memory-fix-request.js";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const encode = (value) => Buffer.from(JSON.stringify(value));
+function refuse(reason) {
+    throw new AppError("memory_fix_run_bundle_invalid", "Repair RUN requires its original source selection, request and Git policy", 2, { reason, effect: "no_effect" });
+}
+/** Initial construction outside the writer only; no RUN or workspace is created.
+ * The request owner must retain this selection before allocation and use the
+ * retained bundle on retry, never recapture a later diagnostic or Git policy.
+ */
+export function prepareMemoryFixRunBundle(context, input) {
+    if (context.db.isOwnedWriteTransaction?.())
+        refuse("preparation_outside_writer_required");
+    if (!(input.source instanceof PreparedInstalledFlowSource) || !(input.execution instanceof FrozenGenericExecution)
+        || !(input.engine instanceof AdmittedFrozenEngine) || !Number.isFinite(Date.parse(input.boundAt)))
+        refuse("unprepared_selection");
+    if (typeof input.requestText !== "string" || !input.requestText.trim() || Buffer.byteLength(input.requestText) > 64 * 1024)
+        refuse("original_request_required");
+    const frozen = input.execution.snapshot(), flow = input.source.resolveRegisteredFlow();
+    if (frozen.settings.flow_id !== "mb-fix" || flow.descriptor.id !== "mb-fix"
+        || flow.sha256 !== frozen.settings.descriptor_sha256)
+        refuse("flow_selection_changed");
+    input.source.revalidate();
+    input.engine.admitMemoryFixFlow(input.source);
+    const retained = readMemoryFixRequestArtifacts(context, input);
+    const restored = (path) => ({ path, bytes: Buffer.from(retained.artifacts.find(item => item.path === path).base64, "base64") });
+    const intake = retained ? restored("runtime/repair-intake.json") : prepareMemoryFixSourceIntake(context, { projectRoot: frozen.scope.projectRoot,
+        sourceRunId: input.sourceRunId, findingIds: input.findingIds });
+    const git = retained ? restored("runtime/git-policy.json") : prepareMemoryFixGitPolicy(context.env, { scope: { requestId: frozen.scope.requestId,
+            projectRoot: frozen.scope.projectRoot, workspaceRoot: frozen.scope.workspace }, gitExecutable: input.gitExecutable, selection: input.gitPolicy });
+    const manifest = input.engine.manifest(), checksum = manifest.integrity.checksum;
+    if (typeof checksum !== "string")
+        refuse("engine_identity_missing");
+    const runId = nextDescriptorRunId(context, { projectRoot: frozen.scope.projectRoot, requestId: frozen.scope.requestId, slug: "mb-fix" });
+    const binding = { schema_id: "dd-flow/run-engine-binding@1", run_id: runId,
+        project_root: frozen.scope.projectRoot, bound_at: retained?.bound_at ?? input.boundAt, source: "run_creation", reason: "Request-bound selected Memory Bank repair",
+        engine: { package_name: manifest.package_name, package_version: manifest.package_version, engine_version: manifest.engine_version,
+            integrity_checksum: checksum, snapshot_root: manifest.snapshot_root }, probe: { status: "not_required", command: null } };
+    const blobs = input.source.blobs();
+    const put = (logical, content) => {
+        if (blobs.has(logical) || !content.length || content.length > 1024 * 1024)
+            refuse("bundle_path_collision_or_size");
+        blobs.set(logical, content);
+        return { path: logical, sha256: hash(content) };
+    };
+    put("runtime/source-request.md", Buffer.from(input.requestText));
+    put(intake.path, intake.bytes);
+    put(git.path, git.bytes);
+    for (const reference of [frozen.settings.attached_session_receipt, frozen.settings.delegation.native_capacity_receipt]) {
+        if (!reference)
+            continue;
+        const content = input.receiptBytes?.get(reference.sha256);
+        if (!content || hash(content) !== reference.sha256 || !input.receipts?.has(reference.sha256))
+            refuse("execution_receipt_missing");
+        put(reference.path, Buffer.from(content));
+    }
+    const profiles = { schema_id: "dd-flow/profile-settings@1", profiles: frozen.profiles, aliases: {}, default_profile: null };
+    const profile = put("runtime/profiles.json", encode({ ...profiles, revision: hybridDigest(profiles) }));
+    const execution = put("runtime/execution.json", encode(frozen.settings));
+    const engineBinding = put("runtime/engine-binding.json", encode(binding));
+    const engineManifest = put("runtime/engine-manifest.json", input.engine.manifestBytes());
+    const provenance = { canon: input.source.canonProvenance(), project_pack: null };
+    const bundle = { schema_id: "dd-flow/execution-bundle@1", run_id: runId, flow_id: "mb-fix",
+        descriptor: input.source.descriptorReference(), execution_settings: execution, profile_settings: profile,
+        engine_binding: engineBinding, engine_manifest: engineManifest, bootstrap_receipts: [], ...provenance,
+        inventory: [...blobs].map(([logical, content]) => ({ path: logical, sha256: hash(content) })) };
+    const bytes = encode(bundle);
+    return RetainedExecutionBundle.admit(bytes, hash(bytes), blobs, { runId, executionScope: frozen.scope,
+        bundleProjectRoot: frozen.scope.projectRoot, descriptorSha256: flow.sha256, engineChecksum: checksum,
+        engineBindingSha256: engineBinding.sha256, engineManifestSha256: engineManifest.sha256,
+        descriptorContext: bundledHandlerContext(new Map()), bundleProvenance: provenance, receipts: input.receipts ?? new Map() });
+}

package/dist/services/memory-fix-scope.js

@@ -0,0 +1,78 @@
+import { AppError } from "../shared/errors.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { requireProjectByRoot } from "./projects.js";
+import { readFlowRunExecutionBundle, assertPreparedRunBundleSqlAuthority } from "./runs.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { validateMemoryFixRouting } from "./diagnostic-repair-intake.js";
+import { readMemoryFixSourceIntake, assertMemoryFixSourceIntakeCustody } from "./memory-fix-intake-custody.js";
+import { observeRetainedMemoryFixSources, observeMemoryFixWriteTargets } from "./memory-fix-sources.js";
+import { readPreparedMemoryFlowUserInputs } from "./memory-flow-user-inputs.js";
+import { assertMemoryRepairWritePaths } from "./memory-review-correction-plan.js";
+function refuse(reason) {
+    throw new AppError("memory_fix_scope_invalid", "Memory repair scope requires the selected findings and actual delivered user agreement", 2, { reason, effect: "no_effect" });
+}
+/** Prepares scope evidence, not semantic consent, Stage settlement or permission
+ * to apply files. The active intake coordinator must read the full delivered
+ * conversation, assess drift and bind its decision through the ordinary hook.
+ * Later publication must fence this same input set and original baseline again.
+ */
+export function prepareMemoryFixScopeEvidence(context, input) {
+    if (context.db.isOwnedWriteTransaction?.())
+        refuse("preparation_outside_writer_required");
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const bundle = readFlowRunExecutionBundle(context, input);
+    if (!bundle || bundle.manifest.flow_id !== "mb-fix")
+        refuse("memory_fix_bundle_required");
+    const scope = { projectId: project.id, runId: input.runId };
+    const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle);
+    const source = readMemoryFixSourceIntake(context, input, bundle);
+    const routing = validateMemoryFixRouting(source.intake.selected_findings.map(finding => finding.id), input.routing);
+    const users = readPreparedMemoryFlowUserInputs(context, scope, "mb-fix", bundle), userInputsSha256 = hybridDigest(users);
+    const writeScope = structuredClone(input.writeScope);
+    const repairs = routing.filter(decision => decision.route === "memory_repair").map(decision => decision.finding_id);
+    if (!repairs.length) {
+        if (writeScope !== null)
+            refuse("scope_without_repair_findings");
+    }
+    else {
+        if (!writeScope || typeof writeScope !== "object" || Array.isArray(writeScope)
+            || Object.keys(writeScope).sort().join() !== "approval_source,finding_ids,paths,user_inputs_sha256"
+            || !Array.isArray(writeScope.finding_ids) || !Array.isArray(writeScope.paths)
+            || hybridDigest(writeScope.finding_ids) !== hybridDigest(repairs))
+            refuse("exact_selected_scope_required");
+        assertMemoryRepairWritePaths(writeScope.paths);
+        const paths = [...new Set(routing.flatMap(decision => decision.write_paths))].sort();
+        if (hybridDigest([...writeScope.paths].sort()) !== hybridDigest(paths))
+            refuse("routing_write_scope_changed");
+        const agreement = writeScope.approval_source;
+        if (!agreement || Object.keys(agreement).sort().join() !== "path,root,sha256" || agreement.root !== "run"
+            || !users.sources.some(packet => ["request", "answer"].includes(packet.role)
+                && packet.path === agreement.path && packet.sha256 === agreement.sha256))
+            refuse("delivered_agreement_required");
+        if (writeScope.user_inputs_sha256 !== userInputsSha256)
+            refuse("user_inputs_changed");
+    }
+    const workspaceRoot = resolveProjectRoot(run.workspace_root), runRoot = run.run_root;
+    if (workspaceRoot !== run.workspace_root || !runRoot)
+        refuse("workspace_identity_required");
+    const observation = observeRetainedMemoryFixSources(workspaceRoot, source.intake);
+    const writeTargets = observeMemoryFixWriteTargets(workspaceRoot, writeScope?.paths ?? []);
+    const sourceObservation = { ...observation.snapshot(), write_targets: writeTargets };
+    const evidence = { intake_sha256: source.sha256, user_inputs_sha256: userInputsSha256,
+        workspace_root: workspaceRoot, routing, write_scope: writeScope, source_observation: sourceObservation,
+        source_observation_sha256: hybridDigest(sourceObservation) };
+    return { snapshot: () => structuredClone(evidence), assertSourcesCurrent: () => {
+            if (context.db.isOwnedWriteTransaction?.())
+                refuse("physical_observation_outside_writer_required");
+            observation.revalidate();
+            if (hybridDigest(observeMemoryFixWriteTargets(workspaceRoot, writeScope?.paths ?? [])) !== hybridDigest(writeTargets))
+                refuse("write_targets_changed");
+        }, assertCustody: (writer) => {
+            assertMemoryFixSourceIntakeCustody(writer, scope, bundle, source.sha256);
+            const current = assertPreparedRunBundleSqlAuthority(writer, scope, bundle);
+            if (current.workspace_root !== workspaceRoot || current.run_root !== runRoot)
+                refuse("workspace_identity_changed");
+            if (hybridDigest(readPreparedMemoryFlowUserInputs(writer, scope, "mb-fix", bundle)) !== userInputsSha256)
+                refuse("user_inputs_changed");
+        } };
+}

package/dist/services/memory-fix-sources.js

@@ -0,0 +1,85 @@
+import { AppError } from "../shared/errors.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { readDiagnosticRepairIntake } from "./diagnostic-repair-intake.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+import { MemoryRepairDocumentBaseline } from "./memory-repair-document-delta.js";
+function refuse(reason) {
+    throw new AppError("memory_fix_source_invalid", "Memory repair source observations changed or exceed their bounds", 2, { reason, effect: "no_effect" });
+}
+/** Only selected target metadata, including absence, becomes intake authority.
+ * Neighboring current documents remain protected by the later publication plan
+ * but unrelated edits do not invalidate target approval by themselves. */
+export function observeMemoryFixWriteTargets(projectRoot, paths) {
+    if (!paths.length)
+        return [];
+    const baseline = MemoryRepairDocumentBaseline.capture(projectRoot, paths);
+    return memoryFixWriteTargetsFromBaseline(baseline);
+}
+export function memoryFixWriteTargetsFromBaseline(baseline) {
+    const value = JSON.parse(baseline.bytes().toString("utf8"));
+    const entries = new Map(baseline.entries().map(entry => [entry.path, entry]));
+    return value.write_paths.slice().sort().map(logical => ({ path: logical, before: entries.get(logical) ?? null }));
+}
+/** Read-only drift evidence, never a replacement for the original finding or
+ * permission to repair/close it. The Stage owner must assess drift and revalidate
+ * this same observation before admitting any writer. Unavailable is not unchanged.
+ */
+export function observeMemoryFixSources(context, input) {
+    return observeSources(resolveProjectRoot(input.projectRoot), () => readDiagnosticRepairIntake(context, input));
+}
+/** The handler must first admit this intake from its own frozen RUN bundle.
+ * A scoped restore need not contain the neighboring source audit's SQL rows.
+ * This helper grants no intake/approval authority and never searches another Home.
+ */
+export function observeRetainedMemoryFixSources(projectRoot, intake) {
+    const retained = structuredClone(intake);
+    return observeSources(resolveProjectRoot(projectRoot), () => retained);
+}
+function observeSources(projectRoot, readIntake) {
+    const capture = () => {
+        const intake = readIntake(), references = new Map();
+        for (const finding of intake.selected_findings) {
+            for (const reference of [...finding.evidence, ...finding.resolution.evidence,
+                ...finding.critic_decisions.flatMap(critic => critic.decision.evidence)]) {
+                if (typeof reference.path !== "string" || reference.path.length > 4096 || reference.path.split("/").includes(".git")
+                    || !/^[a-f0-9]{64}$/.test(reference.sha256))
+                    refuse("invalid_original_source");
+                if (references.has(reference.path) && references.get(reference.path) !== reference.sha256)
+                    refuse("conflicting_original_source");
+                references.set(reference.path, reference.sha256);
+            }
+        }
+        if (references.size > 20_000)
+            refuse("source_inventory_exceeds_bound");
+        let total = 0;
+        const observations = [...references].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([path, original_sha256]) => {
+            try {
+                const location = { root: "project", path };
+                const observed = ObservedMemorySources.capture({ project: projectRoot }, [location]);
+                total += observed.bytes(location).length;
+                if (total > 64 * 1024 * 1024)
+                    refuse("source_bytes_exceed_bound");
+                const current_sha256 = observed.hashes().get(memorySourceKey("project", path));
+                return { path, original_sha256, current_sha256,
+                    state: current_sha256 === original_sha256 ? "unchanged" : "changed", reason: null };
+            }
+            catch (error) {
+                if (!(error instanceof AppError) || error.code !== "memory_source_observation_failed")
+                    throw error;
+                return { path, original_sha256, current_sha256: null, state: "unavailable",
+                    reason: String(error.details?.reason ?? "source_unavailable") };
+            }
+        });
+        return { schema_id: "dd-flow/mb-fix-source-observation@1", source: intake.source,
+            finding_ids: intake.selected_findings.map(finding => finding.id), observations,
+            requires_reassessment: !observations.length || observations.some(source => source.state !== "unchanged"),
+            authorization: "not_granted" };
+    };
+    const original = capture();
+    return { snapshot: () => structuredClone(original), revalidate: () => {
+            if (hybridDigest(capture()) !== hybridDigest(original))
+                refuse("sources_changed_after_observation");
+        } };
+}

package/dist/services/memory-fix-stage-entry.js

@@ -0,0 +1,24 @@
+import { AppError } from "../shared/errors.js";
+import { memoryFixStages } from "../domain/memory-fix-flow.js";
+import { readFlowRunExecutionBundle } from "./runs.js";
+import { requireProjectByRoot } from "./projects.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { readMemoryFixSourceIntake, assertMemoryFixSourceIntakeCustody } from "./memory-fix-intake-custody.js";
+import { PreparedDescriptorStageStart } from "./descriptor-stage-start.js";
+import { PreparedDescriptorStageCoordinator } from "./descriptor-stage-coordinator.js";
+/** Registered entry implementation, not standalone RUN-start permission.
+ * Generic runtime alone owns attempts, root Work, coordinator and replay.
+ */
+export function startMemoryFixStage(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const bundle = readFlowRunExecutionBundle(context, input);
+    if (!bundle || bundle.manifest.flow_id !== "mb-fix" || !memoryFixStages.includes(input.stage))
+        throw new AppError("memory_fix_stage_invalid", "Memory repair requires its registered five-stage flow and retained intake", 2, { reason: "memory_fix_stage_required", effect: "no_effect" });
+    bundle.descriptor.stage(input.stage);
+    const source = readMemoryFixSourceIntake(context, input, bundle);
+    const scope = { projectId: project.id, runId: input.runId };
+    const fence = (writer) => assertMemoryFixSourceIntakeCustody(writer, scope, bundle, source.sha256);
+    const start = PreparedDescriptorStageStart.prepare(context, input).apply(context, fence);
+    const coordinator = PreparedDescriptorStageCoordinator.prepare(context, input).apply(context, fence);
+    return { ...start, ...coordinator, intake_sha256: source.sha256, source_intake: source.reference };
+}

package/dist/services/memory-fix-stage-handlers.js

@@ -0,0 +1,282 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { entityReferenceVariants } from "../shared/entity-references.js";
+import { requireProjectByRoot } from "./projects.js";
+import { readFlowRunExecutionBundle, assertPreparedRunBundleSqlAuthority } from "./runs.js";
+import { readDescriptorStageInput } from "./descriptor-stage-coordinator.js";
+import { PreparedDescriptorStageSettlement, readAcceptedDescriptorStageSettlement, readActiveDescriptorStageCoordinator } from "./descriptor-stage-settlement.js";
+import { readAcceptedStageData, prepareStagePacket, acceptStagePacket, resolveStagePublicationPath, prepareStageReport, acceptStageReport, publishStageReport } from "./stage-report-renderer.js";
+import { readMemoryFixSourceIntake, assertMemoryFixSourceIntakeCustody } from "./memory-fix-intake-custody.js";
+import { finishMemoryFixIntake, readAcceptedMemoryFixIntakeEvidence } from "./memory-fix-intake-settlement.js";
+import { readMemoryFixPublication, readMemoryFixPublicationReference } from "./memory-fix-publication.js";
+import { memoryFixBeforeDocumentReferences, publishMemoryFixBeforeDocuments } from "./distill-document-publication.js";
+import { readPreparedMemoryFlowUserInputs } from "./memory-flow-user-inputs.js";
+import { validateMemoryFixStageResult, assertMemoryFixStageScope, memoryFixClosureProjection } from "./memory-fix-stage-results.js";
+import { PreparedDescriptorRunSettlement } from "./descriptor-run-settlement.js";
+import { prepareMemoryFixFinishIntegration } from "./memory-fix-finish-integration.js";
+import { stageLifecycleMatchKey } from "./hooks.js";
+import { assertDiagnosticSessionIndependence } from "./diagnostic-work-collection.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { memoryFixStages } from "../domain/memory-fix-flow.js";
+import { startMemoryFixStage } from "./memory-fix-stage-entry.js";
+/** Engine-owned handlers only; source admission does not allocate or start a RUN. */
+export const memoryFixStageHandlers = Object.freeze(memoryFixStages.map(stage => Object.freeze({
+    flowId: "mb-fix", stage, entryId: "memory-fix-stage-entry", finishId: "memory-fix-stage-finish",
+    entry: startMemoryFixStage, finish: finishMemoryFixStage
+})));
+function refuse(reason) {
+    const correctable = reason.startsWith("changed_") || ["invalid_result_json", "invalid_result_details", "result_exceeds_bound",
+        "preservation_evidence_required", "output_evidence_required"].includes(reason);
+    throw new AppError("memory_fix_stage_invalid", "Repair Stage requires its admitted publication and independent observations", 2, { reason, effect: "no_effect", ...(correctable ? { phase: "prepare", recoverable: true } : {}) });
+}
+function readTerminalReport(context, scope, attempt, root) {
+    const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='flow_run.stage_report' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.stage')='finish' AND json_extract(payload_json,'$.attempt')=? LIMIT 2", [scope.projectId, scope.runId, attempt]);
+    if (!rows.length)
+        return null;
+    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 8 * 1024 * 1024)
+        refuse("terminal_report_custody_invalid");
+    try {
+        const retained = JSON.parse(rows[0].payload_json);
+        const report = prepareStageReport(JSON.parse(retained.bytes.json));
+        if (retained.sha256 !== report.sha256 || hybridDigest(retained.bytes) !== hybridDigest(report.bytes)
+            || resolveStagePublicationPath(context, scope.projectId, scope.runId, retained.root) !== root)
+            refuse("terminal_report_changed");
+        return report;
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        return refuse("terminal_report_custody_invalid");
+    }
+}
+/** Common Stage settlement; public launch still requires the real RUN factory,
+ * command dispatch and installed family acceptance. */
+export function finishMemoryFixStage(context, input) {
+    if (input.stage === "intake")
+        return finishMemoryFixIntake(context, input);
+    if (!["repair", "verify", "review", "finish"].includes(input.stage))
+        refuse("repair_stage_required");
+    const stage = input.stage;
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const bundle = readFlowRunExecutionBundle(context, input);
+    if (!bundle || bundle.manifest.flow_id !== "mb-fix")
+        refuse("memory_fix_bundle_required");
+    const scope = { projectId: project.id, runId: input.runId, stage };
+    const source = readMemoryFixSourceIntake(context, input, bundle), run = assertPreparedRunBundleSqlAuthority(context, scope, bundle);
+    const packet = readDescriptorStageInput(context, scope, bundle, true, true);
+    const previousStage = stage === "repair" ? "intake" : stage === "verify" ? "repair" : stage === "review" ? "verify" : "review";
+    const previous = readAcceptedStageData(context, { ...scope, stage: previousStage });
+    if (packet.input.predecessor?.stage !== previousStage || hybridDigest(packet.input.predecessor.result) !== hybridDigest(previous.result))
+        refuse("predecessor_changed");
+    const prior = JSON.parse(previous.bytes.toString("utf8"));
+    const intakeFile = path.join(packet.runRoot, bundle.descriptor.stage("intake").directory, "intake-evidence.json");
+    const intake = readAcceptedMemoryFixIntakeEvidence(context, scope, intakeFile);
+    if (intake.intake_sha256 !== source.sha256)
+        refuse("source_intake_changed");
+    const publication = readMemoryFixPublication(context, { project_id: project.id, run_id: input.runId });
+    const repairInput = stage === "repair" ? packet : readDescriptorStageInput(context, { ...scope, stage: "repair" }, bundle, true, true);
+    const intakeResult = readAcceptedStageData(context, { ...scope, stage: "intake" });
+    if (intake.write_scope) {
+        if (!publication?.completed || publication.binding.bundle_sha256 !== bundle.sha256
+            || publication.binding.attempt !== repairInput.attempt || publication.binding.input_sha256 !== repairInput.inputSha256
+            || publication.binding.intake_sha256 !== source.sha256 || publication.binding.source_observation_sha256 !== intake.source_observation_sha256
+            || hybridDigest(publication.binding.intake_result) !== hybridDigest(intakeResult.result)
+            || hybridDigest(publication.binding.write_scope) !== hybridDigest(intake.write_scope))
+            refuse("completed_publication_required");
+    }
+    else if (publication)
+        refuse("publication_without_accepted_scope");
+    const reference = publication ? readMemoryFixPublicationReference(context, publication, `${bundle.descriptor.stage("repair").directory}/publication.json`) : null;
+    if (publication && !reference)
+        refuse("publication_reference_required");
+    if (!input.bytes.length || input.bytes.length > 1024 * 1024)
+        refuse("result_exceeds_bound");
+    let result;
+    try {
+        result = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.bytes));
+    }
+    catch {
+        return refuse("invalid_result_json");
+    }
+    if (!result?.details || typeof result.details !== "object" || !Array.isArray(result.details.limitations))
+        refuse("invalid_result_details");
+    const insert = (object, field, expected) => {
+        const proposed = object[field];
+        if (proposed != null && !(Array.isArray(proposed) && !proposed.length) && hybridDigest(proposed) !== hybridDigest(expected))
+            refuse(`changed_${field}`);
+        Object.assign(object, { [field]: structuredClone(expected) });
+    };
+    for (const [field, expected] of Object.entries({ schema_id: "dd-flow/mb-fix-stage-result@1", flow_id: "mb-fix", run_id: input.runId, stage,
+        input_sha256: packet.inputSha256, intake_sha256: source.sha256, source_observation_sha256: intake.source_observation_sha256,
+        predecessors: [{ stage: previousStage, ...previous.result }] }))
+        insert(result, field, expected);
+    insert(result.details, "routing", intake.routing);
+    insert(result.details, "write_scope", intake.write_scope);
+    insert(result.details, "repair_receipt", reference);
+    if (stage === "review" || stage === "finish")
+        insert(result.details, "verification", prior.details.verification);
+    if (stage === "finish")
+        insert(result.details, "review", prior.details.review);
+    result.details.limitations = [...new Set([...prior.details.limitations, ...source.intake.limitations, ...result.details.limitations])];
+    const bytes = Buffer.from(JSON.stringify(result));
+    const index = JSON.parse(run.index_json), replay = index.stage_runs.some((entry) => entry.stage === stage && entry.status === "done");
+    const logicalReadback = `${bundle.descriptor.stage(stage).directory}/publication-readback.json`;
+    const readback = prepareStagePacket(path.join(packet.runRoot, logicalReadback), Buffer.from(JSON.stringify({
+        schema_id: "dd-flow/mb-fix-publication-readback@1", run_id: input.runId, stage, input_sha256: packet.inputSha256,
+        result_sha256: createHash("sha256").update(bytes).digest("hex"), publication: reference,
+        documents: publication ? publication.binding.write_scope.paths.map(logical => ({ path: logical,
+            after: publication.plan.state(publication.plan.actions().length).entries().find(entry => entry.path === logical) ?? null })) : []
+    })));
+    if (replay) {
+        if (!readAcceptedStageData(context, scope).bytes.equals(bytes))
+            refuse("accepted_result_changed");
+    }
+    else {
+        if (publication) {
+            const actual = publication.plan.classify(run.workspace_root);
+            if (actual.completed !== actual.total)
+                refuse("publication_not_observed");
+            publishMemoryFixBeforeDocuments(packet.runRoot, publication.plan, publication.beforeDocuments);
+        }
+        result = validateMemoryFixStageResult(bytes, bundle.descriptor.stageBlob(stage, "result_schema"), {
+            runId: input.runId, stage, inputSha256: packet.inputSha256, intakeSha256: source.sha256, sourceObservationSha256: intake.source_observation_sha256,
+            findingIds: source.intake.selected_findings.map(finding => finding.id), projectRoot: run.workspace_root, runRoot: packet.runRoot,
+            predecessors: [{ stage: previousStage, ...previous.result }], writeScope: intake.write_scope, repairReceipt: reference
+        });
+        if (publication && stage !== "repair") {
+            const evidence = result.details.verification.flatMap(item => item.evidence);
+            if (memoryFixBeforeDocumentReferences(publication.plan).some(document => !evidence.some(ref => ref.root === "run"
+                && ref.path === document.source.path && ref.sha256 === document.source.sha256)))
+                refuse("preservation_evidence_required");
+            const after = publication.plan.state(publication.plan.actions().length).entries();
+            if (publication.binding.write_scope.paths.some(logical => {
+                const document = after.find(entry => entry.path === logical);
+                return document?.kind === "file" && !evidence.some(ref => ref.root === "project" && ref.path === logical && ref.sha256 === document.sha256);
+            }))
+                refuse("output_evidence_required");
+        }
+        assertMemoryFixStageScope(result, prior);
+    }
+    const settlement = PreparedDescriptorStageSettlement.prepare(context, { ...input, bytes });
+    const keys = (name) => entityReferenceVariants(input.runId).map(ref => stageLifecycleMatchKey("stage_finish", ref, name, input.projectRoot));
+    const repairKeys = stage !== "repair" || replay ? keys("repair") : [];
+    const verifyKeys = stage === "review" || stage === "finish" ? keys("verify") : [];
+    const reviewKeys = stage === "finish" ? keys("review") : [];
+    const readOwner = (writer) => {
+        const physical = (sessionId) => {
+            const session = writer.db.get("SELECT harness,provider_session_id FROM sessions WHERE project_id=? AND run_id=? AND session_id=?", [project.id, input.runId, sessionId]);
+            if (!session?.harness || !session.provider_session_id)
+                refuse("physical_owner_missing");
+            return session;
+        };
+        const repair = stage !== "repair" || replay ? readAcceptedDescriptorStageSettlement(writer, { ...scope, stage: "repair" }, bundle, repairKeys) : null;
+        const verify = stage === "review" || stage === "finish" ? readAcceptedDescriptorStageSettlement(writer, { ...scope, stage: "verify" }, bundle, verifyKeys) : null;
+        const review = stage === "finish" ? readAcceptedDescriptorStageSettlement(writer, { ...scope, stage: "review" }, bundle, reviewKeys) : null;
+        const authorId = repair?.binding.sessionId ?? settlement.coordinatorSessionId(), author = physical(authorId);
+        const authorProof = repair ? { work_id: repair.work_id, work_session_id: repair.work_session_id, session_id: authorId,
+            ...author, start_hook: repair.binding.startHook, association_sha256: repair.binding.associationSha256,
+            physical_binding_sha256: repair.binding.physicalBindingSha256, prompt_path: repair.binding.promptPath }
+            : readActiveDescriptorStageCoordinator(writer, scope, bundle);
+        if (publication && hybridDigest(publication.binding.author) !== hybridDigest(authorProof))
+            refuse("publication_author_changed");
+        if (stage === "finish") {
+            assertDiagnosticSessionIndependence([physical(verify.binding.sessionId)], [author]);
+            assertDiagnosticSessionIndependence([physical(review.binding.sessionId)], [author, physical(verify.binding.sessionId)]);
+        }
+        else if (stage !== "repair")
+            assertDiagnosticSessionIndependence([physical(settlement.coordinatorSessionId())], [author, ...(verify ? [physical(verify.binding.sessionId)] : [])]);
+        return { repair, verify, review, author };
+    };
+    const owner = context.db.readSnapshot(() => readOwner(context));
+    const closure = stage === "finish" ? memoryFixClosureProjection(result) : null;
+    const reportRoot = path.join(packet.runRoot, bundle.descriptor.stage(stage).directory);
+    const retainedReport = stage === "finish" ? readTerminalReport(context, scope, packet.attempt, reportRoot) : null;
+    if (stage === "finish" && replay && !retainedReport)
+        refuse("accepted_terminal_report_missing");
+    const acceptedRepair = !!closure && !!publication && !closure.some(item => item.status === "open");
+    const integration = stage === "finish" && acceptedRepair && (!replay || run.status !== "done")
+        ? prepareMemoryFixFinishIntegration(context, scope, bundle) : null;
+    const integrationOutcome = replay && retainedReport ? retainedReport.normalized.integration
+        : integration ? { state: "integrated", observation: integration.value() }
+            : { state: publication ? "not_integrated_open_findings" : "not_applicable" };
+    const report = closure ? prepareStageReport({ run_id: input.runId, stage: "finish",
+        verdict: closure.some(item => item.status === "open") ? "completed_with_open_findings" : "completed", summary: result.summary,
+        memory_fix: { result, closure, source: source.intake.source, source_intake: source.reference,
+            unselected_ids: source.intake.unselected_ids, limitations: source.intake.limitations }, integration: integrationOutcome,
+        semantic: { acceptance: closure.map(item => `${item.finding_id}: ${item.status}; route=${item.route}`),
+            checks: result.details.verification.map(item => `${item.finding_id}: ${item.verdict}; ${item.summary}`),
+            evidence: [...result.details.verification, ...result.details.review].flatMap(item => item.evidence.map(ref => `${ref.root}:${ref.path}@${ref.sha256}`)),
+            next_action: closure.some(item => item.status === "open") ? "Open findings remain open; retain unintegrated work for explicit follow-up. Do not silently retry or close DEF records."
+                : "Only this accepted scope is complete; routed, deferred and unselected findings are not repaired by this RUN." } }) : null;
+    if (report && Buffer.byteLength(JSON.stringify(report.bytes)) > 7 * 1024 * 1024)
+        refuse("terminal_report_exceeds_bound");
+    if (retainedReport && report && retainedReport.sha256 !== report.sha256)
+        refuse("accepted_terminal_report_changed");
+    integration?.revalidate();
+    if (!replay && publication) {
+        const observed = publication.plan.classify(run.workspace_root);
+        if (observed.completed !== observed.total)
+            refuse("publication_not_observed");
+    }
+    const fence = (writer) => {
+        assertMemoryFixSourceIntakeCustody(writer, scope, bundle, source.sha256);
+        if (hybridDigest(readAcceptedStageData(writer, { ...scope, stage: previousStage })) !== hybridDigest(previous)
+            || hybridDigest(readAcceptedMemoryFixIntakeEvidence(writer, scope, intakeFile)) !== hybridDigest(intake)
+            || hybridDigest(readOwner(writer)) !== hybridDigest(owner))
+            refuse("stage_authority_changed");
+        const current = readMemoryFixPublication(writer, { project_id: project.id, run_id: input.runId });
+        if (publication && (!current?.completed || current.plan.sha256 !== publication.plan.sha256 || hybridDigest(current.binding) !== hybridDigest(publication.binding)
+            || hybridDigest(readMemoryFixPublicationReference(writer, current, reference.path)) !== hybridDigest(reference)))
+            refuse("publication_changed");
+        if (!publication && current)
+            refuse("publication_without_accepted_scope");
+        if (stage === "repair" && !replay && intake.user_inputs_sha256 !== hybridDigest(readPreparedMemoryFlowUserInputs(writer, scope, "mb-fix", bundle)))
+            refuse("user_inputs_changed");
+        const rows = writer.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='flow_run.stage_packet' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.stage')=? AND json_extract(payload_json,'$.attempt')=? LIMIT 33", [project.id, input.runId, stage, packet.attempt]);
+        if (rows.length > 32 || rows.some(row => Buffer.byteLength(row.payload_json) > 8 * 1024 * 1024))
+            refuse("readback_custody_invalid");
+        const packets = rows.map(row => JSON.parse(row.payload_json)).filter(value => typeof value.file === "string"
+            && resolveStagePublicationPath(writer, project.id, input.runId, value.file) === readback.file);
+        if (packets.length > 1 || packets.some(value => value.sha256 !== readback.sha256 || value.base64 !== readback.bytes.toString("base64")))
+            refuse("readback_custody_changed");
+        if (!packets.length) {
+            if (replay)
+                refuse("accepted_readback_missing");
+            acceptStagePacket(writer, { ...scope, prepared: readback });
+        }
+        integration?.assertCustody(writer);
+        if (report) {
+            const currentReport = readTerminalReport(writer, scope, packet.attempt, reportRoot);
+            if (currentReport && currentReport.sha256 !== report.sha256)
+                refuse("terminal_report_changed");
+            if (!currentReport) {
+                if (replay)
+                    refuse("accepted_terminal_report_missing");
+                acceptStageReport(writer, { ...scope, root: reportRoot, prepared: report });
+            }
+        }
+    };
+    try {
+        const accepted = settlement.apply(context, fence);
+        if (stage !== "finish")
+            return accepted;
+        integration?.revalidate();
+        const complete = PreparedDescriptorRunSettlement.prepare(context, input).apply(context, fence);
+        publishStageReport(context, project.id, input.runId, "finish", reportRoot);
+        return { ...accepted, ...complete, closure, reports: ["json", "md", "html"].map(extension => path.join(reportRoot, `stage-report.${extension}`)) };
+    }
+    catch (error) {
+        if (stage !== "finish")
+            throw error;
+        let committed = false;
+        try {
+            committed = readAcceptedStageData(context, scope).bytes.equals(bytes);
+        }
+        catch { /* No accepted terminal data. */ }
+        if (!committed)
+            throw error;
+        throw new AppError("memory_fix_finish_pending", "Accepted finish requires projection or RUN settlement reconciliation", 1, { effect: "committed", run_id: input.runId, next_action: "reconcile_accepted_finish", cause: error instanceof AppError ? error.code : "finish_settlement_failed" });
+    }
+}