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

package/dist/services/memory-composition-registration.js

@@ -0,0 +1,146 @@
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { appendAudit } from "./audit.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedMemoryStageResult } from "./memory-stage-results.js";
+import { stageGraphScope } from "./stage-work-graph.js";
+import { addWorkBatch, prepareWorkBatch, readWorkBatchCustody } from "./work-registry.js";
+const workerSchema = "dd-flow/memory-composition-work-result@1";
+function refuse(reason) {
+    throw new AppError("memory_composition_registration_invalid", "Retained composition registration cannot authorize this graph", 1, { reason, effect: "no_effect" });
+}
+const bytesHash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function readReceipt(context, scope) {
+    const requestSha256 = hybridDigest(scope);
+    const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id = ? AND event_type = 'memory.composition_registration' AND json_extract(payload_json, '$.request_sha256') = ?", [scope.project_id, requestSha256]);
+    if (!rows.length)
+        return null;
+    try {
+        if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 2 * 1024 * 1024)
+            refuse("ambiguous_or_unbounded_receipt");
+        const receipt = JSON.parse(rows[0].payload_json);
+        if (receipt.schema_id !== "dd-flow/memory-composition-registration@1" || receipt.request_sha256 !== requestSha256
+            || receipt.run_id !== scope.run_id || hybridDigest(receipt.scope) !== requestSha256 || receipt.result_schema !== workerSchema
+            || [receipt.batch_sha256, receipt.compose_result_sha256, receipt.input_sha256, receipt.execution_sha256].some(hash => typeof hash !== "string" || !/^[a-f0-9]{64}$/.test(hash))
+            || typeof receipt.result_base64 !== "string" || !receipt.work_ids || Array.isArray(receipt.work_ids)
+            || typeof receipt.work_ids !== "object" || !Object.keys(receipt.work_ids).length || Object.keys(receipt.work_ids).length > 4096
+            || Object.values(receipt.work_ids).some(id => typeof id !== "string")
+            || new Set(Object.values(receipt.work_ids)).size !== Object.keys(receipt.work_ids).length)
+            refuse("foreign_receipt_binding");
+        const bytes = Buffer.from(receipt.result_base64, "base64");
+        if (!bytes.length || bytes.length > 1024 * 1024 || bytes.toString("base64") !== receipt.result_base64
+            || bytesHash(bytes) !== receipt.compose_result_sha256)
+            refuse("changed_result_bytes");
+        for (const [key, id] of Object.entries(receipt.work_ids)) {
+            const custody = readWorkBatchCustody(context, id);
+            if (custody.item_key !== key || custody.request_sha256 !== requestSha256 || custody.batch_sha256 !== receipt.batch_sha256
+                || hybridDigest(custody.work_ids) !== hybridDigest(receipt.work_ids) || hybridDigest(custody.scope) !== requestSha256)
+                refuse("changed_work_custody");
+        }
+        return receipt;
+    }
+    catch (error) {
+        if (error instanceof AppError && error.code === "memory_composition_registration_invalid")
+            throw error;
+        return refuse("invalid_receipt_or_work_custody");
+    }
+}
+/** SQL-only identity check for the settlement writer; no schema or filesystem I/O. */
+export function memoryCompositionRegistrationDigest(context, scope) {
+    const receipt = readReceipt(context, scope);
+    if (!receipt)
+        refuse("composition_receipt_missing");
+    return hybridDigest(receipt);
+}
+/** Independent SQL blueprint bytes, never the final result or mutable file. */
+export function readMemoryCompositionRegistration(context, scope) {
+    const receipt = readReceipt(context, scope);
+    if (!receipt)
+        refuse("composition_receipt_missing");
+    return structuredClone(receipt);
+}
+/** Finish selects the sole original plan for this independently owned stage
+ * attempt; an agent result does not choose a request key or its Work graph.
+ */
+export function selectMemoryCompositionRegistration(context, scope) {
+    const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='memory.composition_registration' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.scope.stage')=? AND json_extract(payload_json,'$.scope.attempt')=? AND json_extract(payload_json,'$.scope.cycle')=? AND json_extract(payload_json,'$.scope.parent_work_id')=? LIMIT 2", [scope.project_id, scope.run_id, scope.stage, scope.attempt, scope.cycle, scope.parent_work_id]);
+    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 2 * 1024 * 1024)
+        refuse("original_composition_missing_or_ambiguous");
+    let retained;
+    try {
+        retained = JSON.parse(rows[0].payload_json);
+    }
+    catch {
+        return refuse("invalid_receipt_or_work_custody");
+    }
+    if (typeof retained?.scope?.request_key !== "string" || hybridDigest(retained.scope) !== hybridDigest({ ...scope, request_key: retained.scope.request_key }))
+        refuse("foreign_receipt_binding");
+    return readMemoryCompositionRegistration(context, { ...scope, request_key: retained.scope.request_key });
+}
+/** Registration custody, not semantic stage acceptance. The caller must first
+ * establish accepted predecessor/source and coordinator/Session authority.
+ * Prepared bytes and Work allocation commit together; no mutable file is read
+ * under the writer. An existing generic batch cannot be retroactively adopted.
+ */
+export function registerMemoryComposition(context, input, assertHandlerCustody) {
+    if (!(input.composition instanceof PreparedMemoryStageResult))
+        refuse("foreign_prepared_result");
+    const value = input.composition.compositionBatch({ ...input.binding, resultSchema: workerSchema });
+    const bytes = input.composition.bytes();
+    const batchInput = { parentWorkId: input.parentWorkId, requestKey: input.requestKey, stage: "compose", value };
+    const prepared = prepareWorkBatch(context, batchInput);
+    return context.db.writeTransaction(() => {
+        assertHandlerCustody?.(context);
+        const parent = context.db.get("SELECT project_id, run_id FROM works WHERE work_id = ?", [input.parentWorkId]);
+        if (!parent || parent.run_id !== input.binding.runId)
+            refuse("foreign_coordinator");
+        const scope = { ...stageGraphScope(context, parent.project_id, parent.run_id, "compose"),
+            stage: "compose", parent_work_id: input.parentWorkId, request_key: input.requestKey };
+        // One immutable blueprint per coordinator/attempt. A different request key
+        // cannot create another productive graph or bypass a lost original receipt.
+        const originals = context.db.all("SELECT json_extract(payload_json,'$.request_sha256') AS request_sha256 FROM audit_events WHERE project_id=? AND event_type='memory.composition_registration' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.scope.stage')='compose' AND json_extract(payload_json,'$.scope.attempt')=? AND json_extract(payload_json,'$.scope.cycle')=? AND json_extract(payload_json,'$.scope.parent_work_id')=? LIMIT 2", [scope.project_id, scope.run_id, scope.attempt, scope.cycle, scope.parent_work_id]);
+        if (originals.length > 1 || originals.length === 1 && originals[0].request_sha256 !== hybridDigest(scope))
+            refuse("original_composition_already_registered");
+        const prior = readReceipt(context, scope);
+        if (!prior && context.db.get("SELECT 1 FROM works w JOIN stage_work_memberships m ON m.work_id=w.work_id AND m.project_id=w.project_id AND m.run_id=w.run_id WHERE w.project_id=? AND w.run_id=? AND w.parent_work_id=? AND w.result_schema=? AND m.stage='compose' AND m.attempt=? AND m.cycle=? LIMIT 1", [scope.project_id, scope.run_id, scope.parent_work_id, workerSchema, scope.attempt, scope.cycle]))
+            refuse("composition_receipt_missing");
+        if (prior && (prior.compose_result_sha256 !== input.composition.sha256 || prior.batch_sha256 !== hybridDigest(value.works)
+            || prior.input_sha256 !== input.binding.inputSha256 || prior.execution_sha256 !== input.binding.executionSha256))
+            refuse("request_conflict");
+        const allocation = addWorkBatch(context, { ...batchInput, prepared });
+        const workIds = allocation.work_ids;
+        if (prior) {
+            if (hybridDigest(prior.work_ids) !== hybridDigest(workIds))
+                refuse("changed_allocation");
+        }
+        else {
+            if (allocation.replayed)
+                refuse("composition_receipt_missing");
+            const receipt = { schema_id: "dd-flow/memory-composition-registration@1", scope, run_id: parent.run_id,
+                request_sha256: hybridDigest(scope), batch_sha256: hybridDigest(value.works), compose_result_sha256: input.composition.sha256,
+                result_base64: bytes.toString("base64"), input_sha256: input.binding.inputSha256,
+                execution_sha256: input.binding.executionSha256, result_schema: workerSchema, work_ids: workIds };
+            appendAudit(context, { projectId: parent.project_id, eventType: "memory.composition_registration", payload: { ...receipt } });
+        }
+        return { scope, compose_result_sha256: input.composition.sha256, work_ids: { ...workIds }, replayed: Boolean(prior) };
+    });
+}
+/** Restore the exact registered bytes and re-prepare with independently selected
+ * frozen schema/execution and predecessor/source observations. No file or settings
+ * fallback; restored registration does not attest completed Works or stage acceptance.
+ */
+export function readRegisteredMemoryComposition(context, input) {
+    const receipt = readReceipt(context, input.scope);
+    if (!receipt)
+        refuse("composition_receipt_missing");
+    if (input.binding.runId !== input.scope.run_id || input.binding.stage !== "compose"
+        || input.binding.inputSha256 !== receipt.input_sha256 || input.binding.executionSha256 !== receipt.execution_sha256)
+        refuse("foreign_restore_binding");
+    const result = PreparedMemoryStageResult.prepare(Buffer.from(receipt.result_base64, "base64"), input.flow, input.binding);
+    const batch = result.compositionBatch({ runId: input.binding.runId, inputSha256: receipt.input_sha256,
+        executionSha256: receipt.execution_sha256, resultSchema: workerSchema });
+    if (result.sha256 !== receipt.compose_result_sha256 || hybridDigest(batch.works) !== receipt.batch_sha256
+        || batch.works.length !== Object.keys(receipt.work_ids).length || batch.works.some(item => !Object.hasOwn(receipt.work_ids, item.key)))
+        refuse("changed_registered_graph");
+    return result;
+}

