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

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

@@ -0,0 +1,196 @@
+import path from "node:path";
+import fs from "node:fs";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { appendAudit } from "./audit.js";
+import { projectCheckoutRoot } from "../storage/paths.js";
+import { prepareMemoryFixRepairAdmission } from "./memory-fix-repair-admission.js";
+import { RetainedMemoryRepairPublicationPlan } from "./memory-repair-publication-plan.js";
+import { prepareMemoryFixDocumentPlan, applyMemoryFixDocumentStep, captureDistillBeforeDocuments, validateDistillBeforeDocuments, publishMemoryFixBeforeDocuments, memoryFixBeforeDocumentReferences } from "./distill-document-publication.js";
+import { readFlowRunExecutionBundle } from "./runs.js";
+import { prepareStagePacket, acceptStagePacket, resolveStagePublicationPath } from "./stage-report-renderer.js";
+const intent = "memory_fix.publication_intent", complete = "memory_fix.publication_complete";
+const key = (scope) => `memory_fix_publication:${hybridDigest({ project_id: scope.project_id, run_id: scope.run_id })}`;
+function refuse(reason) {
+    throw new AppError("memory_fix_publication_invalid", "Repair publication requires its original admitted output and retained plan", 2, { reason, effect: "no_effect" });
+}
+const receipt = (binding, plan, completed = false) => ({
+    schema_id: completed ? "dd-flow/mb-fix-publication-complete@1" : "dd-flow/mb-fix-publication-intent@1",
+    run_id: binding.run_id, binding_sha256: hybridDigest(binding), plan_sha256: plan.sha256
+});
+/** SQL custody only, never current write admission or proof of independent
+ * verification. Consumers must match this binding to their own frozen RUN.
+ * Missing either the retained value or independent receipt is not a new intent.
+ */
+export function readMemoryFixPublication(context, scope) {
+    return context.db.readSnapshot(() => {
+        const row = context.db.get("SELECT value_json FROM runtime_config WHERE key=?", [key(scope)]);
+        const anchor = context.db.get("SELECT json_extract(index_json,'$.variables.\"memory_fix.publication\"') anchor FROM runs WHERE project_id=? AND id=?", [scope.project_id, scope.run_id])?.anchor;
+        const events = (type) => context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type=? AND json_extract(payload_json,'$.run_id')=? LIMIT 2", [scope.project_id, type, scope.run_id]);
+        const starts = events(intent), ends = events(complete);
+        if (!row && !starts.length && !ends.length && !anchor)
+            return null;
+        if (!row || !anchor || starts.length !== 1 || ends.length > 1 || Buffer.byteLength(row.value_json) > 180 * 1024 * 1024
+            || [...starts, ...ends].some(event => Buffer.byteLength(event.payload_json) > 32768))
+            refuse("publication_custody_missing");
+        try {
+            const value = JSON.parse(row.value_json), binding = value.binding;
+            if (Object.keys(value).sort().join() !== "before_documents,binding,plan_json,plan_sha256" || !binding
+                || binding.project_id !== scope.project_id || binding.run_id !== scope.run_id || typeof value.plan_json !== "string")
+                refuse("publication_binding_changed");
+            const plan = RetainedMemoryRepairPublicationPlan.restore(Buffer.from(value.plan_json), value.plan_sha256);
+            const beforeDocuments = validateDistillBeforeDocuments(plan, value.before_documents);
+            const paths = JSON.parse(plan.state(0).bytes().toString("utf8")).write_paths;
+            if (hybridDigest([...paths].sort()) !== hybridDigest([...binding.write_scope.paths].sort())
+                || anchor !== hybridDigest(receipt(binding, plan))
+                || hybridDigest(JSON.parse(starts[0].payload_json)) !== hybridDigest(receipt(binding, plan))
+                || ends.length && hybridDigest(JSON.parse(ends[0].payload_json)) !== hybridDigest(receipt(binding, plan, true)))
+                refuse("publication_receipt_changed");
+            return { binding: structuredClone(binding), plan, beforeDocuments, completed: ends.length === 1 };
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            return refuse("invalid_publication_custody");
+        }
+    });
+}
+/** Exact handoff bytes include removed paths and original retained text refs.
+ * Serialization alone is not publication, Stage acceptance or finding closure. */
+export function memoryFixPublicationArtifact(binding, plan) {
+    const entries = new Map(plan.state(plan.actions().length).entries().map(entry => [entry.path, entry]));
+    return Buffer.from(JSON.stringify({ schema_id: "dd-flow/mb-fix-publication@1", binding, plan_sha256: plan.sha256,
+        documents: binding.write_scope.paths.map(logical => ({ path: logical, after: entries.get(logical) ?? null })),
+        before_documents: memoryFixBeforeDocumentReferences(plan), receipt: receipt(binding, plan, true) }));
+}
+export function readMemoryFixPublicationReference(context, retained, logical) {
+    if (!retained.completed)
+        refuse("publication_not_complete");
+    if (!logical || path.isAbsolute(logical) || logical.includes("\\") || logical.split("/").some(part => !part || part === "." || part === ".."))
+        refuse("invalid_publication_locator");
+    const { binding, plan } = retained;
+    const run = context.db.get("SELECT run_root FROM runs WHERE project_id=? AND id=?", [binding.project_id, binding.run_id]);
+    if (!run?.run_root)
+        refuse("run_home_required");
+    const file = path.join(run.run_root, logical), bytes = memoryFixPublicationArtifact(binding, plan);
+    const rows = context.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')='repair' AND json_extract(payload_json,'$.attempt')=? LIMIT 33", [binding.project_id, binding.run_id, binding.attempt]);
+    if (rows.length > 32 || rows.some(row => Buffer.byteLength(row.payload_json) > 8 * 1024 * 1024))
+        refuse("unbounded_publication_packets");
+    const packets = rows.map(row => JSON.parse(row.payload_json)).filter(packet => typeof packet.file === "string"
+        && resolveStagePublicationPath(context, binding.project_id, binding.run_id, packet.file) === file);
+    if (!packets.length)
+        return null;
+    const sha256 = createHash("sha256").update(bytes).digest("hex");
+    if (packets.some(packet => packet.sha256 !== sha256 || packet.base64 !== bytes.toString("base64")))
+        refuse("publication_packet_changed");
+    return { root: "run", path: logical, sha256 };
+}
+/** Internal publisher: actual active author + accepted intake, SQL intent before
+ * effects, exact retained prefix and effect-aware retry. No public registration,
+ * new Session allocation, independent verification or finding closure here. */
+export function prepareMemoryFixPublication(context, input) {
+    const admission = prepareMemoryFixRepairAdmission(context, input), selected = admission.snapshot();
+    const proposal = structuredClone(input.proposal), scope = selected.intake.write_scope;
+    if (!proposal || Object.keys(proposal).join() !== "outputs" || !Array.isArray(proposal.outputs) || !proposal.outputs.length || proposal.outputs.length > 512
+        || proposal.outputs.some(output => !output || Object.keys(output).sort().join() !== "content,finding_ids,path"
+            || typeof output.path !== "string" || output.content !== null && typeof output.content !== "string"
+            || !Array.isArray(output.finding_ids) || !output.finding_ids.length || new Set(output.finding_ids).size !== output.finding_ids.length
+            || output.finding_ids.some(id => !scope.finding_ids.includes(id) || !selected.intake.routing.some(decision => decision.finding_id === id && decision.route === "memory_repair" && decision.write_paths.includes(output.path))))
+        || hybridDigest(proposal.outputs.map(output => output.path).sort()) !== hybridDigest([...scope.paths].sort())
+        || scope.finding_ids.some(id => !proposal.outputs.some(output => output.finding_ids.includes(id))))
+        refuse("output_scope_changed");
+    if (proposal.outputs.some(output => output.content !== null && Buffer.byteLength(output.content) > 16 * 1024 * 1024)
+        || proposal.outputs.reduce((total, output) => total + (output.content === null ? 0 : Buffer.byteLength(output.content)), 0) > 64 * 1024 * 1024)
+        refuse("unbounded_output");
+    const { intake, run_root: runRoot, ...identity } = selected;
+    const checkoutRelative = path.relative(projectCheckoutRoot(context.ddFlowHome, selected.project_id), selected.workspace_root);
+    const managedCheckout = !!checkoutRelative && !path.isAbsolute(checkoutRelative)
+        && checkoutRelative !== ".." && !checkoutRelative.startsWith(`..${path.sep}`);
+    // The bound project checkout is productive workspace, even when its owner
+    // stores it in Home. Other Home areas and every RUN root remain protected.
+    for (const protectedRoot of [...(managedCheckout ? [] : [context.ddFlowHome]), runRoot]) {
+        const root = fs.realpathSync(protectedRoot);
+        for (const output of proposal.outputs) {
+            const destination = path.join(selected.workspace_root, output.path), relative = path.relative(root, destination);
+            if (!relative || !path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`))
+                refuse("output_overlaps_runtime");
+        }
+    }
+    const binding = { ...identity, intake_sha256: intake.intake_sha256, source_observation_sha256: intake.source_observation_sha256,
+        user_inputs_sha256: intake.user_inputs_sha256, write_scope: scope, proposal_sha256: hybridDigest(proposal),
+        assignments: proposal.outputs.map(output => ({ path: output.path, finding_ids: [...output.finding_ids] })) };
+    const selection = { project_id: binding.project_id, run_id: binding.run_id };
+    const prior = readMemoryFixPublication(context, selection);
+    if (prior && hybridDigest(prior.binding) !== hybridDigest(binding))
+        refuse("original_publication_required");
+    if (!prior)
+        admission.assertOriginalSources();
+    const plan = prior?.plan ?? prepareMemoryFixDocumentPlan(selected.workspace_root, proposal.outputs.map(output => ({ path: output.path, bytes: output.content === null ? null : Buffer.from(output.content) })));
+    const beforeDocuments = prior?.beforeDocuments ?? captureDistillBeforeDocuments(selected.workspace_root, plan);
+    const bundle = readFlowRunExecutionBundle(context, input);
+    if (!bundle || bundle.sha256 !== selected.bundle_sha256)
+        refuse("bundle_changed");
+    const logical = `${bundle.descriptor.stage("repair").directory}/publication.json`, file = path.join(runRoot, logical);
+    const assertIntent = () => {
+        const current = readMemoryFixPublication(context, selection);
+        if (!current || hybridDigest(current.binding) !== hybridDigest(binding) || current.plan.sha256 !== plan.sha256)
+            refuse("publication_intent_changed");
+        return current;
+    };
+    const fence = () => { admission.assertCustody(context); admission.assertPlanSources(plan); assertIntent(); };
+    const applyStep = () => {
+        admission.assertPhysical();
+        admission.assertPlanSources(plan);
+        context.db.writeTransaction(() => {
+            admission.assertCustody(context);
+            const current = readMemoryFixPublication(context, selection);
+            if (current) {
+                assertIntent();
+                return;
+            }
+            if (prior)
+                refuse("publication_custody_missing");
+            const value = JSON.stringify({ binding, plan_json: plan.bytes().toString("utf8"), plan_sha256: plan.sha256, before_documents: beforeDocuments });
+            if (Buffer.byteLength(value) > 180 * 1024 * 1024)
+                refuse("unbounded_publication_custody");
+            context.db.run("INSERT INTO runtime_config(key,value_json,created_at,updated_at) VALUES (?,?,?,?)", [key(selection), value, context.now(), context.now()]);
+            appendAudit(context, { projectId: binding.project_id, eventType: intent, payload: receipt(binding, plan) });
+            context.db.run("UPDATE runs SET index_json=json_set(index_json,'$.variables.\"memory_fix.publication\"',?) WHERE project_id=? AND id=?", [hybridDigest(receipt(binding, plan)), binding.project_id, binding.run_id]);
+            assertIntent();
+        });
+        publishMemoryFixBeforeDocuments(runRoot, plan, beforeDocuments);
+        const result = applyMemoryFixDocumentStep(selected.workspace_root, plan, fence);
+        if (result.status !== "applied")
+            return result;
+        try {
+            fence();
+            const packet = prepareStagePacket(file, memoryFixPublicationArtifact(binding, plan));
+            context.db.writeTransaction(() => {
+                admission.assertCustody(context);
+                const current = assertIntent();
+                if (!current.completed)
+                    appendAudit(context, { projectId: binding.project_id, eventType: complete, payload: receipt(binding, plan, true) });
+                const completed = assertIntent();
+                if (!readMemoryFixPublicationReference(context, completed, logical))
+                    acceptStagePacket(context, { projectId: binding.project_id, runId: binding.run_id, stage: "repair", prepared: packet });
+            });
+            fence();
+            const reference = readMemoryFixPublicationReference(context, assertIntent(), logical);
+            if (!reference)
+                refuse("publication_reference_missing");
+            return { ...result, publication: reference };
+        }
+        catch (error) {
+            throw new AppError("memory_fix_publication_pending", "Reconcile this retained publication before claiming repair completion", 1, { effect: "publication_pending", plan_sha256: plan.sha256, cause: error instanceof Error ? error.message : String(error) });
+        }
+    };
+    return { binding: () => structuredClone(binding), applyStep, apply: () => {
+            for (let step = 0; step <= plan.actions().length; step++) {
+                const result = applyStep();
+                if (result.status === "applied")
+                    return result;
+            }
+            return refuse("publication_did_not_progress");
+        } };
+}

package/dist/services/memory-fix-repair-admission.js

@@ -0,0 +1,116 @@
+import fs from "node:fs";
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { entityReferenceVariants } from "../shared/entity-references.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { requireProjectByRoot } from "./projects.js";
+import { readFlowRunExecutionBundle, assertPreparedRunBundleSqlAuthority } from "./runs.js";
+import { readDescriptorStageInput } from "./descriptor-stage-coordinator.js";
+import { readAcceptedDescriptorStageSettlement, readActiveDescriptorStageCoordinator } from "./descriptor-stage-settlement.js";
+import { readAcceptedStageData } from "./stage-report-renderer.js";
+import { stageLifecycleMatchKey } from "./hooks.js";
+import { readMemoryFixSourceIntake, assertMemoryFixSourceIntakeCustody } from "./memory-fix-intake-custody.js";
+import { readAcceptedMemoryFixIntakeEvidence } from "./memory-fix-intake-settlement.js";
+import { readPreparedMemoryFlowUserInputs } from "./memory-flow-user-inputs.js";
+import { observeRetainedMemoryFixSources, observeMemoryFixWriteTargets, memoryFixWriteTargetsFromBaseline } from "./memory-fix-sources.js";
+import { RetainedMemoryRepairPublicationPlan } from "./memory-repair-publication-plan.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+function refuse(reason) {
+    throw new AppError("memory_fix_repair_admission_invalid", "Repair requires its accepted intake and current delivered scope", 2, { reason, effect: "no_effect" });
+}
+/** Intake/Stage/user and active author Work custody, not publication permission.
+ * The publisher must also admit the author's exact output and retain its original
+ * plan before effects. Fresh plans require assertOriginalSources; resumed plans
+ * require assertPlanSources on that same SQL-retained plan, never a new baseline.
+ */
+export function prepareMemoryFixRepairAdmission(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, stage: "repair" };
+    const source = readMemoryFixSourceIntake(context, input, bundle);
+    const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle);
+    const stage = readDescriptorStageInput(context, scope, bundle);
+    const accepted = readAcceptedStageData(context, { ...scope, stage: "intake" });
+    if (stage.input.predecessor?.stage !== "intake" || hybridDigest(stage.input.predecessor.result) !== hybridDigest(accepted.result))
+        refuse("accepted_intake_predecessor_required");
+    const keys = entityReferenceVariants(input.runId).map(reference => stageLifecycleMatchKey("stage_finish", reference, "intake", input.projectRoot));
+    const settlement = readAcceptedDescriptorStageSettlement(context, { ...scope, stage: "intake" }, bundle, keys);
+    const author = readActiveDescriptorStageCoordinator(context, scope, bundle);
+    const file = path.join(stage.runRoot, bundle.descriptor.stage("intake").directory, "intake-evidence.json");
+    const evidence = readAcceptedMemoryFixIntakeEvidence(context, scope, file);
+    if (evidence.intake_sha256 !== source.sha256 || !evidence.write_scope)
+        refuse("accepted_repair_scope_required");
+    const workspace = resolveProjectRoot(run.workspace_root);
+    const physical = () => {
+        if (fs.realpathSync(workspace) !== workspace)
+            refuse("workspace_identity_changed");
+        const stat = fs.lstatSync(workspace);
+        if (!stat.isDirectory())
+            refuse("workspace_identity_changed");
+        return { dev: stat.dev, ino: stat.ino };
+    };
+    const identity = physical();
+    const assertPhysical = () => {
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("physical_check_outside_writer_required");
+        if (hybridDigest(physical()) !== hybridDigest(identity))
+            refuse("workspace_identity_changed");
+    };
+    const assertCustody = (writer) => {
+        assertMemoryFixSourceIntakeCustody(writer, scope, bundle, source.sha256);
+        const current = assertPreparedRunBundleSqlAuthority(writer, scope, bundle);
+        if (current.workspace_root !== workspace || current.run_root !== stage.runRoot
+            || hybridDigest(readDescriptorStageInput(writer, scope, bundle)) !== hybridDigest(stage)
+            || hybridDigest(readAcceptedStageData(writer, { ...scope, stage: "intake" })) !== hybridDigest(accepted)
+            || hybridDigest(readAcceptedDescriptorStageSettlement(writer, { ...scope, stage: "intake" }, bundle, keys)) !== hybridDigest(settlement)
+            || hybridDigest(readActiveDescriptorStageCoordinator(writer, scope, bundle)) !== hybridDigest(author)
+            || hybridDigest(readAcceptedMemoryFixIntakeEvidence(writer, scope, file)) !== hybridDigest(evidence)
+            || hybridDigest(readPreparedMemoryFlowUserInputs(writer, scope, "mb-fix", bundle)) !== evidence.user_inputs_sha256)
+            refuse("accepted_scope_changed");
+    };
+    assertCustody(context);
+    const observe = () => { assertPhysical(); return observeRetainedMemoryFixSources(workspace, source.intake).snapshot(); };
+    return {
+        snapshot: () => structuredClone({ project_id: project.id, run_id: input.runId, workspace_root: workspace,
+            workspace_identity: identity, run_root: stage.runRoot, intake: evidence,
+            intake_result: accepted.result, bundle_sha256: bundle.sha256, author, attempt: stage.attempt, input_sha256: stage.inputSha256 }),
+        assertCustody, assertPhysical,
+        assertOriginalSources: () => {
+            const current = { ...observe(), write_targets: observeMemoryFixWriteTargets(workspace, evidence.write_scope.paths) };
+            if (hybridDigest(current) !== hybridDigest(evidence.source_observation))
+                refuse("sources_changed_since_intake");
+        },
+        assertPlanSources: (plan) => {
+            assertPhysical();
+            if (!(plan instanceof RetainedMemoryRepairPublicationPlan))
+                refuse("retained_plan_required");
+            const before = JSON.parse(plan.state(0).bytes().toString("utf8"));
+            if (hybridDigest([...before.write_paths].sort()) !== hybridDigest([...evidence.write_scope.paths].sort())
+                || plan.state(0).canonicalWritePaths().size)
+                refuse("plan_scope_changed");
+            if (hybridDigest(memoryFixWriteTargetsFromBaseline(plan.state(0))) !== hybridDigest(evidence.source_observation.write_targets))
+                refuse("write_targets_changed_since_intake");
+            const current = plan.classify(workspace), entries = plan.state(current.completed).entries();
+            const actual = observe();
+            for (const original of evidence.source_observation.observations) {
+                const observed = actual.observations.find(item => item.path === original.path);
+                if (!observed)
+                    refuse("source_inventory_changed");
+                if (before.write_paths.includes(original.path)) {
+                    const baseline = before.entries.find((entry) => entry.path === original.path);
+                    if ((baseline?.sha256 ?? null) !== original.current_sha256)
+                        refuse("plan_rebased_after_intake");
+                    const expected = entries.find(entry => entry.path === original.path);
+                    if ((expected?.sha256 ?? null) !== observed.current_sha256)
+                        refuse("source_differs_from_retained_prefix");
+                }
+                else if (hybridDigest(observed) !== hybridDigest(original))
+                    refuse("sources_changed_since_intake");
+            }
+        }
+    };
+}

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

@@ -0,0 +1,141 @@
+import { AppError } from "../shared/errors.js";
+import { requireProjectByRoot } from "./projects.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { appendAudit } from "./audit.js";
+import { prepareMemoryFixRunBundle } from "./memory-fix-run-bundle.js";
+import { PreparedInstalledFlowSource } from "./installed-flow-source.js";
+import { FrozenGenericExecution } from "./generic-execution.js";
+import { AdmittedFrozenEngine } from "./frozen-engine.js";
+import { PreparedDescriptorRunStart } from "./descriptor-run-start.js";
+import { readRunStartRequest } from "./run-start-custody.js";
+import { prepareMemoryFixGitPolicy } from "./memory-fix-finish-integration.js";
+const event = "memory_fix.request";
+function refuse(reason) {
+    throw new AppError("memory_fix_request_invalid", "Repair launch requires its original retained request", 2, { reason, effect: "no_effect" });
+}
+function selection(input) {
+    return hybridDigest({ source_sha256: input.source.sha256, execution_sha256: input.execution.sha256,
+        engine_manifest_sha256: input.engine.manifestSha256, request_text: input.requestText,
+        source_run_id: input.sourceRunId, finding_ids: input.findingIds, git_executable: input.gitExecutable, git_policy: input.gitPolicy,
+        receipts: [...input.receipts ?? []], receipt_bytes: [...input.receiptBytes ?? []].map(([key, bytes]) => [key, Buffer.from(bytes).toString("base64")]) });
+}
+/** SQL-only lookup, also used by the allocation writer. No neighboring audit,
+ * current canon/profile settings or filesystem observation is consulted. */
+export function readMemoryFixRequest(context, { projectRoot, requestId }) {
+    const scope = { projectRoot, requestId };
+    const project = context.db.get("SELECT id FROM projects WHERE root=? AND status='active'", [scope.projectRoot]);
+    if (!project)
+        refuse("project_not_registered");
+    const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type=? AND json_extract(payload_json,'$.scope.requestId')=? LIMIT 2", [project.id, event, scope.requestId]);
+    if (!rows.length)
+        return null;
+    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 48 * 1024 * 1024)
+        refuse("ambiguous_request");
+    let value;
+    try {
+        value = JSON.parse(rows[0].payload_json);
+    }
+    catch {
+        return refuse("invalid_request");
+    }
+    if (value.schema_id !== "dd-flow/memory-fix-request@1" || value.project_id !== project.id
+        || hybridDigest(value.scope) !== hybridDigest(scope) || !/^[a-f0-9]{64}$/.test(value.selection_sha256)
+        || !Number.isFinite(Date.parse(value.bound_at)) || typeof value.request_text !== "string" || !value.request_text.trim()
+        || Buffer.byteLength(value.request_text) > 64 * 1024 || !Array.isArray(value.artifacts) || value.artifacts.length !== 2
+        || new Set(value.artifacts.map(item => item.path)).size !== 2
+        || value.artifacts.some(item => !["runtime/repair-intake.json", "runtime/git-policy.json"].includes(item.path)
+            || typeof item.base64 !== "string" || !item.base64 || item.base64.length > 2 * 1024 * 1024
+            || Buffer.from(item.base64, "base64").toString("base64") !== item.base64)
+        || !Array.isArray(value.receipts) || !Array.isArray(value.receipt_bytes)
+        || value.launch_selection !== null && (!value.launch_selection || typeof value.launch_selection !== "object" || Array.isArray(value.launch_selection))
+        || value.execution?.scope?.projectRoot !== scope.projectRoot || value.execution.scope.requestId !== scope.requestId
+        || value.execution.settings.flow_id !== "mb-fix")
+        refuse("request_scope_changed");
+    return value;
+}
+export function readMemoryFixRequestArtifacts(context, input) {
+    const frozen = input.execution.snapshot(), request = readMemoryFixRequest(context, { projectRoot: frozen.scope.projectRoot, requestId: frozen.scope.requestId });
+    if (request && request.selection_sha256 !== selection(input))
+        refuse("request_changed");
+    return request;
+}
+/** Allocation fence: metadata and retained bytes only. Historical RUN replay
+ * owns its bundle independently and does not need the neighboring source RUN. */
+export function assertMemoryFixRequestBundle(context, projectId, bundle) {
+    const frozen = bundle.execution.snapshot(), request = readMemoryFixRequest(context, { projectRoot: frozen.scope.projectRoot, requestId: frozen.scope.requestId });
+    if (!request || request.project_id !== projectId || bundle.manifest.flow_id !== "mb-fix" || bundle.manifest.bootstrap_receipts.length
+        || bundle.execution.sha256 !== request.execution_sha256 || bundle.manifest.descriptor.sha256 !== request.source.descriptor.sha256
+        || bundle.blob("runtime/source-request.md").toString("utf8") !== request.request_text
+        || bundle.manifest.engine_manifest.sha256 !== request.engine.manifest_sha256
+        || request.artifacts.some(item => bundle.blob(item.path).toString("base64") !== item.base64)
+        || request.source.blobs.some(item => bundle.blob(item.path).toString("base64") !== item.base64))
+        refuse("request_bundle_changed");
+}
+/** Preserve prepared input before allocating a RUN. IDs are selected only by
+ * common RUN-start, so another request may allocate between retain and start. */
+export function retainMemoryFixRequest(context, input, launchSelection) {
+    if (context.db.isOwnedWriteTransaction?.())
+        refuse("preparation_outside_writer_required");
+    const frozen = input.execution.snapshot(), scope = { projectRoot: frozen.scope.projectRoot, requestId: frozen.scope.requestId };
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(scope.requestId))
+        refuse("invalid_request_id");
+    const project = requireProjectByRoot(context, scope.projectRoot), digest = selection(input), prior = readMemoryFixRequest(context, scope);
+    const raw = structuredClone(launchSelection ?? null);
+    const assertSame = (request) => {
+        if (request.selection_sha256 !== digest || launchSelection !== undefined && hybridDigest(request.launch_selection) !== hybridDigest(raw))
+            refuse("request_changed");
+    };
+    if (prior) {
+        assertSame(prior);
+        return prior;
+    }
+    if (readRunStartRequest(context, project.id, scope.requestId))
+        refuse("foreign_run_request");
+    const bundle = prepareMemoryFixRunBundle(context, input), manifest = input.engine.manifest();
+    const value = { schema_id: "dd-flow/memory-fix-request@1", project_id: project.id, scope, selection_sha256: digest,
+        bound_at: input.boundAt, request_text: input.requestText, source_run_id: input.sourceRunId, finding_ids: [...input.findingIds],
+        source: input.source.snapshot(), source_sha256: input.source.sha256, execution: frozen, execution_sha256: input.execution.sha256,
+        engine: { identity: { package_name: manifest.package_name, package_version: manifest.package_version, engine_version: manifest.engine_version,
+                integrity_checksum: manifest.integrity.checksum, snapshot_root: manifest.snapshot_root }, manifest_sha256: input.engine.manifestSha256 },
+        git_executable: input.gitExecutable, git_policy: structuredClone(input.gitPolicy),
+        launch_selection: raw,
+        artifacts: ["runtime/repair-intake.json", "runtime/git-policy.json"].map(path => ({ path, base64: bundle.blob(path).toString("base64") })),
+        receipts: [...input.receipts ?? []], receipt_bytes: [...input.receiptBytes ?? []].map(([key, bytes]) => [key, Buffer.from(bytes).toString("base64")]) };
+    if (Buffer.byteLength(JSON.stringify(value)) > 48 * 1024 * 1024)
+        refuse("request_exceeds_bound");
+    return context.db.writeTransaction(() => {
+        const current = readMemoryFixRequest(context, scope);
+        if (current) {
+            assertSame(current);
+            return current;
+        }
+        if (readRunStartRequest(context, project.id, scope.requestId))
+            refuse("foreign_run_request");
+        appendAudit(context, { projectId: project.id, eventType: event, payload: value });
+        return value;
+    });
+}
+/** Existing allocations resume the common publisher. Before allocation only
+ * retained source/execution and input artifacts are restored, never refreshed. */
+export function startMemoryFixRun(context, scope) {
+    const request = readMemoryFixRequest(context, scope);
+    if (!request)
+        refuse("original_request_required");
+    const allocation = readRunStartRequest(context, request.project_id, scope.requestId);
+    if (allocation) {
+        if (allocation.payload.initial_index.flow_kind !== "mb-fix")
+            refuse("foreign_run_request");
+        return PreparedDescriptorRunStart.restore(context, scope).apply(context);
+    }
+    const source = PreparedInstalledFlowSource.restoreRetained(request.source, request.source_sha256), receipts = new Map(request.receipts);
+    const execution = FrozenGenericExecution.restore(request.execution, request.execution_sha256, source.resolveRegisteredFlow(), request.execution.scope, receipts);
+    const engine = AdmittedFrozenEngine.admitSelection(request.engine.identity, request.engine.manifest_sha256);
+    const actualGit = prepareMemoryFixGitPolicy(context.env, { scope: { ...scope, workspaceRoot: request.execution.scope.workspace },
+        gitExecutable: request.git_executable, selection: request.git_policy });
+    if (actualGit.bytes.toString("base64") !== request.artifacts.find(item => item.path === actualGit.path)?.base64)
+        refuse("git_selection_changed_before_start");
+    const bundle = prepareMemoryFixRunBundle(context, { source, execution, engine, boundAt: request.bound_at, requestText: request.request_text,
+        sourceRunId: request.source_run_id, findingIds: request.finding_ids, gitExecutable: request.git_executable, gitPolicy: request.git_policy,
+        receipts, receiptBytes: new Map(request.receipt_bytes.map(([key, bytes]) => [key, Buffer.from(bytes, "base64")])) });
+    return PreparedDescriptorRunStart.prepare(context, { bundle }).apply(context);
+}

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");
+        } };
+}