@deksden-com/dd-flow-cli 0.9.0-beta.137 → 0.9.0-beta.139

package/dist/services/memory-init-start.js

@@ -0,0 +1,181 @@
+import { createContext } from "../runtime/context.js";
+import { resolveDdFlowHome } from "../storage/paths.js";
+import { withStoreCleanup } from "../storage/native-cleanup.js";
+import { PreparedMemoryInitTarget } from "./memory-init-preflight.js";
+import { AppError, errorRecord } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { validateMemoryInitStartupScope, readMemoryInitStartupInput, validateMemoryInitObjective } from "./memory-init-startup-custody.js";
+import { PreparedMemoryInitStartupInput } from "./memory-init-startup-input.js";
+import { bootstrapMemoryInit, readMemoryInitBootstrapReadiness } from "./memory-init-bootstrap-readiness.js";
+import { readMemoryInitRunAllocation, reserveMemoryInitRunAllocation } from "./memory-init-run-allocation.js";
+import { readRunStartRequest } from "./run-start-custody.js";
+import { prepareMemoryInitRunBundle } from "./memory-init-run-bundle.js";
+import { PreparedDescriptorRunStart } from "./descriptor-run-start.js";
+import { readSetupStatus } from "./setup.js";
+import { readOperatorProfiles } from "./operator-profiles.js";
+import { FrozenGenericExecution } from "./generic-execution.js";
+import { PreparedInstalledFlowSource } from "./installed-flow-source.js";
+import { PreparedMemoryLayer } from "./memory-layer.js";
+import { selectMemoryInitInstalledEngine } from "./memory-init-engine-release.js";
+import { PreparedMemoryInitGitPolicy } from "./memory-init-git-policy.js";
+import { openMemoryInitStores } from "./memory-init-stores.js";
+import { prepareMemoryInitRequestCandidate } from "./memory-init-request-candidate.js";
+import { prepareMemoryInitHarnessCommands } from "./memory-init-project-bootstrap.js";
+import { readMemoryInitRequestInput } from "./memory-init-request-input.js";
+import { publishSetup } from "../harness-runtime/lib/setup-progress.mjs";
+function refuse(reason) {
+    throw new AppError("memory_init_start_invalid", "Memory init requires its exact startup request", 1, { reason, effect: "no_effect", next_action: "reconcile_exact_request" });
+}
+const selections = new WeakMap();
+function requestMaterial(scope, input) {
+    return { schema_id: "dd-flow/memory-init-request-selection@1", scope,
+        execution: input.execution, git_policy: input.gitPolicy, objective: input.objective, engine_checksum: input.engineChecksum ?? null,
+        receipts: [...(input.receipts ?? [])].sort(([left], [right]) => left.localeCompare(right)) };
+}
+/** Private factory witness: genuine candidate A cannot be grafted onto another
+ * prepared selection B, even when both have the same scope and objective. */
+export function assertMemoryInitRequestSelection(input, home, scope, request) {
+    const witness = selections.get(input), current = input;
+    if (!witness)
+        refuse("unprepared_request_selection");
+    const original = readMemoryInitRequestInput(request, scope, witness.objective ?? "");
+    if (witness.home !== home || witness.scopeSha256 !== hybridDigest(scope) || witness.requestSha256 !== hybridDigest(original.selection)
+        || current.objective !== witness.objective || Object.entries(witness.owners).some(([key, owner]) => current[key] !== owner)
+        || !(current.receipts instanceof Map) || hybridDigest([...current.receipts].sort(([left], [right]) => String(left).localeCompare(String(right)))) !== witness.receiptsSha256)
+        refuse("request_selection_changed");
+}
+/** Fresh selection before any runtime-store open. This is not storage,
+ * bootstrap readiness or retained-request authority; the startup aggregate
+ * still admits those separately before its first project publication. */
+export function prepareMemoryInitSelection(context, scope, input) {
+    validateMemoryInitStartupScope(scope);
+    if (Object.hasOwn(input, "objective"))
+        validateMemoryInitObjective(input.objective);
+    const installation = readSetupStatus(context.ddFlowHome).installation;
+    if (!installation)
+        refuse("installed_release_required");
+    const target = PreparedMemoryInitTarget.prepare(scope, context.env);
+    const source = PreparedInstalledFlowSource.fromInstalledRelease(context.ddFlowHome, installation.manifest_sha256, "mb-init");
+    const layer = PreparedMemoryLayer.fromInstalledRelease(context.ddFlowHome, installation.manifest_sha256, context.now());
+    const execution = FrozenGenericExecution.prepare(source.resolveRegisteredFlow(), readOperatorProfiles(context.ddFlowHome), input.execution, { requestId: scope.requestId, projectRoot: scope.projectRoot, workspace: scope.workspaceRoot }, input.receipts);
+    prepareMemoryInitHarnessCommands(context, execution);
+    const engine = selectMemoryInitInstalledEngine(context.ddFlowHome, installation.manifest_sha256, input.engineChecksum);
+    const gitPolicy = PreparedMemoryInitGitPolicy.prepareFresh(context.env, { target, selection: input.gitPolicy });
+    const selected = { target, source, layer, execution, engine, gitPolicy, receipts: new Map(input.receipts ?? []),
+        receiptBytes: new Map([...input.receiptBytes ?? []].map(([key, bytes]) => [key, Uint8Array.from(bytes)])),
+        ...(input.objective === undefined ? {} : { objective: input.objective }) };
+    selections.set(selected, { home: context.ddFlowHome, scopeSha256: hybridDigest(scope), requestSha256: hybridDigest(requestMaterial(scope, input)),
+        objective: input.objective, owners: { target, source, layer, execution, engine, gitPolicy }, receiptsSha256: hybridDigest(requestMaterial(scope, input).receipts) });
+    return selected;
+}
+/** Complete admission against already prepared stores. Retention remains one
+ * atomic aggregate; published/replayed requests must restore their inputs. */
+export function prepareMemoryInitRequest(context, scope, input) {
+    validateMemoryInitStartupScope(scope);
+    if (Object.hasOwn(input, "objective"))
+        validateMemoryInitObjective(input.objective);
+    if (context.db.isOwnedWriteTransaction?.())
+        refuse("startup_outside_writer_required");
+    if (readMemoryInitStartupInput(context, scope))
+        refuse("restore_existing_startup_input");
+    return PreparedMemoryInitStartupInput.prepare(context, prepareMemoryInitSelection(context, scope, input));
+}
+/** Fresh public preparation owns its connection and may create only a jointly
+ * retained pristine store pair. A retained startup is rejected before ambient
+ * selection: its caller must take the existing restore/replay path instead.
+ * Does not retain startup, publish a project, create a RUN or dispatch. */
+export function prepareMemoryInitFreshRequest(env, scope, input, rawIntake = Buffer.from(input.objective ?? "")) {
+    validateMemoryInitStartupScope(scope);
+    validateMemoryInitObjective(input.objective);
+    const raw = structuredClone(input);
+    const material = requestMaterial(scope, raw);
+    const materialBytes = Buffer.from(JSON.stringify(material));
+    if (materialBytes.length > 256 * 1024)
+        refuse("unbounded_raw_selection");
+    const reader = createContext(env, "read_existing");
+    withStoreCleanup(() => {
+        if (readMemoryInitStartupInput(reader, scope))
+            refuse("restore_existing_startup_input");
+    }, () => reader.db.close?.());
+    const candidate = prepareMemoryInitRequestCandidate(resolveDdFlowHome(env), scope, materialBytes, rawIntake);
+    if (candidate.objective !== raw.objective)
+        refuse("raw_intake_objective_mismatch");
+    publishSetup("probe_completed", "memory-init:request-candidate");
+    const selection = prepareMemoryInitSelection({ ddFlowHome: resolveDdFlowHome(env), env, now: () => new Date().toISOString() }, scope, raw);
+    publishSetup("probe_completed", "memory-init:selection");
+    // A known incompatible delivered reader refuses before candidate/store
+    // effects. Historical SDK requests still use their original @1/@2 contract.
+    selection.engine.admitMemoryInitFlow(selection.source, "dd-flow/memory-init-startup-input@3");
+    publishSetup("probe_completed", "memory-init:flow-admission");
+    const retained = candidate.retain();
+    let stores;
+    try {
+        stores = openMemoryInitStores(env, { scope, selectionSha256: hybridDigest(material) });
+    }
+    catch (error) {
+        if (!retained.created)
+            throw error;
+        throw new AppError("memory_init_fresh_preparation_incomplete", "Request candidate remains retained; store admission did not complete", 1, { effect: "partial", request_id: scope.requestId, cause: errorRecord(error), next_action: "reconcile_exact_request" });
+    }
+    publishSetup("probe_completed", "memory-init:stores");
+    let admitted = false;
+    return withStoreCleanup(() => {
+        try {
+            const prepared = PreparedMemoryInitStartupInput.prepare(stores.context, selection, candidate);
+            publishSetup("probe_completed", "memory-init:startup-input");
+            admitted = true;
+            return { ...stores, prepared };
+        }
+        catch (error) {
+            if (stores.created || retained.created)
+                throw new AppError("memory_init_fresh_preparation_incomplete", "Retained request/stores remain owned; startup admission did not complete", 1, { effect: "partial", store_home: stores.context.ddFlowHome, next_action: "reconcile_exact_request", cause: error instanceof AppError
+                        ? { code: error.code, message: error.message, details: error.details } : String(error) });
+            throw error;
+        }
+    }, () => { if (!admitted)
+        stores.context.db.close?.(); });
+}
+/** Public startup's shared orchestration. The fresh selector is lazy: a retry
+ * never consults current canon/profiles, and a published RUN is restored before
+ * reconstructing its original project baseline. Does not dispatch a Session;
+ * the existing controller owns that subsequent operation. */
+export function startMemoryInitRun(context, scope, prepareFresh) {
+    validateMemoryInitStartupScope(scope);
+    if (context.db.isOwnedWriteTransaction?.())
+        refuse("startup_outside_writer_required");
+    const retained = readMemoryInitStartupInput(context, scope);
+    const ready = readMemoryInitBootstrapReadiness(context, scope);
+    const project = context.db.get("SELECT id FROM projects WHERE root=?", [scope.projectRoot]);
+    const request = project ? readRunStartRequest(context, project.id, scope.requestId) : null;
+    if (request && !ready)
+        refuse("run_bootstrap_missing");
+    if (ready) {
+        const allocation = readMemoryInitRunAllocation(context, scope);
+        if (request) {
+            if (!retained || !allocation || project?.id !== ready.projectId || request.payload.run_id !== allocation.run_id
+                || request.payload.project_root !== scope.projectRoot || request.payload.workspace_root !== scope.workspaceRoot
+                || request.payload.initial_index.flow_kind !== "mb-init")
+                refuse("run_request_changed");
+            return PreparedDescriptorRunStart.restore(context, { projectRoot: scope.projectRoot, requestId: scope.requestId }).apply(context);
+        }
+        if (allocation && context.db.get("SELECT 1 FROM runs WHERE project_id=? AND id=?", [allocation.project_id, allocation.run_id]))
+            refuse("run_request_missing");
+    }
+    let selected;
+    if (retained)
+        selected = PreparedMemoryInitStartupInput.restore(context, scope);
+    else {
+        if (!prepareFresh)
+            refuse("fresh_selection_required");
+        selected = prepareFresh();
+        if (!(selected instanceof PreparedMemoryInitStartupInput))
+            refuse("unprepared_startup_input");
+        const facts = selected.inputs().target.facts();
+        if (hybridDigest(scope) !== hybridDigest({ requestId: facts.request_id, projectRoot: facts.project_root, workspaceRoot: facts.workspace_root }))
+            refuse("foreign_startup_input");
+        selected.retain(context);
+    }
+    bootstrapMemoryInit(context, { bootstrap: selected.bootstrap(), engine: selected.inputs().engine });
+    reserveMemoryInitRunAllocation(context, scope);
+    return PreparedDescriptorRunStart.prepare(context, { bundle: prepareMemoryInitRunBundle(context, selected.inputs()) }).apply(context);
+}

