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

package/dist/services/memory-layer-publication.js

@@ -0,0 +1,611 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError, errorRecord } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { acquireInstallationLock } from "./installation-lock.js";
+import { readBoundedReleaseFile } from "./release-source.js";
+import { PreparedMemoryInitTarget } from "./memory-init-preflight.js";
+import { PreparedMemoryLayer } from "./memory-layer.js";
+import { defaultMemoryLintConfiguration } from "./memory-lint-config.js";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const limit = 1024 * 1024;
+function refuse(reason) {
+    throw new AppError("memory_layer_publication_conflict", "Memory layer publication requires reconciliation", 1, { reason, phase: "publication", effect: "no_effect" });
+}
+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())
+        refuse("unsafe_directory");
+    return stat;
+}
+function homeDirectory(home) {
+    try {
+        if (!path.isAbsolute(home) || fs.realpathSync(home) !== path.resolve(home))
+            refuse("unsafe_home");
+        directory(home);
+        fs.accessSync(home, fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK);
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        refuse("home_unavailable");
+    }
+}
+function childDirectory(parent, name) {
+    directory(parent);
+    const child = path.join(parent, name);
+    if (!exists(child))
+        fs.mkdirSync(child, { mode: 0o700 });
+    directory(child);
+    return child;
+}
+function bytes(value) { return Buffer.from(`${JSON.stringify(value)}\n`); }
+function match(file, expected) {
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.nlink !== 1 || !readBoundedReleaseFile(file, limit).equals(expected))
+        refuse("retained_file_changed_or_linked");
+}
+/** The exact journal owns deterministic temporary files. Hard links publish complete bytes
+ * without rename's ability to replace a concurrently created foreign destination.
+ */
+function immutable(root, logical, content) {
+    let parent = root;
+    for (const segment of logical.split("/").slice(0, -1))
+        parent = childDirectory(parent, segment);
+    const file = path.join(root, logical), temporary = path.join(root, `.dd-flow-write-${hash(Buffer.from(logical))}.tmp`);
+    if (exists(file)) {
+        if (exists(temporary)) {
+            const retained = fs.lstatSync(file), temp = fs.lstatSync(temporary);
+            if (!retained.isFile() || !temp.isFile() || retained.ino !== temp.ino || retained.dev !== temp.dev
+                || retained.nlink !== 2 || !readBoundedReleaseFile(file, limit).equals(content))
+                refuse("foreign_pending_write");
+            fs.unlinkSync(temporary);
+        }
+        match(file, content);
+        return;
+    }
+    if (exists(temporary)) {
+        const stat = fs.lstatSync(temporary);
+        if (!stat.isFile() || stat.nlink !== 1)
+            refuse("foreign_pending_write");
+        fs.unlinkSync(temporary);
+    }
+    const fd = fs.openSync(temporary, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | (fs.constants.O_NOFOLLOW ?? 0), 0o600);
+    try {
+        fs.writeFileSync(fd, content);
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    fs.linkSync(temporary, file);
+    fs.unlinkSync(temporary);
+    match(file, content);
+}
+function layerIndex(layer) {
+    return bytes({ schema_id: "dd-flow/retained-memory-layer@1", layer_sha256: layer.sha256, pack_sha256: layer.packSha256,
+        installation_sha256: layer.installationSha256, inventory: [...layer.files()].map(([logical, content]) => ({ path: logical, sha256: hash(content) })) });
+}
+/** The request cache, not the mutable setup selection, is the restart source. */
+export function readRetainedMemoryLayer(home, selected) {
+    try {
+        homeDirectory(home);
+        if (!path.isAbsolute(selected.projectRoot) || !path.isAbsolute(selected.workspaceRoot)
+            || !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(selected.requestId)
+            || !/^[a-f0-9]{64}$/.test(selected.targetSha256) || !/^[a-f0-9]{64}$/.test(selected.layerSha256)
+            || !/^[a-f0-9]{64}$/.test(selected.installationSha256))
+            refuse("invalid_retained_selection");
+        const namespace = path.join(home, "memory-layer-publications");
+        directory(namespace);
+        const journal = path.join(namespace, hybridDigest([selected.projectRoot, selected.workspaceRoot, selected.requestId]));
+        directory(journal);
+        const intentFile = path.join(journal, "intent.json"), indexFile = path.join(journal, "layer.json");
+        const intent = JSON.parse(readBoundedReleaseFile(intentFile, limit).toString("utf8"));
+        if (intent.target_sha256 !== selected.targetSha256 || intent.layer_sha256 !== selected.layerSha256
+            || intent.installation_sha256 !== selected.installationSha256
+            || intent.facts.request_id !== selected.requestId || intent.facts.project_root !== selected.projectRoot
+            || intent.facts.workspace_root !== selected.workspaceRoot || hybridDigest(intent.facts) !== selected.targetSha256)
+            refuse("foreign_retained_selection");
+        const index = JSON.parse(readBoundedReleaseFile(indexFile, limit).toString("utf8"));
+        if (!Array.isArray(index.inventory) || index.inventory.length < 1 || index.inventory.length > 20_000)
+            refuse("invalid_retained_inventory");
+        const files = new Map();
+        let total = 0;
+        for (const item of index.inventory) {
+            if (!item || typeof item.path !== "string" || !/^(?:mbb|dd-flow)\/[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/.test(item.path)
+                || item.path.split("/").some(segment => segment === "." || segment === "..") || !/^[a-f0-9]{64}$/.test(item.sha256)
+                || files.has(item.path))
+                refuse("invalid_retained_inventory");
+            let parent = path.join(journal, "source");
+            directory(parent);
+            for (const segment of item.path.split("/").slice(0, -1)) {
+                parent = path.join(parent, segment);
+                directory(parent);
+            }
+            const file = path.join(journal, "source", item.path), content = readBoundedReleaseFile(file, limit);
+            if (fs.lstatSync(file).nlink !== 1 || hash(content) !== item.sha256 || (total += content.length) > 64 * limit)
+                refuse("retained_source_changed_or_linked");
+            files.set(item.path, content);
+        }
+        const layer = PreparedMemoryLayer.restoreRetained(files, selected.layerSha256, intent.installation_sha256);
+        match(indexFile, layerIndex(layer));
+        const identity = hybridDigest({ facts: intent.facts, target_sha256: selected.targetSha256, layer_sha256: layer.sha256,
+            pack_sha256: layer.packSha256, installation_sha256: layer.installationSha256 });
+        match(intentFile, bytes({ schema_id: "dd-flow/memory-layer-intent@1", identity, facts: intent.facts,
+            target_sha256: selected.targetSha256, layer_sha256: layer.sha256, installation_sha256: layer.installationSha256 }));
+        return layer;
+    }
+    catch (error) {
+        if (error instanceof AppError && error.code === "memory_layer_publication_conflict")
+            throw error;
+        return refuse("retained_layer_unavailable_or_changed");
+    }
+}
+/** Ownership of the exclusions used by source preservation. No canon pack
+ * restoration or tool capability qualification is needed to read user sources. */
+export function assertPublishedMemoryLayerOwnership(home, selected, facts, publicationSha256, draftIdentitySha256) {
+    try {
+        homeDirectory(home);
+        if (!path.isAbsolute(selected.projectRoot) || !path.isAbsolute(selected.workspaceRoot)
+            || fs.realpathSync(selected.workspaceRoot) !== selected.workspaceRoot
+            || !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(selected.requestId)
+            || [selected.targetSha256, selected.layerSha256, selected.packSha256, selected.installationSha256, publicationSha256].some(value => !/^[a-f0-9]{64}$/.test(value)))
+            refuse("invalid_retained_selection");
+        if (hybridDigest(facts) !== selected.targetSha256 || facts.request_id !== selected.requestId
+            || facts.project_root !== selected.projectRoot || facts.workspace_root !== selected.workspaceRoot)
+            refuse("foreign_retained_selection");
+        const namespace = path.join(home, "memory-layer-publications");
+        directory(namespace);
+        const journal = path.join(namespace, hybridDigest([selected.projectRoot, selected.workspaceRoot, selected.requestId]));
+        directory(journal);
+        const root = path.join(selected.workspaceRoot, ".memory-bank"), stat = directory(root);
+        const identity = hybridDigest({ facts, target_sha256: selected.targetSha256, layer_sha256: selected.layerSha256,
+            pack_sha256: selected.packSha256, installation_sha256: selected.installationSha256 });
+        const receipt = { schema_id: "dd-flow/memory-layer-publication@1", identity,
+            request_id: selected.requestId, project_root: selected.projectRoot, workspace_root: selected.workspaceRoot,
+            target_sha256: selected.targetSha256, layer_sha256: selected.layerSha256, pack_sha256: selected.packSha256,
+            installation_sha256: selected.installationSha256, root_device: stat.dev, root_inode: stat.ino };
+        const expected = bytes(receipt);
+        if (hash(expected) !== publicationSha256)
+            refuse("published_layer_owner_changed");
+        for (const file of [path.join(journal, "owner.json"), path.join(journal, "receipt.json"), path.join(root, ".dd-flow-layer-owner.json")])
+            match(file, expected);
+        if (facts.generated_lint_config_sha256) {
+            const draftBytes = readBoundedReleaseFile(path.join(journal, "draft-identity-receipt.json"), limit);
+            const draft = JSON.parse(draftBytes.toString("utf8"));
+            if (hash(draftBytes) !== draftIdentitySha256 || draft.schema_id !== "dd-flow/memory-init-draft-identity@2"
+                || draft.layer_publication_sha256 !== publicationSha256 || draft.project_root !== selected.projectRoot
+                || draft.workspace_root !== selected.workspaceRoot || draft.request_id !== selected.requestId
+                || draft.lint_configuration?.path !== ".mb-lint.json" || draft.lint_configuration.sha256 !== facts.generated_lint_config_sha256)
+                refuse("generated_lint_configuration_custody_changed");
+            match(path.join(selected.workspaceRoot, ".mb-lint.json"), defaultMemoryLintConfiguration());
+        }
+        return receipt;
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        return refuse("published_layer_unavailable_or_changed");
+    }
+}
+/** Read-only restart of a completed, independently selected publication. It
+ * does not republish drafts or treat a project-local marker as its authority.
+ * The caller selects the publication checksum from its registered SQL receipt.
+ */
+export function restorePublishedMemoryLayer(home, selected, publicationSha256, env, draftIdentitySha256) {
+    try {
+        if (!/^[a-f0-9]{64}$/.test(publicationSha256))
+            refuse("invalid_publication_identity");
+        const layer = readRetainedMemoryLayer(home, selected);
+        const journal = path.join(home, "memory-layer-publications", hybridDigest([selected.projectRoot, selected.workspaceRoot, selected.requestId]));
+        const intent = JSON.parse(readBoundedReleaseFile(path.join(journal, "intent.json"), limit).toString("utf8"));
+        const facts = intent.facts;
+        const receipt = assertPublishedMemoryLayerOwnership(home, { ...selected, packSha256: layer.packSha256 }, facts, publicationSha256, draftIdentitySha256);
+        const target = PreparedMemoryInitTarget.restoreOwnedPublication(facts, selected.targetSha256, env);
+        return { target, layer, receipt: structuredClone(receipt) };
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        return refuse("published_layer_unavailable_or_changed");
+    }
+}
+/** Restart ingress requires independently retained selection, not values from a project marker.
+ * Mutable operator defaults and a fresh target preparation are never fallback sources.
+ */
+export function resumeMemoryLayerPublication(home, selected, layer, env, onCheckpoint) {
+    try {
+        return resumeRetainedPublication(home, selected, layer, env, onCheckpoint);
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        return refuse("retained_publication_unavailable");
+    }
+}
+function resumeRetainedPublication(home, selected, layer, env, onCheckpoint) {
+    homeDirectory(home);
+    if (!path.isAbsolute(selected.projectRoot) || !path.isAbsolute(selected.workspaceRoot)
+        || !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(selected.requestId)
+        || !/^[a-f0-9]{64}$/.test(selected.targetSha256) || layer.sha256 !== selected.layerSha256
+        || layer.installationSha256 !== selected.installationSha256)
+        refuse("invalid_retained_selection");
+    const namespace = path.join(home, "memory-layer-publications");
+    directory(namespace);
+    const journal = path.join(namespace, hybridDigest([selected.projectRoot, selected.workspaceRoot, selected.requestId]));
+    directory(journal);
+    const intentFile = path.join(journal, "intent.json"), ownerFile = path.join(journal, "owner.json");
+    const intent = JSON.parse(readBoundedReleaseFile(intentFile, limit).toString("utf8"));
+    if (intent.target_sha256 !== selected.targetSha256 || intent.layer_sha256 !== selected.layerSha256
+        || intent.facts.project_root !== selected.projectRoot || intent.facts.workspace_root !== selected.workspaceRoot
+        || intent.facts.request_id !== selected.requestId || hybridDigest(intent.facts) !== selected.targetSha256)
+        refuse("foreign_retained_selection");
+    const identity = hybridDigest({ facts: intent.facts, target_sha256: selected.targetSha256, layer_sha256: layer.sha256,
+        pack_sha256: layer.packSha256, installation_sha256: layer.installationSha256 });
+    const expectedIntent = bytes({ schema_id: "dd-flow/memory-layer-intent@1", identity, facts: intent.facts,
+        target_sha256: selected.targetSha256, layer_sha256: layer.sha256, installation_sha256: layer.installationSha256 });
+    match(intentFile, expectedIntent);
+    const root = path.join(selected.workspaceRoot, ".memory-bank");
+    if (exists(root)) {
+        const owner = bytes({ schema_id: "dd-flow/memory-layer-publication@1", identity, request_id: selected.requestId,
+            project_root: selected.projectRoot, workspace_root: selected.workspaceRoot, target_sha256: selected.targetSha256,
+            layer_sha256: layer.sha256, pack_sha256: layer.packSha256, installation_sha256: layer.installationSha256,
+            root_device: directory(root).dev, root_inode: directory(root).ino });
+        match(ownerFile, owner);
+        match(path.join(root, ".dd-flow-layer-owner.json"), owner);
+    }
+    else if (exists(ownerFile))
+        refuse("owned_root_missing");
+    const target = PreparedMemoryInitTarget.restoreOwnedPublication(intent.facts, selected.targetSha256, env);
+    return publishMemoryLayer(home, target, layer, env, onCheckpoint);
+}
+/** File-custody operation only: not registration, storage readiness, profile qualification
+ * or a memory-bootstrap-receipt. The productive dispatcher must admit those separately.
+ * A retained prepared target and selected layer can reconcile after process restart;
+ * a project-local owner marker without the independent CLI-home intent cannot authorize it.
+ */
+export function publishMemoryLayer(home, target, layer, env, onCheckpoint) {
+    const facts = target.facts(), files = layer.files();
+    const identity = hybridDigest({ facts, target_sha256: target.sha256, layer_sha256: layer.sha256,
+        pack_sha256: layer.packSha256, installation_sha256: layer.installationSha256 });
+    const intent = bytes({ schema_id: "dd-flow/memory-layer-intent@1", identity, facts,
+        target_sha256: target.sha256, layer_sha256: layer.sha256, installation_sha256: layer.installationSha256 });
+    const indexBytes = layerIndex(layer);
+    if (indexBytes.length > limit)
+        refuse("layer_index_exceeds_bound");
+    homeDirectory(home);
+    const namespace = path.join(home, "memory-layer-publications"), root = path.join(facts.workspace_root, ".memory-bank");
+    const key = hybridDigest([facts.project_root, facts.workspace_root, facts.request_id]);
+    const journal = path.join(namespace, key), intentFile = path.join(journal, "intent.json");
+    if (exists(namespace))
+        directory(namespace);
+    if (exists(journal))
+        directory(journal);
+    // Fresh input is revalidated before even creating the request namespace.
+    const replay = exists(intentFile);
+    if (!replay)
+        target.revalidate();
+    let lock;
+    let started = replay;
+    let phase = "namespace_retained";
+    let primaryFailure;
+    let failed = false;
+    let result;
+    try {
+        if (!exists(namespace)) {
+            fs.mkdirSync(namespace, { mode: 0o700 });
+            started = true;
+        }
+        directory(namespace);
+        lock = acquireInstallationLock(path.join(namespace, `${hybridDigest(facts.workspace_root)}.lock`), identity);
+        if (replay) {
+            directory(journal);
+            match(intentFile, intent);
+        }
+        else {
+            // The lock does not make a foreign journal or partial MB ours.
+            target.revalidate();
+            if (exists(journal))
+                refuse("foreign_request_journal");
+            fs.mkdirSync(journal, { mode: 0o700 });
+            started = true;
+            immutable(journal, "intent.json", intent);
+        }
+        phase = "intent_retained";
+        onCheckpoint?.(phase);
+        const selected = { projectRoot: facts.project_root, workspaceRoot: facts.workspace_root,
+            requestId: facts.request_id, targetSha256: target.sha256, layerSha256: layer.sha256, installationSha256: layer.installationSha256 };
+        if (exists(path.join(journal, "layer.json")))
+            readRetainedMemoryLayer(home, selected);
+        else {
+            if (exists(path.join(journal, "owner.json")) || exists(path.join(journal, "receipt.json")))
+                refuse("retained_layer_index_missing");
+            for (const [logical, content] of files)
+                immutable(journal, `source/${logical}`, content);
+            immutable(journal, "layer.json", indexBytes);
+            readRetainedMemoryLayer(home, selected);
+        }
+        phase = "layer_retained";
+        onCheckpoint?.(phase);
+        const ownerFile = path.join(journal, "owner.json"), ownerLogical = ".dd-flow-layer-owner.json";
+        let receipt;
+        if (exists(root)) {
+            if (!exists(ownerFile))
+                refuse("unowned_memory_bank");
+            const stat = directory(root);
+            const expected = makeReceipt(facts, target, layer, identity, stat);
+            match(ownerFile, bytes(expected));
+            match(path.join(root, ownerLogical), bytes(expected));
+            receipt = expected;
+        }
+        else {
+            if (exists(ownerFile))
+                refuse("owned_root_missing");
+            target.revalidate();
+            // Exclusive mkdir is the no-clobber reservation. A crash before owner retention
+            // leaves an explicit uncertain partial, never an authorization to replace it.
+            fs.mkdirSync(root, { mode: 0o700 });
+            receipt = makeReceipt(facts, target, layer, identity, directory(root));
+            immutable(root, ownerLogical, bytes(receipt));
+            immutable(journal, "owner.json", bytes(receipt));
+        }
+        phase = "root_owned";
+        onCheckpoint?.(phase);
+        PreparedMemoryInitTarget.revalidateOwnedPublication(facts, target.sha256, env);
+        const completion = path.join(journal, "receipt.json"), wasComplete = exists(completion);
+        if (wasComplete)
+            match(completion, bytes(receipt));
+        for (const [logical, content] of files) {
+            if (wasComplete)
+                match(path.join(root, logical), content);
+            else
+                immutable(root, logical, content);
+            phase = "file_published";
+            onCheckpoint?.(phase);
+        }
+        const allowed = new Set([...files.keys(), ownerLogical]);
+        const inspect = (parent, prefix = "") => {
+            for (const name of fs.readdirSync(parent)) {
+                const logical = prefix ? `${prefix}/${name}` : name, file = path.join(parent, name), stat = fs.lstatSync(file);
+                if (stat.isDirectory()) {
+                    if (![...allowed].some(item => item.startsWith(`${logical}/`)))
+                        refuse("unlisted_publication_directory");
+                    inspect(file, logical);
+                }
+                else {
+                    if (!allowed.has(logical))
+                        refuse("unlisted_publication_file");
+                    match(file, logical === ownerLogical ? bytes(receipt) : files.get(logical));
+                }
+            }
+        };
+        // After completion, project-owned documents/runtime artifacts may legitimately
+        // be created by later bootstrap/stages. Replay reads only our retained inventory;
+        // it is neither a project-tree restoration nor a claim about semantic grounding.
+        if (!wasComplete)
+            inspect(root);
+        PreparedMemoryInitTarget.revalidateOwnedPublication(facts, target.sha256, env);
+        phase = "layer_verified";
+        onCheckpoint?.(phase);
+        immutable(journal, "receipt.json", bytes(receipt));
+        phase = "receipt_retained";
+        onCheckpoint?.(phase);
+        result = { receipt, sha256: hash(bytes(receipt)), changed: !wasComplete };
+    }
+    catch (error) {
+        failed = true;
+        primaryFailure = !started ? error : new AppError("memory_layer_publication_failed", "Memory layer publication retained an incomplete outcome", 1, { reason: error instanceof AppError ? error.details?.reason ?? error.code : "publication_io_failure",
+            phase, effect: "partial", identity, journal_path: journal, workspace_root: facts.workspace_root,
+            next_action: "reconcile_exact_request" });
+    }
+    try {
+        lock?.release();
+    }
+    catch {
+        throw new AppError("memory_layer_publication_failed", "Memory layer owner cleanup requires reconciliation", 1, { reason: "lock_cleanup_failed", phase, effect: "partial", identity, journal_path: journal,
+            ...(failed ? { primary_error: errorRecord(primaryFailure) } : {}), next_action: "reconcile_exact_request" });
+    }
+    if (failed)
+        throw primaryFailure;
+    return result;
+}
+/** Selected publication inventory, without restoring or qualifying tools or
+ * reading every canon file. Referenced physical bytes are checked by the caller. */
+export function readPublishedMemoryReferenceInventory(home, selected, facts, publicationSha256, draftIdentitySha256) {
+    assertPublishedMemoryLayerOwnership(home, selected, facts, publicationSha256, draftIdentitySha256);
+    const journal = path.join(home, "memory-layer-publications", hybridDigest([selected.projectRoot, selected.workspaceRoot, selected.requestId]));
+    const index = JSON.parse(readBoundedReleaseFile(path.join(journal, "layer.json"), limit).toString("utf8"));
+    if (index.schema_id !== "dd-flow/retained-memory-layer@1" || index.layer_sha256 !== selected.layerSha256
+        || index.pack_sha256 !== selected.packSha256 || index.installation_sha256 !== selected.installationSha256
+        || !Array.isArray(index.inventory) || index.inventory.length > 20_000 || hybridDigest(index.inventory) !== selected.layerSha256)
+        refuse("invalid_retained_inventory");
+    const canon = new Map();
+    for (const item of index.inventory) {
+        if (!item || !/^(?:mbb|dd-flow)\/[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/.test(item.path)
+            || item.path.split("/").some(segment => segment === "." || segment === "..")
+            || !/^[a-f0-9]{64}$/.test(item.sha256) || canon.has(item.path))
+            refuse("invalid_retained_inventory");
+        canon.set(item.path, item.sha256);
+    }
+    const draftBytes = readBoundedReleaseFile(path.join(journal, "draft-identity-receipt.json"), limit);
+    const draft = JSON.parse(draftBytes.toString("utf8"));
+    if (hash(draftBytes) !== draftIdentitySha256 || !["dd-flow/memory-init-draft-identity@1", "dd-flow/memory-init-draft-identity@2"].includes(draft.schema_id)
+        || draft.request_id !== selected.requestId || draft.project_root !== selected.projectRoot || draft.workspace_root !== selected.workspaceRoot
+        || draft.layer_publication_sha256 !== publicationSha256 || !Array.isArray(draft.files))
+        refuse("draft_identity_custody_changed");
+    const artifacts = new Map([...canon].map(([logical, sha256]) => [`.memory-bank/${logical}`, sha256]));
+    for (const item of draft.files) {
+        if (!item || !["index.md", "project-policy.md", "structure.md"].includes(item.path) || !/^[a-f0-9]{64}$/.test(item.sha256))
+            refuse("draft_identity_custody_changed");
+        artifacts.set(`.memory-bank/${item.path}`, item.sha256);
+    }
+    artifacts.set(".memory-bank/.dd-flow-layer-owner.json", publicationSha256);
+    if (draft.lint_configuration)
+        artifacts.set(draft.lint_configuration.path, draft.lint_configuration.sha256);
+    return { canon, artifacts };
+}
+/** Publish draft identity and a reserved absent root lint policy after the
+ * retained layer's custody operation; existing user policy is never replaced.
+ * This does not qualify prerequisites, register a project, accept project facts
+ * or issue bootstrap readiness. The productive bootstrap must perform admission
+ * before calling either publication operation.
+ */
+export function publishMemoryInitDraftIdentity(home, target, layer, env, onCheckpoint) {
+    const published = publishMemoryLayer(home, target, layer, env), facts = target.facts();
+    const namespace = path.join(home, "memory-layer-publications"), journal = path.join(namespace, hybridDigest([facts.project_root, facts.workspace_root, facts.request_id]));
+    const root = path.join(facts.workspace_root, ".memory-bank");
+    const intent = path.join(journal, "draft-identity-intent.json"), completion = path.join(journal, "draft-identity-receipt.json");
+    let lock;
+    let phase = "draft_prepare", started = false, primary, failed = false;
+    let result;
+    try {
+        lock = acquireInstallationLock(path.join(namespace, `${hybridDigest(facts.workspace_root)}.lock`), published.receipt.identity);
+        // A project marker alone never authorizes scaffold writes or replay.
+        match(path.join(journal, "owner.json"), bytes(published.receipt));
+        match(path.join(root, ".dd-flow-layer-owner.json"), bytes(published.receipt));
+        match(path.join(journal, "receipt.json"), bytes(published.receipt));
+        const stat = directory(root);
+        if (stat.dev !== published.receipt.root_device || stat.ino !== published.receipt.root_inode)
+            refuse("draft_identity_root_changed");
+        PreparedMemoryInitTarget.revalidateOwnedPublication(facts, target.sha256, env);
+        const preparedAt = exists(intent)
+            ? JSON.parse(readBoundedReleaseFile(intent, limit).toString("utf8")).receipt?.prepared_at
+            : new Date().toISOString();
+        if (typeof preparedAt !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(preparedAt)
+            || !Number.isFinite(Date.parse(preparedAt)) || new Date(preparedAt).toISOString() !== preparedAt)
+            refuse("draft_identity_time_invalid");
+        const documents = draftIdentityDocuments(facts, preparedAt.slice(0, 10));
+        const lintBytes = facts.generated_lint_config_sha256 ? defaultMemoryLintConfiguration() : undefined;
+        const lintFile = path.join(facts.workspace_root, ".mb-lint.json");
+        if (lintBytes && hash(lintBytes) !== facts.generated_lint_config_sha256)
+            refuse("lint_configuration_reservation_changed");
+        const receipt = {
+            schema_id: lintBytes ? "dd-flow/memory-init-draft-identity@2" : "dd-flow/memory-init-draft-identity@1", request_id: facts.request_id,
+            project_root: facts.project_root, workspace_root: facts.workspace_root,
+            layer_publication_sha256: published.sha256, prepared_at: preparedAt,
+            files: [...documents].map(([logical, content]) => ({ path: logical, sha256: hash(content) })),
+            semantic_status: "draft_not_accepted",
+            ...(lintBytes ? { lint_configuration: { path: ".mb-lint.json", sha256: hash(lintBytes) } } : {})
+        };
+        const receiptBytes = bytes(receipt), intentBytes = bytes({ receipt,
+            documents: [...documents].map(([logical, content]) => ({ path: logical, base64: content.toString("base64") })),
+            ...(lintBytes ? { lint_configuration: { path: ".mb-lint.json", base64: lintBytes.toString("base64") } } : {}) });
+        if (exists(completion)) {
+            match(intent, intentBytes);
+            match(completion, receiptBytes);
+            if (lintBytes)
+                match(lintFile, lintBytes);
+            // Drafts become project-owned inputs after publication. Do not replace,
+            // restore or reject later semantic edits, and do not attest their contents.
+            result = { receipt, sha256: hash(receiptBytes), changed: false };
+        }
+        else {
+            const replay = exists(intent);
+            if (replay) {
+                match(intent, intentBytes);
+                started = true;
+            }
+            if (lintBytes && !replay && exists(path.join(facts.workspace_root, `.dd-flow-write-${hash(Buffer.from(".mb-lint.json"))}.tmp`)))
+                refuse("foreign_lint_configuration_temporary");
+            if (lintBytes && exists(lintFile)) {
+                if (!replay)
+                    refuse("foreign_lint_configuration");
+                const stat = fs.lstatSync(lintFile), temporary = path.join(facts.workspace_root, `.dd-flow-write-${hash(Buffer.from(".mb-lint.json"))}.tmp`);
+                if (stat.nlink === 2 && exists(temporary)) {
+                    const pending = fs.lstatSync(temporary);
+                    if (!stat.isFile() || !pending.isFile() || pending.nlink !== 2 || stat.dev !== pending.dev || stat.ino !== pending.ino
+                        || !readBoundedReleaseFile(lintFile, limit).equals(lintBytes))
+                        refuse("foreign_pending_write");
+                }
+                else
+                    match(lintFile, lintBytes);
+            }
+            // Inspect every existing destination before publishing any draft. In an
+            // incomplete own request only the original retained bytes are resumable.
+            for (const [logical, content] of documents) {
+                const destination = path.join(root, logical);
+                if (exists(destination)) {
+                    if (!replay)
+                        refuse("foreign_draft_identity_file");
+                    const stat = fs.lstatSync(destination);
+                    const temporary = path.join(root, `.dd-flow-write-${hash(Buffer.from(logical))}.tmp`);
+                    // A crash between link and unlink leaves two names for our exact
+                    // pending inode. Validate without effects; immutable() reconciles it.
+                    if (stat.nlink === 2 && exists(temporary)) {
+                        const pending = fs.lstatSync(temporary);
+                        if (!stat.isFile() || !pending.isFile() || pending.nlink !== 2
+                            || stat.dev !== pending.dev || stat.ino !== pending.ino
+                            || !readBoundedReleaseFile(destination, limit).equals(content))
+                            refuse("foreign_pending_write");
+                    }
+                    else
+                        match(destination, content);
+                }
+            }
+            started = true;
+            immutable(journal, "draft-identity-intent.json", intentBytes);
+            phase = "draft_intent_retained";
+            onCheckpoint?.("draft_intent_retained");
+            if (lintBytes)
+                immutable(facts.workspace_root, ".mb-lint.json", lintBytes);
+            for (const [logical, content] of documents) {
+                immutable(root, logical, content);
+                phase = "draft_file_published";
+                onCheckpoint?.("draft_file_published");
+            }
+            PreparedMemoryInitTarget.revalidateOwnedPublication(facts, target.sha256, env);
+            immutable(journal, "draft-identity-receipt.json", receiptBytes);
+            phase = "draft_receipt_retained";
+            onCheckpoint?.("draft_receipt_retained");
+            result = { receipt, sha256: hash(receiptBytes), changed: true };
+        }
+    }
+    catch (error) {
+        primary = error;
+        failed = true;
+    }
+    try {
+        lock?.release();
+    }
+    catch {
+        throw new AppError("memory_init_draft_publication_failed", "Draft identity owner cleanup requires reconciliation", 1, { reason: "lock_cleanup_failed", phase, effect: "partial", ...(failed ? { primary_error: errorRecord(primary) } : {}), next_action: "reconcile_exact_request" });
+    }
+    if (failed)
+        throw new AppError("memory_init_draft_publication_failed", "Draft identity publication requires reconciliation", 1, { reason: primary instanceof AppError ? primary.details?.reason ?? primary.code : "draft_publication_io_failure",
+            phase, effect: started || published.changed ? "partial" : "no_effect", next_action: "reconcile_exact_request" });
+    return result;
+}
+function draftIdentityDocuments(facts, date) {
+    const header = (file, description, parent) => `---\nfile: ${JSON.stringify(`.memory-bank/${file}`)}\ndescription: ${JSON.stringify(description)}\npurpose: "Draft bootstrap navigation; project facts and policy require agent acceptance."\nversion: '0.1.0'\ndate: '${date}'\nstatus: 'DRAFT'\nc4_level: 'documentation'\nparent: ${parent === null ? "null" : JSON.stringify(parent)}\ntags: [memory-init, draft]\nbootstrap_request: ${JSON.stringify(facts.request_id)}\n---\n\n`;
+    // No source-code facts, build commands, integration branch or user policy are
+    // inferred from the directory name or the presence of a canonical template.
+    return new Map([
+        ["index.md", Buffer.from(header("index.md", "Draft project Memory Bank entry point.", null)
+                + "# Project Memory Bank — draft\n\nProject identity, scope and facts are not accepted yet. Complete discovery and composition before using this draft as project truth.\n\n"
+                + "- [Structure](structure.md): draft folder map.\n- [Project policy](project-policy.md): unresolved project policy.\n- [MBB](mbb/index.md): selected canonical guidance.\n- [DD Flow](dd-flow/index.md): installed flow pack; not proof of project readiness.\n")],
+        ["structure.md", Buffer.from(header("structure.md", "Draft project Memory Bank folder map.", ".memory-bank/index.md")
+                + "# Memory Bank structure — draft\n\nOnly the bootstrap layer is described here; project architecture and document shelves remain unknown.\n\n"
+                + "- `mbb/`: selected canonical rules and templates.\n- `dd-flow/`: selected curated flow pack.\n- Root identity documents: unaccepted bootstrap drafts.\n\nNext action: derive the project folder map from discovery evidence and update this document during composition.\n")],
+        ["project-policy.md", Buffer.from(header("project-policy.md", "Draft project policy with unresolved decisions.", ".memory-bank/index.md")
+                + "# Project policy — draft\n\nGit integration route, integration branch, required checks, workspace bootstrap, delivery authority and secrets policy are unknown. This draft grants no merge, release, deployment or publication authority.\n\n"
+                + "Reason: bootstrap has not established project-specific policy evidence.\n\nNext action: inspect existing project rules during discovery; ask the user only for material decisions that cannot be established from evidence. Unresolved integration policy blocks completion.\n")]
+    ]);
+}
+function makeReceipt(facts, target, layer, identity, stat) {
+    return { schema_id: "dd-flow/memory-layer-publication@1", identity, request_id: facts.request_id,
+        project_root: facts.project_root, workspace_root: facts.workspace_root, target_sha256: target.sha256,
+        layer_sha256: layer.sha256, pack_sha256: layer.packSha256, installation_sha256: layer.installationSha256,
+        root_device: stat.dev, root_inode: stat.ino };
+}