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

package/dist/services/memory-finish-readiness.js

@@ -0,0 +1,169 @@
+var _a;
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { RetainedExecutionBundle } from "./execution-bundles.js";
+import { PreparedMemoryFinishIntegration, readMemoryUpgradeFinishInventory, observeMemoryUpgradeFinishInventory } from "./memory-finish-integration.js";
+import { PreparedMemoryFinishReview } from "./memory-finish-handler.js";
+import { observeMemoryNormalFlowEntry } from "./memory-normal-flow-entry.js";
+import { readMemoryInitBootstrapReadiness } from "./memory-init-bootstrap-readiness.js";
+import { readMemoryInitProjectBootstrap } from "./memory-init-project-bootstrap.js";
+import { readRetainedMemoryLayer } from "./memory-layer-publication.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { readBoundedReleaseFile } from "./release-source.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { readMemoryUpgradeBootstrapReadiness } from "./memory-upgrade-bootstrap-readiness.js";
+import { readUpgradeStorageReadiness } from "./memory-upgrade-storage-readiness.js";
+import { getProjectVersionStatus } from "./version-status.js";
+const token = Symbol("memory-finish-readiness");
+function refuse(reason) {
+    throw new AppError("memory_finish_readiness_invalid", "Finish lacks reviewed ordinary-flow readiness", 2, { reason, effect: "no_effect" });
+}
+function accepted(context, scope, bundle) {
+    const frozen = bundle.execution.snapshot().scope;
+    const request = { requestId: frozen.requestId, projectRoot: frozen.projectRoot, workspaceRoot: frozen.workspace };
+    if (bundle.descriptor.descriptor.id === "mb-upgrade") {
+        const bootstrap = readMemoryUpgradeBootstrapReadiness(context, request), storage = readUpgradeStorageReadiness(context, request);
+        if (!bootstrap?.hasGitPolicy || !bootstrap.hasLintCapability || !storage?.selection || bootstrap.projectId !== scope.projectId
+            || bootstrap.authority.binding.execution_sha256 !== bundle.execution.sha256
+            || bootstrap.authority.binding.storage_sha256 !== storage.sha256)
+            refuse("accepted_bootstrap_required");
+        return { kind: "upgrade", request, bootstrap, storage };
+    }
+    const bootstrap = readMemoryInitBootstrapReadiness(context, request), registration = readMemoryInitProjectBootstrap(context, request);
+    if (!bootstrap || !registration || bootstrap.projectId !== scope.projectId
+        || bootstrap.authority.binding.execution_sha256 !== bundle.execution.sha256)
+        refuse("accepted_bootstrap_required");
+    return { kind: "init", request, bootstrap, registration };
+}
+function tools(selected) {
+    if (selected.kind === "upgrade") {
+        const git = selected.storage.selection.payload.git, lint = selected.bootstrap.authority.binding.lint;
+        if (!git || !lint)
+            refuse("selected_tool_changed");
+        for (const tool of [git, lint]) {
+            const expected = "probe" in tool ? tool.probe.executable_sha256 : tool.executable_sha256;
+            if (createHash("sha256").update(readBoundedReleaseFile(tool.executable, 64 * 1024 * 1024)).digest("hex") !== expected)
+                refuse("selected_tool_changed");
+        }
+        return;
+    }
+    const target = selected.bootstrap.authority.binding.target;
+    for (const name of ["git", "wt", "mb-lint"]) {
+        const expected = target.tool_probes?.[name].executable_sha256;
+        if (!expected || createHash("sha256").update(readBoundedReleaseFile(target.tools[name], 64 * 1024 * 1024)).digest("hex") !== expected)
+            refuse("selected_tool_changed");
+    }
+}
+/** Fresh readiness requires accepted final review, integrated reviewed bytes,
+ * unchanged selected canonical pack/tools and real ordinary SPECIFY preparation
+ * from the integration checkout. It does not execute the future task or seal a
+ * Stage/RUN; historical replay must use independently committed evidence. */
+export class PreparedMemoryFinishReadiness {
+    static isPrepared(value) {
+        return typeof value === "object" && value !== null && #integration in value;
+    }
+    #scope;
+    #bundle;
+    #integration;
+    #review;
+    #acceptedSha256;
+    #value;
+    constructor(key, scope, bundle, integration, review, acceptedSha256, value) {
+        if (key !== token)
+            refuse("readiness_token_required");
+        this.#scope = { ...scope };
+        this.#bundle = bundle;
+        this.#integration = integration;
+        this.#review = review;
+        this.#acceptedSha256 = acceptedSha256;
+        this.#value = structuredClone(value);
+        Object.freeze(this);
+    }
+    static observe(context, scope, bundle, review, integration) {
+        const selected = context.db.readSnapshot(() => accepted(context, scope, bundle));
+        tools(selected);
+        const files = new Map();
+        let packSha256;
+        let upgrade = null;
+        if (selected.kind === "upgrade") {
+            upgrade = readMemoryUpgradeFinishInventory(context, scope, bundle, review);
+            if (integration.value().upgrade_inventory_sha256 !== hybridDigest(upgrade))
+                refuse("upgrade_integration_inventory_changed");
+            for (const item of upgrade.entries)
+                if (item.kind === "file")
+                    files.set(item.path.slice(".memory-bank/".length), item.sha256);
+            for (const root of new Set([selected.request.projectRoot, selected.request.workspaceRoot])) {
+                observeMemoryUpgradeFinishInventory(root, upgrade);
+                const version = getProjectVersionStatus({ projectRoot: root, rootSource: "explicit", canon: null });
+                const release = selected.storage.selection.release;
+                if (!version || version.memory_bank.version !== release.canon.version || version.flow_pack.canon_version_at_source_commit !== release.canon.version
+                    || version.flow_pack.source_commit !== release.canon.commit)
+                    refuse("upgrade_versions_inconsistent");
+            }
+            packSha256 = selected.bootstrap.authority.receipt.upgrade_target.pack_sha256;
+        }
+        else {
+            const layer = readRetainedMemoryLayer(context.ddFlowHome, { ...selected.request,
+                targetSha256: selected.registration.receipt.target_sha256, layerSha256: selected.registration.receipt.layer_sha256,
+                installationSha256: selected.bootstrap.authority.binding.installation_manifest_sha256 });
+            if (layer.packSha256 !== selected.bootstrap.authority.binding.pack_sha256)
+                refuse("selected_pack_changed");
+            for (const [logical, bytes] of layer.files())
+                files.set(logical, createHash("sha256").update(bytes).digest("hex"));
+            for (const root of new Set([selected.request.projectRoot, selected.request.workspaceRoot])) {
+                const observed = ObservedMemorySources.capture({ project: root }, [...files.keys()].map(logical => ({ root: "project", path: `.memory-bank/${logical}` })));
+                const hashes = observed.hashes();
+                for (const [logical, sha256] of files)
+                    if (hashes.get(memorySourceKey("project", `.memory-bank/${logical}`)) !== sha256)
+                        refuse("installed_pack_bytes_changed");
+                observed.revalidate();
+            }
+            packSha256 = layer.packSha256;
+        }
+        const entry = observeMemoryNormalFlowEntry(context, selected.request.projectRoot);
+        const reviewed = new Map(review.reviewedSources(context).filter(ref => ref.root === "workspace").map(ref => [ref.path, ref.sha256]));
+        for (const source of entry.sources) {
+            const canonical = files.get(source.path.slice(".memory-bank/".length));
+            if (canonical ? canonical !== source.sha256 : reviewed.get(source.path) !== source.sha256)
+                refuse("entry_source_not_reviewed_or_selected_canon");
+        }
+        tools(selected);
+        integration.revalidate(context);
+        review.assertCustody(context);
+        return { schema_id: "dd-flow/memory-finish-readiness-observation@1", scope: { ...scope },
+            bundle_sha256: bundle.sha256, execution_sha256: bundle.execution.sha256,
+            bootstrap_authority_sha256: hybridDigest(selected.bootstrap.authority), pack_sha256: packSha256,
+            integration: integration.value(), entry, readiness: "entry_prepared", model_access: "unknown",
+            ...(upgrade ? { migration_record: upgrade.migrationRecord } : {}) };
+    }
+    static prepare(context, input) {
+        if (!(input.bundle instanceof RetainedExecutionBundle) || !["mb-init", "mb-upgrade"].includes(input.bundle.descriptor.descriptor.id))
+            refuse("registered_memory_bundle_required");
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        const integration = PreparedMemoryFinishIntegration.prepare(context, input), review = PreparedMemoryFinishReview.prepare(context, input);
+        const selected = context.db.readSnapshot(() => accepted(context, input.scope, input.bundle));
+        const value = this.observe(context, input.scope, input.bundle, review, integration);
+        const prepared = new _a(token, input.scope, input.bundle, integration, review, hybridDigest(selected), value);
+        prepared.assertCustody(context);
+        return prepared;
+    }
+    value() { return structuredClone(this.#value); }
+    assertCustody(context) {
+        this.#integration.assertCustody(context);
+        this.#review.assertCustody(context);
+        if (hybridDigest(accepted(context, this.#scope, this.#bundle)) !== this.#acceptedSha256)
+            refuse("readiness_custody_changed");
+    }
+    revalidate(context) {
+        const integration = this.#integration;
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("physical_revalidation_outside_writer_required");
+        this.assertCustody(context);
+        if (hybridDigest(_a.observe(context, this.#scope, this.#bundle, this.#review, integration)) !== hybridDigest(this.#value))
+            refuse("ordinary_readiness_changed");
+        this.assertCustody(context);
+    }
+}
+_a = PreparedMemoryFinishReadiness;

package/dist/services/memory-fix-finish-integration.js

@@ -0,0 +1,129 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { assertPreparedRunBundleSqlAuthority } from "./runs.js";
+import { observeMemoryGitPolicySelection } from "./memory-init-git-policy.js";
+import { observeReviewedMemoryGitIntegration } from "./memory-git-integration.js";
+import { readBoundedReleaseFile } from "./release-source.js";
+import { readAcceptedStageData } from "./stage-report-renderer.js";
+import { readAcceptedDescriptorStageSettlement } from "./descriptor-stage-settlement.js";
+import { readMemoryFixPublication } from "./memory-fix-publication.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { entityReferenceVariants } from "../shared/entity-references.js";
+import { stageLifecycleMatchKey } from "./hooks.js";
+const logical = "runtime/git-policy.json";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function refuse(reason) {
+    throw new AppError("memory_fix_finish_integration_invalid", "Repair finish requires accepted review and project-policy Git readback", 2, { reason, effect: "no_effect" });
+}
+/** Read-only explicit policy preparation before RUN creation. The factory must
+ * retain these bytes in the frozen bundle; this grants no commit/merge/push. */
+export function prepareMemoryFixGitPolicy(environment, input) {
+    if (!path.isAbsolute(input.gitExecutable))
+        refuse("absolute_git_executable_required");
+    const gitExecutable = fs.realpathSync(input.gitExecutable);
+    const policy = observeMemoryGitPolicySelection(environment, { ...input, gitExecutable });
+    const value = { schema_id: "dd-flow/mb-fix-git-policy@1", scope: {
+            requestId: input.scope.requestId, projectRoot: input.scope.projectRoot, workspaceRoot: input.scope.workspaceRoot
+        },
+        git_executable: gitExecutable, git_sha256: hash(readBoundedReleaseFile(gitExecutable, 64 * 1024 * 1024)), policy };
+    const bytes = Buffer.from(JSON.stringify(value));
+    return { path: logical, bytes, sha256: hash(bytes) };
+}
+/** Frozen/SQL custody only, suitable for the acceptance writer. No ambient
+ * main-branch inference, tool discovery or filesystem access in this reader. */
+export function readMemoryFixGitPolicy(context, scope, bundle) {
+    if (bundle.manifest.flow_id !== "mb-fix")
+        refuse("memory_fix_bundle_required");
+    const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle);
+    const references = bundle.manifest.inventory.filter(ref => ref.path === logical), bytes = bundle.blob(logical);
+    if (references.length !== 1 || !bytes.length || bytes.length > 32768 || references[0].sha256 !== hash(bytes))
+        refuse("frozen_git_policy_required");
+    let value;
+    try {
+        value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        return refuse("invalid_git_policy");
+    }
+    if (value?.schema_id !== "dd-flow/mb-fix-git-policy@1" || Object.keys(value).sort().join() !== "git_executable,git_sha256,policy,schema_id,scope"
+        || value.scope?.projectRoot !== run.project_root || value.scope?.workspaceRoot !== run.workspace_root
+        || !value.scope.requestId || value.scope.requestId !== bundle.execution.snapshot().scope.requestId
+        || typeof value.git_executable !== "string" || !/^[a-f0-9]{64}$/.test(value.git_sha256)
+        || value.policy?.source !== "explicit_request" || value.policy.push_authorized !== false
+        || !["feature_worktree", "integration_branch_direct"].includes(value.policy.route)
+        || !value.policy.repository || !value.policy.workspace_branch || !value.policy.integration_branch)
+        refuse("git_policy_scope_changed");
+    return structuredClone(value);
+}
+/** Selected repair changes plus the unchanged mandatory MB index anchor, not
+ * a whole-tree commit inventory. Only existing selected files may be removed. */
+export function memoryFixGitInventory(publication) {
+    const before = new Map(publication.plan.state(0).entries().map(entry => [entry.path, entry]));
+    const after = new Map(publication.plan.state(publication.plan.actions().length).entries().map(entry => [entry.path, entry]));
+    const references = [], removals = [];
+    for (const logical of new Set([...publication.binding.write_scope.paths, ".memory-bank/index.md"])) {
+        const entry = after.get(logical);
+        if (entry) {
+            if (entry.kind !== "file" || !entry.sha256)
+                refuse("regular_reviewed_file_required");
+            references.push({ root: "workspace", path: logical, sha256: entry.sha256, ...((entry.mode & 0o111) ? { git_mode: "100755" } : {}) });
+        }
+        else {
+            const original = before.get(logical);
+            if (logical === ".memory-bank/index.md" || !original?.sha256 || original.kind !== "file")
+                refuse("retained_removal_required");
+            removals.push({ root: "workspace", path: logical, sha256: original.sha256, ...((original.mode & 0o111) ? { git_mode: "100755" } : {}) });
+        }
+    }
+    return { references, removals };
+}
+/** Accepted review/policy/publication inputs for the shared readback and scoped
+ * dispatcher. SQL custody only; this does not grant Git mutation by itself. */
+export function prepareMemoryFixReviewedGitInputs(context, scope, bundle) {
+    if (context.db.isOwnedWriteTransaction?.())
+        refuse("preparation_outside_writer_required");
+    const selected = readMemoryFixGitPolicy(context, scope, bundle);
+    const keys = entityReferenceVariants(scope.runId).map(ref => stageLifecycleMatchKey("stage_finish", ref, "review", selected.scope.projectRoot));
+    const read = (writer) => {
+        const policy = readMemoryFixGitPolicy(writer, scope, bundle), review = readAcceptedStageData(writer, { ...scope, stage: "review" });
+        const settled = readAcceptedDescriptorStageSettlement(writer, { ...scope, stage: "review" }, bundle, keys);
+        const publication = readMemoryFixPublication(writer, { project_id: scope.projectId, run_id: scope.runId });
+        const result = JSON.parse(review.bytes.toString("utf8"));
+        if (review.data_schema_id !== "dd-flow/mb-fix-stage-result@1" || result.run_id !== scope.runId || result.stage !== "review"
+            || !publication?.completed || publication.binding.bundle_sha256 !== bundle.sha256
+            || hybridDigest(result.details.write_scope) !== hybridDigest(publication.binding.write_scope)
+            || result.details.verification.some(item => item.verdict !== "resolved")
+            || publication.binding.write_scope.finding_ids.some(id => !result.details.verification.some(item => item.finding_id === id && item.verdict === "resolved")
+                || !result.details.review.some(item => item.finding_id === id && item.disposition === "accept")))
+            refuse("accepted_repair_review_required");
+        return { policy, review, settled, binding: publication.binding, planSha256: publication.plan.sha256, inventory: memoryFixGitInventory(publication) };
+    };
+    const original = context.db.readSnapshot(() => read(context));
+    return { selected, original, assertCustody: (writer) => {
+            if (hybridDigest(read(writer)) !== hybridDigest(original))
+                refuse("accepted_integration_custody_changed");
+        } };
+}
+/** Current physical readback of independently admitted review/policy inputs. */
+export function prepareMemoryFixFinishIntegration(context, scope, bundle) {
+    const inputs = prepareMemoryFixReviewedGitInputs(context, scope, bundle), { selected, original } = inputs;
+    const observe = () => {
+        if (hash(readBoundedReleaseFile(selected.git_executable, 64 * 1024 * 1024)) !== selected.git_sha256)
+            refuse("selected_git_changed");
+        const observation = observeReviewedMemoryGitIntegration({ projectRoot: selected.scope.projectRoot, workspaceRoot: selected.scope.workspaceRoot,
+            integrationBranch: selected.policy.integration_branch, gitExecutable: selected.git_executable }, context.env, original.inventory.references, original.inventory.removals);
+        if (observation.repository !== selected.policy.repository || observation.workspace_branch !== selected.policy.workspace_branch)
+            refuse("policy_repository_or_branch_changed");
+        return observation;
+    };
+    const observation = observe();
+    return { value: () => structuredClone(observation), assertCustody: inputs.assertCustody, revalidate: () => {
+            if (context.db.isOwnedWriteTransaction?.())
+                refuse("physical_revalidation_outside_writer_required");
+            inputs.assertCustody(context);
+            if (hybridDigest(observe()) !== hybridDigest(observation))
+                refuse("integration_readback_changed");
+        } };
+}

package/dist/services/memory-fix-git-dispatch.js

@@ -0,0 +1,139 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { requireProjectByRoot } from "./projects.js";
+import { readFlowRunExecutionBundle } from "./runs.js";
+import { readDescriptorStageInput } from "./descriptor-stage-coordinator.js";
+import { readActiveDescriptorStageCoordinator } from "./descriptor-stage-settlement.js";
+import { prepareMemoryFixReviewedGitInputs, prepareMemoryFixFinishIntegration } from "./memory-fix-finish-integration.js";
+import { integrateReviewedMemoryFiles } from "./memory-finish-integration.js";
+import { readMemoryFixPublication } from "./memory-fix-publication.js";
+import { readPreparedMemoryFlowUserInputs } from "./memory-flow-user-inputs.js";
+import { readBoundedReleaseFile } from "./release-source.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { appendAudit } from "./audit.js";
+const event = "memory_fix.integration_intent", anchorPath = '$.variables."memory_fix.integration"';
+function refuse(reason) {
+    throw new AppError("memory_fix_git_dispatch_invalid", "Repair integration requires the original scoped reviewed operation", 2, { reason, effect: "no_effect" });
+}
+function pending(reason) {
+    throw new AppError("memory_fix_integration_pending", "Reconcile the original Git operation before redispatch", 1, { reason, effect: "unknown", next_action: "reconcile_original_integration" });
+}
+/** Explicit scoped local commit/merge only. Existing Git mechanics own writes;
+ * each phase has retained intent before effects. Never push, reset, autostash or
+ * repeat an unresolved phase. A proven commit can continue to its first merge.
+ */
+export function integrateMemoryFixFinish(context, input) {
+    if (context.db.isOwnedWriteTransaction?.())
+        refuse("preparation_outside_writer_required");
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot)), bundle = readFlowRunExecutionBundle(context, input);
+    if (!bundle || bundle.manifest.flow_id !== "mb-fix")
+        refuse("memory_fix_bundle_required");
+    const scope = { projectId: project.id, runId: input.runId, stage: "finish" };
+    const stage = readDescriptorStageInput(context, scope, bundle), actor = readActiveDescriptorStageCoordinator(context, scope, bundle);
+    const reviewed = prepareMemoryFixReviewedGitInputs(context, scope, bundle), { selected, original } = reviewed;
+    const delivered = readPreparedMemoryFlowUserInputs(context, scope, "mb-fix", bundle), userDigest = hybridDigest(delivered);
+    const agreement = input.agreement ?? { user_inputs_sha256: original.binding.user_inputs_sha256, approval_source: original.binding.write_scope.approval_source };
+    if (agreement.user_inputs_sha256 !== userDigest || agreement.approval_source?.root !== "run"
+        || !delivered.sources.some(source => ["request", "answer"].includes(source.role)
+            && source.path === agreement.approval_source.path && source.sha256 === agreement.approval_source.sha256))
+        refuse("current_delivered_agreement_required");
+    const selection = { projectRoot: selected.scope.projectRoot, workspaceRoot: selected.scope.workspaceRoot,
+        integrationBranch: selected.policy.integration_branch, gitExecutable: selected.git_executable };
+    const identity = hybridDigest({ scope, bundle_sha256: bundle.sha256, stage, actor, reviewed: original, agreement });
+    const intents = (writer) => {
+        const rows = writer.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type=? AND json_extract(payload_json,'$.run_id')=? LIMIT 3", [project.id, event, input.runId]);
+        const anchor = writer.db.get("SELECT json_extract(index_json,?) identity FROM runs WHERE project_id=? AND id=?", [anchorPath, project.id, input.runId])?.identity;
+        if (rows.length > 2 || rows.some(row => Buffer.byteLength(row.payload_json) > 32768) || !!rows.length !== !!anchor || anchor && anchor !== identity)
+            pending("integration_intent_changed");
+        const values = rows.map(row => JSON.parse(row.payload_json));
+        if (new Set(values.map(value => value.phase)).size !== values.length || values.some(value => value.run_id !== input.runId || value.identity !== identity
+            || !["commit", "merge"].includes(value.phase) || typeof value.baseline !== "string" || value.baseline !== "" && !/^[a-f0-9]{40,64}$/.test(value.baseline)))
+            pending("integration_intent_changed");
+        return values;
+    };
+    const assertTool = () => {
+        if (createHash("sha256").update(readBoundedReleaseFile(selected.git_executable, 64 * 1024 * 1024)).digest("hex") !== selected.git_sha256)
+            refuse("selected_git_changed");
+    };
+    const assertCustody = (writer) => {
+        reviewed.assertCustody(writer);
+        if (hybridDigest(readDescriptorStageInput(writer, scope, bundle)) !== hybridDigest(stage)
+            || hybridDigest(readActiveDescriptorStageCoordinator(writer, scope, bundle)) !== hybridDigest(actor)
+            || hybridDigest(readPreparedMemoryFlowUserInputs(writer, scope, "mb-fix", bundle)) !== userDigest)
+            refuse("integration_authority_changed");
+    };
+    const assertPublication = () => {
+        assertTool();
+        assertCustody(context);
+        const publication = readMemoryFixPublication(context, { project_id: project.id, run_id: input.runId });
+        if (!publication?.completed || publication.plan.sha256 !== original.planSha256)
+            refuse("completed_publication_required");
+        const actual = publication.plan.classify(selection.workspaceRoot);
+        if (actual.completed !== actual.total)
+            refuse("publication_not_observed");
+        assertUnselectedIndexAnchor();
+    };
+    const env = Object.fromEntries(Object.entries(context.env).filter(([name]) => !name.startsWith("GIT_")));
+    const gitRead = (args) => {
+        const result = spawnSync(selected.git_executable, ["-c", "core.fsmonitor=false", "-C", selection.workspaceRoot, ...args], { env: { ...env, GIT_OPTIONAL_LOCKS: "0", GIT_LITERAL_PATHSPECS: "1" }, timeout: 10000, maxBuffer: 16 * 1024 * 1024, shell: false, windowsHide: true });
+        if (result.error || result.signal || result.status !== 0)
+            refuse("git_readback_failed");
+        return result.stdout;
+    };
+    const previous = intents(context);
+    assertPublication();
+    try {
+        const proof = prepareMemoryFixFinishIntegration(context, scope, bundle);
+        proof.revalidate();
+        return { integrated: true, replayed: true, integration: proof.value() };
+    }
+    catch (error) {
+        if (!(error instanceof AppError) || error.code !== "memory_git_integration_invalid")
+            throw error;
+        if (previous.length) {
+            const commit = previous.length === 1 && previous[0].phase === "commit" ? previous[0] : null;
+            if (!commit || selection.workspaceRoot === selection.projectRoot
+                || gitRead(["log", "-1", "--format=%P%n%s"]).toString("utf8").trim() !== `${commit.baseline}\nchore(${input.runId.toLowerCase()}): integrate reviewed Memory Bank`.trim())
+                pending("original_git_effect_not_proven");
+        }
+    }
+    // The required index anchor is observation coverage, not permission to add
+    // an unrelated dirty/untracked index document to this repair's commit.
+    function assertUnselectedIndexAnchor() {
+        if (original.binding.write_scope.paths.includes(".memory-bank/index.md"))
+            return;
+        const index = original.inventory.references.find(ref => ref.path === ".memory-bank/index.md");
+        if (createHash("sha256").update(gitRead(["cat-file", "blob", "HEAD:.memory-bank/index.md"])).digest("hex") !== index.sha256
+            || !gitRead(["ls-tree", "-z", "HEAD", "--", ".memory-bank/index.md"]).toString("utf8").startsWith(`${index.git_mode ?? "100644"} blob `))
+            refuse("unselected_index_anchor_not_committed");
+        if (gitRead(["diff", "--cached", "--name-only", "-z", "--", ".memory-bank/index.md"]).length)
+            refuse("unselected_index_anchor_staged");
+    }
+    let dispatched = false;
+    try {
+        integrateReviewedMemoryFiles(selection, context.env, original.inventory.references, input.runId, (phase, baseline, action) => {
+            assertPublication();
+            context.db.writeTransaction(() => {
+                assertCustody(context);
+                const current = intents(context);
+                if (current.some(value => value.phase === phase))
+                    pending("original_git_phase_unresolved");
+                appendAudit(context, { projectId: project.id, eventType: event, payload: { run_id: input.runId, identity, phase, baseline } });
+                context.db.run("UPDATE runs SET index_json=json_set(index_json,?,?) WHERE project_id=? AND id=?", [anchorPath, identity, project.id, input.runId]);
+            });
+            dispatched = true;
+            assertUnselectedIndexAnchor();
+            action();
+        }, selected.policy, original.inventory.removals);
+        const proof = prepareMemoryFixFinishIntegration(context, scope, bundle);
+        proof.revalidate();
+        return { integrated: true, replayed: false, integration: proof.value() };
+    }
+    catch (error) {
+        if (!dispatched)
+            throw error;
+        return pending(error instanceof AppError ? error.code : "git_operation_failed");
+    }
+}

package/dist/services/memory-fix-intake-custody.js

@@ -0,0 +1,11 @@
+import { assertDiagnosticRepairSourceIntakeCustody, prepareDiagnosticRepairSourceIntake, readDiagnosticRepairSourceIntake } from "./diagnostic-repair-source-intake.js";
+// Preserve this flow's own capsule identity; shared transport grants no approval.
+export function assertMemoryFixSourceIntakeCustody(context, scope, bundle, expectedSha256) {
+    return assertDiagnosticRepairSourceIntakeCustody(context, scope, bundle, expectedSha256, "mb-fix");
+}
+export function prepareMemoryFixSourceIntake(context, input) {
+    return prepareDiagnosticRepairSourceIntake(context, input, "mb-fix");
+}
+export function readMemoryFixSourceIntake(context, input, retainedBundle) {
+    return readDiagnosticRepairSourceIntake(context, input, "mb-fix", retainedBundle);
+}

package/dist/services/memory-fix-intake-settlement.js

@@ -0,0 +1,127 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { requireProjectByRoot } from "./projects.js";
+import { readFlowRunExecutionBundle } from "./runs.js";
+import { readDescriptorStageInput } from "./descriptor-stage-coordinator.js";
+import { PreparedDescriptorStageSettlement } from "./descriptor-stage-settlement.js";
+import { readAcceptedStageData, prepareStagePacket, acceptStagePacket, resolveStagePublicationPath } from "./stage-report-renderer.js";
+import { readMemoryFixSourceIntake, assertMemoryFixSourceIntakeCustody } from "./memory-fix-intake-custody.js";
+import { prepareMemoryFixScopeEvidence } from "./memory-fix-scope.js";
+import { validateMemoryFixStageResult } from "./memory-fix-stage-results.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function refuse(reason) {
+    throw new AppError("memory_fix_intake_settlement_invalid", "Repair intake requires accepted scope and original source observations", 2, { reason, effect: "no_effect" });
+}
+/** Historical SQL read only: repaired files and later user turns must not
+ * replace an already accepted intake baseline. This grants no new write scope.
+ * Reads accepted Stage bytes itself, never caller-provided result JSON. The
+ * caller still needs ordinary coordinator settlement for Stage replay. Retained
+ * workspace_root is provenance only after restore, never a fresh write target.
+ */
+export function readAcceptedMemoryFixIntakeEvidence(context, scope, file) {
+    const accepted = readAcceptedStageData(context, { ...scope, stage: "intake" });
+    const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='flow_run.stage_packet' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.stage')='intake' LIMIT 33", [scope.projectId, scope.runId]);
+    if (rows.length > 32)
+        refuse("ambiguous_intake_evidence");
+    const packets = rows.map(row => {
+        if (Buffer.byteLength(row.payload_json) > 8 * 1024 * 1024)
+            refuse("intake_evidence_exceeds_bound");
+        return JSON.parse(row.payload_json);
+    }).filter(packet => packet && typeof packet.file === "string"
+        && resolveStagePublicationPath(context, scope.projectId, scope.runId, packet.file) === file);
+    if (packets.length !== 1)
+        refuse("intake_evidence_missing");
+    const packet = packets[0];
+    if (typeof packet.base64 !== "string")
+        refuse("intake_evidence_changed");
+    const bytes = Buffer.from(packet.base64, "base64");
+    if (!bytes.length || bytes.length > 4 * 1024 * 1024 || bytes.toString("base64") !== packet.base64
+        || hash(bytes) !== packet.sha256)
+        refuse("intake_evidence_changed");
+    let evidence, result;
+    try {
+        evidence = JSON.parse(bytes.toString("utf8"));
+        result = JSON.parse(accepted.bytes.toString("utf8"));
+    }
+    catch {
+        return refuse("intake_evidence_changed");
+    }
+    if (!evidence || !result?.details || accepted.data_schema_id !== "dd-flow/mb-fix-stage-result@1"
+        || result.schema_id !== "dd-flow/mb-fix-stage-result@1" || result.run_id !== scope.runId || result.stage !== "intake"
+        || result.input_sha256 !== accepted.input_sha256 || evidence.intake_sha256 !== result.intake_sha256
+        || evidence.source_observation_sha256 !== result.source_observation_sha256
+        || hybridDigest(evidence.source_observation) !== result.source_observation_sha256
+        || hybridDigest(evidence.routing) !== hybridDigest(result.details.routing)
+        || hybridDigest(evidence.write_scope) !== hybridDigest(result.details.write_scope)
+        || evidence.write_scope && evidence.user_inputs_sha256 !== evidence.write_scope.user_inputs_sha256)
+        refuse("accepted_intake_changed");
+    return structuredClone(evidence);
+}
+/** Internal family handler. Generic runtime owns hook/Session identity and
+ * atomic completion; the scope packet is retained in that same SQL writer.
+ * Public registration waits for the complete repair/verification family.
+ */
+export function finishMemoryFixIntake(context, input) {
+    if (input.stage !== "intake")
+        refuse("intake_stage_required");
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const bundle = readFlowRunExecutionBundle(context, input);
+    if (!bundle || bundle.manifest.flow_id !== "mb-fix")
+        refuse("memory_fix_bundle_required");
+    const scope = { projectId: project.id, runId: input.runId, stage: "intake" };
+    const source = readMemoryFixSourceIntake(context, input, bundle);
+    const index = context.db.get("SELECT index_json FROM runs WHERE project_id=? AND id=?", [project.id, input.runId]);
+    const replay = JSON.parse(index.index_json).stage_runs.some((stage) => stage.stage === "intake" && stage.status === "done");
+    const packet = readDescriptorStageInput(context, scope, bundle, true, replay);
+    const file = path.join(packet.runRoot, bundle.descriptor.stage("intake").directory, "intake-evidence.json");
+    if (replay) {
+        const accepted = readAcceptedStageData(context, scope);
+        if (!accepted.bytes.equals(Buffer.from(input.bytes)))
+            refuse("accepted_result_changed");
+        const evidence = readAcceptedMemoryFixIntakeEvidence(context, scope, file);
+        if (evidence.intake_sha256 !== source.sha256)
+            refuse("source_intake_changed");
+        const settled = PreparedDescriptorStageSettlement.prepare(context, input);
+        return settled.apply(context, writer => {
+            assertMemoryFixSourceIntakeCustody(writer, scope, bundle, source.sha256);
+            const current = readAcceptedStageData(writer, scope);
+            if (!current.bytes.equals(accepted.bytes)
+                || hybridDigest(readAcceptedMemoryFixIntakeEvidence(writer, scope, file)) !== hybridDigest(evidence))
+                refuse("accepted_intake_changed");
+        });
+    }
+    if (!input.bytes.length || input.bytes.length > 1024 * 1024)
+        refuse("result_exceeds_bound");
+    let proposed;
+    try {
+        proposed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.bytes));
+    }
+    catch {
+        return refuse("invalid_result_json");
+    }
+    if (!proposed?.details || typeof proposed.details !== "object")
+        refuse("invalid_result_details");
+    const prepared = prepareMemoryFixScopeEvidence(context, { ...input, routing: proposed.details.routing, writeScope: proposed.details.write_scope });
+    const evidence = prepared.snapshot();
+    validateMemoryFixStageResult(input.bytes, bundle.descriptor.stageBlob("intake", "result_schema"), {
+        runId: input.runId, stage: "intake", inputSha256: packet.inputSha256, intakeSha256: source.sha256,
+        sourceObservationSha256: evidence.source_observation_sha256, findingIds: source.intake.selected_findings.map(finding => finding.id),
+        projectRoot: evidence.workspace_root, runRoot: packet.runRoot, predecessors: [], writeScope: evidence.write_scope, repairReceipt: null
+    });
+    const evidenceBytes = Buffer.from(JSON.stringify(evidence));
+    if (evidenceBytes.length > 4 * 1024 * 1024)
+        refuse("intake_evidence_exceeds_bound");
+    const retained = prepareStagePacket(file, evidenceBytes);
+    const settled = PreparedDescriptorStageSettlement.prepare(context, input);
+    prepared.assertSourcesCurrent();
+    return settled.apply(context, writer => {
+        prepared.assertCustody(writer);
+        const current = writer.db.get("SELECT index_json FROM runs WHERE project_id=? AND id=?", [project.id, input.runId]);
+        if (JSON.parse(current.index_json).stage_runs.some((stage) => stage.stage === "intake" && stage.status === "done"))
+            refuse("intake_already_accepted");
+        acceptStagePacket(writer, { ...scope, prepared: retained });
+    });
+}