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

package/dist/services/memory-work-result-preparation.js

@@ -0,0 +1,64 @@
+import { AppError } from "../shared/errors.js";
+import { readFlowRunExecutionBundle } from "./runs.js";
+import { readWorkBatchCustody } from "./work-registry.js";
+import { selectMemoryCompositionRegistration } from "./memory-composition-registration.js";
+import { PreparedRegisteredMemoryCompositionWorkResult } from "./memory-composition-work-custody.js";
+import { PreparedRegisteredMemoryReviewWorkResult } from "./memory-review-work-custody.js";
+import { PreparedPublishedMemoryRepairWorkResult } from "./memory-repair-work-custody.js";
+import { restoreMemoryRepairPublicationFromStage, prepareMemorySecondRepairPublicationFromStage } from "./memory-review-handler.js";
+/** Public Work finish selects authority from SQL and the retained bundle, not
+ * from worker JSON, mutable schemas, caller profile or a supplied request key.
+ * Preparation is read-only and occurs before the settlement writer.
+ */
+export function prepareRegisteredMemoryWorkResult(context, work, result, progress) {
+    if (!["dd-flow/memory-composition-work-result@1", "dd-flow/memory-review-work-result@1", "dd-flow/memory-repair-work-result@1"].includes(work.result_schema ?? ""))
+        return null;
+    const bytes = Buffer.from(result, "utf8");
+    if (work.result_schema === "dd-flow/memory-repair-work-result@1") {
+        if (!bytes.length || bytes.length > 1024 * 1024)
+            throw new AppError("memory_work_result_preparation_required", "Repair finish requires bounded published result bytes", 1, { effect: "no_effect" });
+        const run = context.db.get("SELECT project_root FROM runs WHERE project_id=? AND id=?", [work.project_id, work.run_id]);
+        const link = context.db.get("SELECT id,start_receipt_json FROM work_sessions WHERE work_id=? AND status='running'", [work.work_id]);
+        let wave, workspaceRoot;
+        try {
+            const payload = JSON.parse(work.payload_json ?? "null");
+            if (payload?.kind !== "memory-repair" || payload.read_only !== false)
+                throw new Error("Invalid repair payload");
+            wave = payload.memory_repair?.wave;
+            if (!link?.start_receipt_json || Buffer.byteLength(link.start_receipt_json) > 32 * 1024 * 1024)
+                throw new Error("Missing bounded start receipt");
+            const receipt = JSON.parse(link.start_receipt_json);
+            if (typeof receipt.context !== "string" || Buffer.byteLength(receipt.context) > 16 * 1024 * 1024)
+                throw new Error("Missing bounded context");
+            workspaceRoot = JSON.parse(receipt.context).workspace_root;
+        }
+        catch {
+            throw new AppError("memory_work_result_preparation_required", "Repair finish requires retained physical start scope", 1, { effect: "no_effect" });
+        }
+        if (!run || !link || wave !== 1 && wave !== 2 || typeof workspaceRoot !== "string" || !workspaceRoot)
+            throw new AppError("memory_work_result_preparation_required", "Repair finish requires its exact wave and WorkSession", 1, { effect: "no_effect" });
+        const input = { projectRoot: run.project_root, runId: work.run_id, workId: work.work_id, workSessionId: link.id, workspaceRoot };
+        const publication = wave === 1 ? restoreMemoryRepairPublicationFromStage(context, input) : prepareMemorySecondRepairPublicationFromStage(context, input);
+        if (!publication.bytes().equals(bytes))
+            throw new AppError("memory_work_result_preparation_required", "Submitted repair bytes differ from the retained publication", 1, { effect: "no_effect" });
+        return PreparedPublishedMemoryRepairWorkResult.prepare(context, publication);
+    }
+    if (work.result_schema === "dd-flow/memory-review-work-result@1") {
+        return PreparedRegisteredMemoryReviewWorkResult.prepare(context, { workId: work.work_id, bytes, ...(progress ? { progress } : {}) });
+    }
+    const run = context.db.get("SELECT project_root FROM runs WHERE project_id=? AND id=?", [work.project_id, work.run_id]);
+    const bundle = run && readFlowRunExecutionBundle(context, { projectRoot: run.project_root, runId: work.run_id });
+    if (!bundle || !["mb-init", "mb-upgrade"].includes(bundle.descriptor.descriptor.id))
+        throw new AppError("memory_work_result_preparation_required", "Composition finish requires its retained memory flow", 1, { effect: "no_effect" });
+    const stage = bundle.descriptor.descriptor.id === "mb-init" ? "compose" : "upgrade";
+    const custody = readWorkBatchCustody(context, work.work_id);
+    const registration = selectMemoryCompositionRegistration(context, {
+        project_id: work.project_id, run_id: work.run_id, stage, attempt: custody.scope.attempt,
+        cycle: custody.scope.cycle, parent_work_id: custody.scope.parent_work_id
+    });
+    return PreparedRegisteredMemoryCompositionWorkResult.prepareFromStageCustody(context, bytes, bundle.engine(), {
+        projectId: work.project_id, runId: work.run_id, workId: work.work_id,
+        coordinatorWorkId: registration.scope.parent_work_id, requestKey: registration.scope.request_key,
+        flow: bundle.descriptor, execution: bundle.execution, bundle
+    });
+}