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

package/dist/services/memory-repair-work-results.js

@@ -0,0 +1,108 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { AdmittedFrozenEngine } from "./frozen-engine.js";
+import { memoryRepairWorkerSchema } from "./memory-repair-registration.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+import { parseMemoryWorkResultProposal } from "./memory-work-result-json.js";
+/** Claim shape only, never settlement or finding closure. Reconciliation
+ * preserves documents and requires current grounded evidence plus the same
+ * fresh check and independent re-review owners as a physical repair. */
+export function isCompletedMemoryRepairClaim(value) {
+    return Array.isArray(value?.changes) && (value.outcome === "accepted" && value.changes.length > 0
+        || value.outcome === "reconciled" && value.changes.length === 0 && Array.isArray(value.resolutions) && value.resolutions.length > 0
+            && value.resolutions.every(resolution => Array.isArray(resolution?.delta_paths) && resolution.delta_paths.length === 0
+                && Array.isArray(resolution.evidence) && resolution.evidence.some(ref => ref?.root === "workspace")));
+}
+function refuse(reason) {
+    throw new AppError("memory_repair_work_result_invalid", "Repair result differs from registered findings and bounded write paths", 2, { reason, effect: "no_effect" });
+}
+/** Metadata projection, not authority. Only a separately admitted current
+ * view may replace the frozen original workspace references with these.
+ */
+export function memoryRepairCurrentReferences(packet, workspace) {
+    return [...packet.read_inputs.filter(ref => ref.root === "run").map(ref => ({ ...ref })),
+        ...workspace.entries().filter(entry => entry.kind === "file").map(entry => ({ root: "workspace", path: entry.path, sha256: entry.sha256 }))];
+}
+/** Claim validation only. Before/after hashes are not physical evidence until
+ * a registered writer proves its start baseline, exact delta and publication.
+ * An accepted repair is not an independently accepted re-review or closure.
+ */
+export function validateMemoryRepairWorkResult(bytes, engine, binding) {
+    try {
+        if (!(bytes instanceof Uint8Array) || !bytes.byteLength || bytes.byteLength > 1024 * 1024 || !(engine instanceof AdmittedFrozenEngine)
+            || !binding.workId || binding.packet?.result_schema !== memoryRepairWorkerSchema)
+            refuse("invalid_preparation_binding");
+        const schema = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(engine.schema("memory-repair-work-result")));
+        const value = parseMemoryWorkResultProposal(bytes, "memory_repair_work_result_invalid");
+        if (schema.$id !== memoryRepairWorkerSchema)
+            refuse("invalid_result_schema");
+        const packet = binding.packet;
+        if (value.schema_id !== memoryRepairWorkerSchema || value.run_id !== packet.run_id || value.work_id !== binding.workId || value.packet_sha256 !== packet.packet_sha256
+            || value.wave !== packet.wave)
+            refuse("foreign_result_identity");
+        const validate = new Ajv2020({ strict: true, validateFormats: false }).compile(schema);
+        if (!validate(value))
+            throw new AppError("memory_repair_work_result_invalid", "Repair result proposal does not match its schema; correct the reported fields without changing the private repair or assigned packet", 2, { reason: "invalid_result_schema", phase: "prepare", effect: "no_effect", recoverable: true,
+                errors: structuredClone(validate.errors), result_sha256: createHash("sha256").update(bytes).digest("hex") });
+        const nonblank = (text) => Boolean(text.trim()) && !text.includes("\0");
+        if (!nonblank(value.summary))
+            refuse("missing_repair_summary");
+        const paths = new Set();
+        for (const change of value.changes) {
+            if (!packet.write_paths.includes(change.path) || paths.has(change.path))
+                refuse("foreign_or_repeated_delta");
+            paths.add(change.path);
+            if (change.before_sha256 === change.after_sha256)
+                refuse("unchanged_repair_delta");
+        }
+        const sources = new Map((binding.effectiveInputs ?? packet.read_inputs).map(ref => [memorySourceKey(ref.root, ref.path), ref.sha256]));
+        for (const change of value.changes) {
+            const key = memorySourceKey("workspace", change.path);
+            sources.delete(key);
+            if (change.after_sha256 !== null)
+                sources.set(key, change.after_sha256);
+        }
+        const ids = new Set();
+        for (const resolution of value.resolutions) {
+            if (!packet.findings.some(finding => finding.id === resolution.finding_id) || ids.has(resolution.finding_id))
+                refuse("foreign_or_repeated_resolution");
+            ids.add(resolution.finding_id);
+            if (!nonblank(resolution.summary))
+                refuse("missing_resolution_summary");
+            if (resolution.delta_paths.some(logical => !paths.has(logical)))
+                refuse("resolution_without_actual_delta");
+            for (const ref of resolution.evidence) {
+                const key = memorySourceKey(ref.root, ref.path);
+                if (sources.get(key) !== ref.sha256)
+                    refuse("foreign_or_stale_resolution_evidence");
+            }
+            if (value.outcome === "reconciled") {
+                if (value.changes.length || resolution.delta_paths.length)
+                    refuse("reconciliation_has_document_delta");
+                if (!resolution.evidence.some(ref => ref.root === "workspace"))
+                    refuse("reconciliation_without_current_evidence");
+                continue;
+            }
+            if (!resolution.delta_paths.length)
+                refuse("resolution_without_actual_delta");
+            const causal = value.changes.filter(change => resolution.delta_paths.includes(change.path));
+            if (causal.some(change => change.after_sha256 !== null)) {
+                if (!resolution.evidence.some(ref => ref.root === "workspace" && causal.some(change => change.path === ref.path && change.after_sha256 !== null && change.after_sha256 === ref.sha256)))
+                    refuse("resolution_without_changed_output");
+            }
+            else if (!resolution.evidence.some(ref => ref.root === "run"))
+                refuse("deletion_without_retained_evidence");
+        }
+        if (value.outcome !== "blocked" && (!isCompletedMemoryRepairClaim(value) || ids.size !== packet.findings.length))
+            refuse("incomplete_repair_claim");
+        if (value.outcome === "blocked" && (value.changes.length || value.resolutions.length))
+            refuse("blocked_repair_has_productive_claims");
+        return structuredClone(value);
+    }
+    catch (error) {
+        if (error instanceof AppError && ["memory_repair_work_result_invalid", "frozen_engine_invalid"].includes(error.code))
+            throw error;
+        return refuse("invalid_result_or_binding");
+    }
+}

