@deksden-com/dd-flow-cli 0.9.0-beta.152 → 0.9.0-beta.155

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

@@ -2,11 +2,11 @@ import path from "node:path";
 import { AppError } from "../shared/errors.js";
 import { assertMemoryOrdinaryConfigurationCoverage, assertMemoryOrdinaryConfigurationOutputs } from "./memory-ordinary-defaults.js";
 import { hybridDigest } from "./hybrid-contracts.js";
-import { runtimeHarness } from "./execution-policy.js";
 import { readFlowRunExecutionBundle, assertPreparedRunBundleSqlAuthority } from "./runs.js";
 import { requireProjectByRoot } from "./projects.js";
 import { resolveProjectRoot } from "../storage/paths.js";
 import { PreparedDescriptorStageCoordinator, readDescriptorStageInput } from "./descriptor-stage-coordinator.js";
+import { readDescriptorCoordinatorSession } from "./descriptor-coordinator-session.js";
 import { readDescriptorRootWork } from "./descriptor-root-work.js";
 import { stageGraphScope } from "./stage-work-graph.js";
 import { PreparedMemoryResultBinding } from "./memory-result-binding.js";
@@ -64,27 +64,7 @@ function compositionBaseline(context, bundle) {
  * separately. No new Session, hook claim or provider invocation is created.
  */
 function coordinatorSession(context, scope, bundle, workId) {
-    const rows = context.db.all("SELECT ws.id,ws.session_id,ws.hook_event_id,ws.prompt_path,ws.result_path,s.harness,s.provider_session_id FROM work_sessions ws JOIN sessions s ON s.session_id=ws.session_id AND s.project_id=? WHERE ws.work_id=? AND ws.status='running' AND s.run_id=? AND s.current_stage=? AND s.status='active' LIMIT 2", [scope.projectId, workId, scope.runId, scope.stage]);
-    if (rows.length !== 1)
-        refuse("active_coordinator_session_required");
-    const session = rows[0], route = bundle.execution.stage(scope.stage);
-    const input = readDescriptorStageInput(context, scope, bundle), directory = bundle.descriptor.stage(scope.stage).directory;
-    if (session.prompt_path !== path.join(input.runRoot, directory, "coordinator-prompt.md")
-        || session.result_path !== path.join(input.runRoot, directory, "result-input.json"))
-        refuse("coordinator_packet_link_changed");
-    if (session.harness !== runtimeHarness(route.profile)
-        || !context.db.get("SELECT 1 FROM hook_events WHERE project_id=? AND event_key=? AND session_id=? AND harness=? AND provider_session_id=? AND status='claimed' AND event_name='PreToolUse'", [scope.projectId, session.hook_event_id, session.session_id, session.harness, session.provider_session_id]))
-        refuse("coordinator_start_custody_missing");
-    const bindings = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='stage.coordinator_binding' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.scope.stage')=? AND json_extract(payload_json,'$.work_session_id')=? LIMIT 33", [scope.projectId, scope.runId, scope.stage, session.id]);
-    if (!bindings.length || bindings.length > 32 || bindings.some(row => Buffer.byteLength(row.payload_json) > 32768))
-        refuse("physical_binding_missing");
-    const binding = JSON.parse(bindings[0].payload_json);
-    if (bindings.some(row => hybridDigest(JSON.parse(row.payload_json)) !== hybridDigest(binding))
-        || binding.work_id !== workId || binding.session_id !== session.session_id || binding.harness !== session.harness || binding.provider_session_id !== session.provider_session_id
-        || binding.execution_sha256 !== bundle.execution.sha256 || binding.profile_id !== route.profile.id || binding.profile_sha256 !== hybridDigest(route.profile)
-        || binding.session_mode !== route.session_mode || hybridDigest(binding.scope) !== hybridDigest({ ...stageGraphScope(context, scope.projectId, scope.runId, scope.stage), stage: scope.stage }))
-        refuse("physical_binding_changed");
-    return hybridDigest({ session, binding });
+    return readDescriptorCoordinatorSession(context, { scope, bundle, workId }, refuse);
 }
 /** Actual registration path for the composition handler, awaiting complete
  * memory-flow admission. Registers the immutable blueprint before workers run;

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

@@ -5,6 +5,7 @@ import { PreparedMemoryFinishReview } from "./memory-finish-handler.js";
 import { readMemoryInitBootstrapReadiness } from "./memory-init-bootstrap-readiness.js";
 import { readMemoryInitGitPolicy } from "./memory-init-git-policy.js";
 import { hybridDigest } from "./hybrid-contracts.js";
+import { assertReviewedProjectGitInventory, observeReviewedProjectGitIntegration } from "./project-git-integration.js";
 import { observeReviewedMemoryGitIntegration, reviewedMemoryGitFiles, isReviewedMemoryGitFile, assertMemoryGitRemovalSources } from "./memory-git-integration.js";
 import { createHash } from "node:crypto";
 import { readBoundedReleaseFile } from "./release-source.js";
@@ -149,6 +150,20 @@ export function observeMemoryUpgradeFinishInventory(root, expected) {
 /** Physical Git operation only; callers must independently select accepted files
  * and retain each mutation's intent. No ambient Git redirection or whole-tree add. */
 export function integrateReviewedMemoryFiles(selection, environment, references, runId, mutation, policy, removals = []) {
+    if (!Array.isArray(references) || !Array.isArray(removals) || !references.length
+        || references.length + removals.length > 4096 || !references.some(ref => ref?.path === ".memory-bank/index.md")
+        || [...references, ...removals].some(ref => !isReviewedMemoryGitFile(ref))
+        || removals.some(ref => !ref.path.startsWith(".memory-bank/") || ref.path === ".memory-bank/index.md"))
+        refuse("invalid_owned_inventory");
+    return integrateReviewedFiles(selection, environment, references, mutation, policy, removals, () => observeReviewedMemoryGitIntegration(selection, environment, references, removals), `chore(${runId.toLowerCase()}): integrate reviewed Memory Bank`);
+}
+/** Physical project-file variant only. Accepted review and the original dirty
+ * baseline remain the caller's responsibility; this is not a RUN authority. */
+export function integrateReviewedProjectFiles(selection, environment, references, runId, mutation, policy, removals = []) {
+    assertReviewedProjectGitInventory(references, removals);
+    return integrateReviewedFiles(selection, environment, references, mutation, policy, removals, () => observeReviewedProjectGitIntegration(selection, environment, references, removals), `chore(${runId.toLowerCase()}): integrate reviewed project changes`);
+}
+function integrateReviewedFiles(selection, environment, references, mutation, policy, removals, observe, message) {
     const env = { ...Object.fromEntries(Object.entries(environment).filter(([key]) => !key.startsWith("GIT_"))), GIT_LITERAL_PATHSPECS: "1" };
     const git = (directory, args, write = false, absent = false) => {
         const result = spawnSync(selection.gitExecutable, ["-c", "core.fsmonitor=false",
@@ -158,13 +173,8 @@ export function integrateReviewedMemoryFiles(selection, environment, references,
         if (result.error || result.signal || result.status !== 0)
             throw new AppError("memory_finish_integration_invalid", write ? "Git integration did not return success; inspect the original operation before retrying" : "Git integration preparation failed", 2, { reason: "git_operation_failed", effect: write ? "unknown" : "no_effect", operation: args[0], stderr: result.stderr,
                 next_action: write ? "reconcile_original_integration" : "resolve_git_configuration_or_workspace" });
-        return result.stdout.trim();
+        return args.includes("-z") ? result.stdout : result.stdout.trim();
     };
-    if (!Array.isArray(references) || !Array.isArray(removals) || !references.length
-        || references.length + removals.length > 4096 || !references.some(ref => ref?.path === ".memory-bank/index.md")
-        || [...references, ...removals].some(ref => !isReviewedMemoryGitFile(ref))
-        || removals.some(ref => !ref.path.startsWith(".memory-bank/") || ref.path === ".memory-bank/index.md"))
-        refuse("invalid_owned_inventory");
     const paths = [...references, ...removals].map(ref => ref.path);
     if (new Set(paths).size !== paths.length)
         refuse("invalid_owned_inventory");
@@ -195,10 +205,10 @@ export function integrateReviewedMemoryFiles(selection, environment, references,
         if (hashes.get(memorySourceKey(ref.root, ref.path)) !== ref.sha256)
             refuse("reviewed_workspace_bytes_changed");
     try {
-        return observeReviewedMemoryGitIntegration(selection, environment, references, removals);
+        return observe();
     }
     catch (error) {
-        if (!(error instanceof AppError) || error.code !== "memory_git_integration_invalid")
+        if (!(error instanceof AppError) || !["memory_git_integration_invalid", "project_git_integration_invalid"].includes(error.code))
             throw error;
     }
     const visibility = git(source, ["ls-files", "-v", "--", ...paths]);
@@ -207,6 +217,12 @@ export function integrateReviewedMemoryFiles(selection, environment, references,
     if (git(source, ["diff", "--name-only", "--diff-filter=U"]))
         refuse("unmerged_workspace");
     const sourceHead = git(source, ["rev-parse", "--verify", "HEAD"], false, true);
+    let ownedHead = sourceHead;
+    const changedCommit = () => {
+        throw new AppError("memory_finish_integration_invalid", "The scoped commit changed before integration completed; reconcile its original effect", 2, { reason: "scoped_commit_changed", effect: "unknown", next_action: "reconcile_original_integration" });
+    };
+    const assertOwnedHead = () => { if (git(source, ["rev-parse", "HEAD"]) !== ownedHead)
+        changedCommit(); };
     const deleting = [];
     let removedBytes = 0;
     for (const ref of removals) {
@@ -237,26 +253,49 @@ export function integrateReviewedMemoryFiles(selection, environment, references,
         return bytes.status !== 0 || createHash("sha256").update(bytes.stdout).digest("hex") !== ref.sha256
             || !entry.startsWith(`${ref.git_mode ?? "100644"} blob `);
     });
+    const assertSourceBeforeMutation = () => {
+        observed.revalidate();
+        assertModes();
+        assertMemoryGitRemovalSources(source, removals);
+        if (git(source, ["rev-parse", "--verify", "HEAD"], false, true) !== sourceHead
+            || git(source, ["symbolic-ref", "--short", "HEAD"]) !== branch)
+            refuse("source_git_baseline_changed");
+    };
     if (needsCommit) {
         git(source, ["var", "GIT_AUTHOR_IDENT"]);
         git(source, ["var", "GIT_COMMITTER_IDENT"]);
         mutation("commit", sourceHead, () => {
-            observed.revalidate();
-            assertModes();
-            assertMemoryGitRemovalSources(source, removals);
-            if (git(source, ["rev-parse", "--verify", "HEAD"], false, true) !== sourceHead
-                || git(source, ["symbolic-ref", "--short", "HEAD"]) !== branch)
-                refuse("source_git_baseline_changed");
+            assertSourceBeforeMutation();
             const commitPaths = [...references.map(ref => ref.path), ...deleting];
             git(source, ["add", "-f", "--", ...commitPaths], true);
-            git(source, ["commit", "--only", "-m", `chore(${runId.toLowerCase()}): integrate reviewed Memory Bank`, "--", ...commitPaths], true);
+            git(source, ["commit", "--only", "-m", message, "--", ...commitPaths], true);
+        });
+        // Hooks or a concurrent writer may have changed history/index after the
+        // original admission. Never carry an unowned commit into the merge.
+        ownedHead = git(source, ["rev-parse", "HEAD"]);
+        const parentAndSubject = git(source, ["show", "-s", "--format=%P%n%s", ownedHead]);
+        const committedPaths = git(source, ["diff-tree", "--root", "--no-commit-id", "--no-renames", "--name-only", "-r", "-z", ownedHead]).split("\0").filter(Boolean);
+        if (parentAndSubject !== `${sourceHead}\n${message}`.trim() || committedPaths.some(logical => !paths.includes(logical)))
+            changedCommit();
+    }
+    else if (git(source, ["diff", "--cached", "--name-only", "-z", "--", ...paths])) {
+        // The reviewed tree can already equal HEAD while a selected pre-existing
+        // staged version differs. Settle only its admitted index effect; do not
+        // manufacture an empty commit or disturb unrelated staged entries.
+        const indexedRemovals = removals.length ? git(source, ["ls-files", "--cached", "-z", "--", ...removals.map(ref => ref.path)]).split("\0").filter(Boolean) : [];
+        mutation("commit", sourceHead, () => {
+            assertSourceBeforeMutation();
+            git(source, ["add", "-f", "--", ...references.map(ref => ref.path), ...indexedRemovals], true);
         });
+        assertOwnedHead();
     }
     observed.revalidate();
+    assertOwnedHead();
     if (source !== target) {
-        const head = git(source, ["rev-parse", "HEAD"]), targetHead = git(target, ["rev-parse", "HEAD"]);
+        const head = ownedHead, targetHead = git(target, ["rev-parse", "HEAD"]);
         if (head !== targetHead) {
             mutation("merge", targetHead, () => {
+                assertOwnedHead();
                 if (git(target, ["rev-parse", "HEAD"]) !== targetHead
                     || git(target, ["symbolic-ref", "--short", "HEAD"]) !== selection.integrationBranch
                     || git(target, ["diff", "--cached", "--name-only"]))
@@ -265,7 +304,9 @@ export function integrateReviewedMemoryFiles(selection, environment, references,
             });
         }
     }
-    return observeReviewedMemoryGitIntegration(selection, environment, references, removals);
+    const result = observe();
+    assertOwnedHead();
+    return result;
 }
 /** The admitted Memory finish operation. A retained intent never licenses a
  * second dispatch: replay first observes completed Git effects, or reports unknown. */

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 });
+    });
+}