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

package/dist/services/memory-init-request-candidate.js

@@ -0,0 +1,157 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError, errorRecord } from "../shared/errors.js";
+import { publishImmutableInput } from "../storage/immutable-input.js";
+import { assertImportAdmission } from "../storage/import-guard.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { readBoundedReleaseFile } from "./release-source.js";
+import { validateMemoryInitObjective, validateMemoryInitStartupScope } from "./memory-init-startup-custody.js";
+import { prepareMemoryInitRequestInput } from "./memory-init-request-input.js";
+const preparedCandidates = new WeakMap();
+/** Only a genuinely retained candidate can supply fresh startup input. Copied
+ * objects and caller-authored snapshots never acquire candidate authority. */
+export function captureMemoryInitRequestCandidate(candidate, home, scope, objective) {
+    const capture = candidate && typeof candidate === "object" ? preparedCandidates.get(candidate) : undefined;
+    if (!capture)
+        refuse("unprepared_request_candidate");
+    return capture(home, scope, objective);
+}
+const sha = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function refuse(reason) {
+    throw new AppError("memory_init_request_candidate_invalid", "Init request candidate is unavailable or changed", 1, { reason, effect: "no_effect", next_action: "reconcile_exact_request" });
+}
+function exists(file) {
+    try {
+        fs.lstatSync(file);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+function directory(file) {
+    const stat = fs.lstatSync(file);
+    if (!stat.isDirectory() || fs.realpathSync(file) !== file)
+        refuse("linked_candidate_directory");
+    return { dev: stat.dev, ino: stat.ino };
+}
+function syncDirectory(file) {
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+    try {
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Read-only preparation and exact byte capture. A candidate is not startup,
+ * storage, engine or dispatch authority. Retain only after prerequisite checks;
+ * no missing candidate component is reconstructed from ambient selections. */
+export function prepareMemoryInitRequestCandidate(home, scope, selection, intake) {
+    validateMemoryInitStartupScope(scope);
+    scope = structuredClone(scope);
+    const selectionBytes = Buffer.from(selection), intakeBytes = Buffer.from(intake);
+    if (!selectionBytes.length || selectionBytes.length > 256 * 1024 || !intakeBytes.length || intakeBytes.length > 64 * 1024)
+        refuse("unbounded_request");
+    let objective;
+    try {
+        objective = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(intakeBytes);
+    }
+    catch {
+        return refuse("invalid_intake_utf8");
+    }
+    validateMemoryInitObjective(objective);
+    const homeOwner = directory(home);
+    if ([scope.projectRoot, scope.workspaceRoot].some(root => {
+        const relative = path.relative(root, home);
+        return relative === "" || !path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`);
+    }))
+        refuse("candidate_home_inside_project");
+    assertImportAdmission(home);
+    const namespace = path.join(home, "memory-init-request-candidates"), key = hybridDigest(scope);
+    const root = path.join(namespace, key), marker = path.join(namespace, `${key}.json`);
+    const inputFile = path.join(root, "intake.txt"), selectionFile = path.join(root, "selection.json");
+    const facts = { schema_id: "dd-flow/memory-init-request-candidate@1", home, home_owner: homeOwner, scope,
+        selection_sha256: sha(selectionBytes), intake_sha256: sha(intakeBytes) };
+    const verify = () => {
+        if (hybridDigest(directory(home)) !== hybridDigest(homeOwner))
+            refuse("candidate_home_changed");
+        directory(namespace);
+        if (!exists(root) || !exists(marker))
+            refuse("candidate_custody_missing");
+        const expected = { ...facts, owner: directory(root) };
+        const bytes = readBoundedReleaseFile(marker, 16 * 1024);
+        if (!bytes.equals(Buffer.from(JSON.stringify(expected))))
+            refuse("candidate_request_changed");
+        if (!exists(inputFile) || !exists(selectionFile))
+            refuse("candidate_input_missing");
+        if (!readBoundedReleaseFile(inputFile, 64 * 1024).equals(intakeBytes)
+            || !readBoundedReleaseFile(selectionFile, 256 * 1024).equals(selectionBytes))
+            refuse("candidate_input_changed");
+    };
+    if (exists(namespace))
+        directory(namespace);
+    const found = exists(root) || exists(marker);
+    if (found)
+        verify();
+    let retained = false;
+    const complete = (created) => { retained = true; return { created, file: inputFile, sha256: facts.intake_sha256 }; };
+    const candidate = {
+        objective,
+        retain: () => {
+            if (found) {
+                verify();
+                return complete(false);
+            }
+            let started = false;
+            try {
+                if (hybridDigest(directory(home)) !== hybridDigest(homeOwner))
+                    refuse("candidate_home_changed");
+                assertImportAdmission(home);
+                if (!exists(namespace)) {
+                    try {
+                        fs.mkdirSync(namespace, { mode: 0o700 });
+                        started = true;
+                        syncDirectory(home);
+                    }
+                    catch (error) {
+                        if (error.code !== "EEXIST")
+                            throw error;
+                    }
+                }
+                directory(namespace);
+                // A concurrent publication is read-only to this caller. Never fill in
+                // another process's partial directory or claim its writes as ours.
+                if (exists(root) || exists(marker)) {
+                    verify();
+                    return complete(false);
+                }
+                fs.mkdirSync(root, { mode: 0o700 });
+                started = true;
+                syncDirectory(namespace);
+                publishImmutableInput(marker, Buffer.from(JSON.stringify({ ...facts, owner: directory(root) })), "memory_init_request_candidate_conflict");
+                publishImmutableInput(inputFile, intakeBytes, "memory_init_request_candidate_conflict");
+                publishImmutableInput(selectionFile, selectionBytes, "memory_init_request_candidate_conflict");
+                verify();
+                return complete(true);
+            }
+            catch (error) {
+                if (!started)
+                    throw error;
+                throw new AppError("memory_init_request_candidate_incomplete", "Request candidate requires exact reconciliation", 1, { effect: "partial", request_id: scope.requestId, cause: errorRecord(error), next_action: "reconcile_exact_request" });
+            }
+        }
+    };
+    preparedCandidates.set(candidate, (expectedHome, expectedScope, expectedObjective) => {
+        if (!retained)
+            refuse("request_candidate_not_retained");
+        if (home !== expectedHome || hybridDigest(scope) !== hybridDigest(expectedScope) || objective !== expectedObjective)
+            refuse("foreign_request_candidate");
+        verify();
+        return prepareMemoryInitRequestInput(scope, selectionBytes, intakeBytes, objective);
+    });
+    return Object.freeze(candidate);
+}

package/dist/services/memory-init-request-input.js

@@ -0,0 +1,66 @@
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+const sha = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const exact = (value, keys) => object(value) && Object.keys(value).sort().join() === [...keys].sort().join();
+const digest = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+function refuse(reason) {
+    throw new AppError("memory_init_request_input_invalid", "Original init input is unavailable or inconsistent", 1, { reason, effect: "no_effect", next_action: "reconcile_exact_request" });
+}
+function decode(value, expected, limit) {
+    if (typeof value !== "string" || !value.length || value.length > 4 * Math.ceil(limit / 3) || !digest(expected))
+        refuse("invalid_input_encoding");
+    const bytes = Buffer.from(value, "base64");
+    if (!bytes.length || bytes.length > limit || bytes.toString("base64") !== value || sha(bytes) !== expected)
+        refuse("input_bytes_changed");
+    return bytes;
+}
+function text(bytes) {
+    try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        return refuse("invalid_input_utf8");
+    }
+}
+/** Data-only decoding for SQL custody/recovery. No Home, files, engine registry,
+ * installed canon, current profiles or provider is consulted. */
+export function readMemoryInitRequestInput(value, scope, objective) {
+    if (!exact(value, ["schema_id", "scope", "intake_base64", "intake_sha256", "selection_base64", "selection_sha256"])
+        || !object(value) || value.schema_id !== "dd-flow/memory-init-request-input@1"
+        || hybridDigest(value.scope) !== hybridDigest(scope))
+        refuse("invalid_input_scope");
+    const intake = decode(value.intake_base64, value.intake_sha256, 64 * 1024);
+    const selectionBytes = decode(value.selection_base64, value.selection_sha256, 256 * 1024);
+    if (typeof objective !== "string" || !objective.trim() || text(intake) !== objective)
+        refuse("input_objective_changed");
+    let selection;
+    try {
+        selection = JSON.parse(text(selectionBytes));
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        return refuse("invalid_selection_json");
+    }
+    if (!exact(selection, ["schema_id", "scope", "execution", "git_policy", "objective", "engine_checksum", "receipts"])
+        || !object(selection) || selection.schema_id !== "dd-flow/memory-init-request-selection@1"
+        || hybridDigest(selection.scope) !== hybridDigest(scope) || selection.objective !== objective
+        || !object(selection.execution) || !exact(selection.git_policy, ["route", "integrationBranch"])
+        || !object(selection.git_policy) || !["integration_branch_direct", "feature_worktree"].includes(String(selection.git_policy.route))
+        || typeof selection.git_policy.integrationBranch !== "string" || !selection.git_policy.integrationBranch
+        || selection.engine_checksum !== null && !digest(selection.engine_checksum)
+        || !Array.isArray(selection.receipts) || selection.receipts.some(entry => !Array.isArray(entry) || entry.length !== 2 || !digest(entry[0]) || !object(entry[1])))
+        refuse("invalid_original_selection");
+    return { intake, selectionBytes, selection: selection };
+}
+export function prepareMemoryInitRequestInput(scope, selection, intake, objective) {
+    if (!selection.byteLength || selection.byteLength > 256 * 1024 || !intake.byteLength || intake.byteLength > 64 * 1024)
+        refuse("unbounded_original_input");
+    const value = { schema_id: "dd-flow/memory-init-request-input@1", scope: structuredClone(scope),
+        intake_base64: Buffer.from(intake).toString("base64"), intake_sha256: sha(intake),
+        selection_base64: Buffer.from(selection).toString("base64"), selection_sha256: sha(selection) };
+    readMemoryInitRequestInput(value, scope, objective);
+    return value;
+}

package/dist/services/memory-init-resource-storage.js

@@ -0,0 +1,125 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getResourceDatabase } from "../storage/database.js";
+import { STORE_WRITER_VERSION, storeWriterTriggerSql } from "../storage/writer-contract.js";
+import { withStoreCleanup } from "../storage/native-cleanup.js";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { resourceHome } from "./managed-processes.js";
+const footprint = {
+    managed_processes: ["id", "kind", "pid", "pid_started_at", "owner_id", "lease_token", "lease_expires_at", "project_id", "run_id", "work_id", "check_id", "operation_id", "stdout_path", "stderr_path", "state", "started_at", "updated_at", "finished_at", "termination_reason", "metadata_json"],
+    managed_resources: ["resource_kind", "resource_key", "owner_id", "lease_token", "lease_expires_at", "process_id", "metadata_json", "created_at", "updated_at"]
+};
+const keys = { managed_processes: ["id"], managed_resources: ["resource_kind", "resource_key"] };
+const indexes = {
+    idx_managed_processes_lease: { table: "managed_processes", columns: ["state", "lease_expires_at", "updated_at"] },
+    idx_managed_resources_lease: { table: "managed_resources", columns: ["lease_expires_at", "updated_at"] }
+};
+const normalize = (sql) => sql.replace(/\s+/g, " ").trim().replace(/;$/, "");
+function refuse(reason) {
+    throw new AppError("memory_init_resource_storage_incompatible", "Memory init cannot admit the selected shared process registry without preparation", 1, { reason, effect: "no_effect", next_action: "prepare_selected_resource_store_then_retry" });
+}
+function inspect(db, home, owner) {
+    if (db.writable || db.path !== path.join(home, "runtime.sqlite"))
+        refuse("foreign_or_writable_reader");
+    const contract = db.all("SELECT id, version FROM dd_flow_writer_contract");
+    if (contract.length !== 1 || contract[0]?.id !== 1 || contract[0].version !== STORE_WRITER_VERSION)
+        refuse("writer_contract_mismatch");
+    const schema = {};
+    for (const [table, required] of Object.entries(footprint)) {
+        const columns = db.all(`PRAGMA table_info("${table}")`);
+        if (required.some(name => !columns.some(column => column.name === name)))
+            refuse(`missing_operation_column:${table}`);
+        if (required.some(name => columns.find(column => column.name === name)?.type.toUpperCase() !== (table === "managed_processes" && name === "pid" ? "INTEGER" : "TEXT")))
+            refuse(`operation_column_type_mismatch:${table}`);
+        if (JSON.stringify(columns.filter(column => column.pk > 0).sort((a, b) => a.pk - b.pk).map(column => column.name)) !== JSON.stringify(keys[table]))
+            refuse(`operation_primary_key_mismatch:${table}`);
+        schema[table] = columns.map(({ name, type, notnull, pk }) => ({ name, type, notnull, pk }));
+    }
+    for (const table of [...Object.keys(footprint), "dd_flow_writer_contract"]) {
+        const fences = [];
+        for (const action of ["INSERT", "UPDATE", "DELETE"]) {
+            const expected = storeWriterTriggerSql(table, action);
+            const actual = db.get("SELECT sql FROM sqlite_schema WHERE type = 'trigger' AND name = ? AND tbl_name = ?", [expected.name, table]);
+            if (!actual || normalize(actual.sql) !== normalize(expected.sql))
+                refuse(`writer_fence_mismatch:${table}`);
+            fences.push(normalize(actual.sql));
+        }
+        schema[`${table}:fences`] = fences;
+    }
+    for (const [name, expected] of Object.entries(indexes)) {
+        const entry = db.all(`PRAGMA index_list("${expected.table}")`).find(index => index.name === name);
+        if (!entry || entry.unique !== 0 || entry.partial !== 0
+            || JSON.stringify(db.all(`PRAGMA index_info("${name}")`).map(column => column.name)) !== JSON.stringify(expected.columns))
+            refuse(`operation_index_mismatch:${name}`);
+        schema[name] = { table: expected.table, columns: expected.columns };
+    }
+    return { schema_id: "dd-flow/memory-init-resource-storage@1", operation: "memory-init",
+        store_kind: "resource", store_path: db.path, store_dev: owner.dev, store_ino: owner.ino, executing_writer_version: STORE_WRITER_VERSION,
+        schema_sha256: hybridDigest(schema), route: "verified-no-op", outcome: "no-op" };
+}
+/** Retained proof shape, not current physical/storage admission. */
+export function isMemoryInitResourceStorageFacts(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const facts = value;
+    return Object.keys(facts).length === 10 && facts.schema_id === "dd-flow/memory-init-resource-storage@1"
+        && facts.operation === "memory-init" && facts.store_kind === "resource"
+        && typeof facts.store_path === "string" && path.isAbsolute(facts.store_path)
+        && ["store_dev", "store_ino"].every(key => Number.isSafeInteger(facts[key]) && Number(facts[key]) >= 0)
+        && facts.executing_writer_version === 2 && typeof facts.schema_sha256 === "string" && /^[a-f0-9]{64}$/.test(facts.schema_sha256)
+        && facts.route === "verified-no-op" && facts.outcome === "no-op";
+}
+/** Readonly pre-open admission for the executing CLI's selected process registry.
+ * Never initializes/migrates an absent or incompatible store, and never reuses
+ * an ambient cached writer. Does not attest provider, frozen-engine support or
+ * draining/settlement of live processes.
+ */
+export class PreparedMemoryInitResourceStorage {
+    sha256;
+    #home;
+    #facts;
+    constructor(home, facts) {
+        this.#home = home;
+        this.#facts = facts;
+        this.sha256 = hybridDigest(facts);
+        Object.freeze(this);
+    }
+    static prepare(context) {
+        const home = resourceHome(context);
+        if (!path.isAbsolute(home) || path.resolve(home) !== home)
+            refuse("resource_home_not_absolute_canonical");
+        const file = path.join(home, "runtime.sqlite");
+        try {
+            if (fs.realpathSync(home) !== home || !fs.lstatSync(home).isDirectory())
+                refuse("resource_home_linked_or_unavailable");
+            const owner = fs.lstatSync(file);
+            if (!owner.isFile() || owner.nlink !== 1)
+                refuse("resource_store_linked_or_unavailable");
+            const reader = getResourceDatabase(home, "read_isolated", context.databaseDeadlineAt);
+            return withStoreCleanup(() => {
+                const facts = reader.readSnapshot(() => {
+                    const facts = inspect(reader, home, owner), integrity = reader.all("PRAGMA quick_check");
+                    if (integrity.length !== 1 || integrity[0]?.quick_check !== "ok" || reader.all("PRAGMA foreign_key_check").length)
+                        refuse("storage_integrity_failed");
+                    return facts;
+                });
+                const current = fs.lstatSync(file);
+                if (!current.isFile() || current.nlink !== 1 || current.dev !== owner.dev || current.ino !== owner.ino)
+                    refuse("resource_store_owner_changed");
+                return new PreparedMemoryInitResourceStorage(home, facts);
+            }, () => reader.close?.(), () => ({ store_kind: "resource", store_path: file }));
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            return refuse("resource_storage_observation_failed");
+        }
+    }
+    facts() { return { ...this.#facts }; }
+    revalidate(context) {
+        const selected = PreparedMemoryInitResourceStorage.prepare(context);
+        if (selected.#home !== this.#home || selected.sha256 !== this.sha256)
+            refuse("resource_storage_changed_after_preparation");
+    }
+}

package/dist/services/memory-init-run-allocation.js

@@ -0,0 +1,81 @@
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { parseFullEntityId } from "../domain/entity-ids.js";
+import { readMemoryInitBootstrapReadiness } from "./memory-init-bootstrap-readiness.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { nextRunId } from "./ids.js";
+import { appendAudit } from "./audit.js";
+const event = "memory.init_run_allocation", intentEvent = "memory.init_run_allocation_intent";
+function refuse(reason) {
+    throw new AppError("memory_init_run_allocation_invalid", "Memory init RUN allocation requires exact retained bootstrap request custody", 1, { reason, effect: "no_effect", next_action: "reconcile_exact_request" });
+}
+function selected(context, scope) {
+    if (!scope || Object.keys(scope).sort().join() !== "projectRoot,requestId,workspaceRoot"
+        || typeof scope.requestId !== "string" || !scope.requestId.trim() || scope.requestId.length > 256
+        || typeof scope.projectRoot !== "string" || !path.isAbsolute(scope.projectRoot)
+        || typeof scope.workspaceRoot !== "string" || !path.isAbsolute(scope.workspaceRoot))
+        refuse("invalid_request_scope");
+    const ready = readMemoryInitBootstrapReadiness(context, scope);
+    if (!ready)
+        refuse("registered_bootstrap_readiness_required");
+    return { projectId: ready.projectId, sha256: hybridDigest(ready.authority) };
+}
+function retained(context, scope, selection) {
+    const rows = (type) => context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type=? AND json_extract(payload_json,'$.scope.requestId')=? LIMIT 2", [selection.projectId, type, scope.requestId]);
+    const allocations = rows(event), intents = rows(intentEvent);
+    if (!allocations.length && !intents.length)
+        return null;
+    if (allocations.length !== 1 || intents.length !== 1)
+        refuse("allocation_pair_missing_or_ambiguous");
+    try {
+        if (Buffer.byteLength(allocations[0].payload_json) > 16 * 1024 || Buffer.byteLength(intents[0].payload_json) > 16 * 1024)
+            refuse("unbounded_allocation");
+        const allocation = JSON.parse(allocations[0].payload_json);
+        const intent = JSON.parse(intents[0].payload_json);
+        if (typeof allocation?.run_id !== "string")
+            refuse("invalid_allocation_identity");
+        const parsed = parseFullEntityId(allocation.run_id), sequence = Number(parsed.shortId.slice(4));
+        if (parsed.type !== "RUN" || !Number.isSafeInteger(sequence) || sequence < 1)
+            refuse("invalid_allocation_identity");
+        if (Object.keys(allocation).sort().join() !== "bootstrap_authority_sha256,project_id,run_id,schema_id,scope"
+            || allocation.schema_id !== "dd-flow/memory-init-run-allocation@1" || allocation.project_id !== selection.projectId
+            || hybridDigest(allocation.scope) !== hybridDigest(scope) || allocation.bootstrap_authority_sha256 !== selection.sha256
+            || hybridDigest(intent) !== hybridDigest({ schema_id: "dd-flow/memory-init-run-allocation-intent@1", scope, run_id: allocation.run_id, allocation_sha256: hybridDigest(allocation) }))
+            refuse("allocation_custody_changed");
+        return Object.freeze(structuredClone(allocation));
+    }
+    catch (error) {
+        if (error instanceof AppError && error.code === "memory_init_run_allocation_invalid")
+            throw error;
+        return refuse("invalid_allocation_bytes");
+    }
+}
+/** Read only. Neither metadata nor an allocated id authorizes a Session,
+ * bundle, RUN row or project mutation. */
+export function readMemoryInitRunAllocation(context, scope) {
+    return context.db.readSnapshot(() => retained(context, scope, selected(context, scope)));
+}
+/** SQL-only atomic reservation after real bootstrap readiness. The canonical
+ * request retains one RUN identity before bundle or RUN filesystem effects. */
+export function reserveMemoryInitRunAllocation(context, scope) {
+    const prepared = context.db.readSnapshot(() => selected(context, scope));
+    return context.db.writeTransaction(() => {
+        if (context.db.isOwnedWriteTransaction?.() !== true)
+            refuse("owned_allocation_writer_required");
+        const current = selected(context, scope);
+        if (hybridDigest(current) !== hybridDigest(prepared))
+            refuse("bootstrap_changed_before_allocation");
+        const prior = retained(context, scope, current);
+        if (prior)
+            return { allocation: prior, changed: false };
+        const allocation = { schema_id: "dd-flow/memory-init-run-allocation@1", scope: structuredClone(scope),
+            project_id: current.projectId, run_id: nextRunId(context, current.projectId, "mb-init"), bootstrap_authority_sha256: current.sha256 };
+        appendAudit(context, { projectId: current.projectId, eventType: intentEvent,
+            payload: { schema_id: "dd-flow/memory-init-run-allocation-intent@1", scope, run_id: allocation.run_id, allocation_sha256: hybridDigest(allocation) } });
+        appendAudit(context, { projectId: current.projectId, eventType: event, payload: allocation });
+        const accepted = retained(context, scope, current);
+        if (!accepted || hybridDigest(accepted) !== hybridDigest(allocation))
+            refuse("allocation_readback_failed");
+        return { allocation: accepted, changed: true };
+    }, "memoryInit.reserveRun");
+}

package/dist/services/memory-init-run-bundle.js

@@ -0,0 +1,98 @@
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { PreparedInstalledFlowSource } from "./installed-flow-source.js";
+import { FrozenGenericExecution } from "./generic-execution.js";
+import { AdmittedFrozenEngine } from "./frozen-engine.js";
+import { RetainedExecutionBundle } from "./execution-bundles.js";
+import { readMemoryInitBootstrapReadiness } from "./memory-init-bootstrap-readiness.js";
+import { readMemoryInitRunAllocation } from "./memory-init-run-allocation.js";
+import { readMemoryInitProjectBootstrap } from "./memory-init-project-bootstrap.js";
+import { bundledHandlerContext } from "./stage-handlers.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+const bytes = (value) => Buffer.from(JSON.stringify(value));
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+function refuse(reason) {
+    throw new AppError("memory_init_run_bundle_invalid", "Memory RUN bundle requires the exact installed bootstrap selection", 1, { reason, phase: "prepare", effect: "no_effect", next_action: "reconcile_exact_request" });
+}
+/** Initial bundle construction only, outside the SQL writer. Existing RUNs
+ * restore their retained bundle; they must not re-read current operator canon.
+ * No reservation, RUN, Session, Work or filesystem publication occurs here.
+ */
+export function prepareMemoryInitRunBundle(context, input) {
+    if (!(input.source instanceof PreparedInstalledFlowSource) || !(input.execution instanceof FrozenGenericExecution)
+        || !(input.engine instanceof AdmittedFrozenEngine))
+        refuse("unprepared_selection");
+    const snapshot = input.execution.snapshot(), scope = { requestId: snapshot.scope.requestId,
+        projectRoot: snapshot.scope.projectRoot, workspaceRoot: snapshot.scope.workspace };
+    const ready = readMemoryInitBootstrapReadiness(context, scope), allocation = readMemoryInitRunAllocation(context, scope);
+    const bootstrap = readMemoryInitProjectBootstrap(context, scope);
+    if (!ready || !allocation || !bootstrap || allocation.project_id !== ready.projectId
+        || ready.authority.binding.execution_sha256 !== input.execution.sha256)
+        refuse("bootstrap_selection_changed");
+    const { bootstrapIdentity, receipts: bootstrapReceipts } = ready.admission;
+    if (!bootstrapIdentity || !bootstrapReceipts)
+        refuse("bootstrap_admission_missing");
+    const receipts = new Map(bootstrapReceipts);
+    for (const reference of [snapshot.settings.attached_session_receipt, snapshot.settings.delegation.native_capacity_receipt]) {
+        if (reference === null)
+            continue;
+        const fact = input.receipts?.get(reference.sha256);
+        if (!fact)
+            refuse("execution_receipt_custody_missing");
+        if (receipts.has(reference.sha256) && hybridDigest(receipts.get(reference.sha256)) !== hybridDigest(fact))
+            refuse("execution_receipt_collision");
+        receipts.set(reference.sha256, structuredClone(fact));
+    }
+    input.source.revalidate();
+    const flow = input.source.resolveRegisteredFlow(), canon = input.source.canonProvenance();
+    const release = JSON.parse(Buffer.from(ready.authority.binding.installation_manifest_base64, "base64").toString("utf8"));
+    if (input.source.installationSha256() !== ready.authority.binding.installation_manifest_sha256
+        || flow.sha256 !== snapshot.settings.descriptor_sha256 || snapshot.settings.flow_id !== "mb-init"
+        || canon.version !== release.canon.version || canon.commit !== release.canon.commit
+        || canon.archive_sha256 !== release.canon.archive.sha256
+        || !input.engine.manifestBytes().equals(Buffer.from(ready.authority.binding.engine_manifest_base64, "base64")))
+        refuse("frozen_source_changed");
+    const manifest = input.engine.manifest(), runId = allocation.run_id;
+    if (typeof manifest.integrity.checksum !== "string")
+        refuse("missing_engine_checksum");
+    // The accepted bootstrap timestamp makes reconstruction stable after a lost
+    // reply. Current time is not a new selector for this request's engine binding.
+    const binding = { schema_id: "dd-flow/run-engine-binding@1", run_id: runId, project_root: scope.projectRoot,
+        bound_at: bootstrap.receipt.created_at, source: "run_creation", reason: "Request-bound memory init bootstrap",
+        engine: { package_name: manifest.package_name, package_version: manifest.package_version, engine_version: manifest.engine_version,
+            integrity_checksum: manifest.integrity.checksum, snapshot_root: manifest.snapshot_root }, probe: { status: "not_required", command: null } };
+    const blobs = input.source.blobs();
+    const put = (logical, content) => {
+        if (blobs.has(logical))
+            refuse("bundle_path_collision");
+        blobs.set(logical, content);
+        return { path: logical, sha256: hash(content) };
+    };
+    for (const reference of [snapshot.settings.attached_session_receipt, snapshot.settings.delegation.native_capacity_receipt]) {
+        if (reference === null)
+            continue;
+        const content = input.receiptBytes?.get(reference.sha256);
+        if (!content || hash(content) !== reference.sha256)
+            refuse("execution_receipt_evidence_missing_or_changed");
+        put(reference.path, Buffer.from(content));
+    }
+    const profiles = { schema_id: "dd-flow/profile-settings@1", profiles: snapshot.profiles, aliases: {}, default_profile: null };
+    const profile = put("runtime/profiles.json", bytes({ ...profiles, revision: hybridDigest(profiles) }));
+    const execution = put("runtime/execution.json", bytes(snapshot.settings));
+    const engineBinding = put("runtime/engine-binding.json", bytes(binding));
+    const engineManifest = put("runtime/engine-manifest.json", input.engine.manifestBytes());
+    for (const evidence of ready.authority.evidence)
+        put(evidence.path, Buffer.from(evidence.base64, "base64"));
+    const receipt = put("receipts/bootstrap.json", bytes(ready.authority.receipt));
+    const provenance = { canon, project_pack: { sha256: ready.authority.binding.pack_sha256, source_commit: canon.commit } };
+    const bundle = { schema_id: "dd-flow/execution-bundle@1", run_id: runId, flow_id: "mb-init",
+        descriptor: input.source.descriptorReference(), execution_settings: execution, profile_settings: profile,
+        engine_binding: engineBinding, engine_manifest: engineManifest, bootstrap_receipts: [receipt], ...provenance,
+        inventory: [...blobs].map(([logical, content]) => ({ path: logical, sha256: hash(content) })) };
+    const encoded = bytes(bundle);
+    return RetainedExecutionBundle.admit(encoded, hash(encoded), blobs, { runId, executionScope: snapshot.scope,
+        bundleProjectRoot: scope.projectRoot, descriptorSha256: flow.sha256, engineChecksum: manifest.integrity.checksum,
+        engineBindingSha256: engineBinding.sha256, engineManifestSha256: engineManifest.sha256,
+        descriptorContext: bundledHandlerContext(new Map()), bundleProvenance: provenance,
+        bootstrapIdentity, receipts });
+}