package/dist/services/memory-composition-work-custody.js

@@ -0,0 +1,151 @@
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedMemoryCompositionWorkResult } from "./memory-composition-work-results.js";
+import { PreparedMemoryStageResult } from "./memory-stage-results.js";
+import { readRegisteredMemoryComposition, memoryCompositionRegistrationDigest } from "./memory-composition-registration.js";
+import { readWorkBatchCustody } from "./work-registry.js";
+import { stageWorkIds } from "./stage-work-graph.js";
+import { assertRunBundleSqlAuthority } from "./runs.js";
+import { PreparedMemoryResultBinding } from "./memory-result-binding.js";
+import { appendAudit } from "./audit.js";
+import { runtimeHarness } from "./execution-policy.js";
+function refuse() {
+    throw new AppError("memory_composition_work_custody_invalid", "Registered Work differs from the independently selected composition", 1, { phase: "prepare", effect: "no_effect" });
+}
+function assignedRoots(context, custody) {
+    const run = context.db.get("SELECT workspace_root, run_root, run_dir FROM runs WHERE project_id = ? AND id = ?", [custody.scope.project_id, custody.scope.run_id]);
+    if (!run || !path.isAbsolute(run.workspace_root) || !path.isAbsolute(run.run_root ?? run.run_dir))
+        refuse();
+    return { workspace: run.workspace_root, run: run.run_root ?? run.run_dir };
+}
+/** Bridges independent SQL allocation custody and physical output preparation.
+ * The caller must independently select the accepted composition and frozen engine.
+ * This is not stage acceptance, Session settlement, or semantic completeness.
+ */
+export class PreparedRegisteredMemoryCompositionWorkResult {
+    sha256;
+    workId;
+    #custody;
+    #result;
+    #roots;
+    #registration = null;
+    #stageBinding = null;
+    #harness;
+    constructor(custody, roots, result, harness) {
+        this.#custody = custody;
+        this.#roots = roots;
+        this.#result = result;
+        this.#harness = harness;
+        this.sha256 = result.sha256;
+        this.workId = custody.work_id;
+        Object.freeze(this);
+    }
+    /** Restart path: composition bytes come from CLI registration, while its
+     * predecessor/source/schema/execution binding still comes from the controller.
+     */
+    static prepareFromStageCustody(context, input, engine, binding) {
+        const custody = readWorkBatchCustody(context, binding.workId);
+        const selected = binding.bundle ? PreparedMemoryResultBinding.prepareRegisteredComposition(context, { ...binding, bundle: binding.bundle,
+            registrationScope: { project_id: binding.projectId, run_id: binding.runId, stage: "compose", attempt: custody.scope.attempt, cycle: custody.scope.cycle,
+                parent_work_id: binding.coordinatorWorkId, request_key: binding.requestKey } })
+            : binding.sources ? PreparedMemoryResultBinding.prepare(context, { ...binding, sources: binding.sources, stage: "compose" }) : refuse();
+        const prepared = this.prepareFromRegistration(context, input, engine, { ...binding, resultBinding: selected.binding() });
+        prepared.#stageBinding = selected;
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    static prepareFromRegistration(context, input, engine, binding) {
+        const custody = readWorkBatchCustody(context, binding.workId);
+        if (custody.scope.stage !== "compose" || custody.scope.parent_work_id !== binding.coordinatorWorkId
+            || custody.scope.request_key !== binding.requestKey || !binding.resultBinding.executionSha256)
+            refuse();
+        const scope = { project_id: custody.scope.project_id, run_id: custody.scope.run_id,
+            stage: "compose", attempt: custody.scope.attempt, cycle: custody.scope.cycle,
+            parent_work_id: binding.coordinatorWorkId, request_key: binding.requestKey };
+        const registrationSha256 = memoryCompositionRegistrationDigest(context, scope);
+        const composition = readRegisteredMemoryComposition(context, { scope, flow: binding.flow, binding: binding.resultBinding });
+        const prepared = this.prepare(context, input, engine, { workId: binding.workId, coordinatorWorkId: binding.coordinatorWorkId, requestKey: binding.requestKey,
+            composition, compositionSha256: composition.sha256, runId: binding.resultBinding.runId,
+            inputSha256: binding.resultBinding.inputSha256, executionSha256: binding.resultBinding.executionSha256 });
+        prepared.#registration = { scope, sha256: registrationSha256 };
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    static prepare(context, input, engine, binding) {
+        const custody = readWorkBatchCustody(context, binding.workId);
+        if (!(binding.composition instanceof PreparedMemoryStageResult) || binding.composition.sha256 !== binding.compositionSha256
+            || custody.scope.run_id !== binding.runId || custody.scope.stage !== "compose"
+            || custody.scope.parent_work_id !== binding.coordinatorWorkId || custody.scope.request_key !== binding.requestKey)
+            refuse();
+        const batch = binding.composition.compositionBatch({ ...binding, resultSchema: "dd-flow/memory-composition-work-result@1" });
+        if (hybridDigest(batch.works) !== custody.batch_sha256 || batch.works.length !== Object.keys(custody.work_ids).length
+            || batch.works.some(item => !Object.hasOwn(custody.work_ids, item.key)))
+            refuse();
+        const assigned = batch.works.find(item => item.key === custody.item_key);
+        const row = context.db.get("SELECT * FROM works WHERE project_id = ? AND run_id = ? AND work_id = ?", [custody.scope.project_id, binding.runId, binding.workId]);
+        if (!assigned || !row || row.parent_work_id !== binding.coordinatorWorkId || row.task !== assigned.task
+            || row.launch_policy !== assigned.launch_policy || row.result_schema !== assigned.result_schema
+            || hybridDigest(JSON.parse(row.depends_on_json)) !== hybridDigest(assigned.depends_on.map(key => custody.work_ids[key]))
+            || hybridDigest(JSON.parse(row.payload_json)) !== hybridDigest({ ...assigned.payload, _dd_flow_batch_request: {
+                    request_sha256: custody.request_sha256, batch_sha256: custody.batch_sha256, item_key: custody.item_key
+                } }))
+            refuse();
+        const roots = assignedRoots(context, custody);
+        const result = PreparedMemoryCompositionWorkResult.prepare(input, engine, { ...binding, workKey: custody.item_key,
+            roots });
+        const route = binding.composition.compositionRoutes().find(item => item.key === custody.item_key);
+        if (!route)
+            refuse();
+        return new PreparedRegisteredMemoryCompositionWorkResult(custody, roots, result, runtimeHarness(route.execution.worker));
+    }
+    bytes() { return this.#result.bytes(); }
+    /** Physical I/O stays outside the writer; the reservation rechecks SQL only. */
+    revalidate(context) { this.#stageBinding?.revalidate(context); this.assertCustody(context); this.#result.revalidate(); }
+    assertCustody(context) {
+        if (hybridDigest(readWorkBatchCustody(context, this.#custody.work_id)) !== hybridDigest(this.#custody)
+            || hybridDigest(assignedRoots(context, this.#custody)) !== hybridDigest(this.#roots))
+            refuse();
+        if (this.#registration && memoryCompositionRegistrationDigest(context, this.#registration.scope) !== this.#registration.sha256)
+            refuse();
+        this.#stageBinding?.assertCustody(context);
+    }
+    /** Active settlement authority is separate from immutable allocation custody. */
+    assertSettlementScope(context, sessionId, workSessionId) {
+        this.assertCustody(context);
+        const scope = this.#custody.scope;
+        const run = context.db.get("SELECT index_json FROM runs WHERE project_id = ? AND id = ?", [scope.project_id, scope.run_id]);
+        const index = run ? JSON.parse(run.index_json) : null;
+        assertRunBundleSqlAuthority(context, { projectId: scope.project_id, runId: scope.run_id }, index?.execution_bundle);
+        const stage = index?.stage_runs?.findLast((item) => item.stage === "compose" && item.status === "running");
+        if (!this.#registration || !this.#stageBinding || index?.current_stage !== "compose" || !stage || (stage.attempt ?? "try-001") !== scope.attempt
+            || !stageWorkIds(context, scope.project_id, scope.run_id, "compose").has(this.workId)
+            || !stageWorkIds(context, scope.project_id, scope.run_id, "compose").has(scope.parent_work_id)
+            || !context.db.get("SELECT 1 FROM work_sessions WHERE id = ? AND work_id = ? AND session_id = ? AND status = 'running'", [workSessionId, this.workId, sessionId])
+            || !context.db.get("SELECT 1 FROM works WHERE work_id = ? AND project_id = ? AND run_id = ? AND status = 'running'", [scope.parent_work_id, scope.project_id, scope.run_id])
+            || !context.db.get("SELECT 1 FROM sessions s JOIN runs r ON r.project_id = s.project_id AND r.id = s.run_id WHERE s.project_id = ? AND s.session_id = ? AND s.run_id = ? AND s.worker_id = ? AND s.harness = ? AND s.status = 'active' AND s.current_stage = 'work' AND s.project_root = r.project_root AND s.workspace_path = r.workspace_root", [scope.project_id, sessionId, scope.run_id, this.workId, this.#harness])) {
+            throw new AppError("memory_work_settlement_scope_invalid", "Composition Work settlement no longer belongs to its active stage and Session", 1, { work_id: this.workId, effect: "no_effect" });
+        }
+    }
+    /** Called inside the Work settlement writer, before its status CAS. The
+     * receipt commits or rolls back with the result and physical WorkSession.
+     * It retains successful output preparation without requiring an obsolete
+     * writer artifact to survive a declared dependent assembly unchanged.
+     */
+    recordSettlement(context, sessionId, workSessionId) {
+        this.assertSettlementScope(context, sessionId, workSessionId);
+        const registration = this.#registration;
+        const rows = context.db.all("SELECT 1 FROM audit_events WHERE project_id=? AND event_type='memory.composition_work_settlement' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? LIMIT 1", [this.#custody.scope.project_id, this.#custody.scope.run_id, this.workId]);
+        if (rows.length)
+            refuse();
+        const session = context.db.get("SELECT provider_session_id FROM sessions WHERE project_id=? AND session_id=?", [this.#custody.scope.project_id, sessionId]);
+        if (!session || typeof session.provider_session_id !== "string" || !session.provider_session_id)
+            refuse();
+        appendAudit(context, { projectId: this.#custody.scope.project_id, eventType: "memory.composition_work_settlement", payload: {
+                schema_id: "dd-flow/memory-composition-work-settlement@1", run_id: this.#custody.scope.run_id, work_id: this.workId,
+                work_session_id: workSessionId, session_id: sessionId, harness: this.#harness, provider_session_id: session.provider_session_id,
+                scope: registration.scope, registration_sha256: registration.sha256,
+                allocation_sha256: hybridDigest(this.#custody), roots: this.#roots, result_sha256: this.sha256
+            } });
+    }
+}

package/dist/services/memory-composition-work-results.js

@@ -0,0 +1,96 @@
+import { createHash } from "node:crypto";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { AppError } from "../shared/errors.js";
+import { AdmittedFrozenEngine } from "./frozen-engine.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedMemoryStageResult, memorySourceKey } from "./memory-stage-results.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memoryCompositionOutputAllowed } from "./memory-composition-graph.js";
+const schemaId = "dd-flow/memory-composition-work-result@1";
+function refuse(reason) {
+    throw new AppError("memory_composition_work_result_invalid", "Composition Work result lacks assigned output proof", 2, { reason, phase: "prepare", effect: "no_effect" });
+}
+/** Frozen schema/assignment checks only. Retained outputs may have been
+ * overwritten by a declared dependent assembly; this is not current-byte or
+ * settlement authority. The productive Work path also observes physical bytes.
+ */
+export function validateMemoryCompositionWorkResult(input, engine, binding) {
+    try {
+        if (input.byteLength < 1 || input.byteLength > 1024 * 1024 || !binding.workId
+            || !(engine instanceof AdmittedFrozenEngine) || !(binding.composition instanceof PreparedMemoryStageResult)
+            || binding.composition.sha256 !== binding.compositionSha256)
+            refuse("foreign_preparation_binding");
+        const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input));
+        const schema = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(engine.schema("memory-composition-work-result")));
+        if (schema.$id !== schemaId || !new Ajv2020({ strict: true, validateFormats: false }).compile(schema)(value))
+            refuse("invalid_result_schema");
+        const work = binding.composition.compositionBatch({ ...binding, resultSchema: schemaId }).works.find(item => item.key === binding.workKey);
+        if (!work)
+            refuse("unassigned_work_key");
+        const packet = work.payload.memory_composition;
+        if (value.run_id !== binding.runId || value.work_id !== binding.workId || value.packet_sha256 !== packet.packet_sha256)
+            refuse("foreign_result_identity");
+        if (value.outcome !== "accepted")
+            refuse("work_not_accepted");
+        const ids = value.units.map(unit => unit.id);
+        if (new Set(ids).size !== ids.length || ids.length !== packet.unit_ids.length || ids.some(id => !packet.unit_ids.includes(id)))
+            refuse("changed_unit_coverage");
+        const aliases = new Map();
+        for (const unit of value.units) {
+            for (const artifact of unit.artifacts) {
+                const logical = artifact.path;
+                if (logical.includes("\\") || logical.includes("\0") || logical.split("/").some(segment => !segment || segment === "." || segment === ".."))
+                    refuse("unsafe_artifact_path");
+                if (!packet.write_scopes.some(scope => scope.root === artifact.root && (logical === scope.path || logical.startsWith(`${scope.path}/`))))
+                    refuse("artifact_outside_write_scope");
+                if (!memoryCompositionOutputAllowed(logical))
+                    refuse("private_composition_artifact");
+                const alias = memorySourceKey(artifact.root, logical.normalize("NFC").toLowerCase());
+                const identity = hybridDigest({ path: logical, sha256: artifact.sha256 });
+                if (aliases.has(alias) && aliases.get(alias) !== identity)
+                    refuse("conflicting_artifact_reference");
+                aliases.set(alias, identity);
+            }
+        }
+        return value;
+    }
+    catch (error) {
+        if (error instanceof AppError && ["memory_composition_work_result_invalid", "frozen_engine_invalid", "memory_stage_result_invalid"].includes(error.code))
+            throw error;
+        return refuse("invalid_result_or_binding");
+    }
+}
+/** Output-byte preparation only. The handler still owns SQL packet custody,
+ * physical Session settlement, actual write-boundary enforcement and semantic acceptance.
+ */
+export class PreparedMemoryCompositionWorkResult {
+    sha256;
+    #bytes;
+    #observed;
+    constructor(bytes, observed) {
+        this.#bytes = bytes;
+        this.#observed = observed;
+        this.sha256 = createHash("sha256").update(bytes).digest("hex");
+        Object.freeze(this);
+    }
+    static prepare(input, engine, binding) {
+        try {
+            const bytes = Buffer.from(input), value = validateMemoryCompositionWorkResult(bytes, engine, binding);
+            const artifacts = value.units.flatMap(unit => unit.artifacts), selected = new Map();
+            for (const artifact of artifacts) {
+                selected.set(memorySourceKey(artifact.root, artifact.path), { root: artifact.root, path: artifact.path });
+            }
+            const observed = ObservedMemorySources.capture(binding.roots, [...selected.values()]), hashes = observed.hashes();
+            if (artifacts.some(artifact => hashes.get(memorySourceKey(artifact.root, artifact.path)) !== artifact.sha256))
+                refuse("changed_artifact_bytes");
+            return new PreparedMemoryCompositionWorkResult(bytes, observed);
+        }
+        catch (error) {
+            if (error instanceof AppError && ["memory_composition_work_result_invalid", "frozen_engine_invalid", "memory_source_observation_failed", "memory_stage_result_invalid"].includes(error.code))
+                throw error;
+            return refuse("invalid_result_or_binding");
+        }
+    }
+    bytes() { return Buffer.from(this.#bytes); }
+    revalidate() { this.#observed.revalidate(); }
+}

package/dist/services/memory-corrected-review-acceptance.js

@@ -0,0 +1,129 @@
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { runtimeHarness } from "./execution-policy.js";
+import { PreparedRegisteredCorrectedMemoryReview } from "./memory-corrected-review-registration.js";
+import { PreparedCorrectedMemoryReviewInputs } from "./memory-corrected-review-inputs.js";
+import { readMemoryReviewWorkSettlement } from "./memory-review-acceptance.js";
+import { validateMemoryReviewWorkResult } from "./memory-review-work-results.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+import { correctedMemoryReviewFindings } from "./memory-corrected-review-findings.js";
+import { correctedMemoryReviewUnits } from "./memory-corrected-review-projection.js";
+import { PreparedMemoryStageResult } from "./memory-stage-results.js";
+const token = Symbol("corrected-memory-review-acceptance");
+function refuse(reason) {
+    throw new AppError("memory_corrected_review_acceptance_invalid", "Selective review lacks independently registered and settled reviewer custody", 2, { reason, effect: "no_effect" });
+}
+/** Selective fan-in only, not finding resolution or Stage acceptance. Every
+ * allocated affected unit needs its own independent published settlement.
+ * Untouched initial reviewers must not be silently replaced or rerun. */
+export class PreparedCorrectedMemoryReviewAcceptance {
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #registration in value;
+    }
+    sha256;
+    #registration;
+    #workers;
+    #results;
+    #harness;
+    #observed;
+    constructor(key, registration, workers, results, harness, observed) {
+        if (key !== token)
+            refuse("acceptance_token_required");
+        this.#registration = registration;
+        this.#workers = workers;
+        this.#results = structuredClone(results);
+        this.#harness = harness;
+        this.#observed = observed;
+        this.sha256 = hybridDigest({ registration_sha256: registration.sha256, workers: workers.map(worker => ({
+                work_id: worker.workId, authority_sha256: worker.authority, result: worker.result
+            })), results });
+        Object.freeze(this);
+    }
+    static prepare(context, registration) {
+        if (!PreparedRegisteredCorrectedMemoryReview.isPrepared(registration))
+            refuse("prepared_corrected_registration_required");
+        if (!PreparedCorrectedMemoryReviewInputs.isPrepared(registration.inputs()))
+            refuse("first_corrected_registration_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        registration.revalidate(context);
+        const receipt = registration.receipt(), view = receipt.view, bundle = registration.inputs().bundle(), batch = registration.batch();
+        if (view.scope.bundle_sha256 !== bundle.sha256 || view.scope.execution_sha256 !== bundle.execution.sha256)
+            refuse("foreign_wave_bundle");
+        const harness = runtimeHarness(bundle.execution.work("review").worker);
+        const workers = context.db.readSnapshot(() => batch.works.map(item => readMemoryReviewWorkSettlement(context, receipt, receipt.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
+        }));
+        assertSelectiveMemoryReviewCoverage(view.affected_unit_ids, results);
+        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("published_review_result_changed");
+        const prepared = new PreparedCorrectedMemoryReviewAcceptance(token, registration, workers, results, harness, observed);
+        prepared.revalidate(context);
+        return prepared;
+    }
+    registration() { return this.#registration; }
+    results() { return structuredClone(this.#results); }
+    findingProjection() {
+        const wave = this.#registration.inputs().completedWave(), original = wave.registration().review();
+        const batch = wave.registration().batch(), receipt = wave.registration().receipt();
+        return correctedMemoryReviewFindings({ original: original.results(), current: this.results(),
+            diagnostics: original.original().registration().view.diagnostic_findings,
+            diagnosticReference: original.original().registration().view.run_inputs.find(ref => ref.root === "run" && ref.path === `${original.original().bundle().descriptor.stage("verify").directory}/result.json`),
+            affected: this.#registration.receipt().view.affected_unit_ids, originalReferences: original.references(), currentReferences: this.references(),
+            repairs: wave.repairResults().map(repair => ({ ...repair, unit_ids: batch.works.find(item => receipt.work_ids[item.key] === repair.work_id).payload.memory_repair.unit_ids })) });
+    }
+    resultProjection() {
+        const wave = this.#registration.inputs().completedWave(), original = wave.registration().review();
+        const coverage = correctedMemoryReviewUnits({ view: this.#registration.receipt().view, original: original.results(), current: this.results(),
+            originalReferences: original.references(), currentReferences: this.references(), repairWorkIds: wave.repairResults().map(repair => repair.work_id) });
+        return { ...coverage, ...this.findingProjection() };
+    }
+    assertResult(result) {
+        if (!(result instanceof PreparedMemoryStageResult))
+            refuse("prepared_result_required");
+        const value = result.value(), receipt = this.#registration.receipt(), expected = this.resultProjection();
+        if (value.run_id !== receipt.run_id || value.stage !== "review" || value.input_sha256 !== receipt.scope.input_sha256
+            || hybridDigest({ units: value.units, findings: value.findings, outcome: value.outcome, details: value.details }) !== hybridDigest(expected))
+            refuse("review_claim_differs_from_settled_wave");
+    }
+    references() {
+        return this.#workers.map((worker, index) => ({ reviewer_work_id: worker.workId,
+            input_sha256: this.#registration.receipt().input_sha256, result: { ...worker.result }, unit_ids: [this.#results[index].unit_id] }));
+    }
+    settlementProof(context) {
+        this.assertCustody(context);
+        const receipt = this.#registration.receipt();
+        return { registration_scope: structuredClone(receipt.scope), registration_sha256: this.#registration.sha256, wave: receipt.wave,
+            check_receipt_sha256: receipt.check_receipt_sha256, workers: this.#workers.map(worker => ({
+                work_id: worker.workId, authority_sha256: worker.authority, result: { ...worker.result }
+            })) };
+    }
+    assertCustody(context) {
+        this.#registration.assertCustody(context);
+        const receipt = this.#registration.receipt();
+        for (const worker of this.#workers)
+            if (readMemoryReviewWorkSettlement(context, receipt, worker.workId, this.#harness).authority !== worker.authority)
+                refuse("review_settlement_changed");
+    }
+    revalidate(context) {
+        this.#registration.revalidate(context);
+        this.#observed.revalidate();
+        this.assertCustody(context);
+    }
+}
+/** Metadata completeness check only; this does not prove SQL/Session custody. */
+export function assertSelectiveMemoryReviewCoverage(affected, results) {
+    if (!Array.isArray(affected) || !affected.length || affected.length > 256 || affected.some(id => typeof id !== "string" || !id)
+        || new Set(affected).size !== affected.length || !Array.isArray(results) || results.length !== affected.length
+        || results.some(result => !result || typeof result.unit_id !== "string" || typeof result.work_id !== "string" || !result.work_id
+            || !affected.includes(result.unit_id)) || new Set(results.map(result => result.unit_id)).size !== affected.length
+        || new Set(results.map(result => result.work_id)).size !== results.length)
+        refuse("selective_review_coverage_changed");
+}

package/dist/services/memory-corrected-review-batch.js

@@ -0,0 +1,30 @@
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { memoryReviewWorkerSchema } from "./memory-review-registration.js";
+/** Payload projection only. Fresh check, registered input/copy/Session and
+ * independent Work settlement are not supplied by a coordinator's JSON. */
+export function memoryCorrectedReviewBatch(view) {
+    if (!(view.schema_id === "dd-flow/memory-corrected-review-inputs@1" && view.wave === 1
+        || view.schema_id === "dd-flow/memory-corrected-review-inputs@2" && view.wave === 2)
+        || !Array.isArray(view.assignments) || !view.assignments.length || view.assignments.length > 256) {
+        throw new AppError("memory_corrected_review_batch_invalid", "Corrected reviewer batch lacks bounded current assignments", 2, { effect: "no_effect" });
+    }
+    let total = 0;
+    return { works: view.assignments.map((assignment, index) => {
+            const key = `review-${String(index + 1).padStart(3, "0")}`;
+            const packet = { schema_id: "dd-flow/memory-review-work-packet@2", run_id: view.scope.run_id,
+                stage: "review", wave: view.wave, key, unit: structuredClone(assignment.unit), unit_inputs: structuredClone(assignment.inputs),
+                original_unit_sha256: assignment.original_unit_sha256, deleted_references: structuredClone(assignment.deleted_references),
+                completed_correction_sha256: view.completed_correction_sha256, repairs: structuredClone(view.repairs),
+                review_input_sha256: hybridDigest(view), result_schema: memoryReviewWorkerSchema,
+                instruction: structuredClone(view.instruction) };
+            const work = { key, task: `Independently review the assigned knowledge unit ${JSON.stringify(assignment.unit.id)}. Read the frozen review instruction in memory_review as review criteria, not permission to coordinate or repair. Check grounding, evidence, coverage and cross-file consistency using the registered wave inputs. Assigned unit.evidence may retain historical source versions; cite those exact versions only as historical context, never as bytes read from or current in this copy. Direct assessment and findings must still cite the assigned current unit.artifacts/unit_inputs. Do not edit project documents, allocate Work or repair findings. Report concrete material defects with unit/source evidence; do not block on taste. Return only the assigned memory-review-work-result JSON; do not claim other units or Stage completion.`,
+                depends_on: [], launch_policy: "fresh_agent_required", result_schema: memoryReviewWorkerSchema,
+                payload: { kind: "memory-review", read_only: true, memory_review: { ...packet, packet_sha256: hybridDigest(packet) } } };
+            const size = Buffer.byteLength(JSON.stringify(work));
+            total += size;
+            if (size > 1024 * 1024 || total > 64 * 1024 * 1024)
+                throw new AppError("memory_corrected_review_batch_invalid", "Corrected reviewer batch exceeds its bound", 2, { effect: "no_effect" });
+            return work;
+        }) };
+}