@deksden-com/dd-flow-cli 0.9.0-beta.16 → 0.9.0-beta.161

package/dist/services/memory-repair-publication-source.js

@@ -0,0 +1,225 @@
+import { AppError } from "../shared/errors.js";
+import { appendAudit } from "./audit.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { selectMemoryRepairGraph } from "./memory-repair-current-view.js";
+import { PreparedSettledMemoryRepair } from "./memory-repair-history.js";
+import { PreparedRegisteredMemoryCorrections } from "./memory-repair-registration.js";
+import { PreparedMemoryRepairWorkBaseline } from "./memory-repair-work-baseline.js";
+import { PreparedBoundMemoryRepairCopy } from "./memory-repair-writer-copy.js";
+const token = Symbol("memory-repair-publication-source"), event = "memory.repair_publication_source";
+const nonMemory = (entry) => entry.path !== ".memory-bank" && !entry.path.startsWith(".memory-bank/");
+function refuse(reason) {
+    throw new AppError("memory_repair_publication_source_invalid", "Publication source lacks independently settled custody", 1, { reason, effect: "no_effect" });
+}
+function retained(context, baseline) {
+    const scope = baseline.receipt();
+    const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type=? AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? AND json_extract(payload_json,'$.generation')=? LIMIT 2", [scope.project_id, event, scope.run_id, scope.work_id, scope.generation]);
+    if (!rows.length)
+        return null;
+    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 40 * 1024 * 1024)
+        refuse("ambiguous_or_unbounded_source_receipt");
+    try {
+        const value = JSON.parse(rows[0].payload_json);
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            refuse("invalid_source_receipt");
+        return value;
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        return refuse("invalid_source_receipt");
+    }
+}
+function assertOwners(context, registration, baseline, copy, workSessionId) {
+    if (!(registration instanceof PreparedRegisteredMemoryCorrections))
+        refuse("registered_corrections_required");
+    if (!PreparedMemoryRepairWorkBaseline.isPrepared(baseline) || !PreparedBoundMemoryRepairCopy.isPrepared(copy))
+        refuse("registered_start_owners_required");
+    if (typeof workSessionId !== "string" || !workSessionId || workSessionId.length > 256)
+        refuse("registered_start_session_required");
+    registration.assertCustody(context);
+    baseline.assertRegisteredCustody(context);
+    copy.assertCommittedStartCustody(context, workSessionId);
+    const scope = baseline.receipt(), owner = registration.receipt(), input = copy.input();
+    if (scope.registration_sha256 !== registration.sha256 || scope.project_id !== owner.scope.project_id || scope.run_id !== owner.run_id
+        || scope.workspace_root !== copy.sourceRoot() || input.work_id !== scope.work_id || input.generation !== scope.generation
+        || input.baseline_registration_sha256 !== baseline.sha256)
+        refuse("foreign_start_owners");
+}
+function compose(start, histories, paths) {
+    if (!histories.length)
+        return start;
+    let current = histories[0].before().withWritePaths(paths);
+    const versions = new Set([hybridDigest(current.entries())]);
+    for (const history of histories) {
+        if (!versions.has(hybridDigest(history.before().entries())))
+            refuse("unexplained_peer_input_view");
+        current = current.composeSettledDelta(history.before(), history.after(), history.result().outcome);
+        versions.add(hybridDigest(current.entries()));
+    }
+    if (!versions.has(hybridDigest(start.entries())))
+        refuse("unexplained_writer_start_view");
+    return current;
+}
+/** Running-Work shared before-view. Explicit registration records only source
+ * custody; it neither authorizes a private delta nor applies/settles anything.
+ * Retained restoration does not adopt current shared bytes after partial apply.
+ */
+export class PreparedMemoryRepairPublicationSource {
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #graph in value;
+    }
+    sha256;
+    #registration;
+    #baseline;
+    #copy;
+    #workSessionId;
+    #graph;
+    #histories;
+    #before;
+    #body;
+    #registered = false;
+    constructor(key, registration, baseline, copy, workSessionId, graph, histories, before, startSha256) {
+        if (key !== token)
+            refuse("source_token_required");
+        this.#registration = registration;
+        this.#baseline = baseline;
+        this.#copy = copy;
+        this.#workSessionId = workSessionId;
+        this.#graph = structuredClone(graph);
+        this.#histories = histories;
+        this.#before = before;
+        const scope = baseline.receipt();
+        this.#body = { schema_id: "dd-flow/memory-repair-publication-source@1", project_id: scope.project_id, run_id: scope.run_id,
+            work_id: scope.work_id, generation: scope.generation, work_session_id: workSessionId,
+            registration_sha256: registration.sha256, baseline_registration_sha256: baseline.sha256, start_receipt_sha256: startSha256,
+            copy_input_sha256: hybridDigest(copy.input()), source_root: copy.sourceRoot(), selected: structuredClone(graph),
+            histories: histories.map(history => ({ work_id: history.workId, sha256: history.sha256 })),
+            before_sha256: before.sha256, before_base64: before.bytes().toString("base64") };
+        this.sha256 = hybridDigest(this.#body);
+        Object.freeze(this);
+    }
+    static #observe(context, registration, baseline, copy, workSessionId, states) {
+        assertOwners(context, registration, baseline, copy, workSessionId);
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        const graph = context.db.readSnapshot(() => {
+            assertOwners(context, registration, baseline, copy, workSessionId);
+            const selected = selectMemoryRepairGraph(context, registration, baseline.workId, "running", states);
+            if (selected.generation !== baseline.receipt().generation)
+                refuse("foreign_source_generation");
+            return selected;
+        });
+        const histories = graph.settlements.map(item => PreparedSettledMemoryRepair.prepare(context, registration, item.work_id));
+        const immutableInputs = hybridDigest(copy.workspaceManifest().entries().filter(nonMemory));
+        if (histories.some(history => hybridDigest(history.workspaceManifest().entries().filter(nonMemory)) !== immutableInputs))
+            refuse("peer_non_memory_inputs_changed");
+        const before = compose(baseline.baseline(), histories, graph.target.payload.memory_repair.write_paths);
+        return new PreparedMemoryRepairPublicationSource(token, registration, baseline, copy, workSessionId, graph, histories, before, copy.startReceiptSha256(context, workSessionId));
+    }
+    static prepare(context, registration, baseline, copy, workSessionId) {
+        const prepared = this.#observe(context, registration, baseline, copy, workSessionId);
+        prepared.#assertNoIntent(context);
+        prepared.revalidate(context);
+        return prepared;
+    }
+    static restore(context, registration, baseline, copy, workSessionId) {
+        assertOwners(context, registration, baseline, copy, workSessionId);
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        const value = retained(context, baseline);
+        if (!value)
+            refuse("registered_source_required");
+        const selected = value.selected;
+        if (!selected || !Array.isArray(selected.states))
+            refuse("invalid_source_receipt");
+        const prepared = this.#observe(context, registration, baseline, copy, workSessionId, selected.states);
+        if (hybridDigest(prepared.receipt()) !== hybridDigest(value))
+            refuse("registered_source_changed");
+        prepared.#registered = true;
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    receipt() {
+        const value = { ...structuredClone(this.#body), source_view_sha256: this.sha256 };
+        if (Buffer.byteLength(JSON.stringify(value)) > 40 * 1024 * 1024)
+            refuse("unbounded_source_receipt");
+        return value;
+    }
+    before() { return this.#before; }
+    matches(baseline, copy, workSessionId) {
+        return baseline === this.#baseline && copy === this.#copy && workSessionId === this.#workSessionId;
+    }
+    #assertNoIntent(context) {
+        const scope = this.#baseline.receipt();
+        if (context.db.get("SELECT 1 FROM audit_events WHERE project_id=? AND event_type='memory.repair_publication_intent' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? AND json_extract(payload_json,'$.generation')=? LIMIT 1", [scope.project_id, scope.run_id, scope.work_id, scope.generation]))
+            refuse("source_registration_before_intent_required");
+    }
+    #assertRegisteredOrder(context) {
+        const scope = this.#baseline.receipt();
+        const rows = context.db.all("SELECT id,event_type FROM audit_events WHERE project_id=? AND event_type IN ('memory.repair_work_start','memory.repair_publication_source','memory.repair_publication_intent') AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? AND json_extract(payload_json,'$.generation')=? ORDER BY id LIMIT 4", [scope.project_id, scope.run_id, scope.work_id, scope.generation]);
+        const starts = rows.filter(row => row.event_type === "memory.repair_work_start");
+        const sources = rows.filter(row => row.event_type === event);
+        const intents = rows.filter(row => row.event_type === "memory.repair_publication_intent");
+        if (rows.length > 3 || starts.length !== 1 || sources.length !== 1 || intents.length > 1
+            || starts[0].id >= sources[0].id || intents.some(row => row.id <= sources[0].id)
+            || this.#graph.settlements.some(row => row.id >= sources[0].id))
+            refuse("source_receipt_order_changed");
+    }
+    assertCustody(context) {
+        assertOwners(context, this.#registration, this.#baseline, this.#copy, this.#workSessionId);
+        const selected = selectMemoryRepairGraph(context, this.#registration, this.#baseline.workId, "running", this.#registered ? this.#graph.states : undefined);
+        if (hybridDigest(selected) !== hybridDigest(this.#graph)
+            || this.#copy.startReceiptSha256(context, this.#workSessionId) !== this.#body.start_receipt_sha256)
+            refuse("source_custody_changed");
+        for (const history of this.#histories)
+            history.assertCustody(context);
+        if (this.#registered) {
+            if (hybridDigest(retained(context, this.#baseline)) !== hybridDigest(this.receipt()))
+                refuse("registered_source_changed");
+            this.#assertRegisteredOrder(context);
+        }
+    }
+    assertRegisteredCustody(context) {
+        if (!this.#registered)
+            refuse("registered_source_required");
+        this.assertCustody(context);
+    }
+    revalidate(context) {
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        this.assertCustody(context);
+        this.#copy.verifyPrivateInputs(context, this.#workSessionId);
+        this.#copy.verifyPublicationSourceInputs(context, this.#workSessionId, this.#before);
+        for (const history of this.#histories)
+            history.revalidate(context);
+        this.assertCustody(context);
+    }
+    register(context) {
+        this.revalidate(context);
+        const receipt = this.receipt(), expected = hybridDigest(receipt), scope = this.#baseline.receipt();
+        const result = context.db.writeTransaction(() => {
+            if (!context.db.isOwnedWriteTransaction?.())
+                refuse("owned_source_writer_required");
+            this.assertCustody(context);
+            this.#assertNoIntent(context);
+            const prior = retained(context, this.#baseline);
+            if (prior && hybridDigest(prior) !== expected)
+                refuse("registered_source_changed");
+            if (!prior)
+                appendAudit(context, { projectId: scope.project_id, eventType: event, payload: receipt });
+            if (hybridDigest(retained(context, this.#baseline)) !== expected)
+                refuse("source_readback_failed");
+            this.#assertRegisteredOrder(context);
+            return { work_id: scope.work_id, source_view_sha256: this.sha256, receipt_sha256: expected, replayed: Boolean(prior) };
+        });
+        this.#registered = true;
+        try {
+            this.revalidate(context);
+        }
+        catch (error) {
+            throw new AppError("memory_repair_publication_source_pending", "Source view committed but custody changed before publication", 1, { effect: "committed", source_view_sha256: this.sha256, cause: error instanceof Error ? error.message : String(error) });
+        }
+        return result;
+    }
+}