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

package/dist/services/memory-result-binding.js

@@ -0,0 +1,173 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { AppError } from "../shared/errors.js";
+import { ResolvedFlowDescriptor } from "./flow-descriptors.js";
+import { FrozenGenericExecution } from "./generic-execution.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+import { assertPreparedRunBundleAuthority, assertPreparedRunBundleSqlAuthority, assertRunBundleSqlAuthority } from "./runs.js";
+import { readAcceptedStageData } from "./stage-report-renderer.js";
+import { PreparedMemoryBaselinePreservation } from "./memory-baseline-preservation.js";
+import { readAcceptedDescriptorStageSettlement } from "./descriptor-stage-settlement.js";
+import { entityReferenceVariants } from "../shared/entity-references.js";
+import { stageLifecycleMatchKey } from "./hooks.js";
+import { captureRegisteredMemoryCompositionSources } from "./memory-preflight-handler.js";
+import { memoryCompositionRegistrationDigest } from "./memory-composition-registration.js";
+import { PreparedCheckEvidence } from "./code-checks.js";
+function refuse() { throw new AppError("memory_result_binding_custody_invalid", "Memory result binding lacks independently accepted stage custody", 1, { effect: "no_effect" }); }
+/** Select identity, predecessor and unit coverage from SQL, not result fields. */
+function select(context, input) {
+    if (input.checks !== undefined) {
+        if (!(input.checks instanceof PreparedCheckEvidence))
+            refuse();
+        input.checks.assertOwner({ ...input, scope: "aggregate" });
+        input.checks.assertCustody(context);
+    }
+    const run = context.db.get("SELECT index_json, project_root, workspace_root FROM runs WHERE project_id = ? AND id = ?", [input.projectId, input.runId]);
+    if (!run)
+        refuse();
+    const index = JSON.parse(run.index_json), frozen = input.execution.snapshot();
+    if (assertRunBundleSqlAuthority(context, input, index.execution_bundle)) {
+        if (!input.bundle || input.bundle.execution.sha256 !== input.execution.sha256 || input.bundle.descriptor.sha256 !== input.flow.sha256)
+            refuse();
+        assertPreparedRunBundleSqlAuthority(context, input, input.bundle);
+    }
+    const stage = index.stage_runs?.find((item) => item.stage === input.stage);
+    if (input.flow.descriptor.id !== "mb-init" || frozen.settings.flow_id !== "mb-init" || frozen.settings.descriptor_sha256 !== input.flow.sha256
+        || index.execution_bundle && (index.execution_bundle.flow_id !== "mb-init" || index.execution_bundle.descriptor_sha256 !== input.flow.sha256)
+        || frozen.scope.projectRoot !== run.project_root || frozen.scope.workspace !== run.workspace_root
+        || (input.acceptedReplay ? stage?.status !== "done" : index.current_stage !== input.stage || stage?.status !== "running") || stage.dir !== input.flow.stage(input.stage).directory
+        || typeof stage.attempt !== "string" || !/^try-[0-9]{3,}$/.test(stage.attempt)
+        || typeof stage.input_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(stage.input_sha256))
+        refuse();
+    const accepted = input.acceptedReplay ? readAcceptedStageData(context, input) : null;
+    const acceptedValue = accepted ? JSON.parse(accepted.bytes.toString("utf8")) : null;
+    if (accepted && (accepted.data_schema_id !== `dd-flow/mb-init-${input.stage}-result@1`
+        || acceptedValue.schema_id !== accepted.data_schema_id || acceptedValue.run_id !== input.runId
+        || acceptedValue.stage !== input.stage || !(acceptedValue.outcome === "accepted" || input.stage === "verify" && acceptedValue.outcome === "needs_repair" && input.flow.successor("verify", "needs_repair") === "review")
+        || acceptedValue.input_sha256 !== stage.input_sha256))
+        refuse();
+    const settlement = accepted && input.bundle ? readAcceptedDescriptorStageSettlement(context, input, input.bundle, input.matchKeys) : null;
+    const edges = input.flow.descriptor.edges.filter(edge => edge.to === input.stage && edge.on === "accepted");
+    const entry = input.stage === input.flow.descriptor.entry_stage;
+    if (edges.length !== (entry ? 0 : 1))
+        refuse();
+    const predecessor = entry ? null : readAcceptedStageData(context, { ...input, stage: edges[0].from });
+    const value = predecessor ? JSON.parse(predecessor.bytes.toString("utf8")) : null;
+    const preflight = entry ? null : readAcceptedStageData(context, { ...input, stage: "preflight" });
+    const preflightValue = preflight ? JSON.parse(preflight.bytes.toString("utf8")) : null;
+    if (preflight && (preflight.data_schema_id !== "dd-flow/mb-init-preflight-result@1"
+        || preflightValue.schema_id !== preflight.data_schema_id || preflightValue.run_id !== input.runId
+        || preflightValue.stage !== "preflight" || preflightValue.outcome !== "accepted"
+        || preflightValue.input_sha256 !== preflight.input_sha256
+        || typeof preflight.input_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(preflight.input_sha256)))
+        refuse();
+    if (predecessor && (predecessor.data_schema_id !== `dd-flow/mb-init-${edges[0].from}-result@1`
+        || value.schema_id !== predecessor.data_schema_id || value.run_id !== input.runId || value.stage !== edges[0].from
+        || !(value.outcome === "accepted" || edges[0].from === "verify" && value.outcome === "needs_repair" && input.flow.successor("verify", "needs_repair") === input.stage)
+        || typeof predecessor.input_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(predecessor.input_sha256)
+        || value.input_sha256 !== predecessor.input_sha256 || !Array.isArray(value.units)))
+        refuse();
+    const unitIds = ["preflight", "discover"].includes(input.stage) ? null : value?.units.map((unit) => unit.id);
+    if (unitIds !== null && (!Array.isArray(unitIds) || unitIds.some(id => typeof id !== "string") || new Set(unitIds).size !== unitIds.length))
+        refuse();
+    const binding = { runId: input.runId, stage: input.stage, inputSha256: stage.input_sha256,
+        predecessors: predecessor ? [{ stage: edges[0].from, result: predecessor.result, input_sha256: predecessor.input_sha256 }] : [],
+        unitIds, sources: new Map([...input.sources.hashes(), ...(input.checks?.artifactReferences() ?? []).map(ref => [memorySourceKey(ref.root, ref.path), ref.sha256])]),
+        historicalEvidence: new Set([...input.historicalEvidence ?? [], ...(value?.units ?? []).flatMap((unit) => unit.evidence.map(ref => `${memorySourceKey(ref.root, ref.path)}\0${ref.sha256}`))]),
+        execution: input.execution, executionSha256: input.execution.sha256,
+        ...(preflight ? { preflight: { result: preflight.result, input_sha256: preflight.input_sha256,
+                semantic_scope: preflightValue.details.semantic_scope } } : {}) };
+    const authority = hybridDigest({ projectId: input.projectId, runId: input.runId, stage: input.stage,
+        attempt: stage.attempt, input: stage.input_sha256, directory: stage.dir, predecessor: predecessor?.authority_sha256 ?? null,
+        anchor: index.execution_bundle ?? null, execution: input.execution.sha256, preflight: preflight?.authority_sha256 ?? null,
+        accepted: accepted?.authority_sha256 ?? null, settlement: settlement ? hybridDigest(settlement) : null });
+    return { binding, authority, predecessorStage: edges[0]?.from, value, preflightValue, accepted, acceptedValue };
+}
+/** Controller-owned input for result preparation and writer-safe rechecking.
+ * Semantic/check acceptance still belongs to productive stage handlers.
+ */
+export class PreparedMemoryResultBinding {
+    #selection;
+    #binding;
+    #authority;
+    #preservation;
+    #accepted;
+    #registration = null;
+    constructor(input, selected, preservation) {
+        this.#selection = { ...input };
+        this.#binding = selected.binding;
+        this.#authority = selected.authority;
+        this.#preservation = preservation;
+        this.#accepted = selected.accepted ? Buffer.from(selected.accepted.bytes) : null;
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        if (!(input.flow instanceof ResolvedFlowDescriptor) || !(input.execution instanceof FrozenGenericExecution) || !(input.sources instanceof ObservedMemorySources))
+            refuse();
+        if (input.acceptedReplay !== undefined && typeof input.acceptedReplay !== "boolean")
+            refuse();
+        if (input.bundle)
+            assertPreparedRunBundleAuthority(context, input, input.bundle);
+        const preparedInput = { ...input, matchKeys: input.acceptedReplay && input.bundle
+                ? entityReferenceVariants(input.runId).map(reference => stageLifecycleMatchKey("stage_finish", reference, input.stage, input.execution.snapshot().scope.projectRoot)) : [] };
+        const selected = context.db.readSnapshot(() => select(context, preparedInput));
+        if (selected.acceptedValue) {
+            const schema = JSON.parse(input.flow.stageBlob(input.stage, "result_schema").toString("utf8"));
+            if (!new Ajv2020({ strict: true, strictRequired: false, validateFormats: false }).compile(schema)(selected.acceptedValue))
+                refuse();
+        }
+        if (selected.predecessorStage) {
+            const schema = JSON.parse(input.flow.stageBlob(selected.predecessorStage, "result_schema").toString("utf8"));
+            if (!new Ajv2020({ strict: true, strictRequired: false, validateFormats: false }).compile(schema)(selected.value))
+                refuse();
+        }
+        if (selected.preflightValue) {
+            const schema = JSON.parse(input.flow.stageBlob("preflight", "result_schema").toString("utf8"));
+            if (!new Ajv2020({ strict: true, strictRequired: false, validateFormats: false }).compile(schema)(selected.preflightValue))
+                refuse();
+        }
+        // Productive bound discovery/composition preserve independently accepted source
+        // bytes. Unbound data-only SDK fixtures gain no bootstrap qualification.
+        const preservation = input.bundle && ["discover", "compose"].includes(input.stage) ? PreparedMemoryBaselinePreservation.prepare(context, input.execution) : null;
+        const prepared = new PreparedMemoryResultBinding(preparedInput, selected, preservation);
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    static prepareRegisteredComposition(context, input) {
+        if (input.registrationScope.project_id !== input.projectId || input.registrationScope.run_id !== input.runId
+            || input.bundle.execution.sha256 !== input.execution.sha256 || input.bundle.descriptor.sha256 !== input.flow.sha256)
+            refuse();
+        const observed = captureRegisteredMemoryCompositionSources(context, input.bundle, input.registrationScope);
+        const prepared = this.prepare(context, { ...input, stage: "compose", sources: observed.sources });
+        if (prepared.#binding.inputSha256 !== observed.inputSha256)
+            refuse();
+        prepared.#registration = { scope: structuredClone(input.registrationScope), sha256: observed.registrationSha256 };
+        prepared.#binding = { ...prepared.#binding, sources: new Map([...prepared.#binding.sources, ...observed.historical]) };
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    binding() {
+        return { ...this.#binding, historicalEvidence: new Set(this.#binding.historicalEvidence), predecessors: structuredClone(this.#binding.predecessors), unitIds: structuredClone(this.#binding.unitIds),
+            ...(this.#binding.preflight ? { preflight: structuredClone(this.#binding.preflight) } : {}), sources: new Map(this.#binding.sources) };
+    }
+    /** Retained accepted data for handler replay, never caller-supplied bytes. */
+    acceptedBytes() { return this.#accepted ? Buffer.from(this.#accepted) : null; }
+    assertCustody(context) {
+        context.db.readSnapshot(() => {
+            this.#preservation?.assertCustody(context);
+            if (this.#registration && memoryCompositionRegistrationDigest(context, this.#registration.scope) !== this.#registration.sha256)
+                refuse();
+            if (select(context, this.#selection).authority !== this.#authority)
+                refuse();
+        });
+    }
+    revalidate(context) {
+        this.#selection.checks?.revalidate(context);
+        this.#preservation?.revalidate(context);
+        this.#selection.sources.revalidate();
+        if (this.#selection.bundle)
+            assertPreparedRunBundleAuthority(context, this.#selection, this.#selection.bundle);
+        this.assertCustody(context);
+    }
+}

package/dist/services/memory-retained-review-authority.js

@@ -0,0 +1,129 @@
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { RetainedExecutionBundle } from "./execution-bundles.js";
+import { assertPreparedRunBundleSqlAuthority } from "./runs.js";
+import { assertRunMutationAllowed } from "./run-recovery-guard.js";
+import { readMemoryReviewPhase } from "./memory-review-inputs.js";
+import { readRegisteredMemoryReview } from "./memory-review-registration.js";
+import { PreparedDescriptorStageCoordinator } from "./descriptor-stage-coordinator.js";
+import { readDescriptorCoordinatorSession } from "./descriptor-coordinator-session.js";
+import { PreparedMemoryBaselinePreservation } from "./memory-baseline-preservation.js";
+import { PreparedAcceptedMemoryVerification } from "./memory-verification-receipt.js";
+import { PreparedMemoryResultBinding } from "./memory-result-binding.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { readAcceptedStageData } from "./stage-report-renderer.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+function refuse(reason) {
+    throw new AppError("memory_retained_review_invalid", "Retained review lacks independent original-wave authority", 2, { reason, effect: "no_effect" });
+}
+function original(context, scope, bundle) {
+    const phase = readMemoryReviewPhase(context, scope, bundle), registration = readRegisteredMemoryReview(context, phase, 0);
+    const compose = readAcceptedStageData(context, { ...scope, stage: "compose" });
+    const verify = readAcceptedStageData(context, { ...scope, stage: "verify" });
+    const composed = JSON.parse(compose.bytes.toString("utf8")), verified = JSON.parse(verify.bytes.toString("utf8"));
+    const view = registration.view;
+    if (registration.input_sha256 !== hybridDigest(view) || view.wave !== 0 || view.scope.bundle_sha256 !== bundle.sha256
+        || view.scope.execution_sha256 !== bundle.execution.sha256 || view.source_policy !== "review-inputs@1"
+        || compose.data_schema_id !== "dd-flow/mb-init-compose-result@1" || composed.schema_id !== compose.data_schema_id
+        || composed.run_id !== scope.runId || composed.stage !== "compose" || composed.outcome !== "accepted"
+        || composed.input_sha256 !== compose.input_sha256 || hybridDigest(composed.units) !== hybridDigest(view.unit_inventory)
+        || verify.data_schema_id !== "dd-flow/mb-init-verify-result@1" || verified.schema_id !== verify.data_schema_id
+        || verified.run_id !== scope.runId || verified.stage !== "verify" || !["accepted", "needs_repair"].includes(verified.outcome)
+        || verified.input_sha256 !== verify.input_sha256)
+        refuse("changed_original_review_binding");
+    for (const accepted of [compose, verify]) {
+        const refs = view.run_inputs.filter(ref => ref.root === "run" && ref.path === accepted.result.path);
+        if (refs.length !== 1 || refs[0].sha256 !== accepted.result.sha256)
+            refuse("original_predecessor_missing_or_changed");
+    }
+    return { registration, compose, verify,
+        sha256: hybridDigest({ phase, registration, compose: compose.authority_sha256, verify: verify.authority_sha256 }) };
+}
+/** Historical original-wave proof for correction/restart, not current document
+ * admission. Changed MB outputs must be justified separately by registered
+ * repair settlements; this owner never rebases them or grants Work writes.
+ * Original user sources, accepted SQL predecessors, independent verification
+ * executions and their retained result files remain mandatory.
+ */
+export class PreparedRetainedMemoryReviewAuthority {
+    sha256;
+    #scope;
+    #bundle;
+    #registration;
+    #original;
+    #generation;
+    #coordinator;
+    #session;
+    #preservation;
+    #compose;
+    #verify;
+    #observed;
+    constructor(scope, bundle, selected, generation, coordinator, session, preservation, compose, verify, observed) {
+        this.#scope = { ...scope };
+        this.#bundle = bundle;
+        this.#registration = structuredClone(selected.registration);
+        this.#original = selected.sha256;
+        this.#generation = generation;
+        this.#coordinator = coordinator;
+        this.#session = session;
+        this.#preservation = preservation;
+        this.#compose = compose;
+        this.#verify = verify;
+        this.#observed = observed;
+        this.sha256 = hybridDigest({ registration: selected.registration, original: selected.sha256 });
+        Object.freeze(this);
+    }
+    static prepare(context, scope, bundle) {
+        if (!(bundle instanceof RetainedExecutionBundle) || bundle.descriptor.descriptor.id !== "mb-init")
+            refuse("registered_memory_bundle_required");
+        const generation = assertRunMutationAllowed(context, scope.projectId, scope.runId);
+        const selected = context.db.readSnapshot(() => original(context, scope, bundle));
+        const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle), root = run.run_root ?? run.run_dir;
+        const observed = ObservedMemorySources.capture({ run: root }, [selected.compose, selected.verify].map(data => ({ root: "run", path: data.result.path })));
+        const hashes = observed.hashes();
+        if ([selected.compose, selected.verify].some(data => hashes.get(memorySourceKey("run", data.result.path)) !== data.result.sha256))
+            refuse("retained_predecessor_bytes_changed");
+        const coordinator = PreparedDescriptorStageCoordinator.prepare(context, {
+            projectRoot: bundle.execution.snapshot().scope.projectRoot, runId: scope.runId, stage: "review"
+        });
+        coordinator.assertAllocatedCustody(context);
+        const session = readDescriptorCoordinatorSession(context, { scope: { ...scope, stage: "review" }, bundle,
+            workId: selected.registration.scope.parent_work_id }, refuse);
+        const preservation = PreparedMemoryBaselinePreservation.prepare(context, bundle.execution);
+        // Historical accepted compose binding intentionally observes only retained
+        // predecessor files. It does not claim today's repaired documents still
+        // have the original output hashes or rerun current project policy.
+        const compose = PreparedMemoryResultBinding.prepare(context, { ...scope, stage: "compose", flow: bundle.descriptor,
+            execution: bundle.execution, bundle, acceptedReplay: true, sources: observed });
+        if (!compose.acceptedBytes()?.equals(selected.compose.bytes))
+            refuse("accepted_composition_changed");
+        const verify = PreparedAcceptedMemoryVerification.prepare(context, { ...scope, bytes: selected.verify.bytes });
+        const prepared = new PreparedRetainedMemoryReviewAuthority(scope, bundle, selected, generation, coordinator, session, preservation, compose, verify, observed);
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    registration() { return structuredClone(this.#registration); }
+    bundle() { return this.#bundle; }
+    verificationProfileHash(context) {
+        this.assertCustody(context);
+        return this.#verify.profileHash(context);
+    }
+    assertCustody(context) {
+        assertRunMutationAllowed(context, this.#scope.projectId, this.#scope.runId, this.#generation);
+        this.#coordinator.assertAllocatedCustody(context);
+        if (original(context, this.#scope, this.#bundle).sha256 !== this.#original
+            || readDescriptorCoordinatorSession(context, { scope: { ...this.#scope, stage: "review" }, bundle: this.#bundle,
+                workId: this.#registration.scope.parent_work_id }, refuse) !== this.#session)
+            refuse("original_review_authority_changed");
+        this.#preservation.assertCustody(context);
+        this.#compose.assertCustody(context);
+        this.#verify.assertCustody(context);
+    }
+    revalidate(context) {
+        this.#preservation.revalidate(context);
+        this.#compose.revalidate(context);
+        this.#verify.revalidate(context);
+        this.#observed.revalidate();
+        this.assertCustody(context);
+    }
+}

package/dist/services/memory-retained-review-results.js

@@ -0,0 +1,70 @@
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { runtimeHarness } from "./execution-policy.js";
+import { PreparedRetainedMemoryReviewAuthority } from "./memory-retained-review-authority.js";
+import { readMemoryReviewWorkSettlement } from "./memory-review-acceptance.js";
+import { memoryReviewBatch } from "./memory-review-registration.js";
+import { validateMemoryReviewWorkResult } from "./memory-review-work-results.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+function refuse(reason) {
+    throw new AppError("memory_retained_review_results_invalid", "Correction lacks retained independent review results", 2, { reason, effect: "no_effect" });
+}
+/** Independent initial-review findings survive authorized document corrections.
+ * This proves historical results, not current document completeness, permission
+ * to mutate, resolution of a finding, or admission of another reviewer wave.
+ */
+export class PreparedRetainedMemoryReviewResults {
+    sha256;
+    #owner;
+    #workers;
+    #results;
+    #observed;
+    #harness;
+    constructor(owner, workers, results, observed, harness) {
+        this.#owner = owner;
+        this.#workers = workers;
+        this.#results = results;
+        this.#observed = observed;
+        this.#harness = harness;
+        this.sha256 = hybridDigest({ original: owner.sha256, workers: workers.map(worker => ({ work_id: worker.workId,
+                authority: worker.authority, result: worker.result })), results });
+        Object.freeze(this);
+    }
+    static prepare(context, owner) {
+        if (!(owner instanceof PreparedRetainedMemoryReviewAuthority))
+            refuse("prepared_original_review_required");
+        owner.revalidate(context);
+        const registration = owner.registration(), bundle = owner.bundle(), view = registration.view;
+        const batch = memoryReviewBatch(view), harness = runtimeHarness(bundle.execution.work("review").worker);
+        const workers = context.db.readSnapshot(() => batch.works.map(item => readMemoryReviewWorkSettlement(context, registration, registration.work_ids[item.key], harness)));
+        const results = workers.map((worker, index) => validateMemoryReviewWorkResult(worker.bytes, bundle.engine(), {
+            workId: worker.workId, packet: batch.works[index].payload.memory_review, references: view.run_inputs
+        }));
+        const root = context.db.get("SELECT run_root,run_dir FROM runs WHERE project_id=? AND id=?", [view.scope.project_id, view.scope.run_id]);
+        if (!root)
+            refuse("owned_run_missing");
+        const observed = ObservedMemorySources.capture({ run: root.run_root ?? root.run_dir }, workers.map(worker => ({ root: "run", path: worker.result.path })));
+        const hashes = observed.hashes();
+        if (workers.some(worker => hashes.get(memorySourceKey("run", worker.result.path)) !== worker.result.sha256))
+            refuse("retained_review_result_changed");
+        const prepared = new PreparedRetainedMemoryReviewResults(owner, workers, results, observed, harness);
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    original() { return this.#owner; }
+    results() { return structuredClone(this.#results); }
+    references() {
+        return this.#workers.map(worker => ({ reviewer_work_id: worker.workId,
+            input_sha256: this.#owner.registration().input_sha256, result: { ...worker.result },
+            unit_ids: [this.#results.find(result => result.work_id === worker.workId).unit_id] }));
+    }
+    assertCustody(context) {
+        this.#owner.assertCustody(context);
+        const registration = this.#owner.registration();
+        for (const worker of this.#workers)
+            if (readMemoryReviewWorkSettlement(context, registration, worker.workId, this.#harness).authority !== worker.authority)
+                refuse("retained_review_settlement_changed");
+    }
+    revalidate(context) { this.#owner.revalidate(context); this.#observed.revalidate(); this.assertCustody(context); }
+}

package/dist/services/memory-retained-second-baseline.js

@@ -0,0 +1,102 @@
+import { AppError } from "../shared/errors.js";
+import { RetainedExecutionBundle } from "./execution-bundles.js";
+import { PreparedRetainedSecondMemoryRepairs } from "./memory-retained-second-repairs.js";
+import { readWorkBatchCustody } from "./work-registry.js";
+import { assertRunMutationAllowed } from "./run-recovery-guard.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedMemoryRepairCurrentView } from "./memory-repair-current-view.js";
+const token = Symbol("retained-second-memory-baseline");
+function refuse(reason) {
+    throw new AppError("memory_retained_second_baseline_invalid", "Second baseline lacks independent original receipt and settled source custody", 2, { reason, effect: "no_effect" });
+}
+function selected(context, scope, workId) {
+    const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='memory.repair_work_baseline' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? LIMIT 2", [scope.project_id, scope.run_id, workId]);
+    if (!rows.length)
+        refuse("registered_baseline_required");
+    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 24 * 1024 * 1024)
+        refuse("ambiguous_or_unbounded_baseline");
+    try {
+        return JSON.parse(rows[0].payload_json);
+    }
+    catch {
+        return refuse("invalid_baseline");
+    }
+}
+/** Retained initial or registered post-peer second baseline, not start authority.
+ * No obsolete workspace/private bytes are inspected or recaptured. */
+export class PreparedRetainedSecondMemoryBaseline {
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #registration in value;
+    }
+    #registration;
+    #receipt;
+    #baseline;
+    #exported;
+    #current;
+    constructor(key, registration, receipt, baseline, exported, current = null) {
+        if (key !== token)
+            refuse("retained_baseline_token_required");
+        this.#registration = registration;
+        this.#receipt = structuredClone(receipt);
+        this.#baseline = baseline;
+        this.#exported = exported;
+        this.#current = current;
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        if (!PreparedRetainedSecondMemoryRepairs.isPrepared(input.registration))
+            refuse("retained_second_registration_required");
+        if (!(input.bundle instanceof RetainedExecutionBundle) || input.bundle.descriptor.descriptor.id !== "mb-init")
+            refuse("registered_memory_bundle_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        const registration = input.registration, owner = registration.receipt(), scope = owner.scope;
+        registration.revalidate(context);
+        if (scope.bundle_sha256 !== input.bundle.sha256 || scope.execution_sha256 !== input.bundle.execution.sha256)
+            refuse("foreign_bundle");
+        const assigned = registration.batch().works.find(item => owner.work_ids[item.key] === input.workId);
+        if (!assigned)
+            refuse("foreign_second_work");
+        const receipt = selected(context, scope, input.workId), generation = assertRunMutationAllowed(context, scope.project_id, scope.run_id);
+        const current = receipt.schema_id === "dd-flow/memory-repair-work-baseline@5"
+            ? PreparedMemoryRepairCurrentView.restore(context, registration, input.workId) : null;
+        if (assigned.depends_on.length && !current)
+            refuse("settled_second_dependency_view_required");
+        const baseline = current ? current.baseline() : registration.initialDocumentBaseline().withWritePaths(assigned.payload.memory_repair.write_paths);
+        const files = new Set(baseline.entries().filter(entry => entry.kind === "file").map(entry => entry.path));
+        const selectedFiles = registration.initialInputView().run_inputs.filter(ref => ref.root === "workspace" && ref.path.startsWith(".memory-bank/") && files.has(ref.path)).map(ref => ref.path);
+        const exported = current ? current.exportedBaseline() : baseline.exported(selectedFiles);
+        const expected = { schema_id: current ? "dd-flow/memory-repair-work-baseline@5" : "dd-flow/memory-repair-work-baseline@4", wave: 2, project_id: scope.project_id, run_id: scope.run_id,
+            work_id: input.workId, generation, registration_sha256: hybridDigest(owner), allocation_sha256: hybridDigest(readWorkBatchCustody(context, input.workId)),
+            packet_sha256: assigned.payload.memory_repair.packet_sha256, workspace_root: input.bundle.execution.snapshot().scope.workspace,
+            first_review_input_sha256: owner.first_review_input_sha256, first_check_receipt_sha256: owner.first_check_receipt_sha256,
+            baseline_sha256: baseline.sha256, baseline_base64: baseline.bytes().toString("base64"), export_policy: "memory-repair-export@1",
+            exported_baseline_sha256: exported.sha256, exported_baseline_base64: exported.bytes().toString("base64"),
+            ...(current ? { current_view_sha256: current.sha256, current_view_receipt_sha256: hybridDigest(current.receipt()) } : {}) };
+        if (hybridDigest(receipt) !== hybridDigest(expected))
+            refuse("registered_baseline_changed");
+        const prepared = new PreparedRetainedSecondMemoryBaseline(token, registration, receipt, baseline, exported, current);
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    receipt() { return structuredClone(this.#receipt); }
+    baseline() { return this.#baseline; }
+    exportedBaseline() { return this.#exported; }
+    copyInput() {
+        if (this.#current)
+            return this.#current.copyInput();
+        const view = this.#registration.initialInputView();
+        return { source_sha256: view.source_sha256, base: view.base, explicit_inputs: view.run_inputs.filter(ref => ref.root === "workspace").map(ref => ref.path) };
+    }
+    currentView() { return this.#current?.receipt() ?? null; }
+    assertCustody(context) {
+        this.#registration.assertCustody(context);
+        this.#current?.assertCustody(context);
+        const receipt = this.#receipt;
+        assertRunMutationAllowed(context, receipt.project_id, receipt.run_id, receipt.generation);
+        if (hybridDigest(selected(context, receipt, receipt.work_id)) !== hybridDigest(receipt)
+            || hybridDigest(readWorkBatchCustody(context, receipt.work_id)) !== receipt.allocation_sha256)
+            refuse("retained_baseline_custody_changed");
+    }
+    revalidate(context) { this.#registration.revalidate(context); this.assertCustody(context); }
+}

package/dist/services/memory-retained-second-repairs.js

@@ -0,0 +1,156 @@
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { RetainedExecutionBundle } from "./execution-bundles.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedHistoricalOriginalMemoryReview } from "./memory-historical-original-review.js";
+import { PreparedHistoricalCorrectedMemoryReview } from "./memory-historical-corrected-review.js";
+import { readRetainedCorrectedMemoryReviewRegistration } from "./memory-corrected-review-registration.js";
+import { validateMemoryReviewCorrectionPlan } from "./memory-review-correction-plan.js";
+import { memoryRepairBatch, memoryRepairWorkerSchema } from "./memory-repair-registration.js";
+import { readWorkBatchCustody } from "./work-registry.js";
+const token = Symbol("retained-second-memory-repairs");
+function refuse(reason) {
+    throw new AppError("memory_retained_second_repairs_invalid", "Second repair history lacks independent plan, review and allocation custody", 2, { reason, effect: "no_effect" });
+}
+function selected(context, scope) {
+    const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='memory.second_repair_registration' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.scope.attempt')=? AND json_extract(payload_json,'$.scope.parent_work_id')=? LIMIT 2", [scope.project_id, scope.run_id, scope.attempt, scope.parent_work_id]);
+    if (!rows.length)
+        refuse("registration_missing");
+    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 2 * 1024 * 1024)
+        refuse("ambiguous_or_unbounded_registration");
+    let receipt;
+    try {
+        receipt = JSON.parse(rows[0].payload_json);
+    }
+    catch {
+        return refuse("invalid_registration");
+    }
+    if (!receipt || receipt.schema_id !== "dd-flow/memory-second-repair-registration@1" || receipt.run_id !== scope.run_id
+        || receipt.wave !== 2 || hybridDigest(receipt.scope) !== hybridDigest(scope)
+        || [receipt.first_review_registration_sha256, receipt.first_review_input_sha256, receipt.first_check_receipt_sha256,
+            receipt.review_sha256, receipt.projection_sha256, receipt.plan_sha256, receipt.batch_sha256].some(hash => typeof hash !== "string" || !/^[a-f0-9]{64}$/.test(hash))
+        || typeof receipt.plan_base64 !== "string")
+        refuse("changed_registration");
+    const bytes = Buffer.from(receipt.plan_base64, "base64");
+    if (!bytes.length || bytes.length > 1024 * 1024 || bytes.toString("base64") !== receipt.plan_base64
+        || createHash("sha256").update(bytes).digest("hex") !== receipt.plan_sha256)
+        refuse("changed_plan_bytes");
+    return receipt;
+}
+function assertAllocation(context, receipt, batch) {
+    const ids = receipt.work_ids, scope = receipt.scope;
+    if (!ids || typeof ids !== "object" || Array.isArray(ids) || Object.keys(ids).length !== batch.works.length
+        || Object.values(ids).some(id => typeof id !== "string" || !id) || new Set(Object.values(ids)).size !== batch.works.length
+        || hybridDigest(batch.works) !== receipt.batch_sha256)
+        refuse("changed_repair_batch");
+    for (const item of batch.works) {
+        const id = ids[item.key];
+        if (!id)
+            refuse("missing_repair_work");
+        const custody = readWorkBatchCustody(context, id);
+        if (custody.item_key !== item.key || custody.batch_sha256 !== receipt.batch_sha256
+            || hybridDigest(custody.work_ids) !== hybridDigest(ids) || hybridDigest(custody.scope) !== hybridDigest({
+            project_id: scope.project_id, run_id: scope.run_id, stage: "review", attempt: scope.attempt, cycle: "",
+            parent_work_id: scope.parent_work_id, request_key: "memory-repair-wave-2"
+        }))
+            refuse("changed_work_custody");
+    }
+}
+/** Retained second graph only. Does not grant current source/write admission,
+ * allocate replacement Works or dispatch providers after receipt loss. */
+export class PreparedRetainedSecondMemoryRepairs {
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #receipt in value;
+    }
+    #history;
+    #receipt;
+    #batch;
+    #plan;
+    #bundle;
+    constructor(key, history, receipt, batch, plan) {
+        if (key !== token)
+            refuse("retained_token_required");
+        this.#history = history;
+        this.#receipt = structuredClone(receipt);
+        this.#batch = structuredClone(batch);
+        this.#plan = structuredClone(plan);
+        this.#bundle = history.bundle();
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        return this.#prepare(context, input, false);
+    }
+    /** Closed-review history only. The original owner pins closed SQL custody;
+     * this never reopens review or grants new writer/launch admission. */
+    static prepareAfterReview(context, input) {
+        return this.#prepare(context, input, true);
+    }
+    static #prepare(context, input, closed) {
+        if (!(input.bundle instanceof RetainedExecutionBundle) || input.bundle.descriptor.descriptor.id !== "mb-init")
+            refuse("registered_memory_bundle_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        const original = closed ? PreparedHistoricalOriginalMemoryReview.prepare(context, input)
+            : PreparedHistoricalOriginalMemoryReview.prepareWhileReviewOpen(context, input);
+        const scope = original.registration().scope;
+        const receipt = context.db.readSnapshot(() => selected(context, scope)), bytes = Buffer.from(receipt.plan_base64, "base64");
+        if (input.expectedBytes !== undefined && (!(input.expectedBytes instanceof Uint8Array) || !bytes.equals(Buffer.from(input.expectedBytes))))
+            refuse("plan_replay_conflict");
+        const first = readRetainedCorrectedMemoryReviewRegistration(context, scope, receipt.first_review_input_sha256, receipt.first_check_receipt_sha256);
+        if (!first || hybridDigest(first) !== receipt.first_review_registration_sha256)
+            refuse("changed_first_registration");
+        const history = PreparedHistoricalCorrectedMemoryReview.prepare(context, { original, correctedInputSha256: first.input_sha256,
+            checkReceiptSha256: first.check_receipt_sha256 });
+        if (history.reviewSha256() !== receipt.review_sha256 || hybridDigest(history.projection()) !== receipt.projection_sha256)
+            refuse("changed_first_review");
+        const view = first.view, assignments = new Map(view.assignments.map(item => [item.unit.id, item.unit]));
+        const plan = validateMemoryReviewCorrectionPlan(bytes, input.bundle.engine(), { runId: scope.run_id, wave: 2,
+            reviewSha256: receipt.review_sha256, units: view.unit_inventory.map(unit => assignments.get(unit.id) ?? unit), findings: history.projection().findings });
+        if (history.projection().outcome === "blocked")
+            refuse("blocked_first_review");
+        for (const item of plan.works)
+            input.bundle.execution.work("review", item.profile_id ?? undefined);
+        if (JSON.parse(input.bundle.engine().schema("memory-repair-work-result").toString("utf8")).$id !== memoryRepairWorkerSchema)
+            refuse("frozen_worker_schema_required");
+        const refs = new Map(view.run_inputs.map(ref => [`${ref.root}:${ref.path}`, ref]));
+        for (const worker of history.settlementProof(context).workers) {
+            const ref = { root: "run", ...worker.result }, key = `run:${ref.path}`, prior = refs.get(key);
+            if (prior && prior.sha256 !== ref.sha256)
+                refuse("conflicting_review_reference");
+            refs.set(key, ref);
+        }
+        const batch = memoryRepairBatch({ scope, plan, planSha256: receipt.plan_sha256, originalRegistrationSha256: hybridDigest(first),
+            references: [...refs.values()], findings: history.projection().findings });
+        const expected = { schema_id: "dd-flow/memory-second-repair-registration@1", run_id: scope.run_id, scope, wave: 2,
+            first_review_registration_sha256: hybridDigest(first), first_review_input_sha256: first.input_sha256,
+            first_check_receipt_sha256: first.check_receipt_sha256, review_sha256: history.reviewSha256(), projection_sha256: hybridDigest(history.projection()),
+            plan_sha256: receipt.plan_sha256, plan_base64: bytes.toString("base64"), batch_sha256: hybridDigest(batch.works), work_ids: receipt.work_ids };
+        if (hybridDigest(expected) !== hybridDigest(receipt))
+            refuse("changed_registration");
+        const prepared = new PreparedRetainedSecondMemoryRepairs(token, history, receipt, batch, plan);
+        prepared.revalidate(context);
+        return prepared;
+    }
+    receipt() { return structuredClone(this.#receipt); }
+    get sha256() { return hybridDigest(this.#receipt); }
+    bundle() { return this.#bundle; }
+    batch() { return structuredClone(this.#batch); }
+    plan() { return structuredClone(this.#plan); }
+    /** The first wave's actual settled baseline, with only this registered
+     * second plan's admitted write paths. No current bytes are adopted here. */
+    initialDocumentBaseline() {
+        const paths = [...new Set(this.#batch.works.flatMap(item => item.payload.memory_repair.write_paths))].sort();
+        return this.#history.settledDocumentBaseline().withWritePaths(paths);
+    }
+    initialInputView() { return this.#history.retainedInputView(); }
+    firstReviewProof(context) { this.assertCustody(context); return this.#history.settlementProof(context); }
+    firstEffectiveReviewProof(context) { this.assertCustody(context); return this.#history.effectiveReviewProof(context); }
+    verificationProfileHash(context) { this.assertCustody(context); return this.#history.verificationProfileHash(context); }
+    assertCustody(context) {
+        this.#history.assertCustody(context);
+        if (hybridDigest(selected(context, this.#receipt.scope)) !== hybridDigest(this.#receipt))
+            refuse("registration_changed");
+        assertAllocation(context, this.#receipt, this.#batch);
+    }
+    revalidate(context) { this.#history.revalidate(context); this.assertCustody(context); }
+}