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

package/dist/services/memory-verification-checks.js

@@ -0,0 +1,317 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createHash } from "node:crypto";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { AppError } from "../shared/errors.js";
+import { FrozenGenericExecution } from "./generic-execution.js";
+import { ResolvedFlowDescriptor } from "./flow-descriptors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { readAcceptedStageData } from "./stage-report-renderer.js";
+import { readMemoryInitBootstrapReadiness } from "./memory-init-bootstrap-readiness.js";
+import { readMemoryInitProjectBootstrapLintCapability } from "./memory-init-project-bootstrap.js";
+import { PreparedMemoryBaselinePreservation } from "./memory-baseline-preservation.js";
+import { readBoundedReleaseFile } from "./release-source.js";
+import { codeCheckProfileHash, projectPolicyCheckDeclarationsFromProfile, readCodeCheckProfile, runCodeChecks, PreparedCheckEvidence } from "./code-checks.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memoryVerificationActivePaths, memoryUpgradeLintGuidance, memoryVerificationSupplementalLintFiles, memoryCanonicalLintExceptions, memoryCanonicalTemplatePaths } from "./memory-lint-config.js";
+import { isMemoryCorrectionInputOwner } from "./memory-correction-input-owner.js";
+import { readMemoryUpgradeBootstrapReadiness } from "./memory-upgrade-bootstrap-readiness.js";
+import { readUpgradeStorageReadiness } from "./memory-upgrade-storage-readiness.js";
+import { PreparedAcceptedMemoryComposition } from "./memory-accepted-composition.js";
+import { RetainedExecutionBundle } from "./execution-bundles.js";
+import { retainedBrowserEnvironment, validateCheckEnvironment } from "./check-environment.js";
+const token = Symbol("memory-verification-checks");
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+const profilePath = ".memory-bank/spec/engineering/code-check-profile.json";
+export function memorySupplementalLintCommand(executable, workspace, files, exceptions = []) {
+    const config = JSON.stringify(exceptions.length ? { ignoreFindings: exceptions } : {});
+    return `printf '%s\\n' ${quote(config)} > "$DD_FLOW_EVIDENCE_DIR/mb-lint-active-config.json" && ${quote(executable)} --root ${quote(workspace)} --config "$DD_FLOW_EVIDENCE_DIR/mb-lint-active-config.json" --files ${files.map(quote).join(" ")} --format json > "$DD_FLOW_EVIDENCE_DIR/mb-lint-active.json"`;
+}
+function refuse(reason) {
+    throw new AppError("memory_verification_checks_invalid", "Verification checks lack admitted tool, policy or accepted composition custody", 2, { reason, effect: "no_effect" });
+}
+/** First introduction adds obligations to mandatory lint; an existing policy
+ * remains immutable, including in the next correction wave. */
+export function assertRetainedMemoryVerificationPolicy(previous, current) {
+    if (previous !== null && current !== previous)
+        refuse("correction_policy_requires_readmission");
+}
+/** Finite project checks use the original Codex home, never a temporary
+ * provider Session overlay. Keep every other application environment input. */
+export function memoryCheckEnvironment(context, projectId, runId) {
+    let browser = retainedBrowserEnvironment(context.env);
+    if (!context.db.get("SELECT 1 FROM sqlite_schema WHERE type='table' AND name='run_controllers'"))
+        return browser;
+    const controllers = context.db.all("SELECT state_json,manifest_json FROM run_controllers WHERE project_id=? AND run_id=?", [projectId, runId]);
+    const retained = new Set(controllers.flatMap(controller => {
+        const manifest = JSON.parse(controller.manifest_json);
+        const value = validateCheckEnvironment(manifest.check_environment)?.PLAYWRIGHT_BROWSERS_PATH;
+        return value === undefined ? [] : [value];
+    }));
+    if (retained.size > 1)
+        refuse("ambiguous_check_browser_resource");
+    if (retained.size)
+        browser = { PLAYWRIGHT_BROWSERS_PATH: [...retained][0] };
+    const targets = new Set();
+    for (const controller of controllers) {
+        const state = JSON.parse(controller.state_json);
+        const session = state.current_session === null ? undefined : state.sessions?.[state.current_session];
+        if (session?.codex_home)
+            targets.add(session.codex_home);
+    }
+    if (!targets.size)
+        return browser;
+    const current = process.env.CODEX_HOME;
+    if (current && !targets.has(current) && context.db.get("SELECT 1 FROM sqlite_schema WHERE type='table' AND name='work_launches'")) {
+        const launches = context.db.all("SELECT l.state_dir FROM work_launches l JOIN works w ON w.work_id=l.work_id WHERE w.project_id=? AND w.run_id=?", [projectId, runId]);
+        if (launches.some(launch => path.join(launch.state_dir, "codex-home") === current))
+            targets.add(current);
+    }
+    const sources = new Set();
+    for (const target of targets) {
+        const rows = context.db.all("SELECT source_home,target_home FROM codex_home_profiles WHERE project_id=? AND target_home=? AND status='ready'", [projectId, target]);
+        if (rows.length !== 1)
+            refuse("managed_check_home_unavailable");
+        const row = rows[0], marker = JSON.parse(readBoundedReleaseFile(path.join(target, ".dd-flow-home.json"), 1024 * 1024).toString("utf8"));
+        if (marker.managed_by !== "dd-flow-cli" || marker.project_id !== projectId || marker.source_home !== row.source_home || marker.target_home !== target
+            || !path.isAbsolute(row.source_home))
+            refuse("managed_check_home_changed");
+        sources.add(row.source_home);
+    }
+    if (sources.size !== 1)
+        refuse("ambiguous_managed_check_home");
+    const base = [...sources][0];
+    if (current === undefined ? base !== path.join(os.homedir(), ".codex") : current !== base && !targets.has(current))
+        refuse("foreign_check_home");
+    return { ...browser, CODEX_HOME: base };
+}
+function lintConfig(workspace) {
+    const file = path.join(workspace, ".mb-lint.json");
+    try {
+        fs.lstatSync(file);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        refuse("lint_config_unavailable");
+    }
+    return readBoundedReleaseFile(file, 1024 * 1024);
+}
+function accepted(context, input) {
+    if (input.corrected !== undefined) {
+        if (!isMemoryCorrectionInputOwner(input.corrected))
+            refuse("prepared_corrected_inputs_required");
+        input.corrected.assertCustody(context);
+        const view = input.corrected.value(), bundle = input.corrected.bundle();
+        if (view.scope.project_id !== input.projectId || view.scope.run_id !== input.runId
+            || bundle.execution.sha256 !== input.execution.sha256 || bundle.descriptor.sha256 !== input.flow.sha256)
+            refuse("foreign_corrected_inputs");
+    }
+    const frozen = input.execution.snapshot(), scope = { requestId: frozen.scope.requestId, projectRoot: frozen.scope.projectRoot, workspaceRoot: frozen.scope.workspace };
+    const run = context.db.get("SELECT workspace_root,project_root,run_root,run_dir,index_json FROM runs WHERE project_id=? AND id=?", [input.projectId, input.runId]);
+    const upgrade = input.flow.descriptor.id === "mb-upgrade";
+    const init = upgrade ? null : readMemoryInitBootstrapReadiness(context, scope);
+    const updated = upgrade ? readMemoryUpgradeBootstrapReadiness(context, scope) : null;
+    const bootstrap = init ?? updated;
+    const lint = upgrade ? updated?.authority.binding.lint ? { facts: updated.authority.binding.lint, sha256: hybridDigest(updated.authority.binding.lint) } : null
+        : readMemoryInitProjectBootstrapLintCapability(context, scope);
+    if (!run || run.project_root !== scope.projectRoot || run.workspace_root !== scope.workspaceRoot || !bootstrap || !lint
+        || bootstrap.projectId !== input.projectId || bootstrap.authority.binding.execution_sha256 !== input.execution.sha256)
+        refuse("accepted_bootstrap_scope_required");
+    const authoring = upgrade ? "upgrade" : "compose";
+    const compose = readAcceptedStageData(context, { projectId: input.projectId, runId: input.runId, stage: authoring });
+    if (compose.data_schema_id !== (upgrade ? "dd-flow/mb-upgrade-stage-result@1" : "dd-flow/mb-init-compose-result@1"))
+        refuse("accepted_composition_required");
+    const baselineProfile = upgrade ? readUpgradeStorageReadiness(context, scope)?.selection?.payload.current.inventory.inventory.entries
+        .find(entry => entry.path === profilePath.slice(13))?.current?.sha256 ?? null : null;
+    const active = input.corrected ? "review" : "verify";
+    const { index_json, ...roots } = run, index = JSON.parse(index_json), stage = index.stage_runs.find((stage) => stage.stage === active);
+    if (index.current_stage !== active || stage?.status !== "running" || typeof stage.input_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(stage.input_sha256))
+        refuse(input.corrected ? "active_corrected_review_required" : "active_verification_required");
+    const phase = { attempt: stage.attempt ?? null, cycle: stage.cycle ?? null, input_sha256: stage.input_sha256 };
+    const probe = init?.authority.binding.target.tool_probes?.["mb-lint"] ?? updated?.authority.binding.lint;
+    const executable = init?.authority.binding.target.tools["mb-lint"] ?? updated?.authority.binding.lint?.executable;
+    return { run: roots, bootstrap, lint, compose, scope, probe, executable, baselineProfile, authority: hybridDigest({ run: roots, phase, bootstrap: bootstrap.authority, lint, compose: compose.authority_sha256,
+            ...(input.corrected ? { corrected_sha256: input.corrected.sha256 } : {}) }) };
+}
+/** Owning CLI policy, not agent-proposed commands. The bootstrap-selected
+ * functional linter supplies schema/frontmatter/link checks; project readiness
+ * declarations supplement it. Absence of an optional alias profile does not
+ * waive the mandatory linter. The complete finish handler still owns composed
+ * output/check-result acceptance and semantic assessments.
+ */
+export class PreparedMemoryVerificationChecks {
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #input in value;
+    }
+    #input;
+    #authority;
+    #executable;
+    #executableSha256;
+    #profileSha256;
+    #profile;
+    #lintConfigSha256;
+    #preservation;
+    #checks;
+    #runHome;
+    #directory;
+    #workspace;
+    #checkEnvironment;
+    constructor(key, input, selected, profile, preservation, checks, configSha256) {
+        if (key !== token)
+            refuse("verification_policy_token_required");
+        this.#input = { ...input };
+        this.#authority = selected.authority;
+        this.#executable = selected.lint.facts.executable;
+        this.#executableSha256 = selected.lint.facts.executable_sha256;
+        this.#profile = profile;
+        this.#lintConfigSha256 = configSha256;
+        this.#preservation = preservation;
+        this.#checks = structuredClone(checks);
+        this.#workspace = selected.run.workspace_root;
+        this.#runHome = selected.run.run_root ?? selected.run.run_dir;
+        this.#directory = input.corrected ? `${input.flow.stage("review").directory}/checks-wave-${input.corrected.value().wave}` : input.flow.stage("verify").directory;
+        this.#profileSha256 = codeCheckProfileHash(this.#workspace, checks);
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        if (input.corrected !== undefined && !isMemoryCorrectionInputOwner(input.corrected))
+            refuse("prepared_corrected_inputs_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        if (!(input.execution instanceof FrozenGenericExecution) || !(input.flow instanceof ResolvedFlowDescriptor)
+            || !["mb-init", "mb-upgrade"].includes(input.flow.descriptor.id) || input.execution.settings.flow_id !== input.flow.descriptor.id
+            || input.execution.settings.descriptor_sha256 !== input.flow.sha256)
+            refuse("frozen_memory_selection_required");
+        input.corrected?.revalidate(context);
+        const selected = context.db.readSnapshot(() => accepted(context, input)), value = JSON.parse(selected.compose.bytes.toString("utf8"));
+        const upgrade = input.flow.descriptor.id === "mb-upgrade", authoring = upgrade ? "upgrade" : "compose";
+        const schema = JSON.parse(input.flow.stageBlob(authoring, "result_schema").toString("utf8"));
+        if (!new Ajv2020({ strict: true, strictRequired: false, validateFormats: false }).compile(schema)(value))
+            refuse("accepted_composition_required");
+        const compose = value;
+        if (compose.run_id !== input.runId || compose.stage !== authoring || compose.outcome !== "accepted")
+            refuse("accepted_composition_required");
+        const probe = selected.probe;
+        if (!probe || selected.executable !== selected.lint.facts.executable
+            || probe.executable_sha256 !== selected.lint.facts.executable_sha256 || probe.version !== selected.lint.facts.version
+            || hash(readBoundedReleaseFile(selected.lint.facts.executable, 64 * 1024 * 1024)) !== probe.executable_sha256)
+            refuse("selected_linter_changed");
+        const bundle = input.bundle ?? input.corrected?.bundle();
+        if (upgrade && (!(bundle instanceof RetainedExecutionBundle) || bundle.execution.sha256 !== input.execution.sha256 || bundle.descriptor.sha256 !== input.flow.sha256))
+            refuse("registered_upgrade_bundle_required");
+        if (input.composition && (!(input.composition instanceof PreparedAcceptedMemoryComposition) || input.composition.result().sha256 !== selected.compose.result.sha256))
+            refuse("foreign_accepted_composition");
+        const preservation = upgrade ? input.corrected ?? input.composition ?? PreparedAcceptedMemoryComposition.prepare(context, { scope: input, bundle: bundle }) : PreparedMemoryBaselinePreservation.prepare(context, input.execution);
+        const workspace = selected.run.workspace_root;
+        const config = lintConfig(workspace);
+        const corrected = input.corrected?.value();
+        let guidance;
+        let canonicalEntries = [];
+        let canonicalFiles = new Map();
+        let templates;
+        if (upgrade) {
+            const storage = readUpgradeStorageReadiness(context, selected.scope);
+            if (!storage?.selection)
+                refuse("retained_upgrade_inventory_required");
+            const diff = readAcceptedStageData(context, { projectId: input.projectId, runId: input.runId, stage: "diff-analysis" });
+            guidance = memoryUpgradeLintGuidance(storage.selection.payload.current.inventory.inventory.entries, JSON.parse(diff.bytes.toString("utf8")).details.path_map);
+            canonicalEntries = storage.selection.payload.current.inventory.inventory.entries;
+            canonicalFiles = new Map(storage.selection.payload.layer.files.map(file => [file.path, Buffer.from(file.base64, "base64")]));
+            const current = new Map(canonicalEntries.filter(entry => /^mbb\/templates\/.+\.(?:md|markdown)$/.test(entry.path) && entry.current?.kind === "file" && entry.target && ["canonical", "local-customized"].includes(entry.ownership))
+                .map(entry => [entry.path, readBoundedReleaseFile(path.join(workspace, ".memory-bank", entry.path), 64 * 1024 * 1024)]));
+            templates = memoryCanonicalTemplatePaths(canonicalEntries, canonicalFiles, current);
+        }
+        const supplementalFiles = config ? memoryVerificationSupplementalLintFiles(config, corrected
+            ? memoryVerificationActivePaths(corrected.unit_inventory, corrected.assignments, guidance, templates)
+            : memoryVerificationActivePaths(compose.units, [], guidance, templates)) : [];
+        const canonicalExceptions = memoryCanonicalLintExceptions(canonicalEntries, canonicalFiles, supplementalFiles);
+        let observed = null;
+        let exists = false;
+        try {
+            fs.lstatSync(path.join(workspace, profilePath));
+            exists = true;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                refuse("profile_unavailable");
+        }
+        const profileRefs = input.corrected ? input.corrected.value().run_inputs : compose.units.flatMap(unit => unit.artifacts);
+        const expectedProfiles = new Set(profileRefs.filter(artifact => artifact.root === "workspace" && artifact.path === profilePath).map(artifact => artifact.sha256));
+        if (upgrade && exists && !expectedProfiles.size && selected.baselineProfile)
+            expectedProfiles.add(selected.baselineProfile);
+        if (expectedProfiles.size !== (exists ? 1 : 0))
+            refuse("profile_presence_differs_from_composition");
+        if (exists) {
+            observed = ObservedMemorySources.capture({ workspace }, [{ root: "workspace", path: profilePath }]);
+            const sha256 = observed.hashes().get(`workspace\0${profilePath}`);
+            if (!expectedProfiles.has(sha256))
+                refuse("profile_not_accepted_composed_artifact");
+        }
+        const { profile: policy, hash: profileHash } = readCodeCheckProfile(workspace);
+        if (profileHash !== (observed?.hashes().get(`workspace\0${profilePath}`) ?? null))
+            refuse("profile_changed_during_preparation");
+        const lintCheck = { id: "MEMORY/verify/lint-schema-links", canonical_ref: "MEMORY/verify/lint-schema-links",
+            command: `${quote(selected.lint.facts.executable)} --root ${quote(workspace)} --format json > "$DD_FLOW_EVIDENCE_DIR/mb-lint.json"`,
+            purpose: "Mandatory bootstrap-selected Memory Bank lint, frontmatter/schema and Markdown target checks", run_at: "readiness", availability: "available", required_artifacts: ["mb-lint.json"], inputs: ["."],
+            // The pinned linter reads project files/config and invokes Git; provider
+            // Session configuration is not one of its execution dependencies.
+            environment_inputs: ["PATH", "PATHEXT", "HOME", "XDG_CONFIG_HOME", "NODE_*", "UV_*", "GIT_*", "LANG", "LC_*", "TZ", "DYLD_*", "LD_*", "SYSTEMROOT", "COMSPEC", "TMPDIR", "TMP", "TEMP"] };
+        const checks = [lintCheck,
+            ...(supplementalFiles.length ? [{ ...lintCheck, id: "MEMORY/verify/lint-active-documents", canonical_ref: "MEMORY/verify/lint-active-documents",
+                    command: memorySupplementalLintCommand(selected.lint.facts.executable, workspace, supplementalFiles, canonicalExceptions),
+                    purpose: "Mandatory independent lint of active Markdown excluded by preserved project policy",
+                    required_artifacts: ["mb-lint-active-config.json", "mb-lint-active.json"] }] : []),
+            ...projectPolicyCheckDeclarationsFromProfile(policy, "readiness")];
+        if (input.corrected)
+            assertRetainedMemoryVerificationPolicy(input.corrected.verificationProfileHash(context), codeCheckProfileHash(workspace, checks));
+        const prepared = new PreparedMemoryVerificationChecks(token, input, selected, observed, preservation, checks, config ? hash(config) : null);
+        prepared.#checkEnvironment = memoryCheckEnvironment(context, input.projectId, input.runId);
+        prepared.revalidate(context);
+        return prepared;
+    }
+    declarations() { return structuredClone(this.#checks); }
+    profileHash() { return this.#profileSha256; }
+    assertCorrectionOwner(corrected) {
+        if (!isMemoryCorrectionInputOwner(corrected) || this.#input.corrected !== corrected)
+            refuse("foreign_correction_check_owner");
+    }
+    checkInput() {
+        return { projectId: this.#input.projectId, runId: this.#input.runId, runHome: this.#runHome, workspaceRoot: this.#workspace, scope: "aggregate",
+            checks: this.declarations(), expectedProfileHash: this.#profileSha256, artifactDir: this.#directory,
+            ...(this.#checkEnvironment ? { checkEnvironment: this.#checkEnvironment } : {}),
+            ...(this.#input.corrected ? { evidenceContext: `memory-review:wave-${this.#input.corrected.value().wave}:${this.#input.corrected.sha256}` } : {}) };
+    }
+    assertCustody(context) {
+        this.#preservation.assertCustody(context);
+        if (context.db.readSnapshot(() => accepted(context, this.#input)).authority !== this.#authority)
+            refuse("verification_policy_custody_changed");
+    }
+    revalidate(context) {
+        if (hybridDigest(memoryCheckEnvironment(context, this.#input.projectId, this.#input.runId) ?? null) !== hybridDigest(this.#checkEnvironment ?? null))
+            refuse("managed_check_home_changed");
+        this.#input.corrected?.revalidate(context);
+        if (hash(readBoundedReleaseFile(this.#executable, 64 * 1024 * 1024)) !== this.#executableSha256)
+            refuse("selected_linter_changed");
+        this.#profile?.revalidate();
+        const config = lintConfig(this.#workspace);
+        if ((config ? hash(config) : null) !== this.#lintConfigSha256)
+            refuse("lint_config_changed");
+        if (codeCheckProfileHash(this.#workspace, this.#checks) !== this.#profileSha256)
+            refuse("verification_profile_changed");
+        this.#preservation.revalidate(context);
+        this.assertCustody(context);
+    }
+    async execute(context) {
+        this.revalidate(context);
+        const receipts = await runCodeChecks(context, this.checkInput());
+        this.revalidate(context);
+        return receipts;
+    }
+    evidence(context, mode) {
+        this.revalidate(context);
+        return PreparedCheckEvidence.prepare(context, { ...this.checkInput(), ...(mode ? { mode } : {}) });
+    }
+}

package/dist/services/memory-verification-receipt.js

@@ -0,0 +1,160 @@
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { appendAudit } from "./audit.js";
+import { PreparedCheckEvidence, PreparedRetainedCheckEvidence } from "./code-checks.js";
+import { PreparedMemoryStageResult } from "./memory-stage-results.js";
+import { PreparedMemoryVerificationAcceptance } from "./memory-verification-acceptance.js";
+import { readAcceptedStageData } from "./stage-report-renderer.js";
+const event = "memory.verification_acceptance";
+function refuse(reason) {
+    throw new AppError("memory_verification_receipt_invalid", "Verification lacks committed historical check custody", 2, { reason, effect: "no_effect" });
+}
+function stage(context, scope) {
+    const run = context.db.get("SELECT index_json FROM runs WHERE project_id=? AND id=?", [scope.projectId, scope.runId]);
+    if (!run)
+        refuse("run_missing");
+    const index = JSON.parse(run.index_json), selected = index.stage_runs.find((value) => value.stage === "verify");
+    if (!selected || typeof selected.attempt !== "string" || !/^try-[0-9]{3,}$/.test(selected.attempt)
+        || typeof selected.input_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(selected.input_sha256))
+        refuse("verify_identity_missing");
+    return { current: index.current_stage, attempt: selected.attempt, input_sha256: selected.input_sha256, status: selected.status };
+}
+function receiptRows(context, scope) {
+    return context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type=? AND json_extract(payload_json,'$.run_id')=? LIMIT 2", [scope.projectId, event, scope.runId]);
+}
+/** Independent receipt written in the same transaction as fresh acceptance.
+ * A later replay does not re-evaluate today's policy or repaired workspace.
+ * It proves only that these exact bytes/checks were accepted historically.
+ */
+export class PreparedMemoryVerificationReceipt {
+    #scope;
+    #receipt;
+    #checks;
+    #acceptance;
+    #result;
+    constructor(scope, receipt, checks, acceptance, result) {
+        this.#scope = { ...scope };
+        this.#receipt = structuredClone(receipt);
+        this.#checks = checks;
+        this.#acceptance = acceptance;
+        this.#result = result;
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        if (!(input.result instanceof PreparedMemoryStageResult) || !(input.checks instanceof PreparedCheckEvidence)
+            || !(input.acceptance instanceof PreparedMemoryVerificationAcceptance))
+            refuse("prepared_acceptance_required");
+        input.checks.assertOwner({ ...input.scope, scope: "aggregate" });
+        input.acceptance.assertCustody(context, input.result, input.checks);
+        const selected = context.db.readSnapshot(() => stage(context, input.scope)), value = input.result.value();
+        if (selected.current !== "verify" || selected.status !== "running" || value.stage !== "verify" || (value.outcome !== "accepted" && value.outcome !== "needs_repair")
+            || value.run_id !== input.scope.runId || value.input_sha256 !== selected.input_sha256)
+            refuse("active_result_required");
+        if (receiptRows(context, input.scope).length)
+            refuse("fresh_receipt_already_exists");
+        const receipt = { schema_id: "dd-flow/memory-verification-acceptance@1", run_id: input.scope.runId, stage: "verify", project_id: input.scope.projectId,
+            attempt: selected.attempt, input_sha256: selected.input_sha256, result_sha256: input.result.sha256, checks: input.checks.retainedReferences(context) };
+        if (!receipt.checks.length || receipt.checks.length > 4096 || Buffer.byteLength(JSON.stringify(receipt)) > 2 * 1024 * 1024)
+            refuse("receipt_exceeds_bound");
+        return new PreparedMemoryVerificationReceipt(input.scope, receipt, input.checks, input.acceptance, input.result);
+    }
+    record(context) {
+        this.#checks.assertCustody(context);
+        this.#acceptance.assertCustody(context, this.#result);
+        const selected = stage(context, this.#scope);
+        if (selected.current !== "verify" || selected.status !== "running" || selected.attempt !== this.#receipt.attempt
+            || selected.input_sha256 !== this.#receipt.input_sha256 || receiptRows(context, this.#scope).length)
+            refuse("fresh_custody_changed");
+        if (hybridDigest(this.#checks.retainedReferences(context)) !== hybridDigest(this.#receipt.checks))
+            refuse("selected_checks_changed");
+        appendAudit(context, { projectId: this.#scope.projectId, eventType: event, payload: this.#receipt });
+    }
+}
+export class PreparedAcceptedMemoryVerification {
+    #scope;
+    #authority;
+    #receiptSha256;
+    #checks;
+    constructor(scope, authority, receiptSha256, checks) {
+        this.#scope = { ...scope };
+        this.#authority = authority;
+        this.#receiptSha256 = receiptSha256;
+        this.#checks = checks;
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        if (!(input.bytes instanceof Uint8Array) || !input.bytes.length || input.bytes.length > 1024 * 1024)
+            refuse("invalid_replay_bytes");
+        const selected = context.db.readSnapshot(() => accepted(context, input));
+        if (!selected.data.bytes.equals(input.bytes))
+            refuse("accepted_result_changed");
+        const checks = PreparedRetainedCheckEvidence.prepare(context, { projectId: input.projectId, runId: input.runId, references: selected.receipt.checks,
+            ...(JSON.parse(selected.data.bytes.toString("utf8")).outcome === "needs_repair" ? { mode: "diagnostic" } : {}) });
+        const prepared = new PreparedAcceptedMemoryVerification(input, selected.authority, selected.sha256, checks);
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    assertCustody(context) {
+        const selected = context.db.readSnapshot(() => accepted(context, this.#scope));
+        if (selected.sha256 !== this.#receiptSha256 || selected.authority !== this.#authority)
+            refuse("accepted_custody_changed");
+        this.#checks.assertCustody(context);
+    }
+    revalidate(context) { this.#checks.revalidate(context); this.assertCustody(context); }
+    qualityPassed(context) { this.assertCustody(context); return JSON.parse(accepted(context, this.#scope).data.bytes.toString("utf8")).outcome === "accepted"; }
+    diagnosticFindings(context) {
+        this.assertCustody(context);
+        const findings = JSON.parse(accepted(context, this.#scope).data.bytes.toString("utf8")).findings;
+        return findings.map(finding => ({ ...structuredClone(finding), evidence: finding.evidence.map(source => ({ ...source, root: source.root === "run" ? "run" : "workspace", path: source.root === "canon" ? `.memory-bank/${source.path}` : source.path })) }));
+    }
+    finalChecks(context) { if (!this.qualityPassed(context))
+        refuse("verification_quality_not_passed"); return structuredClone(accepted(context, this.#scope).receipt.checks); }
+    /** SQL-only policy identity from the independently accepted check rows,
+     * not today's mutable project profile or coordinator result JSON. */
+    profileHash(context) {
+        this.assertCustody(context);
+        const selected = accepted(context, this.#scope);
+        const hashes = selected.receipt.checks.map(reference => {
+            const row = context.db.get("SELECT profile_hash FROM check_receipts WHERE project_id=? AND run_id=? AND id=?", [this.#scope.projectId, this.#scope.runId, reference.id]);
+            if (!row || (row.profile_hash !== null && (typeof row.profile_hash !== "string" || !/^[a-f0-9]{64}$/.test(row.profile_hash))))
+                refuse("accepted_policy_hash_missing");
+            return row.profile_hash;
+        });
+        if (!hashes.length || hashes.some(value => value !== hashes[0]))
+            refuse("accepted_policy_hash_inconsistent");
+        return hashes[0];
+    }
+}
+function accepted(context, scope) {
+    const selected = stage(context, scope), data = readAcceptedStageData(context, { ...scope, stage: "verify" }), rows = receiptRows(context, scope);
+    if (selected.status !== "done" || rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 2 * 1024 * 1024)
+        refuse("accepted_receipt_missing");
+    let receipt;
+    try {
+        receipt = JSON.parse(rows[0].payload_json);
+    }
+    catch {
+        return refuse("invalid_receipt_json");
+    }
+    if (!receipt || typeof receipt !== "object" || Array.isArray(receipt) || hybridDigest({ ...receipt, checks: undefined }) !== hybridDigest({ schema_id: "dd-flow/memory-verification-acceptance@1", run_id: scope.runId, stage: "verify", project_id: scope.projectId,
+        attempt: selected.attempt, input_sha256: selected.input_sha256, result_sha256: data.result.sha256 }) || !["dd-flow/mb-init-verify-result@1", "dd-flow/mb-upgrade-stage-result@1"].includes(data.data_schema_id ?? "")
+        || data.input_sha256 !== selected.input_sha256)
+        refuse("accepted_receipt_changed");
+    const value = JSON.parse(data.bytes.toString("utf8"));
+    const authoring = data.data_schema_id === "dd-flow/mb-upgrade-stage-result@1" ? "upgrade" : "compose";
+    const compose = readAcceptedStageData(context, { ...scope, stage: authoring }), composed = JSON.parse(compose.bytes.toString("utf8"));
+    if (compose.data_schema_id !== (authoring === "upgrade" ? data.data_schema_id : "dd-flow/mb-init-compose-result@1")
+        || composed.schema_id !== compose.data_schema_id || composed.stage !== authoring || composed.run_id !== scope.runId
+        || composed.outcome !== "accepted" || composed.input_sha256 !== compose.input_sha256
+        || hybridDigest(value.predecessors) !== hybridDigest([{ stage: authoring, result: compose.result, input_sha256: compose.input_sha256 }]))
+        refuse("accepted_predecessor_changed");
+    if (value.stage !== "verify" || value.run_id !== scope.runId || !["accepted", "needs_repair"].includes(value.outcome) || value.input_sha256 !== selected.input_sha256
+        || !Array.isArray(receipt.checks) || receipt.checks.some(reference => !reference || typeof reference !== "object" || Array.isArray(reference)
+        || Object.keys(reference).some(key => !["id", "path", "sha256", "sql_sha256"].includes(key))
+        || typeof reference.id !== "string" || !reference.id || typeof reference.path !== "string"
+        || typeof reference.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(reference.sha256)
+        || typeof reference.sql_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(reference.sql_sha256)) || !Array.isArray(value.details?.checks)
+        || receipt.checks.some(({ path, sha256 }) => !value.details.checks.some((reference) => reference.path === path && reference.sha256 === sha256)))
+        refuse("accepted_check_references_changed");
+    return { data, receipt, sha256: hybridDigest(receipt), authority: hybridDigest({ verify: data.authority_sha256, compose: compose.authority_sha256 }) };
+}

package/dist/services/memory-verify-handler.js

@@ -0,0 +1,137 @@
+import { createHash } from "node:crypto";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { AppError } from "../shared/errors.js";
+import { readFlowRunExecutionBundle, assertPreparedRunBundleSqlAuthority } from "./runs.js";
+import { requireProjectByRoot } from "./projects.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { PreparedMemoryBaselinePreservation } from "./memory-baseline-preservation.js";
+import { readAcceptedStageData } from "./stage-report-renderer.js";
+import { PreparedDescriptorStageStart } from "./descriptor-stage-start.js";
+import { PreparedDescriptorStageCoordinator } from "./descriptor-stage-coordinator.js";
+import { PreparedMemoryVerificationChecks } from "./memory-verification-checks.js";
+import { PreparedMemoryResultBinding } from "./memory-result-binding.js";
+import { PreparedMemoryStageResult } from "./memory-stage-results.js";
+import { PreparedAcceptedMemoryComposition } from "./memory-accepted-composition.js";
+import { PreparedMemoryVerificationAcceptance, projectMemoryVerificationChecks, projectMemoryVerificationArtifacts } from "./memory-verification-acceptance.js";
+import { PreparedDescriptorStageSettlement } from "./descriptor-stage-settlement.js";
+import { PreparedMemoryVerificationReceipt, PreparedAcceptedMemoryVerification } from "./memory-verification-receipt.js";
+function refuse(reason) {
+    throw new AppError("memory_verify_handler_invalid", "Memory verification lacks registered scope or accepted composition", 2, { reason, effect: "no_effect" });
+}
+/** CLI-owned finite checks for the active verifier. Callers supply no command,
+ * profile hash, receipt path or alternate executable. Public routing remains
+ * pending complete memory handler registration.
+ */
+export function runMemoryVerificationChecks(context, input) {
+    const bundle = readFlowRunExecutionBundle(context, input);
+    if (!bundle || !["mb-init", "mb-upgrade"].includes(bundle.descriptor.descriptor.id) || bundle.descriptor.successor(bundle.descriptor.descriptor.id === "mb-upgrade" ? "upgrade" : "compose", "accepted") !== "verify"
+        || bundle.descriptor.successor("verify", "accepted") !== "review")
+        refuse("registered_memory_bundle_required");
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot)), scope = { projectId: project.id, runId: input.runId };
+    const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle), index = JSON.parse(run.index_json);
+    if (index.current_stage !== "verify" || index.stage_runs.find((stage) => stage.stage === "verify")?.status !== "running")
+        refuse("active_verification_required");
+    return PreparedMemoryVerificationChecks.prepare(context, { ...scope, execution: bundle.execution, flow: bundle.descriptor, bundle }).execute(context);
+}
+/** Productive entry implementation, not registered until the complete six-stage
+ * memory group is ready. Checks and semantic assessment acceptance belong to
+ * its finish path, not this allocation of a verifier coordinator.
+ */
+export function startMemoryVerification(context, input) {
+    if (!(input.bytes instanceof Uint8Array) || input.bytes.length > 1024 * 1024)
+        refuse("invalid_input_bytes");
+    const bundle = readFlowRunExecutionBundle(context, input);
+    if (!bundle || !["mb-init", "mb-upgrade"].includes(bundle.descriptor.descriptor.id) || bundle.descriptor.successor(bundle.descriptor.descriptor.id === "mb-upgrade" ? "upgrade" : "compose", "accepted") !== "verify"
+        || bundle.descriptor.successor("verify", "accepted") !== "review")
+        refuse("registered_memory_bundle_required");
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot)), scope = { projectId: project.id, runId: input.runId, stage: "verify" };
+    const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle), index = JSON.parse(run.index_json);
+    if (index.stage_runs.find((stage) => stage.stage === "verify")?.status === "done")
+        refuse("use_accepted_finish_replay");
+    const upgrade = bundle.descriptor.descriptor.id === "mb-upgrade", authoring = upgrade ? "upgrade" : "compose";
+    const preservation = upgrade ? PreparedAcceptedMemoryComposition.prepare(context, { scope, bundle }) : PreparedMemoryBaselinePreservation.prepare(context, bundle.execution);
+    const inherited = context.db.readSnapshot(() => ({ compose: readAcceptedStageData(context, { ...scope, stage: authoring }), preflight: readAcceptedStageData(context, { ...scope, stage: "preflight" }) }));
+    const compose = JSON.parse(inherited.compose.bytes.toString("utf8")), preflight = JSON.parse(inherited.preflight.bytes.toString("utf8"));
+    if (compose.schema_id !== (upgrade ? "dd-flow/mb-upgrade-stage-result@1" : "dd-flow/mb-init-compose-result@1") || compose.run_id !== input.runId || compose.outcome !== "accepted"
+        || preflight.schema_id !== (upgrade ? compose.schema_id : "dd-flow/mb-init-preflight-result@1") || preflight.run_id !== input.runId || preflight.outcome !== "accepted")
+        refuse("accepted_composition_and_baseline_required");
+    const fence = (writer) => {
+        preservation.assertCustody(writer);
+        if (readAcceptedStageData(writer, { ...scope, stage: authoring }).authority_sha256 !== inherited.compose.authority_sha256
+            || readAcceptedStageData(writer, { ...scope, stage: "preflight" }).authority_sha256 !== inherited.preflight.authority_sha256)
+            refuse("inherited_custody_changed");
+    };
+    const start = PreparedDescriptorStageStart.prepare(context, { ...input, stage: "verify" });
+    preservation.revalidate(context);
+    const stage = start.apply(context, fence), coordinator = PreparedDescriptorStageCoordinator.prepare(context, { ...input, stage: "verify" });
+    preservation.revalidate(context);
+    return { ...stage, ...coordinator.apply(context, fence) };
+}
+/** Verification settlement. Restore composition from committed SQL and
+ * its original registration, never from verifier-proposed predecessor bytes.
+ * Replay consumes independent historical acceptance/check custody instead of
+ * current workspace policy. No partial registry is enabled by this path.
+ */
+export function finishMemoryVerification(context, input) {
+    if (!(input.bytes instanceof Uint8Array) || !input.bytes.length || input.bytes.length > 1024 * 1024)
+        refuse("invalid_result_bytes");
+    const bundle = readFlowRunExecutionBundle(context, input);
+    if (!bundle || !["mb-init", "mb-upgrade"].includes(bundle.descriptor.descriptor.id) || bundle.descriptor.successor(bundle.descriptor.descriptor.id === "mb-upgrade" ? "upgrade" : "compose", "accepted") !== "verify"
+        || bundle.descriptor.successor("verify", "accepted") !== "review")
+        refuse("registered_memory_bundle_required");
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot)), scope = { projectId: project.id, runId: input.runId };
+    const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle), index = JSON.parse(run.index_json);
+    if (index.stage_runs.find((stage) => stage.stage === "verify")?.status === "done") {
+        const data = readAcceptedStageData(context, { ...scope, stage: "verify" });
+        const accepted = PreparedAcceptedMemoryVerification.prepare(context, { ...scope, bytes: data.bytes });
+        const value = JSON.parse(data.bytes.toString("utf8"));
+        let proposal;
+        try {
+            proposal = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.bytes));
+        }
+        catch {
+            refuse("invalid_result_bytes");
+        }
+        if (hybridDigest(projectMemoryVerificationChecks(projectMemoryVerificationArtifacts(proposal, value.units, value.units.flatMap((unit) => unit.artifacts)), value.details.checks, bundle.descriptor.stage("verify").directory, createHash("sha256").update(input.bytes).digest("hex"))) !== hybridDigest(value))
+            refuse("accepted_result_changed");
+        const settlement = PreparedDescriptorStageSettlement.prepare(context, { ...input, stage: "verify", bytes: data.bytes });
+        accepted.revalidate(context);
+        return settlement.apply(context, writer => accepted.assertCustody(writer));
+    }
+    const composition = PreparedAcceptedMemoryComposition.prepare(context, { scope, bundle }), compose = composition.result();
+    const composedUnits = compose.value().units;
+    const preservation = bundle.descriptor.descriptor.id === "mb-upgrade" ? composition : PreparedMemoryBaselinePreservation.prepare(context, bundle.execution);
+    const policy = PreparedMemoryVerificationChecks.prepare(context, { ...scope, execution: bundle.execution, flow: bundle.descriptor, bundle, composition });
+    const checks = policy.evidence(context, "diagnostic");
+    const binding = PreparedMemoryResultBinding.prepare(context, { ...scope, stage: "verify", flow: bundle.descriptor, execution: bundle.execution, bundle,
+        sources: composition.captureSources(context, input.bytes, checks), checks, historicalEvidence: composition.historicalEvidence() });
+    let proposal;
+    try {
+        proposal = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.bytes));
+    }
+    catch {
+        PreparedMemoryStageResult.prepare(input.bytes, bundle.descriptor, binding.binding());
+        refuse("invalid_result_bytes");
+    }
+    const references = checks.sourceReferences().map(({ path, sha256 }) => ({ path, sha256 }));
+    const result = PreparedMemoryStageResult.prepare(Buffer.from(JSON.stringify(projectMemoryVerificationChecks(projectMemoryVerificationArtifacts(proposal, composedUnits, composition.outputReferences(), createHash("sha256").update(input.bytes).digest("hex")), references, bundle.descriptor.stage("verify").directory, createHash("sha256").update(input.bytes).digest("hex")))), bundle.descriptor, binding.binding());
+    const acceptance = PreparedMemoryVerificationAcceptance.prepare({ scope, result, compose, checks, composition, roots: bundle.execution.snapshot().scope,
+        proposalSha256: createHash("sha256").update(input.bytes).digest("hex") });
+    const receipt = PreparedMemoryVerificationReceipt.prepare(context, { scope, result, checks, acceptance });
+    const settlement = PreparedDescriptorStageSettlement.prepare(context, { ...input, stage: "verify", bytes: result.bytes() });
+    composition.revalidate(context);
+    binding.revalidate(context);
+    // Binding owns the check artifact references and has just revalidated the
+    // same checks; acceptance adds SQL custody, not another physical pass.
+    preservation.revalidate(context);
+    policy.revalidate(context);
+    acceptance.assertCustody(context, result);
+    return settlement.apply(context, writer => {
+        composition.assertCustody(writer);
+        binding.assertCustody(writer);
+        preservation.assertCustody(writer);
+        policy.assertCustody(writer);
+        acceptance.assertCustody(writer, result);
+        receipt.record(writer);
+    });
+}

package/dist/services/memory-work-result-json.js

@@ -0,0 +1,12 @@
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+/** Syntax only: the caller still owns bounds, assignment and evidence checks. */
+export function parseMemoryWorkResultProposal(bytes, code) {
+    try {
+        return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        throw new AppError(code, "Memory result proposal is not valid UTF-8 JSON. Correct only this proposal using its assigned packet; do not rerun settled work or change retained inputs", 2, { reason: "invalid_result_json", phase: "prepare", effect: "no_effect", recoverable: true,
+            result_sha256: createHash("sha256").update(bytes).digest("hex") });
+    }
+}