package/dist/services/memory-init-startup-custody.js

@@ -0,0 +1,80 @@
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { readMemoryInitReleaseSelection } from "./memory-init-project-bootstrap.js";
+import { readMemoryInitGitPolicy } from "./memory-init-git-policy.js";
+import { readMemoryInitRequestInput } from "./memory-init-request-input.js";
+export const memoryInitStartupInputEvent = "memory.init_startup_input";
+export const memoryInitStartupInputIntentEvent = "memory.init_startup_input_intent";
+export const memoryInitStartupInputLimit = 64 * 1024 * 1024;
+export const memoryInitStartupInputSchemas = Object.freeze(["dd-flow/memory-init-startup-input@1", "dd-flow/memory-init-startup-input@2", "dd-flow/memory-init-startup-input@3"]);
+const exact = (value, keys) => value !== null && typeof value === "object" && !Array.isArray(value)
+    && Object.keys(value).sort().join() === [...keys].sort().join();
+const digest = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+export function validateMemoryInitObjective(value) {
+    if (typeof value !== "string" || !value.trim() || Buffer.byteLength(value) > 64 * 1024)
+        refuseMemoryInitStartupInput("invalid_objective");
+}
+export function refuseMemoryInitStartupInput(reason) {
+    throw new AppError("memory_init_startup_input_invalid", "Init requires its complete independently retained startup input", 1, { reason, phase: "prepare", effect: "no_effect", next_action: "reconcile_exact_request" });
+}
+export function validateMemoryInitStartupScope(scope) {
+    if (!scope || Object.keys(scope).sort().join() !== "projectRoot,requestId,workspaceRoot"
+        || typeof scope.requestId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(scope.requestId)
+        || [scope.projectRoot, scope.workspaceRoot].some(value => typeof value !== "string" || !path.isAbsolute(value) || path.resolve(value) !== value))
+        refuseMemoryInitStartupInput("invalid_scope");
+}
+/** SQL-only historical custody. Never imports the executable handler registry,
+ * reconstructs physical owners or consults current canon/operator settings. */
+export function readMemoryInitStartupInput(context, scope) {
+    return context.db.readSnapshot(() => {
+        try {
+            validateMemoryInitStartupScope(scope);
+            const rows = (type) => context.db.all(`SELECT project_id,payload_json FROM audit_events WHERE event_type=?
+        AND json_extract(payload_json,'$.scope.requestId')=? AND json_extract(payload_json,'$.scope.projectRoot')=? LIMIT 2`, [type, scope.requestId, scope.projectRoot]);
+            const values = rows(memoryInitStartupInputEvent), intents = rows(memoryInitStartupInputIntentEvent);
+            if (!values.length && !intents.length) {
+                if (context.db.get(`SELECT 1 FROM audit_events WHERE event_type IN
+          ('memory.init_release_selection','memory.init_project_bootstrap_intent','memory.init_project_bootstrap','memory.bootstrap_ready','memory.bootstrap_readiness_intent')
+          AND ((json_extract(payload_json,'$.scope.requestId')=? AND json_extract(payload_json,'$.scope.projectRoot')=?)
+            OR (json_extract(payload_json,'$.request_id')=? AND json_extract(payload_json,'$.project_root')=?)) LIMIT 1`, [scope.requestId, scope.projectRoot, scope.requestId, scope.projectRoot]))
+                    refuseMemoryInitStartupInput("startup_input_missing_after_release_selection");
+                return null;
+            }
+            if (values.length !== 1 || intents.length !== 1)
+                refuseMemoryInitStartupInput("startup_pair_missing_or_ambiguous");
+            if (values[0].project_id !== null || intents[0].project_id !== null)
+                refuseMemoryInitStartupInput("foreign_startup_owner");
+            if (Buffer.byteLength(values[0].payload_json) > memoryInitStartupInputLimit || Buffer.byteLength(intents[0].payload_json) > 16 * 1024)
+                refuseMemoryInitStartupInput("unbounded_input");
+            const payload = JSON.parse(values[0].payload_json), sha256 = hybridDigest(payload), intent = JSON.parse(intents[0].payload_json);
+            const requestVersion = payload.schema_id === "dd-flow/memory-init-startup-input@3";
+            const objectiveVersion = payload.schema_id === "dd-flow/memory-init-startup-input@2" || requestVersion;
+            if (objectiveVersion)
+                validateMemoryInitObjective(payload.objective);
+            if (requestVersion)
+                readMemoryInitRequestInput(payload.request_input, scope, payload.objective);
+            if (!exact(payload, ["engine", "execution", "git_policy_sha256", "layer", "release", "schema_id", "scope", "source", "target", ...(objectiveVersion ? ["objective"] : []), ...(requestVersion ? ["request_input"] : [])])
+                || !exact(payload.target, ["sha256", "facts"]) || !exact(payload.layer, ["sha256", "installation_sha256", "files"])
+                || !exact(payload.source, ["sha256", "snapshot"]) || !exact(payload.execution, ["sha256", "snapshot", "receipts", ...(Object.hasOwn(payload.execution, "receipt_blobs") ? ["receipt_blobs"] : [])])
+                || !exact(payload.engine, ["identity", "manifest_sha256", "flow_admission_sha256", "release_pairing"])
+                || !exact(payload.engine.release_pairing, ["facts", "sha256"]) || !digest(payload.engine.release_pairing.sha256)
+                || hybridDigest(payload.engine.release_pairing.facts) !== payload.engine.release_pairing.sha256
+                || [payload.target.sha256, payload.layer.sha256, payload.layer.installation_sha256, payload.source.sha256,
+                    payload.execution.sha256, payload.engine.manifest_sha256, payload.engine.flow_admission_sha256, payload.git_policy_sha256].some(value => !digest(value))
+                || !Array.isArray(payload.execution.receipts) || payload.execution.receipts.length > 2
+                || payload.execution.receipt_blobs !== undefined && (!Array.isArray(payload.execution.receipt_blobs) || payload.execution.receipt_blobs.length > 2)
+                || !memoryInitStartupInputSchemas.includes(payload.schema_id) || hybridDigest(payload.scope) !== hybridDigest(scope)
+                || hybridDigest(intent) !== hybridDigest({ schema_id: "dd-flow/memory-init-startup-input-intent@1", scope, input_sha256: sha256 })
+                || hybridDigest(readMemoryInitReleaseSelection(context, scope)) !== hybridDigest(payload.release)
+                || hybridDigest(readMemoryInitGitPolicy(context, scope)) !== payload.git_policy_sha256)
+                refuseMemoryInitStartupInput("startup_custody_changed");
+            return { payload, sha256 };
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            return refuseMemoryInitStartupInput("invalid_retained_input");
+        }
+    });
+}

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

