@deksden-com/dd-flow-cli 0.9.0-beta.14 → 0.9.0-beta.141

package/dist/services/memory-stage-results.js

@@ -0,0 +1,199 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { validateMemoryCompositionGraph } from "./memory-composition-graph.js";
+import { FrozenGenericExecution } from "./generic-execution.js";
+const stages = ["preflight", "discover", "compose", "verify", "review", "finish"];
+const sha = (value) => /^[a-f0-9]{64}$/.test(value);
+function refuse(reason) {
+    throw new AppError("memory_stage_result_invalid", "Memory stage result is not bound to its retained input", 2, { reason, phase: "prepare", effect: "no_effect" });
+}
+function contained(logical, allowRoot = false) {
+    if (allowRoot && logical === ".")
+        return;
+    if (!logical || path.posix.isAbsolute(logical) || path.win32.isAbsolute(logical) || logical.includes("\\")
+        || logical.includes("\0") || logical.split("/").some(segment => !segment || segment === "." || segment === ".."))
+        refuse("unsafe_reference_path");
+}
+export function memorySourceKey(root, logical) { return `${root}\0${logical}`; }
+function unique(values, reason) {
+    if (new Set(values).size !== values.length)
+        refuse(reason);
+    return new Set(values);
+}
+/** Read-only result preparation. The stage handler must still establish physical check,
+ * Work/reviewer, bootstrap, integration and readiness custody before settlement.
+ * Schema validity and source identity are not semantic completeness or finish authority.
+ */
+export class PreparedMemoryStageResult {
+    sha256;
+    #bytes;
+    #value;
+    #routes;
+    #executionSha256;
+    #preflight;
+    constructor(bytes, value, routes, executionSha256, preflight) {
+        this.#bytes = Buffer.from(bytes);
+        this.#value = structuredClone(value);
+        this.#routes = structuredClone(routes);
+        this.#executionSha256 = executionSha256;
+        this.#preflight = structuredClone(preflight);
+        this.sha256 = createHash("sha256").update(bytes).digest("hex");
+        Object.freeze(this);
+    }
+    static prepare(input, flow, binding) {
+        try {
+            if (input.byteLength < 1 || input.byteLength > 1024 * 1024 || flow.descriptor.id !== "mb-init"
+                || !stages.includes(binding.stage) || !binding.runId || !sha(binding.inputSha256))
+                refuse("invalid_input_binding");
+            const bytes = Buffer.from(input), value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+            const schema = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(flow.stageBlob(binding.stage, "result_schema")));
+            if (schema.$id !== `dd-flow/mb-init-${binding.stage}-result@1`)
+                refuse("invalid_result_schema");
+            const validate = new Ajv2020({ strict: true, strictRequired: false, validateFormats: false }).compile(schema);
+            if (!validate(value))
+                throw new AppError("memory_stage_result_invalid", "Memory stage result proposal does not match its schema", 2, { reason: "invalid_result_schema", phase: "prepare", effect: "no_effect", recoverable: true,
+                    errors: structuredClone(validate.errors), result_sha256: createHash("sha256").update(bytes).digest("hex") });
+            if (value.run_id !== binding.runId || value.stage !== binding.stage || value.input_sha256 !== binding.inputSha256)
+                refuse("foreign_result_identity");
+            const isEntry = flow.descriptor.entry_stage === binding.stage;
+            if (binding.predecessors.length !== (isEntry ? 0 : 1))
+                refuse("incomplete_predecessor_binding");
+            for (const predecessor of binding.predecessors) {
+                contained(predecessor.result.path);
+                if (!sha(predecessor.result.sha256) || !sha(predecessor.input_sha256)
+                    || flow.successor(predecessor.stage, "accepted") !== binding.stage)
+                    refuse("foreign_predecessor_binding");
+            }
+            if (hybridDigest(value.predecessors) !== hybridDigest(binding.predecessors))
+                refuse("foreign_predecessor_reference");
+            const units = unique(value.units.map(unit => unit.id), "duplicate_unit");
+            if (binding.unitIds === null) {
+                if (!["preflight", "discover"].includes(binding.stage))
+                    refuse("missing_unit_inventory");
+            }
+            else {
+                const expected = unique(binding.unitIds, "duplicate_bound_unit");
+                if (units.size !== expected.size || [...units].some(id => !expected.has(id)))
+                    refuse("changed_unit_coverage");
+            }
+            unique(value.findings.map(finding => finding.id), "duplicate_finding");
+            if (value.findings.some(finding => !units.has(finding.unit_id)))
+                refuse("foreign_finding_unit");
+            const facts = value.details.facts;
+            if (binding.stage === "discover") {
+                unique(facts.map(fact => fact.id), "duplicate_fact");
+                if (facts.some(fact => !units.has(fact.unit_id)))
+                    refuse("foreign_fact_unit");
+            }
+            const visit = (node, role = "source") => {
+                if (Array.isArray(node)) {
+                    node.forEach(child => visit(child, role));
+                    return;
+                }
+                if (!node || typeof node !== "object")
+                    return;
+                const record = node;
+                if (typeof record.unit_id === "string" && !units.has(record.unit_id))
+                    refuse("foreign_unit_reference");
+                if (Array.isArray(record.unit_ids) && record.unit_ids.some(id => typeof id !== "string" || !units.has(id)))
+                    refuse("foreign_unit_reference");
+                if (typeof record.path === "string" && (typeof record.root === "string" || typeof record.sha256 === "string"))
+                    contained(record.path, typeof record.root === "string" && record.sha256 === undefined);
+                if (typeof record.root === "string" && typeof record.path === "string" && typeof record.sha256 === "string") {
+                    const key = memorySourceKey(record.root, record.path);
+                    if (binding.sources.get(key) !== record.sha256 && !(role === "evidence" && binding.historicalEvidence?.has(`${key}\0${record.sha256}`)))
+                        refuse("unobserved_or_changed_source");
+                }
+                Object.entries(record).forEach(([key, child]) => visit(child, key === "evidence" || key === "artifacts" ? key : role));
+            };
+            visit(value);
+            let routes = null;
+            if (binding.stage === "compose") {
+                validateMemoryCompositionGraph(value);
+                if (!(binding.execution instanceof FrozenGenericExecution) || binding.execution.settings.flow_id !== flow.descriptor.id
+                    || binding.execution.settings.descriptor_sha256 !== flow.sha256 || binding.execution.sha256 !== binding.executionSha256)
+                    refuse("missing_or_foreign_composition_execution");
+                const works = value.details.works;
+                try {
+                    routes = works.map(work => ({ key: work.key, execution: binding.execution.work("compose", work.profile_id ?? undefined) }));
+                }
+                catch {
+                    refuse("unapproved_composition_profile");
+                }
+            }
+            if (binding.preflight) {
+                contained(binding.preflight.result.path);
+                if (!sha(binding.preflight.result.sha256) || !sha(binding.preflight.input_sha256)
+                    || typeof binding.preflight.semantic_scope !== "string" || !binding.preflight.semantic_scope.trim()
+                    || Buffer.byteLength(binding.preflight.semantic_scope) > 16384 || binding.preflight.semantic_scope.includes("\0"))
+                    refuse("invalid_preflight_binding");
+                if (binding.preflight.preserved_paths !== undefined) {
+                    if (!Array.isArray(binding.preflight.preserved_paths) || binding.preflight.preserved_paths.length > 4096)
+                        refuse("invalid_preflight_binding");
+                    unique(binding.preflight.preserved_paths, "duplicate_preserved_path");
+                    for (const logical of binding.preflight.preserved_paths) {
+                        if (typeof logical !== "string" || logical.length > 4096)
+                            refuse("invalid_preflight_binding");
+                        contained(logical);
+                    }
+                }
+            }
+            return new PreparedMemoryStageResult(bytes, value, routes, routes ? binding.executionSha256 : null, binding.preflight ?? null);
+        }
+        catch (error) {
+            if (error instanceof AppError && error.code === "memory_stage_result_invalid")
+                throw error;
+            return refuse("invalid_result_or_binding");
+        }
+    }
+    bytes() { return Buffer.from(this.#bytes); }
+    value() { return structuredClone(this.#value); }
+    compositionRoutes() {
+        if (!this.#routes)
+            refuse("not_a_composition_result");
+        return structuredClone(this.#routes);
+    }
+    /** Pure registration input, not allocation, dispatch or stage completion authority.
+     * The handler must select a registered result schema and independently bind
+     * this result's predecessor/source custody before passing the batch to its writer.
+     */
+    compositionBatch(binding) {
+        if (!this.#routes || this.#value.stage !== "compose")
+            refuse("not_a_composition_result");
+        // Registration assigns unfinished authoring; only final acceptance attests
+        // settled outputs. A repairable blueprint is not a blocked dispatch.
+        if (this.#value.outcome === "blocked")
+            refuse("composition_not_accepted");
+        // Unknown facts may survive DISCOVER with a reason/next action. Unknown
+        // target applicability must be resolved before immutable Work assignment,
+        // rather than dispatching a graph that cannot later accept its own units.
+        if (this.#value.units.some(unit => unit.applicability === "unknown"))
+            refuse("unresolved_composition_applicability");
+        if (binding.runId !== this.#value.run_id || binding.inputSha256 !== this.#value.input_sha256
+            || binding.executionSha256 !== this.#executionSha256)
+            refuse("foreign_composition_batch_binding");
+        if (typeof binding.resultSchema !== "string" || !/^dd-flow\/[A-Za-z0-9][A-Za-z0-9._-]*@[1-9][0-9]*$/.test(binding.resultSchema))
+            refuse("invalid_composition_work_schema");
+        const routes = new Map(this.#routes.map(route => [route.key, route]));
+        const works = this.#value.details.works;
+        return { works: works.map(work => {
+                // Historical retained schemas can still be read, but cannot invent tasks.
+                if (typeof work.task !== "string" || !work.task.trim() || work.task.length > 16384)
+                    refuse("missing_composition_work_task");
+                const packet = { schema_id: "dd-flow/memory-composition-work-packet@1", run_id: binding.runId,
+                    stage: "compose", key: work.key, role: work.role, unit_ids: work.unit_ids,
+                    task: work.task, depends_on: work.depends_on, result_schema: binding.resultSchema,
+                    read_scopes: work.read_scopes, write_scopes: work.write_scopes,
+                    compose_result_sha256: this.sha256, compose_input_sha256: binding.inputSha256,
+                    execution_sha256: binding.executionSha256, predecessors: this.#value.predecessors };
+                const scopedPacket = { ...packet, ...(this.#preflight ? { preflight: structuredClone(this.#preflight) } : {}) };
+                return { key: work.key, task: work.task, depends_on: [...work.depends_on],
+                    launch_policy: "fresh_agent_required", result_schema: binding.resultSchema,
+                    payload: structuredClone({ memory_composition: { ...scopedPacket, packet_sha256: hybridDigest(scopedPacket) },
+                        execution_override: { agent_profile_id: routes.get(work.key).execution.worker.id } }) };
+            }) };
+    }
+}

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

@@ -0,0 +1,135 @@
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedCheckEvidence } from "./code-checks.js";
+import { PreparedMemoryStageResult, memorySourceKey } from "./memory-stage-results.js";
+import { PreparedAcceptedMemoryComposition } from "./memory-accepted-composition.js";
+function refuse(reason) {
+    throw new AppError("memory_verification_acceptance_invalid", "Verification lacks current check proof or accepted per-unit assessments", 2, { reason, effect: "no_effect" });
+}
+/** Check references are a CLI projection of the selected current owner, not
+ * agent-generated proof. Admit an optional echo only when it names those bytes. */
+export function projectMemoryVerificationChecks(value, references, directory, resultSha256) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const candidate = value;
+    if (!candidate.details || typeof candidate.details !== "object" || Array.isArray(candidate.details))
+        return value;
+    if (candidate.details.checks !== undefined && (!Array.isArray(candidate.details.checks) || candidate.details.checks.some(reference => {
+        if (!reference || typeof reference !== "object" || Array.isArray(reference) || Object.keys(reference).some(key => !["path", "sha256"].includes(key)))
+            return true;
+        const matches = references.filter(current => current.sha256 === reference.sha256 && (current.path === reference.path
+            || current.path.startsWith(`${directory}/checks/`) && current.path.slice(directory.length + 1) === reference.path));
+        return new Set(matches.map(current => hybridDigest(current))).size !== 1;
+    })))
+        throw new AppError("memory_verification_acceptance_invalid", "Use only the selected current CLI check references; correct the proposed result without rerunning settled checks", 2, { reason: "checks_not_selected_current_receipts", phase: "prepare", effect: "no_effect", recoverable: true, check_references: references, result_sha256: resultSha256 });
+    return { ...candidate, details: { ...candidate.details, checks: references } };
+}
+/** Pure reference comparison; the caller must obtain admitted outputs from
+ * the current accepted composition owner, never from proposed result bytes. */
+export function assertMemoryVerificationArtifactReferences(original, proposed, outputs) {
+    const identities = (sources) => sources.map(source => hybridDigest(source));
+    const declared = new Set(identities(proposed)), accepted = new Set(identities([...original, ...outputs]));
+    if (identities(original).some(identity => !declared.has(identity))
+        || [...declared].some(identity => !accepted.has(identity)))
+        refuse("changed_composed_artifacts");
+}
+/** Accepted compose owns these associations; the verifier owns assessments. */
+export function projectMemoryVerificationArtifacts(value, units, outputs, resultSha256) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const candidate = value;
+    if (!Array.isArray(candidate.units))
+        return value;
+    const originals = new Map(units.map(unit => [unit.id, unit.artifacts]));
+    return { ...candidate, units: candidate.units.map(unit => {
+            if (!unit || typeof unit !== "object" || Array.isArray(unit) || unit.artifacts !== undefined && !Array.isArray(unit.artifacts))
+                return unit;
+            const original = originals.get(unit.id);
+            if (!original)
+                return unit;
+            const allowed = new Set([...original, ...outputs].map(reference => hybridDigest(reference)));
+            const provided = unit.artifacts ?? [];
+            if (provided.some((reference) => !allowed.has(hybridDigest(reference)))) {
+                if (resultSha256 === undefined)
+                    refuse("changed_composed_artifacts");
+                throw new AppError("memory_verification_acceptance_invalid", "Omit units[].artifacts: the CLI preserves accepted compose outputs. Cite preserved source documents in semantic assessment evidence, not as new artifacts; correct the proposal without rerunning settled checks", 2, { reason: "changed_composed_artifacts", phase: "prepare", effect: "no_effect", recoverable: true, unit_id: unit.id,
+                    output_references: structuredClone(original), result_sha256: resultSha256 });
+            }
+            const merged = new Map([...original, ...provided].map(reference => [hybridDigest(reference), reference]));
+            return { ...unit, artifacts: [...merged.values()] };
+        }) };
+}
+/** Admission of the verifier's claims, not an independent judgment of their
+ * semantic truth. The handler must independently select and fence accepted
+ * compose SQL custody and current output observations; REVIEW/Eval still own
+ * their separate gates. Lint alone cannot supply these unit assessments.
+ */
+export class PreparedMemoryVerificationAcceptance {
+    #resultSha256;
+    #checks;
+    constructor(result, checks) {
+        this.#resultSha256 = result.sha256;
+        this.#checks = checks;
+        Object.freeze(this);
+    }
+    static prepare(input) {
+        if (!(input.result instanceof PreparedMemoryStageResult) || !(input.compose instanceof PreparedMemoryStageResult)
+            || !(input.checks instanceof PreparedCheckEvidence))
+            refuse("prepared_authority_required");
+        const result = input.result.value(), compose = input.compose.value();
+        if (input.composition !== undefined && (!(input.composition instanceof PreparedAcceptedMemoryComposition)
+            || input.composition.result().sha256 !== input.compose.sha256))
+            refuse("prepared_authority_required");
+        const outputs = input.composition?.outputReferences() ?? [];
+        input.checks.assertOwner({ ...input.scope, scope: "aggregate" });
+        const diagnostic = result.outcome === "needs_repair";
+        if (compose.stage !== "compose" || compose.outcome !== "accepted" || result.stage !== "verify" || !["accepted", "needs_repair"].includes(result.outcome)
+            || result.run_id !== compose.run_id || result.run_id !== input.scope.runId || result.predecessors.length !== 1 || result.predecessors[0].stage !== "compose"
+            || result.predecessors[0].input_sha256 !== compose.input_sha256 || result.predecessors[0].result.sha256 !== input.compose.sha256
+            || compose.findings.some(finding => finding.severity !== "minor" && finding.status !== "resolved")
+            || (!diagnostic && (!input.checks.qualityPassed() || result.findings.some(finding => finding.severity !== "minor" && finding.status !== "resolved"))))
+            refuse("unaccepted_or_foreign_predecessor");
+        const expected = input.checks.resultReferences().map(reference => hybridDigest(reference)), actual = result.details.checks.map(reference => hybridDigest(reference));
+        const allowedChecks = new Set(input.checks.sourceReferences().map(({ path, sha256 }) => hybridDigest({ path, sha256 })));
+        if (expected.some(reference => !actual.includes(reference))
+            || actual.some(reference => !allowedChecks.has(reference)))
+            refuse("checks_not_selected_current_receipts");
+        const units = new Map(compose.units.map(unit => [unit.id, unit]));
+        if (result.units.length !== units.size || new Set(result.units.map(unit => unit.id)).size !== units.size)
+            refuse("changed_unit_coverage");
+        const assessments = new Map(result.details.semantic_assessments.map(assessment => [assessment.unit_id, assessment]));
+        if (assessments.size !== result.details.semantic_assessments.length || [...assessments.keys()].some(id => !units.has(id))
+            || compose.units.some(unit => unit.applicability !== "not-applicable" && !assessments.has(unit.id)))
+            refuse("incomplete_or_duplicate_assessments");
+        const key = (source) => memorySourceKey(input.roots && input.roots.projectRoot === input.roots.workspace && source.root === "project" ? "workspace" : source.root, source.path);
+        for (const unit of result.units) {
+            const original = units.get(unit.id), assessment = assessments.get(unit.id);
+            if (!original || unit.aspect !== original.aspect || unit.applicability !== original.applicability || unit.applicability === "unknown"
+                || (unit.applicability === "not-applicable" ? unit.outcome !== "not-applicable" : !["accepted", ...(diagnostic ? ["needs_repair"] : [])].includes(unit.outcome))
+                || (assessment && (!["accepted", ...(diagnostic ? ["needs_repair"] : [])].includes(assessment.verdict) || !assessment.summary.trim())))
+                refuse("unit_not_accepted_or_changed");
+            assertMemoryVerificationArtifactReferences(original.artifacts, unit.artifacts, outputs);
+            if (!assessment)
+                continue;
+            // PreparedMemoryStageResult already binds every evidence reference to
+            // admitted bytes. Cross-unit and earlier-stage evidence is useful context,
+            // but cannot replace examination of this unit's own composed output.
+            if (unit.applicability !== "not-applicable" && !assessment.evidence.some(source => original.artifacts.some(artifact => key(artifact) === key(source) && artifact.sha256 === source.sha256))) {
+                throw new AppError("memory_verification_acceptance_invalid", "Assess the composed documents themselves and cite a direct output reference for EACH applicable unit; the listed references identify this unit's outputs. Work result receipts do not replace direct output examination", 2, { reason: "assessment_does_not_examine_composed_output", phase: "prepare", effect: "no_effect", recoverable: true,
+                    unit_id: unit.id, output_references: structuredClone(original.artifacts), result_sha256: input.result.sha256 });
+            }
+        }
+        if (diagnostic && !result.findings.some(finding => finding.severity !== "minor" && finding.status === "open")) {
+            throw new AppError("memory_verification_acceptance_invalid", "needs_repair requires an open material finding; correct the proposed outcome and unit assessments without inventing severity", 2, { reason: "repair_requires_material_finding", phase: "prepare", effect: "no_effect", recoverable: true });
+        }
+        return new PreparedMemoryVerificationAcceptance(input.result, input.checks);
+    }
+    assertCustody(context, result, checks) {
+        if (!(result instanceof PreparedMemoryStageResult) || result.sha256 !== this.#resultSha256)
+            refuse("verification_result_changed");
+        if (checks !== undefined && checks !== this.#checks)
+            refuse("foreign_check_owner");
+        this.#checks.assertCustody(context);
+    }
+    revalidate(context) { this.#checks.revalidate(context); }
+}

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

@@ -0,0 +1,252 @@
+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, validateMemoryLintConfig } from "./memory-lint-config.js";
+import { isMemoryCorrectionInputOwner } from "./memory-correction-input-owner.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";
+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" });
+}
+/** 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) {
+    if (!context.db.get("SELECT 1 FROM sqlite_schema WHERE type='table' AND name='run_controllers'"))
+        return undefined;
+    const controllers = context.db.all("SELECT state_json FROM run_controllers WHERE project_id=? AND run_id=?", [projectId, runId]);
+    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 undefined;
+    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 { 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 bootstrap = readMemoryInitBootstrapReadiness(context, scope), lint = 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 compose = readAcceptedStageData(context, { projectId: input.projectId, runId: input.runId, stage: "compose" });
+    if (compose.data_schema_id !== "dd-flow/mb-init-compose-result@1")
+        refuse("accepted_composition_required");
+    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 };
+    return { run: roots, bootstrap, lint, compose, scope, 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)
+            || input.flow.descriptor.id !== "mb-init" || input.execution.settings.flow_id !== "mb-init"
+            || 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 schema = JSON.parse(input.flow.stageBlob("compose", "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 !== "compose" || compose.outcome !== "accepted")
+            refuse("accepted_composition_required");
+        const probe = selected.bootstrap.authority.binding.target.tool_probes?.["mb-lint"];
+        if (!probe || selected.bootstrap.authority.binding.target.tools["mb-lint"] !== 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 preservation = PreparedMemoryBaselinePreservation.prepare(context, input.execution);
+        const workspace = selected.run.workspace_root;
+        const config = lintConfig(workspace);
+        const corrected = input.corrected?.value();
+        if (config)
+            validateMemoryLintConfig(config, corrected
+                ? memoryVerificationActivePaths(corrected.unit_inventory, corrected.assignments)
+                : memoryVerificationActivePaths(compose.units));
+        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 (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 checks = [{ 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"] },
+            ...projectPolicyCheckDeclarationsFromProfile(policy, "readiness")];
+        if (input.corrected && codeCheckProfileHash(workspace, checks) !== input.corrected.verificationProfileHash(context))
+            refuse("correction_policy_requires_readmission");
+        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); }
+    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 } : {}) });
+    }
+}