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

package/dist/services/memory-init-git-policy.js

@@ -0,0 +1,165 @@
+import path from "node:path";
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { appendAudit } from "./audit.js";
+import { PreparedMemoryInitTarget } from "./memory-init-preflight.js";
+const event = "memory.init_git_policy", token = Symbol("memory-init-git-policy");
+function refuse(reason) {
+    throw new AppError("memory_init_git_policy_invalid", "Init lacks explicit retained Git policy", 2, { reason, effect: "no_effect" });
+}
+function validScope(scope) {
+    if (!scope || typeof scope.requestId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(scope.requestId)
+        || typeof scope.projectRoot !== "string" || !path.isAbsolute(scope.projectRoot)
+        || typeof scope.workspaceRoot !== "string" || !path.isAbsolute(scope.workspaceRoot)
+        || Object.keys(scope).sort().join() !== "projectRoot,requestId,workspaceRoot")
+        refuse("invalid_request_scope");
+}
+/** Shared read-only policy observation for init and upgrade. The caller owns
+ * retained input custody; these facts grant neither dispatch nor push. */
+export function observeMemoryGitPolicySelection(environment, input) {
+    validScope(input.scope);
+    const { scope, selection } = input;
+    if (!selection || Object.keys(selection).sort().join() !== "integrationBranch,route"
+        || !["integration_branch_direct", "feature_worktree"].includes(selection.route)
+        || typeof selection.integrationBranch !== "string" || !selection.integrationBranch || selection.integrationBranch.startsWith("-") || selection.integrationBranch.length > 1024
+        || [...selection.integrationBranch].some(character => character.charCodeAt(0) <= 32 || character.charCodeAt(0) === 127))
+        refuse("explicit_policy_required");
+    if (typeof input.gitExecutable !== "string" || !path.isAbsolute(input.gitExecutable))
+        refuse("explicit_git_required");
+    const env = Object.fromEntries(Object.entries(environment).filter(([key]) => !key.startsWith("GIT_")));
+    const git = (directory, args, optional = false) => {
+        const result = spawnSync(input.gitExecutable, ["-c", "core.fsmonitor=false", "-C", directory, ...args], { env: { ...env, GIT_OPTIONAL_LOCKS: "0" }, encoding: "utf8", timeout: 5000, maxBuffer: 64 * 1024, shell: false, windowsHide: true });
+        if (result.error || result.signal || !optional && result.status !== 0)
+            refuse("git_policy_observation_failed");
+        return result.status === 0 ? result.stdout.trim() : null;
+    };
+    const valid = spawnSync(input.gitExecutable, ["check-ref-format", `refs/heads/${selection.integrationBranch}`], { env: { ...env, GIT_OPTIONAL_LOCKS: "0" }, timeout: 5000, maxBuffer: 64 * 1024, shell: false, windowsHide: true });
+    if (valid.error || valid.signal || valid.status !== 0)
+        refuse("invalid_integration_branch");
+    const common = (directory) => {
+        if (git(directory, ["rev-parse", "--is-bare-repository"]) !== "false"
+            || fs.realpathSync(git(directory, ["rev-parse", "--show-toplevel"])) !== directory)
+            refuse("not_repository_root");
+        return fs.realpathSync(path.resolve(directory, git(directory, ["rev-parse", "--git-common-dir"])));
+    };
+    const repository = common(scope.projectRoot);
+    if (common(scope.workspaceRoot) !== repository)
+        refuse("foreign_workspace_repository");
+    const branch = git(scope.workspaceRoot, ["symbolic-ref", "--short", "HEAD"]);
+    if (!branch)
+        refuse("workspace_branch_unavailable");
+    if (selection.route === "integration_branch_direct"
+        ? scope.projectRoot !== scope.workspaceRoot || branch !== selection.integrationBranch
+        : scope.projectRoot === scope.workspaceRoot || branch === selection.integrationBranch)
+        refuse("route_workspace_mismatch");
+    if (selection.route === "feature_worktree"
+        && !/^[a-f0-9]{40,64}$/.test(git(scope.projectRoot, ["rev-parse", "--verify", `refs/heads/${selection.integrationBranch}^{commit}`], true) ?? ""))
+        refuse("integration_branch_unavailable");
+    const head = git(scope.workspaceRoot, ["rev-parse", "--verify", "HEAD"], true);
+    return { repository, workspace_branch: branch, initial_head: head, source: "explicit_request",
+        route: selection.route, integration_branch: selection.integrationBranch, push_authorized: false };
+}
+/** SQL preservation, not fresh policy inference, Git execution or permission. */
+export function readMemoryInitGitPolicy(context, scope) {
+    validScope(scope);
+    const rows = context.db.all(`SELECT payload_json FROM audit_events WHERE event_type=?
+    AND json_extract(payload_json,'$.scope.requestId')=? AND json_extract(payload_json,'$.scope.projectRoot')=?
+    AND json_extract(payload_json,'$.scope.workspaceRoot')=? LIMIT 2`, [event, scope.requestId, scope.projectRoot, scope.workspaceRoot]);
+    if (!rows.length)
+        return null;
+    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 32 * 1024)
+        refuse("ambiguous_or_unbounded_policy");
+    let value;
+    try {
+        value = JSON.parse(rows[0].payload_json);
+    }
+    catch {
+        return refuse("invalid_policy_receipt");
+    }
+    if (!value || value.schema_id !== "dd-flow/memory-init-git-policy@1" || hybridDigest(value.scope) !== hybridDigest(scope)
+        || Object.keys(value).sort().join() !== "initial_head,integration_branch,push_authorized,repository,route,schema_id,scope,source,target_sha256,workspace_branch"
+        || value.source !== "explicit_request" || value.push_authorized !== false
+        || !["integration_branch_direct", "feature_worktree"].includes(value.route)
+        || typeof value.target_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(value.target_sha256)
+        || typeof value.repository !== "string" || !path.isAbsolute(value.repository)
+        || typeof value.workspace_branch !== "string" || !value.workspace_branch
+        || typeof value.integration_branch !== "string" || !value.integration_branch
+        || (value.initial_head !== null && (typeof value.initial_head !== "string" || !/^[a-f0-9]{40,64}$/.test(value.initial_head))))
+        refuse("policy_receipt_changed");
+    return structuredClone(value);
+}
+/** Explicit request choice frozen against genuine no-effect target preflight.
+ * Retaining this receipt must precede bootstrap publication. It grants no
+ * dispatch authority by itself or compatibility with a historical bootstrap.
+ * Memory finish integrates only after independently accepted current review;
+ * this receipt never authorizes push. */
+export class PreparedMemoryInitGitPolicy {
+    #target;
+    #receipt;
+    constructor(key, target, receipt) {
+        if (key !== token)
+            refuse("policy_token_required");
+        this.#target = target;
+        this.#receipt = structuredClone(receipt);
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        if (!(input.target instanceof PreparedMemoryInitTarget))
+            refuse("prepared_target_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        const prepared = this.prepareFresh(context.env, input);
+        const receipt = prepared.value(), retained = readMemoryInitGitPolicy(context, receipt.scope);
+        if (retained && hybridDigest(retained) !== hybridDigest(receipt))
+            refuse("policy_request_conflict");
+        return prepared;
+    }
+    /** Fresh explicit policy before opening runtime stores. This checks Git and
+     * scope, but grants no SQL custody, integration or provider authority. */
+    static prepareFresh(environment, input) {
+        if (!(input.target instanceof PreparedMemoryInitTarget))
+            refuse("prepared_target_required");
+        input.target.revalidate();
+        const facts = input.target.facts(), scope = { requestId: facts.request_id, projectRoot: facts.project_root, workspaceRoot: facts.workspace_root };
+        if (!facts.tool_probes)
+            refuse("fresh_target_required");
+        const policy = observeMemoryGitPolicySelection(environment, { scope, gitExecutable: facts.tools.git, selection: input.selection });
+        if (policy.repository !== facts.repository || policy.workspace_branch !== facts.branch || policy.initial_head !== facts.head)
+            refuse("target_changed_after_preparation");
+        const receipt = { schema_id: "dd-flow/memory-init-git-policy@1", scope, target_sha256: input.target.sha256,
+            ...policy };
+        return new PreparedMemoryInitGitPolicy(token, input.target, receipt);
+    }
+    value() { return structuredClone(this.#receipt); }
+    retain(context) {
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        this.#target.revalidate();
+        return context.db.writeTransaction(() => this.retainPreparedSql(context), "memoryInit.retainGitPolicy");
+    }
+    /** Metadata-only publication for an already prepared aggregate owner. */
+    retainPreparedSql(context) {
+        if (!context.db.isOwnedWriteTransaction?.())
+            refuse("owned_policy_writer_required");
+        const receipt = readMemoryInitGitPolicy(context, this.#receipt.scope);
+        if (receipt) {
+            if (hybridDigest(receipt) !== hybridDigest(this.#receipt))
+                refuse("policy_request_conflict");
+            return receipt;
+        }
+        const scope = this.#receipt.scope;
+        if (context.db.get(`SELECT 1 FROM audit_events WHERE event_type IN ('memory.init_project_bootstrap_intent','memory.init_project_bootstrap')
+        AND json_extract(payload_json,'$.scope.requestId')=? AND json_extract(payload_json,'$.scope.projectRoot')=?
+        AND json_extract(payload_json,'$.scope.workspaceRoot')=? LIMIT 1`, [scope.requestId, scope.projectRoot, scope.workspaceRoot]))
+            refuse("policy_must_precede_bootstrap");
+        appendAudit(context, { eventType: event, payload: this.#receipt });
+        this.assertCustody(context);
+        return this.value();
+    }
+    assertCustody(context) {
+        if (hybridDigest(readMemoryInitGitPolicy(context, this.#receipt.scope)) !== hybridDigest(this.#receipt))
+            refuse("policy_receipt_changed");
+    }
+}

package/dist/services/memory-init-lint-capability.js

@@ -0,0 +1,203 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedMemoryInitTarget } from "./memory-init-preflight.js";
+import { readBoundedReleaseFile } from "./release-source.js";
+import { runMemoryToolProbe } from "./memory-tool-probe.js";
+function refuse(reason, diagnostics) {
+    throw new AppError("memory_init_lint_capability_failed", "Selected mb-lint cannot validate Memory Bank documents", 1, { reason, effect: "no_effect", next_action: "repair_prerequisite_then_retry", ...(diagnostics ? { tool_probe: diagnostics } : {}) });
+}
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const logical = ".memory-bank/index.md";
+const validDocument = `---
+file: '.memory-bank/index.md'
+description: 'Isolated deterministic capability probe.'
+purpose: 'Validate the selected linter without reading project documents.'
+version: '0.1.0'
+date: '2026-01-01'
+status: 'DRAFT'
+c4_level: 'documentation'
+parent: null
+tags: [capability-probe]
+---
+
+# Isolated capability probe
+`;
+/** Shape validation for historical SQL custody, never executable qualification. */
+export function isMemoryInitLintCapabilityFacts(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const facts = value, hashes = ["executable_sha256", "valid_document_sha256", "invalid_document_sha256",
+        "positive_report_sha256", "negative_report_sha256", "required_fields_report_sha256", "missing_link_report_sha256"];
+    return facts.schema_id === "dd-flow/memory-init-lint-capability@1" && typeof facts.executable === "string" && path.isAbsolute(facts.executable)
+        && typeof facts.version === "string" && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(facts.version)
+        && Object.keys(facts).length === hashes.length + 3
+        && hashes.every(key => typeof facts[key] === "string" && /^[a-f0-9]{64}$/.test(facts[key]));
+}
+/** Tests deterministic JSON lint behavior, not semantic grounding or provider readiness.
+ * CLI writes only its own temporary files containing fixed probe data.
+ */
+export class PreparedMemoryInitLintCapability {
+    sha256;
+    #facts;
+    constructor(facts) {
+        this.#facts = facts;
+        this.sha256 = hybridDigest(facts);
+        Object.freeze(this);
+    }
+    static prepare(target, env) {
+        if (!(target instanceof PreparedMemoryInitTarget))
+            refuse("unprepared_target");
+        const selected = target.facts(), executable = selected.tools["mb-lint"], probe = selected.tool_probes?.["mb-lint"];
+        if (!probe)
+            refuse("missing_selected_tool_probe");
+        return PreparedMemoryInitLintCapability.prepareExecutable(executable, probe, env);
+    }
+    static prepareExecutable(executable, probe, env, options = {}) {
+        if (!path.isAbsolute(executable) || !probe || !/^[a-f0-9]{64}$/.test(probe.executable_sha256)
+            || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(probe.version))
+            refuse("invalid_selected_tool");
+        const checksum = () => {
+            try {
+                return hash(readBoundedReleaseFile(executable, 64 * 1024 * 1024));
+            }
+            catch {
+                return refuse("selected_executable_unavailable");
+            }
+        };
+        if (checksum() !== probe.executable_sha256)
+            refuse("selected_executable_changed");
+        let scratch, rootOwner, primary, prepared;
+        try {
+            scratch = fs.mkdtempSync(path.join(os.tmpdir(), "dd-flow-init-lint-"));
+            rootOwner = fs.lstatSync(scratch);
+            const bank = path.join(scratch, ".memory-bank");
+            fs.mkdirSync(bank);
+            const bankOwner = fs.lstatSync(bank);
+            const file = path.join(scratch, logical);
+            fs.writeFileSync(file, validDocument, { flag: "wx", mode: 0o600 });
+            const fileOwner = fs.lstatSync(file);
+            let expectedDocument = validDocument;
+            const same = (actual, selected) => actual.dev === selected.dev && actual.ino === selected.ino;
+            const ownDirectories = () => {
+                const root = fs.lstatSync(scratch), directory = fs.lstatSync(bank);
+                if (!root.isDirectory() || !directory.isDirectory() || !same(root, rootOwner) || !same(directory, bankOwner))
+                    refuse("probe_directory_owner_changed");
+            };
+            const writeProbe = (document) => {
+                ownDirectories();
+                const fd = fs.openSync(file, fs.constants.O_WRONLY | (fs.constants.O_NOFOLLOW ?? 0));
+                try {
+                    const actual = fs.fstatSync(fd);
+                    if (!actual.isFile() || actual.nlink !== 1 || !same(actual, fileOwner))
+                        refuse("probe_file_owner_changed");
+                    fs.ftruncateSync(fd, 0);
+                    fs.writeFileSync(fd, document);
+                    expectedDocument = document;
+                }
+                finally {
+                    fs.closeSync(fd);
+                }
+            };
+            const probeEnv = Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_")));
+            const run = (status, rule, config) => {
+                ownDirectories();
+                const { result, diagnostics } = runMemoryToolProbe(executable, ["--root", scratch, "--files", logical, "--format", "json", ...(config ? ["--config", config] : [])], { cwd: scratch, env: { ...probeEnv, GIT_OPTIONAL_LOCKS: "0" } });
+                if (result.error || result.signal || result.status !== status)
+                    refuse(config ? "temporary_configuration_not_supported" : "lint_probe_execution_failed", { ...diagnostics, phase: "lint_probe", expected_status: status });
+                ownDirectories();
+                const actual = fs.lstatSync(file);
+                if (!actual.isFile() || actual.nlink !== 1 || !same(actual, fileOwner)
+                    || hash(readBoundedReleaseFile(file, 64 * 1024)) !== hash(Buffer.from(expectedDocument)))
+                    refuse("probe_input_changed");
+                let report;
+                try {
+                    report = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(result.stdout));
+                }
+                catch {
+                    return refuse("lint_probe_invalid_json");
+                }
+                if (!report || report.tool !== "mb-lint" || report.version !== probe.version || report.root !== "."
+                    || report.memoryBank !== ".memory-bank" || !Array.isArray(report.findings)
+                    || !report.summary || typeof report.summary !== "object")
+                    refuse("lint_probe_invalid_report");
+                const summary = report.summary;
+                if (Object.keys(summary).length !== 4 || ["errors", "warnings", "info", "suggestions"].some(key => !Number.isSafeInteger(summary[key]) || Number(summary[key]) < 0)
+                    || summary.errors !== report.findings.filter(value => value?.severity === "error").length)
+                    refuse("lint_probe_invalid_summary");
+                if (status === 0 && (Object.values(summary).some(value => value !== 0) || report.findings.length !== 0))
+                    refuse("valid_document_rejected");
+                if (status === 1 && (!(Number(summary.errors) > 0) || !report.findings.some(value => value && typeof value === "object"
+                    && value.ruleId === rule && value.severity === "error" && value.file === logical)))
+                    refuse(`lint_rule_not_detected:${rule}`);
+                return hybridDigest(report);
+            };
+            const positive = run(0), invalid = "---\nfile: [\n---\n\n# Invalid YAML probe\n";
+            writeProbe(invalid);
+            const negative = run(1, "frontmatter/parseable");
+            writeProbe("---\nfile: '.memory-bank/index.md'\n---\n\n# Missing frontmatter fields\n");
+            const fields = run(1, "frontmatter/required-fields");
+            writeProbe(`${validDocument}\n[Missing target](missing-probe-target.md)\n`);
+            const links = run(1, "links/markdown-target-exists");
+            if (options.temporaryConfiguration) {
+                // Upgrade's active-document profile needs an external config with exact
+                // finding exclusions; a version response or basic JSON lint is insufficient.
+                const config = path.join(scratch, "upgrade-lint.json");
+                fs.writeFileSync(config, JSON.stringify({ ignoreFindings: [{
+                            ruleId: "links/markdown-target-exists", file: logical, target: "missing-probe-target.md"
+                        }] }), { flag: "wx", mode: 0o600 });
+                run(0, undefined, config);
+            }
+            if (checksum() !== probe.executable_sha256)
+                refuse("selected_executable_changed");
+            prepared = new PreparedMemoryInitLintCapability({ schema_id: "dd-flow/memory-init-lint-capability@1",
+                executable, executable_sha256: probe.executable_sha256, version: probe.version,
+                valid_document_sha256: hash(Buffer.from(validDocument)), invalid_document_sha256: hash(Buffer.from(invalid)),
+                positive_report_sha256: positive, negative_report_sha256: negative,
+                required_fields_report_sha256: fields, missing_link_report_sha256: links });
+        }
+        catch (error) {
+            primary = error instanceof AppError ? error : new AppError("memory_init_lint_capability_failed", "Lint probe observation failed", 1, { reason: "lint_probe_observation_failed", effect: "no_effect", next_action: "repair_prerequisite_then_retry" });
+        }
+        if (scratch)
+            try {
+                const actual = fs.lstatSync(scratch);
+                if (!rootOwner || !actual.isDirectory() || actual.dev !== rootOwner.dev || actual.ino !== rootOwner.ino)
+                    refuse("probe_root_owner_changed");
+                fs.rmSync(scratch, { recursive: true });
+            }
+            catch {
+                throw new AppError("memory_init_lint_probe_cleanup_failed", "Isolated lint probe requires cleanup", 1, { reason: primary instanceof AppError ? primary.details.reason : primary ? "probe_failed" : "cleanup_failed",
+                    effect: "partial", owned_probe_path: scratch, next_action: "reconcile_owned_probe" });
+            }
+        if (primary)
+            throw primary;
+        return prepared;
+    }
+    facts() { return { ...this.#facts }; }
+    revalidate(target, _env) {
+        if (!(target instanceof PreparedMemoryInitTarget))
+            refuse("unprepared_target");
+        const selected = target.facts(), probe = selected.tool_probes?.["mb-lint"];
+        if (!probe || selected.tools["mb-lint"] !== this.#facts.executable
+            || probe.version !== this.#facts.version || probe.executable_sha256 !== this.#facts.executable_sha256)
+            refuse("lint_capability_changed");
+        this.revalidateExecutable();
+    }
+    revalidateExecutable() {
+        // This instance already passed the functional probes. Publication checks
+        // preserve its selected executable, not repeat qualification after effects.
+        let checksum;
+        try {
+            checksum = hash(readBoundedReleaseFile(this.#facts.executable, 64 * 1024 * 1024));
+        }
+        catch {
+            return refuse("selected_executable_unavailable");
+        }
+        if (checksum !== this.#facts.executable_sha256)
+            refuse("selected_executable_changed");
+    }
+}