@@ -0,0 +1,240 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { appendAudit } from "./audit.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedInstalledFlowSource } from "./installed-flow-source.js";
+import { FrozenGenericExecution } from "./generic-execution.js";
+import { AdmittedFrozenEngine } from "./frozen-engine.js";
+import { PreparedMemoryInitTarget } from "./memory-init-preflight.js";
+import { PreparedMemoryLayer } from "./memory-layer.js";
+import { readRetainedMemoryLayer } from "./memory-layer-publication.js";
+import { PreparedMemoryInitProjectBootstrap } from "./memory-init-project-bootstrap.js";
+import { prepareMemoryInitBootstrapSchema } from "./memory-init-bootstrap-readiness.js";
+import { PreparedMemoryInitGitPolicy, readMemoryInitGitPolicy } from "./memory-init-git-policy.js";
+import { PreparedMemoryInitRuntimeStorage } from "./memory-init-storage.js";
+import { prepareMemoryInitEngineRelease, revalidateMemoryInitEngineRelease } from "./memory-init-engine-release.js";
+import { captureMemoryInitRequestCandidate } from "./memory-init-request-candidate.js";
+import { assertMemoryInitRequestSelection } from "./memory-init-start.js";
+import { readMemoryInitStartupInput as read, validateMemoryInitStartupScope as scopeValid, refuseMemoryInitStartupInput as refuse, memoryInitStartupInputEvent as event, memoryInitStartupInputIntentEvent as intentEvent, memoryInitStartupInputLimit as limit, validateMemoryInitObjective } from "./memory-init-startup-custody.js";
+export { readMemoryInitStartupInput } from "./memory-init-startup-custody.js";
+/** Fresh admission cannot be supplied by a self-hashed restore snapshot. */
+function revalidateFreshSource(context, input) {
+    const actual = PreparedInstalledFlowSource.fromInstalledRelease(context.ddFlowHome, input.source.installationSha256(), "mb-init");
+    if (actual.sha256 !== input.source.sha256)
+        refuse("source_not_verified_installation");
+    let installedAt;
+    try {
+        installedAt = JSON.parse(input.layer.files().get("dd-flow/manifest.json").toString("utf8")).installed_at;
+    }
+    catch {
+        return refuse("invalid_layer_manifest");
+    }
+    if (typeof installedAt !== "string" || PreparedMemoryLayer.fromInstalledRelease(context.ddFlowHome, input.layer.installationSha256, installedAt).sha256 !== input.layer.sha256)
+        refuse("layer_not_verified_installation");
+}
+/** One prepared selection before project effects. Existing bootstrap/RUN
+ * owners still perform their own engine/storage/physical admission and writes. */
+export class PreparedMemoryInitStartupInput {
+    sha256;
+    #payload;
+    #storage;
+    #input;
+    #bootstrap;
+    constructor(payload, storage, input, bootstrap) {
+        this.#payload = structuredClone(payload);
+        this.sha256 = hybridDigest(payload);
+        this.#storage = storage;
+        this.#input = input;
+        this.#bootstrap = bootstrap;
+        Object.freeze(this);
+    }
+    static prepare(context, input, requestCandidate) {
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        if (Object.hasOwn(input, "objective"))
+            validateMemoryInitObjective(input.objective);
+        if (!(input.target instanceof PreparedMemoryInitTarget) || !(input.layer instanceof PreparedMemoryLayer)
+            || !(input.source instanceof PreparedInstalledFlowSource) || !(input.execution instanceof FrozenGenericExecution)
+            || !(input.engine instanceof AdmittedFrozenEngine))
+            refuse("unprepared_selection");
+        const facts = input.target.facts(), scope = { requestId: facts.request_id, projectRoot: facts.project_root, workspaceRoot: facts.workspace_root };
+        scopeValid(scope);
+        const prior = context.db.readSnapshot(() => read(context, scope));
+        if (prior)
+            refuse("restore_existing_startup_input");
+        if (input.requestCandidate !== undefined)
+            refuse("unexpected_request_candidate");
+        const requestInput = requestCandidate === undefined ? undefined
+            : captureMemoryInitRequestCandidate(requestCandidate, context.ddFlowHome, scope, input.objective ?? "");
+        if (requestInput)
+            assertMemoryInitRequestSelection(input, context.ddFlowHome, scope, requestInput);
+        const schemaId = requestInput ? "dd-flow/memory-init-startup-input@3" : input.objective === undefined ? "dd-flow/memory-init-startup-input@1" : "dd-flow/memory-init-startup-input@2";
+        revalidateFreshSource(context, input);
+        input.target.revalidate();
+        const flow = input.source.resolveRegisteredFlow(), snapshot = input.execution.snapshot(), receipts = input.receipts ?? new Map();
+        FrozenGenericExecution.restore(snapshot, input.execution.sha256, flow, { requestId: scope.requestId, projectRoot: scope.projectRoot, workspace: scope.workspaceRoot }, receipts);
+        const selectedReceipts = new Map([snapshot.settings.attached_session_receipt,
+            snapshot.settings.delegation.native_capacity_receipt].filter(reference => reference !== null)
+            .map(reference => [reference.sha256, structuredClone(receipts.get(reference.sha256))]));
+        const receiptBlobs = [];
+        for (const checksum of selectedReceipts.keys()) {
+            const bytes = input.receiptBytes?.get(checksum);
+            if (!bytes || bytes.byteLength > 256 * 1024 || createHash("sha256").update(bytes).digest("hex") !== checksum)
+                refuse("execution_receipt_bytes_required");
+            receiptBlobs.push([checksum, Buffer.from(bytes).toString("base64")]);
+        }
+        if (input.source.installationSha256() !== input.layer.installationSha256)
+            refuse("foreign_layer_selection");
+        prepareMemoryInitBootstrapSchema(input.engine);
+        const pairing = prepareMemoryInitEngineRelease(context.ddFlowHome, input.source.installationSha256(), input.engine);
+        const admittedFlow = input.engine.admitMemoryInitFlow(input.source, schemaId === "dd-flow/memory-init-startup-input@1" ? undefined : schemaId);
+        const bootstrap = PreparedMemoryInitProjectBootstrap.prepare(context, input), release = bootstrap.releaseSelection();
+        if (input.gitPolicy !== undefined && !(input.gitPolicy instanceof PreparedMemoryInitGitPolicy))
+            refuse("unprepared_git_policy");
+        const priorPolicy = readMemoryInitGitPolicy(context, scope), policy = input.gitPolicy?.value() ?? priorPolicy;
+        if (priorPolicy && hybridDigest(priorPolicy) !== hybridDigest(policy))
+            refuse("git_policy_changed");
+        if (policy && hybridDigest(policy.scope) !== hybridDigest(scope))
+            refuse("foreign_git_policy");
+        if (!policy || policy.target_sha256 !== input.target.sha256)
+            refuse("explicit_git_policy_required");
+        const manifest = input.engine.manifest(), selectedRelease = JSON.parse(Buffer.from(release.installation_manifest_base64, "base64").toString("utf8"));
+        if (manifest.package_name !== selectedRelease.engine.package || manifest.package_version !== selectedRelease.engine.version
+            || typeof manifest.integrity.checksum !== "string")
+            refuse("foreign_engine_selection");
+        const identity = { package_name: manifest.package_name, package_version: manifest.package_version, engine_version: manifest.engine_version,
+            snapshot_root: manifest.snapshot_root, integrity_checksum: manifest.integrity.checksum };
+        const payload = { schema_id: schemaId, scope,
+            ...(input.objective === undefined ? {} : { objective: input.objective }),
+            ...(requestInput === undefined ? {} : { request_input: requestInput }),
+            target: { sha256: input.target.sha256, facts },
+            layer: { sha256: input.layer.sha256, installation_sha256: input.layer.installationSha256,
+                files: [...input.layer.files()].map(([logical, content]) => ({ path: logical, base64: content.toString("base64") })) },
+            source: { sha256: input.source.sha256, snapshot: input.source.snapshot() },
+            execution: { sha256: input.execution.sha256, snapshot, receipts: [...selectedReceipts], ...(receiptBlobs.length ? { receipt_blobs: receiptBlobs } : {}) },
+            engine: { identity, manifest_sha256: input.engine.manifestSha256, flow_admission_sha256: admittedFlow.sha256, release_pairing: pairing }, release, git_policy_sha256: hybridDigest(policy) };
+        if (Buffer.byteLength(JSON.stringify(payload)) > limit)
+            refuse("unbounded_input");
+        return new PreparedMemoryInitStartupInput(payload, PreparedMemoryInitRuntimeStorage.prepare(context), { ...input, receipts: new Map(receipts), ...(requestCandidate ? { requestCandidate } : {}) }, bootstrap);
+    }
+    retain(context) {
+        const p = this.#payload;
+        // Fresh publication rechecks physical selection outside the writer. A reply
+        // replay only reads custody and cannot reselect current canon/profile bytes.
+        const prior = context.db.readSnapshot(() => read(context, p.scope));
+        if (prior) {
+            if (prior.sha256 !== this.sha256)
+                refuse("request_selection_changed");
+            return { sha256: this.sha256, changed: false };
+        }
+        revalidateFreshSource(context, this.#input);
+        this.#input.target.revalidate();
+        if (p.request_input && hybridDigest(captureMemoryInitRequestCandidate(this.#input.requestCandidate, context.ddFlowHome, p.scope, p.objective)) !== hybridDigest(p.request_input))
+            refuse("request_candidate_changed");
+        if (prepareMemoryInitEngineRelease(context.ddFlowHome, this.#input.source.installationSha256(), this.#input.engine).sha256 !== p.engine.release_pairing.sha256)
+            refuse("engine_release_pairing_changed");
+        if (this.#input.engine.admitMemoryInitFlow(this.#input.source, p.schema_id === "dd-flow/memory-init-startup-input@1" ? undefined : p.schema_id).sha256 !== p.engine.flow_admission_sha256)
+            refuse("engine_flow_admission_changed");
+        return context.db.writeTransaction(() => {
+            if (context.db.isOwnedWriteTransaction?.() !== true)
+                refuse("owned_writer_required");
+            this.#storage.assertCompatibility(context);
+            const current = read(context, p.scope);
+            if (current) {
+                if (current.sha256 !== this.sha256)
+                    refuse("request_selection_changed");
+                return { sha256: this.sha256, changed: false };
+            }
+            this.#input.gitPolicy?.retainPreparedSql(context);
+            if (hybridDigest(readMemoryInitGitPolicy(context, p.scope)) !== p.git_policy_sha256)
+                refuse("git_policy_changed");
+            appendAudit(context, { eventType: "memory.init_release_selection", payload: p.release });
+            appendAudit(context, { eventType: intentEvent, payload: { schema_id: "dd-flow/memory-init-startup-input-intent@1", scope: p.scope, input_sha256: this.sha256 } });
+            appendAudit(context, { eventType: event, payload: p });
+            if (read(context, p.scope)?.sha256 !== this.sha256)
+                refuse("startup_readback_failed");
+            return { sha256: this.sha256, changed: true };
+        }, "memoryInit.retainStartupInput");
+    }
+    /** Actual paired SQL owner supplies all expected digests. No ambient profile,
+     * canon or release selection is read while reconstructing this request. */
+    static restore(context, scope) {
+        const retained = context.db.readSnapshot(() => read(context, scope));
+        if (!retained)
+            refuse("startup_input_required");
+        try {
+            const p = retained.payload, source = PreparedInstalledFlowSource.restoreRetained(p.source.snapshot, p.source.sha256);
+            if (!Array.isArray(p.layer.files) || p.layer.files.length > 20_000)
+                refuse("invalid_layer_input");
+            const files = new Map();
+            for (const entry of p.layer.files) {
+                if (!entry || Object.keys(entry).sort().join() !== "base64,path" || typeof entry.path !== "string" || files.has(entry.path)
+                    || typeof entry.base64 !== "string" || entry.base64.length > 2 * 1024 * 1024)
+                    refuse("invalid_layer_input");
+                const content = Buffer.from(entry.base64, "base64");
+                if (content.toString("base64") !== entry.base64)
+                    refuse("invalid_layer_input");
+                files.set(entry.path, content);
+            }
+            const layer = PreparedMemoryLayer.restoreRetained(files, p.layer.sha256, p.layer.installation_sha256);
+            if (!Array.isArray(p.execution.receipts) || p.execution.receipts.length > 2
+                || p.execution.receipts.some(entry => !Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string" || !/^[a-f0-9]{64}$/.test(entry[0])))
+                refuse("invalid_execution_receipts");
+            const receipts = new Map(p.execution.receipts);
+            const receiptBytes = new Map();
+            for (const entry of p.execution.receipt_blobs ?? []) {
+                if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string" || typeof entry[1] !== "string" || receiptBytes.has(entry[0]))
+                    refuse("invalid_execution_receipt_bytes");
+                const bytes = Buffer.from(entry[1], "base64");
+                if (bytes.byteLength > 256 * 1024 || bytes.toString("base64") !== entry[1] || createHash("sha256").update(bytes).digest("hex") !== entry[0])
+                    refuse("execution_receipt_bytes_changed");
+                receiptBytes.set(entry[0], bytes);
+            }
+            if (receiptBytes.size !== receipts.size || [...receipts.keys()].some(key => !receiptBytes.has(key)))
+                refuse("execution_receipt_bytes_required");
+            if (receipts.size !== p.execution.receipts.length)
+                refuse("duplicate_execution_receipt");
+            const execution = FrozenGenericExecution.restore(p.execution.snapshot, p.execution.sha256, source.resolveRegisteredFlow(), { requestId: scope.requestId, projectRoot: scope.projectRoot, workspace: scope.workspaceRoot }, receipts);
+            const referenced = new Set([execution.settings.attached_session_receipt, execution.settings.delegation.native_capacity_receipt]
+                .filter(reference => reference !== null).map(reference => reference.sha256));
+            if (receipts.size !== referenced.size || [...receipts.keys()].some(sha => !referenced.has(sha)))
+                refuse("unused_execution_receipt");
+            const engine = AdmittedFrozenEngine.admitSelection(p.engine.identity, p.engine.manifest_sha256);
+            if (p.engine.release_pairing.facts.installation_sha256 !== p.layer.installation_sha256)
+                refuse("foreign_engine_release_pairing");
+            revalidateMemoryInitEngineRelease(p.engine.release_pairing.facts, p.engine.release_pairing.sha256, engine);
+            if (engine.admitMemoryInitFlow(source, p.schema_id === "dd-flow/memory-init-startup-input@1" ? undefined : p.schema_id).sha256 !== p.engine.flow_admission_sha256)
+                refuse("engine_flow_admission_changed");
+            let target;
+            if (fs.existsSync(path.join(scope.workspaceRoot, ".memory-bank"))) {
+                readRetainedMemoryLayer(context.ddFlowHome, { ...scope, targetSha256: p.target.sha256, layerSha256: layer.sha256, installationSha256: layer.installationSha256 });
+                target = PreparedMemoryInitTarget.restoreOwnedPublication(p.target.facts, p.target.sha256, context.env);
+            }
+            else {
+                target = PreparedMemoryInitTarget.prepare(scope, context.env);
+                if (target.sha256 !== p.target.sha256 || hybridDigest(target.facts()) !== hybridDigest(p.target.facts))
+                    refuse("target_changed");
+            }
+            const input = { target, layer, source, execution, engine, receipts, receiptBytes, ...(p.objective === undefined ? {} : { objective: p.objective }) };
+            const bootstrap = PreparedMemoryInitProjectBootstrap.prepare(context, input);
+            if (hybridDigest(bootstrap.releaseSelection()) !== hybridDigest(p.release))
+                refuse("bootstrap_selection_changed");
+            const result = new PreparedMemoryInitStartupInput(p, PreparedMemoryInitRuntimeStorage.prepare(context), input, bootstrap);
+            if (result.sha256 !== retained.sha256)
+                refuse("restored_input_changed");
+            return result;
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            return refuse("invalid_retained_input");
+        }
+    }
+    inputs() {
+        return { ...this.#input, receipts: new Map(structuredClone(this.#payload.execution.receipts)),
+            receiptBytes: new Map((this.#payload.execution.receipt_blobs ?? []).map(([checksum, bytes]) => [checksum, Buffer.from(bytes, "base64")])) };
+    }
+    bootstrap() { return this.#bootstrap; }
+}

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

@@ -0,0 +1,81 @@
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { STORE_WRITER_VERSION, storeWriterTriggerSql } from "../storage/writer-contract.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+const footprint = {
+    projects: ["id", "short_id", "slug", "root", "status", "state_root", "created_at", "updated_at"],
+    runs: ["id", "short_id", "slug", "project_id", "project_root", "workspace_root", "flow_kind", "subject_type", "subject_id", "status", "verdict",
+        "next_action", "runtime_path", "run_dir", "run_index_path", "run_home_path", "run_root", "layout_version", "artifact_root_kind", "index_json", "created_at", "updated_at", "completed_at"],
+    works: ["work_id", "project_id", "run_id", "parent_work_id", "task", "payload_json", "status", "result_schema"],
+    work_sessions: ["id", "work_id", "session_id", "status", "result_path", "start_receipt_json", "result_receipt_json"],
+    stage_work_memberships: ["project_id", "run_id", "work_id", "stage", "attempt", "cycle"],
+    audit_events: ["id", "protocol_id", "project_id", "event_type", "forced", "reason", "payload_json", "created_at"]
+};
+const primaryKeys = {
+    projects: ["id"], runs: ["project_id", "id"], works: ["work_id"],
+    work_sessions: ["id"], stage_work_memberships: ["project_id", "run_id", "work_id", "stage", "attempt", "cycle"],
+    audit_events: ["id"]
+};
+function refuse(reason) { throw new AppError("memory_init_storage_incompatible", "Executing CLI cannot admit memory-init runtime storage without migration or repair", 1, { reason, effect: "no_effect" }); }
+const normalize = (sql) => sql.replace(/\s+/g, " ").trim().replace(/;$/, "");
+function inspect(context) {
+    if (!context.db.writable || !path.isAbsolute(context.ddFlowHome) || path.resolve(context.db.path) !== path.join(path.resolve(context.ddFlowHome), "db.sqlite"))
+        refuse("foreign_or_readonly_store");
+    const contract = context.db.all("SELECT id, version FROM dd_flow_writer_contract");
+    if (contract.length !== 1 || contract[0]?.id !== 1 || contract[0].version !== STORE_WRITER_VERSION
+        || context.db.get("SELECT dd_flow_writer_version() AS version")?.version !== STORE_WRITER_VERSION)
+        refuse("writer_contract_mismatch");
+    const schema = {};
+    for (const [table, required] of Object.entries(footprint)) {
+        const columns = context.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 === "audit_events" && ["id", "forced"].includes(name) ? "INTEGER" : "TEXT")))
+            refuse(`operation_column_type_mismatch:${table}`);
+        const key = columns.filter(column => column.pk > 0).sort((a, b) => a.pk - b.pk).map(column => column.name);
+        if (JSON.stringify(key) !== JSON.stringify(primaryKeys[table]))
+            refuse(`operation_primary_key_mismatch:${table}`);
+        const fences = [];
+        for (const action of ["INSERT", "UPDATE", "DELETE"]) {
+            const expected = storeWriterTriggerSql(table, action);
+            const actual = context.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] = { columns: columns.map(({ name, type, notnull, pk }) => ({ name, type, notnull, pk })), fences };
+    }
+    return { schema_id: "dd-flow/memory-init-runtime-storage@1", operation: "memory-init",
+        store_kind: "run", store_path: context.db.path, executing_writer_version: STORE_WRITER_VERSION,
+        schema_sha256: hybridDigest(schema), route: "verified-no-op", outcome: "no-op" };
+}
+/** Current executing CLI only: never inferred support for another engine.
+ * No migrations, schema installation, writer probes or filesystem writes.
+ * Shared process stores/provider readiness require separate admission.
+ */
+export class PreparedMemoryInitRuntimeStorage {
+    sha256;
+    #facts;
+    constructor(facts) { this.#facts = facts; this.sha256 = hybridDigest(facts); Object.freeze(this); }
+    static prepare(context) {
+        try {
+            return context.db.readSnapshot(() => {
+                const facts = inspect(context), integrity = context.db.all("PRAGMA quick_check");
+                if (integrity.length !== 1 || integrity[0]?.quick_check !== "ok" || context.db.all("PRAGMA foreign_key_check").length)
+                    refuse("storage_integrity_failed");
+                return new PreparedMemoryInitRuntimeStorage(facts);
+            });
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            return refuse("storage_observation_failed");
+        }
+    }
+    facts() { return { ...this.#facts }; }
+    /** Writer-safe metadata fence; expensive integrity scan remains preparation. */
+    assertCompatibility(context) {
+        if (hybridDigest(inspect(context)) !== this.sha256)
+            refuse("storage_changed_after_preparation");
+    }
+}