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

package/dist/services/memory-fix-intake-settlement.js

@@ -0,0 +1,127 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { requireProjectByRoot } from "./projects.js";
+import { readFlowRunExecutionBundle } from "./runs.js";
+import { readDescriptorStageInput } from "./descriptor-stage-coordinator.js";
+import { PreparedDescriptorStageSettlement } from "./descriptor-stage-settlement.js";
+import { readAcceptedStageData, prepareStagePacket, acceptStagePacket, resolveStagePublicationPath } from "./stage-report-renderer.js";
+import { readMemoryFixSourceIntake, assertMemoryFixSourceIntakeCustody } from "./memory-fix-intake-custody.js";
+import { prepareMemoryFixScopeEvidence } from "./memory-fix-scope.js";
+import { validateMemoryFixStageResult } from "./memory-fix-stage-results.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function refuse(reason) {
+    throw new AppError("memory_fix_intake_settlement_invalid", "Repair intake requires accepted scope and original source observations", 2, { reason, effect: "no_effect" });
+}
+/** Historical SQL read only: repaired files and later user turns must not
+ * replace an already accepted intake baseline. This grants no new write scope.
+ * Reads accepted Stage bytes itself, never caller-provided result JSON. The
+ * caller still needs ordinary coordinator settlement for Stage replay. Retained
+ * workspace_root is provenance only after restore, never a fresh write target.
+ */
+export function readAcceptedMemoryFixIntakeEvidence(context, scope, file) {
+    const accepted = readAcceptedStageData(context, { ...scope, stage: "intake" });
+    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')='intake' LIMIT 33", [scope.projectId, scope.runId]);
+    if (rows.length > 32)
+        refuse("ambiguous_intake_evidence");
+    const packets = rows.map(row => {
+        if (Buffer.byteLength(row.payload_json) > 8 * 1024 * 1024)
+            refuse("intake_evidence_exceeds_bound");
+        return JSON.parse(row.payload_json);
+    }).filter(packet => packet && typeof packet.file === "string"
+        && resolveStagePublicationPath(context, scope.projectId, scope.runId, packet.file) === file);
+    if (packets.length !== 1)
+        refuse("intake_evidence_missing");
+    const packet = packets[0];
+    if (typeof packet.base64 !== "string")
+        refuse("intake_evidence_changed");
+    const bytes = Buffer.from(packet.base64, "base64");
+    if (!bytes.length || bytes.length > 4 * 1024 * 1024 || bytes.toString("base64") !== packet.base64
+        || hash(bytes) !== packet.sha256)
+        refuse("intake_evidence_changed");
+    let evidence, result;
+    try {
+        evidence = JSON.parse(bytes.toString("utf8"));
+        result = JSON.parse(accepted.bytes.toString("utf8"));
+    }
+    catch {
+        return refuse("intake_evidence_changed");
+    }
+    if (!evidence || !result?.details || accepted.data_schema_id !== "dd-flow/mb-fix-stage-result@1"
+        || result.schema_id !== "dd-flow/mb-fix-stage-result@1" || result.run_id !== scope.runId || result.stage !== "intake"
+        || result.input_sha256 !== accepted.input_sha256 || evidence.intake_sha256 !== result.intake_sha256
+        || evidence.source_observation_sha256 !== result.source_observation_sha256
+        || hybridDigest(evidence.source_observation) !== result.source_observation_sha256
+        || hybridDigest(evidence.routing) !== hybridDigest(result.details.routing)
+        || hybridDigest(evidence.write_scope) !== hybridDigest(result.details.write_scope)
+        || evidence.write_scope && evidence.user_inputs_sha256 !== evidence.write_scope.user_inputs_sha256)
+        refuse("accepted_intake_changed");
+    return structuredClone(evidence);
+}
+/** Internal family handler. Generic runtime owns hook/Session identity and
+ * atomic completion; the scope packet is retained in that same SQL writer.
+ * Public registration waits for the complete repair/verification family.
+ */
+export function finishMemoryFixIntake(context, input) {
+    if (input.stage !== "intake")
+        refuse("intake_stage_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: "intake" };
+    const source = readMemoryFixSourceIntake(context, input, bundle);
+    const index = context.db.get("SELECT index_json FROM runs WHERE project_id=? AND id=?", [project.id, input.runId]);
+    const replay = JSON.parse(index.index_json).stage_runs.some((stage) => stage.stage === "intake" && stage.status === "done");
+    const packet = readDescriptorStageInput(context, scope, bundle, true, replay);
+    const file = path.join(packet.runRoot, bundle.descriptor.stage("intake").directory, "intake-evidence.json");
+    if (replay) {
+        const accepted = readAcceptedStageData(context, scope);
+        if (!accepted.bytes.equals(Buffer.from(input.bytes)))
+            refuse("accepted_result_changed");
+        const evidence = readAcceptedMemoryFixIntakeEvidence(context, scope, file);
+        if (evidence.intake_sha256 !== source.sha256)
+            refuse("source_intake_changed");
+        const settled = PreparedDescriptorStageSettlement.prepare(context, input);
+        return settled.apply(context, writer => {
+            assertMemoryFixSourceIntakeCustody(writer, scope, bundle, source.sha256);
+            const current = readAcceptedStageData(writer, scope);
+            if (!current.bytes.equals(accepted.bytes)
+                || hybridDigest(readAcceptedMemoryFixIntakeEvidence(writer, scope, file)) !== hybridDigest(evidence))
+                refuse("accepted_intake_changed");
+        });
+    }
+    if (!input.bytes.length || input.bytes.length > 1024 * 1024)
+        refuse("result_exceeds_bound");
+    let proposed;
+    try {
+        proposed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.bytes));
+    }
+    catch {
+        return refuse("invalid_result_json");
+    }
+    if (!proposed?.details || typeof proposed.details !== "object")
+        refuse("invalid_result_details");
+    const prepared = prepareMemoryFixScopeEvidence(context, { ...input, routing: proposed.details.routing, writeScope: proposed.details.write_scope });
+    const evidence = prepared.snapshot();
+    validateMemoryFixStageResult(input.bytes, bundle.descriptor.stageBlob("intake", "result_schema"), {
+        runId: input.runId, stage: "intake", inputSha256: packet.inputSha256, intakeSha256: source.sha256,
+        sourceObservationSha256: evidence.source_observation_sha256, findingIds: source.intake.selected_findings.map(finding => finding.id),
+        projectRoot: evidence.workspace_root, runRoot: packet.runRoot, predecessors: [], writeScope: evidence.write_scope, repairReceipt: null
+    });
+    const evidenceBytes = Buffer.from(JSON.stringify(evidence));
+    if (evidenceBytes.length > 4 * 1024 * 1024)
+        refuse("intake_evidence_exceeds_bound");
+    const retained = prepareStagePacket(file, evidenceBytes);
+    const settled = PreparedDescriptorStageSettlement.prepare(context, input);
+    prepared.assertSourcesCurrent();
+    return settled.apply(context, writer => {
+        prepared.assertCustody(writer);
+        const current = writer.db.get("SELECT index_json FROM runs WHERE project_id=? AND id=?", [project.id, input.runId]);
+        if (JSON.parse(current.index_json).stage_runs.some((stage) => stage.stage === "intake" && stage.status === "done"))
+            refuse("intake_already_accepted");
+        acceptStagePacket(writer, { ...scope, prepared: retained });
+    });
+}

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