package/dist/services/memory-repair-workspace.js

@@ -0,0 +1,261 @@
+import fs from "node:fs";
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+import { reviewEnvironmentAllowed, reviewSourceFilter, reviewSourcePaths } from "./review-copy.js";
+function refuse(reason) {
+    throw new AppError("memory_repair_workspace_invalid", "Private writer workspace differs from its selected source", 1, { reason, effect: "no_effect" });
+}
+function inventory(root) {
+    if (!path.isAbsolute(root) || fs.realpathSync(root) !== path.resolve(root) || !fs.lstatSync(root).isDirectory())
+        refuse("noncanonical_workspace");
+    if ((fs.lstatSync(root).mode & 0o7777) !== 0o700)
+        refuse("nonprivate_workspace_root");
+    const entries = [], aliases = new Set();
+    const visit = (relative, depth) => {
+        if (depth > 64 || relative.length > 4096 || entries.length >= 20_000)
+            refuse("unbounded_inventory");
+        const stat = fs.lstatSync(path.join(root, relative));
+        if (!stat.isDirectory() && !stat.isFile() || stat.isFile() && stat.nlink !== 1)
+            refuse("linked_or_special_entry");
+        const alias = relative.normalize("NFC").toLowerCase();
+        if (aliases.has(alias))
+            refuse("aliased_inventory");
+        aliases.add(alias);
+        entries.push({ path: relative, kind: stat.isDirectory() ? "directory" : "file", mode: stat.mode & 0o7777, sha256: null });
+        if (stat.isDirectory())
+            for (const name of fs.readdirSync(path.join(root, relative)).sort()) {
+                if (name.includes("\\") || name.includes("\0"))
+                    refuse("unsafe_entry");
+                visit(`${relative}/${name}`, depth + 1);
+            }
+    };
+    for (const name of fs.readdirSync(root).sort())
+        visit(name, 0);
+    const observations = ObservedMemorySources.capture({ workspace: root }, entries.filter(entry => entry.kind === "file")
+        .map(entry => ({ root: "workspace", path: entry.path })));
+    const initial = structuredClone(entries);
+    entries.length = 0;
+    aliases.clear();
+    for (const name of fs.readdirSync(root).sort())
+        visit(name, 0);
+    observations.revalidate();
+    if (hybridDigest(entries) !== hybridDigest(initial))
+        refuse("inventory_changed_during_observation");
+    const hashes = observations.hashes();
+    return entries.map(entry => ({ ...entry, sha256: entry.kind === "file" ? hashes.get(memorySourceKey("workspace", entry.path)) : null }));
+}
+/** Physical selected-input copy only. Its manifest also protects non-MB
+ * inputs at settlement. It does not establish SQL, Session or launch custody.
+ */
+export class PreparedMemoryRepairWorkspace {
+    sha256;
+    #entries;
+    #source;
+    #observed;
+    #exported;
+    constructor(source, entries, observed, exported) {
+        this.#source = source;
+        this.#entries = structuredClone(entries);
+        this.#observed = observed;
+        this.#exported = exported;
+        this.sha256 = hybridDigest(entries);
+        Object.freeze(this);
+    }
+    static capture(source, input, exported) {
+        const candidates = reviewSourcePaths(source, input.explicit_inputs, input.base);
+        if (!candidates)
+            refuse("git_source_inventory_required");
+        const allowed = reviewSourceFilter(source, input.explicit_inputs, input.base);
+        const exportedFiles = new Set(exported.entries().filter(entry => entry.kind === "file").map(entry => entry.path));
+        const selected = candidates.filter(logical => allowed(path.join(source, logical))
+            && logical.split("/").every(part => ![".git", "node_modules", ".dd-flow"].includes(part.normalize("NFC").toLowerCase()))).filter(logical => {
+            const stat = fs.lstatSync(path.join(source, logical), { throwIfNoEntry: false });
+            // The sanitized writer copy contains regular inputs only. This applies
+            // to project command links too; never follow or materialize their targets.
+            if (stat?.isSymbolicLink())
+                return false;
+            if (!logical.startsWith(".memory-bank/") || exportedFiles.has(logical))
+                return true;
+            // Git's cached inventory includes tracked deletions. A retained export
+            // can explain an absent MB file, never a present unselected object.
+            if (stat)
+                refuse("exported_source_changed");
+            return false;
+        });
+        const observed = ObservedMemorySources.capture({ workspace: source }, selected.map(logical => ({ root: "workspace", path: logical })));
+        const hashes = observed.hashes(), entries = new Map(exported.entries().map(entry => {
+            if (entry.kind === "link")
+                refuse("linked_exported_source");
+            return [entry.path, { ...entry, kind: entry.kind }];
+        }));
+        for (const logical of selected) {
+            const file = path.join(source, logical), stat = fs.lstatSync(file);
+            const entry = { path: logical, kind: "file", mode: stat.mode & 0o7777, sha256: hashes.get(memorySourceKey("workspace", logical)) };
+            if (logical.startsWith(".memory-bank/")) {
+                if (hybridDigest(entries.get(logical)) !== hybridDigest(entry))
+                    refuse("exported_source_changed");
+            }
+            else
+                entries.set(logical, entry);
+            const parts = logical.split("/");
+            for (let length = 1; length < parts.length; length++) {
+                const parent = parts.slice(0, length).join("/");
+                if (!entries.has(parent))
+                    entries.set(parent, { path: parent, kind: "directory", mode: fs.lstatSync(path.join(source, parent)).mode & 0o7777, sha256: null });
+            }
+        }
+        const prepared = new PreparedMemoryRepairWorkspace(source, [...entries.values()].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0), observed, exported);
+        if (entries.size > 20_000 || new Set([...entries.keys()].map(logical => logical.normalize("NFC").toLowerCase())).size !== entries.size)
+            refuse("unbounded_or_aliased_selection");
+        prepared.revalidateSource();
+        return prepared;
+    }
+    entries() { return structuredClone(this.#entries); }
+    bytes() {
+        const bytes = Buffer.from(JSON.stringify({ schema_id: "dd-flow/memory-repair-workspace-manifest@1", entries: this.#entries }));
+        if (bytes.length > 8 * 1024 * 1024)
+            refuse("unbounded_manifest_receipt");
+        return bytes;
+    }
+    /** Pure restoration for later start/settlement from independently retained
+     * SQL bytes. It cannot create a copy or claim fresh source observations.
+     */
+    static restore(bytes, expectedSha256, exported) {
+        try {
+            if (!(bytes instanceof Uint8Array) || bytes.length > 8 * 1024 * 1024)
+                refuse("invalid_manifest_receipt");
+            const value = JSON.parse(Buffer.from(bytes).toString("utf8"));
+            if (!value || Object.keys(value).sort().join(",") !== "entries,schema_id"
+                || value.schema_id !== "dd-flow/memory-repair-workspace-manifest@1" || !Array.isArray(value.entries)
+                || value.entries.length > 20_000)
+                refuse("invalid_manifest_receipt");
+            const entries = [], byPath = new Map(), aliases = new Set();
+            for (const entry of value.entries) {
+                if (!entry || Object.keys(entry).sort().join(",") !== "kind,mode,path,sha256" || typeof entry.path !== "string"
+                    || !entry.path || entry.path.length > 4096 || entry.path.includes("\\") || entry.path.includes("\0")
+                    || entry.path.split("/").length > 65
+                    || path.posix.isAbsolute(entry.path) || path.win32.isAbsolute(entry.path)
+                    || entry.path.split("/").some((part) => !part || part === "." || part === ".."
+                        || [".git", "node_modules", ".dd-flow"].includes(part.normalize("NFC").toLowerCase()))
+                    || !reviewEnvironmentAllowed(entry.path) || !["file", "directory"].includes(entry.kind)
+                    || !Number.isSafeInteger(entry.mode) || entry.mode < 0 || entry.mode > 0o7777
+                    || (entry.kind === "file" ? typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(entry.sha256) : entry.sha256 !== null))
+                    refuse("invalid_manifest_receipt");
+                const alias = entry.path.normalize("NFC").toLowerCase();
+                if (aliases.has(alias))
+                    refuse("invalid_manifest_receipt");
+                aliases.add(alias);
+                entries.push({ path: entry.path, kind: entry.kind, mode: entry.mode, sha256: entry.sha256 });
+                byPath.set(entry.path, entry);
+            }
+            for (const entry of entries) {
+                const parts = entry.path.split("/");
+                for (let length = 1; length < parts.length; length++)
+                    if (byPath.get(parts.slice(0, length).join("/"))?.kind !== "directory")
+                        refuse("invalid_manifest_receipt");
+            }
+            const prepared = new PreparedMemoryRepairWorkspace(null, entries, null, exported);
+            if (entries.some((entry, index) => index > 0 && entries[index - 1].path >= entry.path))
+                refuse("invalid_manifest_receipt");
+            const mb = entries.filter(entry => entry.path === ".memory-bank" || entry.path.startsWith(".memory-bank/"));
+            if (prepared.sha256 !== expectedSha256 || !prepared.bytes().equals(Buffer.from(bytes))
+                || hybridDigest(mb) !== hybridDigest(exported.entries().sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)))
+                refuse("manifest_receipt_changed");
+            return prepared;
+        }
+        catch (error) {
+            if (error instanceof AppError && error.code === "memory_repair_workspace_invalid")
+                throw error;
+            return refuse("invalid_manifest_receipt");
+        }
+    }
+    revalidateSource() {
+        if (!this.#observed || !this.#source)
+            refuse("source_observation_required");
+        this.#observed.revalidate();
+        for (const entry of this.#entries) {
+            const stat = fs.lstatSync(path.join(this.#source, entry.path));
+            if ((stat.mode & 0o7777) !== entry.mode || (entry.kind === "directory" ? !stat.isDirectory() : !stat.isFile() || stat.nlink !== 1))
+                refuse("source_metadata_changed");
+        }
+    }
+    verify(root) {
+        const actual = inventory(root).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+        if (hybridDigest(actual) !== this.sha256)
+            refuse("copy_changed_or_incomplete");
+        this.#exported.revalidate(root);
+    }
+    /** MB changes are separately admitted by the registered physical delta
+     * owner. Nothing elsewhere in the private workspace may change or appear.
+     */
+    verifyUnchangedInputs(root) {
+        const outsideMemory = (entry) => entry.path !== ".memory-bank" && !entry.path.startsWith(".memory-bank/");
+        const actual = inventory(root).filter(outsideMemory).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+        if (hybridDigest(actual) !== hybridDigest(this.#entries.filter(outsideMemory)))
+            refuse("non_memory_input_changed");
+    }
+    /** Verify shared selected inputs against this immutable start manifest.
+     * A separate publication owner must admit the expected MB prefix; this
+     * physical helper neither grants that admission nor writes any document.
+     */
+    verifySelectedSourceInputs(source, input, expected) {
+        expected.revalidate(source);
+        const candidates = reviewSourcePaths(source, input.explicit_inputs, input.base);
+        if (!candidates)
+            refuse("git_source_inventory_required");
+        const available = new Set(expected.entries().filter(entry => entry.kind === "file").map(entry => entry.path));
+        const exported = expected.exported(candidates.filter(logical => logical.startsWith(".memory-bank/") && available.has(logical)));
+        const fresh = PreparedMemoryRepairWorkspace.capture(source, input, exported);
+        const outsideMemory = (entry) => entry.path !== ".memory-bank" && !entry.path.startsWith(".memory-bank/");
+        if (hybridDigest(fresh.entries().filter(outsideMemory)) !== hybridDigest(this.#entries.filter(outsideMemory)))
+            refuse("shared_non_memory_input_changed");
+        expected.revalidate(source);
+    }
+    create(root) {
+        this.revalidateSource();
+        if (!path.isAbsolute(root) || fs.realpathSync(path.dirname(root)) !== path.dirname(root))
+            refuse("noncanonical_copy_parent");
+        if (fs.lstatSync(root, { throwIfNoEntry: false }))
+            refuse("copy_already_exists");
+        fs.mkdirSync(root, { mode: 0o700 });
+        this.#populate(root, new Set());
+    }
+    /** Only an independently journaled, unstarted build may call this. Exact
+     * retained files are never rewritten; unknown or partial file bytes refuse.
+     */
+    resume(root) {
+        this.revalidateSource();
+        const partial = inventory(root), expected = new Map(this.#entries.map(entry => [entry.path, entry]));
+        for (const entry of partial) {
+            const original = expected.get(entry.path);
+            if (!original || original.kind !== entry.kind || original.sha256 !== entry.sha256
+                || entry.mode !== original.mode && entry.mode !== (entry.kind === "file" ? 0o600 : 0o700))
+                refuse("foreign_or_changed_partial_copy");
+        }
+        this.#populate(root, new Set(partial.map(entry => entry.path)));
+    }
+    #populate(root, retained) {
+        try {
+            for (const entry of this.#entries.filter(entry => entry.kind === "directory").sort((a, b) => a.path.split("/").length - b.path.split("/").length)) {
+                if (!retained.has(entry.path))
+                    fs.mkdirSync(path.join(root, entry.path), { mode: 0o700 });
+            }
+            for (const entry of this.#entries.filter(entry => entry.kind === "file")) {
+                const file = path.join(root, entry.path);
+                if (!retained.has(entry.path))
+                    fs.writeFileSync(file, this.#observed.bytes({ root: "workspace", path: entry.path }), { flag: "wx", mode: 0o600 });
+                fs.chmodSync(file, entry.mode);
+            }
+            for (const entry of this.#entries.filter(entry => entry.kind === "directory").reverse())
+                fs.chmodSync(path.join(root, entry.path), entry.mode);
+            this.revalidateSource();
+            this.verify(root);
+        }
+        catch (error) {
+            throw new AppError("memory_repair_workspace_publication_pending", "Private copy was created but is not admitted; retain it for owned recovery", 1, { effect: "publication_pending", copy_root: root, cause: error instanceof Error ? error.message : String(error) });
+        }
+    }
+}