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

package/dist/services/memory-flow-user-inputs.js

@@ -0,0 +1,88 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { readFlowRunExecutionBundle, assertPreparedRunBundleSqlAuthority } from "./runs.js";
+import { requireProjectByRoot } from "./projects.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { resolveStagePublicationPath } from "./stage-report-renderer.js";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const inputOwners = {
+    "mb-distill": { code: "distill_user_input_invalid", message: "Distillation needs its original delivered request and answers", bundle: "distill_bundle_required", schema: "dd-flow/distill-user-inputs@1" },
+    "mb-fix": { code: "memory_fix_user_input_invalid", message: "Memory repair needs its original delivered request and answers", bundle: "memory_fix_bundle_required", schema: "dd-flow/mb-fix-user-inputs@1" },
+    "review-fix": { code: "review_fix_user_input_invalid", message: "Review-fix needs its original delivered request and answers", bundle: "review_fix_bundle_required", schema: "dd-flow/review-fix-user-inputs@1" },
+    "interactive": { code: "interactive_user_input_invalid", message: "Interactive needs its original delivered request and answers", bundle: "interactive_bundle_required", schema: "dd-flow/interactive-user-answers@1" },
+    "release": { code: "delivery_user_input_invalid", message: "Release needs its original delivered request and answers", bundle: "delivery_bundle_required", schema: "dd-flow/release-user-inputs@1" },
+    "deploy": { code: "delivery_user_input_invalid", message: "Deploy needs its original delivered request and answers", bundle: "delivery_bundle_required", schema: "dd-flow/deploy-user-inputs@1" },
+    "publish": { code: "delivery_user_input_invalid", message: "Publish needs its original delivered request and answers", bundle: "delivery_bundle_required", schema: "dd-flow/publish-user-inputs@1" }
+};
+/** Read task evidence, not approval semantics. A Stage owner must consider the
+ * full ordered input set, select the actual agreement and fence this same set
+ * again before publication. Agent files and result claims are not user input.
+ * SQL custody survives projection loss and supported RUN relocation. */
+export function readMemoryFlowUserInputs(context, input, flowId, retainedBundle) {
+    const owner = Object.hasOwn(inputOwners, flowId) ? inputOwners[flowId] : inputOwners["mb-fix"];
+    function refuse(reason) {
+        throw new AppError(owner.code, owner.message, 1, { reason, effect: "no_effect" });
+    }
+    if (!Object.hasOwn(inputOwners, flowId))
+        refuse("unsupported_flow");
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const bundle = retainedBundle ?? readFlowRunExecutionBundle(context, input);
+    return readPreparedMemoryFlowUserInputs(context, { projectId: project.id, runId: input.runId }, flowId, bundle);
+}
+/** SQL/in-memory read for an already selected RUN. No root discovery or
+ * filesystem reads occur inside a Stage/publication settlement fence. */
+export function readPreparedMemoryFlowUserInputs(context, scope, flowId, bundle) {
+    const owner = Object.hasOwn(inputOwners, flowId) ? inputOwners[flowId] : inputOwners["mb-fix"];
+    function refuse(reason) {
+        throw new AppError(owner.code, owner.message, 1, { reason, effect: "no_effect" });
+    }
+    if (!Object.hasOwn(inputOwners, flowId))
+        refuse("unsupported_flow");
+    if (!bundle || bundle.manifest.flow_id !== flowId)
+        refuse(owner.bundle);
+    return context.db.readSnapshot(() => {
+        const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle);
+        if (!run.run_root)
+            refuse("run_home_required");
+        const request = bundle.blob("runtime/source-request.md"), reference = bundle.manifest.inventory.find(ref => ref.path === "runtime/source-request.md");
+        if (!request.length || request.length > 64 * 1024 || !reference || hash(request) !== reference.sha256)
+            refuse("original_request_missing");
+        const sources = [{ role: "request", event_id: 0, stage: null, pause_id: null,
+                root: "run", path: "execution-bundle/runtime/source-request.md", sha256: reference.sha256, base64: request.toString("base64") }];
+        const rows = context.db.all("SELECT id,payload_json FROM audit_events WHERE project_id=? AND event_type='flow_run.stage_resumed' AND json_extract(payload_json,'$.run_id')=? ORDER BY id LIMIT 129", [scope.projectId, scope.runId]);
+        if (rows.length > 128)
+            refuse("too_many_answers");
+        const pauses = new Set();
+        let total = request.length;
+        for (const row of rows) {
+            if (Buffer.byteLength(row.payload_json) > 64 * 1024)
+                refuse("unbounded_answer_event");
+            const answer = JSON.parse(row.payload_json);
+            if (typeof answer.stage !== "string" || typeof answer.pause_id !== "string" || !answer.pause_id || pauses.has(answer.pause_id)
+                || typeof answer.answer_path !== "string")
+                refuse("ambiguous_answer");
+            pauses.add(answer.pause_id);
+            for (const [role, locator] of [["question", path.join(path.dirname(answer.answer_path), "question.md")], ["answer", answer.answer_path]]) {
+                const file = resolveStagePublicationPath(context, scope.projectId, scope.runId, locator);
+                const relative = path.relative(run.run_root, file).split(path.sep).join("/");
+                if (!relative || path.isAbsolute(relative) || relative.split("/").some(part => !part || part === ".." || part === "."))
+                    refuse("input_outside_run");
+                const packets = 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')=? AND json_extract(payload_json,'$.file')=? LIMIT 2", [scope.projectId, scope.runId, answer.stage, locator]);
+                if (packets.length !== 1 || Buffer.byteLength(packets[0].payload_json) > 2 * 1024 * 1024)
+                    refuse("answer_custody_missing");
+                const packet = JSON.parse(packets[0].payload_json);
+                if (typeof packet.base64 !== "string")
+                    refuse("answer_custody_changed");
+                const bytes = Buffer.from(packet.base64, "base64");
+                total += bytes.length;
+                if (!bytes.length || bytes.length > 1024 * 1024 || total > 16 * 1024 * 1024 || bytes.toString("base64") !== packet.base64
+                    || hash(bytes) !== packet.sha256)
+                    refuse("answer_custody_changed");
+                sources.push({ role: role, event_id: row.id, stage: answer.stage, pause_id: answer.pause_id,
+                    root: "run", path: relative, sha256: packet.sha256, base64: packet.base64 });
+            }
+        }
+        return { schema_id: owner.schema, run_id: scope.runId, bundle_sha256: bundle.sha256, sources };
+    });
+}

package/dist/services/memory-init-contexts.js

@@ -7,20 +7,70 @@ import { publishImmutableInput } from "../storage/immutable-input.js";
 import { readBoundedReleaseFile } from "./release-source.js";
 import { readMemoryInitStartupInput } from "./memory-init-startup-custody.js";
 import { readUpgradeStorageReadiness } from "./memory-upgrade-storage-readiness.js";
-import { isDiagnosticFlow } from "../domain/diagnostic-flows.js";
+import { isSourceSnapshotFlow } from "../domain/source-snapshot-flows.js";
 import { readDiagnosticRequest } from "./diagnostic-start.js";
+import { isDeliveryFlow } from "../domain/delivery-flows.js";
+/** Repair's objective is already part of its own retained bundle. Continuation
+ * does not need the source diagnostic or mutable operator/request files. */
+export function prepareMemoryFixContexts(bundle, directory) {
+    return prepareRequestContexts(bundle, directory, "mb-fix");
+}
+/** Static controller candidates carry only the original request. Current turns,
+ * scope and checks are read from their retained owners at each Stage boundary. */
+export function prepareInteractiveContexts(bundle, directory) {
+    return prepareRequestContexts(bundle, directory, "interactive");
+}
+export function prepareDeliveryContexts(bundle, directory) {
+    if (!isDeliveryFlow(bundle.manifest.flow_id))
+        throw new AppError("delivery_context_invalid", "Delivery bundle required", 2, { effect: "no_effect" });
+    return prepareRequestContexts(bundle, directory, bundle.manifest.flow_id);
+}
+export function publishDeliveryContexts(bundle, objective, directory, expectedSha256, expectedOwner) {
+    const original = prepareDeliveryContexts(bundle, directory);
+    if (objective !== original.objective)
+        throw new AppError("delivery_context_invalid", "Delivery objective cannot be replaced", 2, { effect: "no_effect" });
+    return publishMemoryContexts(bundle, objective, directory, expectedSha256, expectedOwner, bundle.manifest.flow_id);
+}
+function prepareRequestContexts(bundle, directory, flowId) {
+    const code = isDeliveryFlow(flowId) ? "delivery_context_invalid" : flowId === "interactive" ? "interactive_context_invalid" : "memory_fix_context_invalid";
+    if (!(bundle instanceof RetainedExecutionBundle) || bundle.manifest.flow_id !== flowId)
+        throw new AppError(code, "Retained request-owning bundle required", 2, { effect: "no_effect" });
+    const bytes = bundle.blob("runtime/source-request.md"), refs = bundle.manifest.inventory.filter(ref => ref.path === "runtime/source-request.md");
+    if (!bytes.length || bytes.length > 64 * 1024 || refs.length !== 1 || refs[0].sha256 !== createHash("sha256").update(bytes).digest("hex"))
+        throw new AppError(code, "Original retained request required", 2, { effect: "no_effect" });
+    let objective;
+    try {
+        objective = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        throw new AppError(code, "Original request must be UTF-8", 2, { effect: "no_effect" });
+    }
+    return { ...prepareMemoryContexts(bundle, objective, directory, flowId), objective };
+}
+export function publishInteractiveContexts(bundle, objective, directory, expectedSha256, expectedOwner) {
+    const original = prepareInteractiveContexts(bundle, directory);
+    if (objective !== original.objective)
+        throw new AppError("interactive_context_invalid", "Interactive objective cannot be replaced", 2, { effect: "no_effect" });
+    return publishMemoryContexts(bundle, objective, directory, expectedSha256, expectedOwner, "interactive");
+}
+export function publishMemoryFixContexts(bundle, objective, directory, expectedSha256, expectedOwner) {
+    const original = prepareMemoryFixContexts(bundle, directory);
+    if (objective !== original.objective)
+        throw new AppError("memory_fix_context_invalid", "Repair objective cannot be replaced", 2, { effect: "no_effect" });
+    return publishMemoryContexts(bundle, objective, directory, expectedSha256, expectedOwner, "mb-fix");
+}
 export function prepareDiagnosticContextsFromRequest(context, bundle, directory) {
     const scope = bundle.execution.snapshot().scope, flowId = bundle.manifest.flow_id;
-    if (!isDiagnosticFlow(flowId))
-        throw new AppError("diagnostic_context_invalid", "Diagnostic bundle required", 2, { effect: "no_effect" });
+    if (!isSourceSnapshotFlow(flowId))
+        throw new AppError("diagnostic_context_invalid", "Source-snapshot bundle required", 2, { effect: "no_effect" });
     const request = readDiagnosticRequest(context, { projectRoot: scope.projectRoot, requestId: scope.requestId, flowId });
     if (!request || request.execution_sha256 !== bundle.execution.sha256)
         throw new AppError("diagnostic_context_invalid", "Original diagnostic objective required", 2, { effect: "no_effect" });
     return { ...prepareMemoryContexts(bundle, request.objective, directory, flowId), objective: request.objective };
 }
 export function publishDiagnosticContexts(bundle, objective, directory, expectedSha256, expectedOwner) {
-    if (!isDiagnosticFlow(bundle.manifest.flow_id))
-        throw new AppError("diagnostic_context_invalid", "Diagnostic bundle required", 2, { effect: "no_effect" });
+    if (!isSourceSnapshotFlow(bundle.manifest.flow_id))
+        throw new AppError("diagnostic_context_invalid", "Source-snapshot bundle required", 2, { effect: "no_effect" });
     return publishMemoryContexts(bundle, objective, directory, expectedSha256, expectedOwner, bundle.manifest.flow_id);
 }
 /** Original upgrade intake comes from the independently retained storage

package/dist/services/memory-init-controller-start.js

@@ -11,9 +11,16 @@ import { requireRun } from "./run-controller-state.js";
 import { prepareRunControllerLaunch } from "./run-controller.js";
 import { prepareMemoryInitContextsFromStartup, publishMemoryInitContexts, prepareMemoryUpgradeContextsFromStartup, publishMemoryUpgradeContexts } from "./memory-init-contexts.js";
 import { parseRuntimeBudget } from "./runtime-budget.js";
-import { isDiagnosticFlow } from "../domain/diagnostic-flows.js";
+import { isSourceSnapshotFlow } from "../domain/source-snapshot-flows.js";
 import { startDiagnosticRun } from "./diagnostic-start.js";
 import { prepareDiagnosticContextsFromRequest, publishDiagnosticContexts } from "./memory-init-contexts.js";
+import { prepareMemoryFixContexts, publishMemoryFixContexts } from "./memory-init-contexts.js";
+import { startMemoryFixRun } from "./memory-fix-request.js";
+import { startInteractiveRun } from "./interactive-request.js";
+import { prepareInteractiveContexts, publishInteractiveContexts } from "./memory-init-contexts.js";
+import { prepareDeliveryContexts, publishDeliveryContexts } from "./memory-init-contexts.js";
+import { isDeliveryFlow } from "../domain/delivery-flows.js";
+import { startDeliveryRun } from "./delivery-request.js";
 function refuse(reason) {
     throw new AppError("memory_init_controller_start_invalid", "Init controller requires its exact published startup request", 1, { reason, effect: "no_effect", next_action: "reconcile_exact_request" });
 }
@@ -30,6 +37,15 @@ export function prepareMemoryUpgradeControllerStart(context, scope) {
 export function prepareDiagnosticControllerStart(context, scope, flowId) {
     return prepareMemoryControllerStart(context, scope, flowId);
 }
+export function prepareMemoryFixControllerStart(context, scope) {
+    return prepareMemoryControllerStart(context, scope, "mb-fix");
+}
+export function prepareInteractiveControllerStart(context, scope) {
+    return prepareMemoryControllerStart(context, scope, "interactive");
+}
+export function prepareDeliveryControllerStart(context, scope, flowId) {
+    return prepareMemoryControllerStart(context, scope, flowId);
+}
 function prepareMemoryControllerStart(context, scope, flowId) {
     validateMemoryInitStartupScope(scope);
     if (context.db.isOwnedWriteTransaction?.())
@@ -47,7 +63,7 @@ function prepareMemoryControllerStart(context, scope, flowId) {
         refuse("published_run_required");
     // Restores the exact request and verifies independent SQL/physical root
     // ownership without consulting current canon/profiles or creating a RUN.
-    const started = isDiagnosticFlow(flowId) ? startDiagnosticRun(context, { projectRoot: scope.projectRoot, requestId: scope.requestId, flowId })
+    const started = isDeliveryFlow(flowId) ? startDeliveryRun(context, { projectRoot: scope.projectRoot, requestId: scope.requestId, flowId }) : flowId === "interactive" ? startInteractiveRun(context, scope) : flowId === "mb-fix" ? startMemoryFixRun(context, scope) : isSourceSnapshotFlow(flowId) ? startDiagnosticRun(context, { projectRoot: scope.projectRoot, requestId: scope.requestId, flowId })
         : flowId === "mb-init" ? startMemoryInitRun(context, scope) : startMemoryUpgradeRun(context, scope);
     const run = requireRun(context, project.id, started.runId);
     const bundle = readFlowRunExecutionBundle(context, { projectRoot: scope.projectRoot, runId: run.id });
@@ -55,7 +71,7 @@ function prepareMemoryControllerStart(context, scope, flowId) {
         refuse("retained_bundle_required");
     if (bundle.execution.settings.execution !== "managed")
         refuse("managed_execution_required");
-    const contexts = isDiagnosticFlow(flowId) ? prepareDiagnosticContextsFromRequest(context, bundle, run.run_root)
+    const contexts = isDeliveryFlow(flowId) ? prepareDeliveryContexts(bundle, run.run_root) : flowId === "interactive" ? prepareInteractiveContexts(bundle, run.run_root) : flowId === "mb-fix" ? prepareMemoryFixContexts(bundle, run.run_root) : isSourceSnapshotFlow(flowId) ? prepareDiagnosticContextsFromRequest(context, bundle, run.run_root)
         : flowId === "mb-init" ? prepareMemoryInitContextsFromStartup(context, bundle, run.run_root)
             : prepareMemoryUpgradeContextsFromStartup(context, bundle, run.run_root);
     const input = { projectRoot: scope.projectRoot, runId: run.id, requestId: scope.requestId,
@@ -91,7 +107,7 @@ function prepareMemoryControllerStart(context, scope, flowId) {
     });
     if (!rootOwner || !Number.isSafeInteger(rootOwner.dev) || !Number.isSafeInteger(rootOwner.ino))
         refuse("root_owner_changed");
-    const publish = isDiagnosticFlow(flowId) ? publishDiagnosticContexts : flowId === "mb-init" ? publishMemoryInitContexts : publishMemoryUpgradeContexts;
+    const publish = isDeliveryFlow(flowId) ? publishDeliveryContexts : flowId === "interactive" ? publishInteractiveContexts : flowId === "mb-fix" ? publishMemoryFixContexts : isSourceSnapshotFlow(flowId) ? publishDiagnosticContexts : flowId === "mb-init" ? publishMemoryInitContexts : publishMemoryUpgradeContexts;
     publish(bundle, contexts.objective, run.run_root, contexts.sha256, rootOwner);
     try {
         return { input, prepared: prepareRunControllerLaunch(context, input) };

package/dist/services/memory-layer.js

@@ -12,12 +12,14 @@ import { inspectReleaseArchive } from "./release-archive.js";
 import { canonicalOnlyFlowNames } from "./version-status.js";
 export function isCanonicalOnlyMemoryPath(logical) {
     return logical.startsWith("dd-flow/project-review/")
+        || logical.startsWith("dd-flow/delivery/")
+        || logical === "dd-flow/mb-sdlc/review-fix.md"
         || canonicalOnlyFlowNames.some(name => logical === `dd-flow/${name}` || logical.startsWith(`dd-flow/${name.slice(0, -3)}/`));
 }
 const rootFiles = ["README.md", "index.md", "compatibility.json", "flow-contract.json", "go.md", "f.md", "prime.md", "protocol.md",
     "protocol-implement.md", "plan.md", "code.md", "merge.md", "merge-start.md", "merge-stop.md", "release.md", "deploy.md", "publish.md",
-    "review-fix.md", "mb-fix.md", "mb-lint.md", "interactive.md", "finish.md", "fix-def.md"];
-const supportDirectories = ["common", "prime", "mb-sdlc", "aspects", "def", "workers", "schemas", "vnext", "specify", "stage-reports", "dashboard", "plan", "code", "merge"];
+    "mb-lint.md", "interactive.md", "finish.md", "fix-def.md"];
+const supportDirectories = ["common", "prime", "mb-sdlc", "aspects", "def", "workers", "schemas", "vnext", "specify", "stage-reports", "dashboard", "plan", "code", "merge", "interactive"];
 const required = ["README.md", "index.md", "flow-contract.json", "compatibility.json", "prime.md", "go.md",
     "common/style.md", "common/runtime-contract.md", "common/lifecycle-guards.md", "common/workspace-bootstrap.md", "common/worker-session.md",
     "vnext/start.md", "vnext/specify.md", "vnext/protocolize.md", "vnext/plan.md", "vnext/plan-review.md", "vnext/code.md", "vnext/code-review.md", "vnext/merge.md",
@@ -77,6 +79,8 @@ export class PreparedMemoryLayer {
                 directory(source);
                 for (const name of fs.readdirSync(source).sort()) {
                     const file = path.join(source, name), target = `${logical}/${name}`, stat = fs.lstatSync(file);
+                    if (isCanonicalOnlyMemoryPath(target))
+                        continue;
                     if (stat.isDirectory())
                         collect(file, target);
                     else if (stat.isFile())
@@ -91,7 +95,7 @@ export class PreparedMemoryLayer {
             const flowRoot = path.join(memoryRoot, "dd-flow");
             directory(flowRoot);
             for (const name of rootFiles)
-                if (fs.existsSync(path.join(flowRoot, name)))
+                if (!isCanonicalOnlyMemoryPath(`dd-flow/${name}`) && fs.existsSync(path.join(flowRoot, name)))
                     put(`dd-flow/${name}`, readBoundedReleaseFile(path.join(flowRoot, name), 1024 * 1024));
             for (const name of supportDirectories)
                 if (fs.existsSync(path.join(flowRoot, name)))

package/dist/services/memory-native-review-copy.js

@@ -8,10 +8,29 @@ import { assertRunMutationAllowed } from "./run-recovery-guard.js";
 import { reviewSourceFilter, reviewSourceHash, reviewExecutionCopyHash } from "./review-copy.js";
 import { writeReviewGitEvidence } from "./external-work-launch.js";
 import { memoryReviewPhysicalDestination } from "./hook-memory-routing.js";
+import { assertSharedReviewInput } from "./work-registry.js";
+import { readFlowRunExecutionBundle } from "./runs.js";
+import { PreparedInteractiveWorkStart } from "./interactive-work-start.js";
 function refuse(reason) { throw new AppError("memory_native_review_copy_invalid", "Native Memory review requires an independently owned immutable execution copy", 1, { reason, effect: "no_effect" }); }
 export { memoryNativeReviewAssignedHookCwd } from "./hook-memory-routing.js";
+function prepareInteractiveReviewOwner(context, work, run, generation) {
+    const bundle = readFlowRunExecutionBundle(context, { projectRoot: run.project_root, runId: work.run_id });
+    if (bundle?.manifest.flow_id !== "interactive" || JSON.parse(work.payload_json ?? "null")?.kind !== "interactive-review")
+        refuse("registered_interactive_review_required");
+    const input = assertSharedReviewInput(context, work, { ...run, id: work.run_id }, generation);
+    if (!input)
+        refuse("registered_interactive_review_required");
+    const start = PreparedInteractiveWorkStart.prepare(context, { projectId: work.project_id, runId: work.run_id, workId: work.work_id, projectRoot: run.project_root });
+    return { bundle, input, assertCustody: (writer) => start.assertCustody(writer),
+        revalidate: (reader) => {
+            start.revalidate();
+            if (hybridDigest(assertSharedReviewInput(reader, work, { ...run, id: work.run_id }, generation)) !== hybridDigest(input))
+                refuse("review_input_changed");
+        } };
+}
 /** Existing source/copy policy, separate native physical custody: no external
- * launch row is invented. An interrupted allocation is never overwritten. */
+ * launch row is invented. An interrupted allocation is never overwritten.
+ * Interactive review reuses this owner and its historical copy event format. */
 export function prepareMemoryNativeReviewCopy(context, workId, allocate = false, preparedOwner) {
     const work = context.db.get("SELECT * FROM works WHERE work_id=?", [workId]);
     if (!work)
@@ -20,8 +39,13 @@ export function prepareMemoryNativeReviewCopy(context, workId, allocate = false,
     if (!run)
         refuse("owned_run_required");
     const generation = assertRunMutationAllowed(context, work.project_id, work.run_id);
-    const owner = preparedOwner ?? prepareMemoryReviewWorkInput(context, work, run, generation);
-    assertPreparedMemoryReviewWorkInput(context, owner, work, run, generation);
+    const interactive = work.result_schema === "dd-flow/interactive-work-result@1";
+    if (interactive && preparedOwner)
+        refuse("foreign_prepared_review_input");
+    const memoryOwner = interactive ? null : preparedOwner ?? prepareMemoryReviewWorkInput(context, work, run, generation);
+    if (memoryOwner)
+        assertPreparedMemoryReviewWorkInput(context, memoryOwner, work, run, generation);
+    const owner = memoryOwner ?? prepareInteractiveReviewOwner(context, work, run, generation);
     const route = owner.bundle.execution.work("review");
     if (route.delegation.mode !== "native")
         refuse("native_route_required");

package/dist/services/memory-repair-document-delta.js

@@ -20,6 +20,7 @@ function ordered(entries) {
         return left.length - right.length;
     });
 }
+export { ordered as orderMemoryDocumentEntries };
 function refuse(reason) {
     throw new AppError("memory_repair_document_delta_invalid", "Physical repair documents differ from their bounded baseline", 2, { reason, effect: "no_effect" });
 }

package/dist/services/project-flow-source.js

@@ -0,0 +1,195 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { Ajv } from "ajv/dist/ajv.js";
+import semver from "semver";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest, validateHybridShape } from "./hybrid-contracts.js";
+import { readBoundedReleaseFile } from "./release-source.js";
+import { isCanonicalOnlyMemoryPath } from "./memory-layer.js";
+import { localEnvironmentAllowed } from "./workspace-files.js";
+import { admitBundledFlow } from "./stage-handlers.js";
+import { normalizeFlowContract } from "../domain/flow-contract.js";
+const limit = 1024 * 1024, manifestPath = "project-pack/manifest.json";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function refuse(reason) {
+    throw new AppError("project_flow_source_invalid", "Project-local flow requires its own valid curated pack; use the supported pack upgrade/repair route", 2, { reason, phase: "prepare", effect: "no_effect", next_action: "inspect_project_pack_and_upgrade_or_repair" });
+}
+function safe(name) {
+    return typeof name === "string" && /^[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/.test(name)
+        && name.split("/").every(part => ![".", "..", ".git", "node_modules", ".dd-flow"].includes(part.toLowerCase()) && localEnvironmentAllowed(part));
+}
+function schema(name) { return JSON.parse(fs.readFileSync(new URL(`../schemas/${name}.schema.json`, import.meta.url), "utf8")); }
+function decoded(bytes) { try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+}
+catch {
+    return refuse("invalid_pack_json");
+} }
+function validate(scope, blobs) {
+    if (!scope || Object.keys(scope).sort().join() !== "flowId,projectRoot,workspace" || scope.flowId !== "interactive"
+        || [scope.projectRoot, scope.workspace].some(value => typeof value !== "string" || !path.isAbsolute(value)))
+        refuse("invalid_project_scope");
+    const manifest = decoded(blobs.get(manifestPath) ?? Buffer.alloc(0));
+    if (!new Ajv({ strict: false, validateFormats: false }).compile(schema("project-flow-pack-manifest"))(manifest)
+        || manifest.schema_id !== "dd-flow/project-flow-pack-manifest@2" || !/^[a-f0-9]{40}$/.test(manifest.source_commit)
+        || !semver.valid(manifest.canon_version_at_source_commit))
+        refuse("invalid_or_legacy_project_manifest");
+    if (manifest.included_files.length > 20_000 || manifest.included_files.some(name => !safe(name) || name === manifestPath
+        || name.startsWith("project-pack/") || isCanonicalOnlyMemoryPath(`dd-flow/${name}`)))
+        refuse("invalid_curated_inventory");
+    const names = [manifestPath, ...manifest.included_files], folded = new Set();
+    let total = 0;
+    if (blobs.size !== names.length)
+        refuse("pack_inventory_changed");
+    for (const name of names) {
+        if (folded.has(name.toLowerCase()))
+            refuse("aliased_pack_path");
+        folded.add(name.toLowerCase());
+        const bytes = blobs.get(name);
+        if (!bytes?.length || bytes.length > limit || (total += bytes.length) > 32 * limit)
+            refuse("missing_or_unbounded_pack_file");
+        if (name !== manifestPath && manifest.file_hashes?.[name] !== undefined && manifest.file_hashes[name] !== hash(bytes))
+            refuse("project_pack_file_changed");
+    }
+    const descriptorPath = `${scope.flowId}/flow-descriptor.json`, descriptor = decoded(blobs.get(descriptorPath) ?? Buffer.alloc(0));
+    if (validateHybridShape("flow-descriptor", descriptor).length || descriptor.id !== scope.flowId || descriptor.origin !== "project")
+        refuse("project_descriptor_required");
+    for (const stage of descriptor.stages)
+        for (const kind of ["instruction", "result_schema"]) {
+            const ref = stage[kind], bytes = blobs.get(ref.path);
+            if (!bytes || ref.path === manifestPath || !manifest.included_files.includes(ref.path) || hash(bytes) !== ref.sha256)
+                refuse("stage_source_not_in_project_pack");
+            try {
+                new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+            }
+            catch {
+                refuse("invalid_stage_source_encoding");
+            }
+            if (kind === "result_schema")
+                decoded(bytes);
+        }
+    const compatibility = decoded(blobs.get("compatibility.json") ?? Buffer.alloc(0));
+    if (!new Ajv({ strict: false, validateFormats: false }).compile(schema("compatibility"))(compatibility))
+        refuse("invalid_project_compatibility");
+    const contract = normalizeFlowContract(decoded(blobs.get("flow-contract.json") ?? Buffer.alloc(0)));
+    if (contract.id !== manifest.flow_contract || compatibility.dd_flow_cli.flow_contract !== contract.id
+        || compatibility.memory_bank_version !== manifest.canon_version_at_source_commit)
+        refuse("project_contract_mismatch");
+    return { manifest, descriptorPath, compatibility };
+}
+/** Project pack data, not engine/handler admission. Manifest canon paths are
+ * provenance hints only: never follow them or fall back to global instructions. */
+export class PreparedProjectFlowSource {
+    sha256;
+    #scope;
+    #blobs;
+    #facts;
+    #fresh;
+    constructor(scope, blobs, fresh) {
+        this.#facts = validate(scope, blobs);
+        this.#scope = structuredClone(scope);
+        this.#blobs = new Map([...blobs].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, bytes]) => [name, Buffer.from(bytes)]));
+        this.sha256 = hybridDigest({ scope, inventory: [...this.#blobs].map(([name, bytes]) => ({ path: name, sha256: hash(bytes) })) });
+        this.#fresh = fresh;
+        Object.freeze(this);
+    }
+    static fromProject(scope) {
+        try {
+            for (const root of [scope.projectRoot, scope.workspace])
+                if (fs.realpathSync(root) !== root || !fs.lstatSync(root).isDirectory())
+                    refuse("noncanonical_project_root");
+            let root = scope.workspace;
+            for (const name of [".memory-bank", "dd-flow"]) {
+                root = path.join(root, name);
+                if (!fs.lstatSync(root).isDirectory())
+                    refuse("linked_project_pack");
+            }
+            const read = (logical) => {
+                if (!safe(logical))
+                    refuse("unsafe_pack_path");
+                let parent = root;
+                for (const part of logical.split("/").slice(0, -1)) {
+                    parent = path.join(parent, part);
+                    if (!fs.lstatSync(parent).isDirectory())
+                        refuse("linked_project_pack");
+                }
+                return readBoundedReleaseFile(path.join(root, logical), limit);
+            };
+            const raw = read("manifest.json"), manifest = decoded(raw);
+            if (!new Ajv({ strict: false, validateFormats: false }).compile(schema("project-flow-pack-manifest"))(manifest)
+                || manifest.schema_id !== "dd-flow/project-flow-pack-manifest@2")
+                refuse("invalid_or_legacy_project_manifest");
+            const blobs = new Map([[manifestPath, raw]]);
+            if (manifest.included_files.length > 20_000)
+                refuse("unbounded_project_pack");
+            let total = raw.length;
+            for (const name of manifest.included_files) {
+                if (!safe(name) || isCanonicalOnlyMemoryPath(`dd-flow/${name}`) || name.startsWith("project-pack/"))
+                    refuse("invalid_curated_inventory");
+                const bytes = read(name);
+                total += bytes.length;
+                if (total > 32 * limit)
+                    refuse("unbounded_project_pack");
+                blobs.set(name, bytes);
+            }
+            if (!read("manifest.json").equals(raw))
+                refuse("manifest_changed_during_capture");
+            return new PreparedProjectFlowSource(scope, blobs, true);
+        }
+        catch (error) {
+            if (error instanceof AppError && error.code === "project_flow_source_invalid")
+                throw error;
+            return refuse("project_pack_unavailable_or_changed");
+        }
+    }
+    snapshot() { return { schema_id: "dd-flow/project-flow-source@1", scope: structuredClone(this.#scope), blobs: [...this.#blobs].map(([name, bytes]) => ({ path: name, base64: bytes.toString("base64") })) }; }
+    /** Data restoration only. expectedSha256 must come from independent request/
+     * RUN custody. Engine/handler admission is separate and never inferred here. */
+    static restoreRetained(value, expectedSha256) {
+        if (!value || Object.keys(value).sort().join() !== "blobs,schema_id,scope" || value.schema_id !== "dd-flow/project-flow-source@1"
+            || !Array.isArray(value.blobs) || value.blobs.length > 20_001)
+            refuse("invalid_retained_project_source");
+        const blobs = new Map();
+        let total = 0;
+        for (const item of value.blobs) {
+            if (!item || Object.keys(item).sort().join() !== "base64,path" || !safe(item.path) || typeof item.base64 !== "string" || item.base64.length > 2 * limit || blobs.has(item.path))
+                refuse("invalid_retained_project_source");
+            const bytes = Buffer.from(item.base64, "base64");
+            total += bytes.length;
+            if (!bytes.length || bytes.length > limit || total > 32 * limit || bytes.toString("base64") !== item.base64)
+                refuse("invalid_retained_project_source");
+            blobs.set(item.path, bytes);
+        }
+        const result = new PreparedProjectFlowSource(value.scope, blobs, false);
+        if (result.sha256 !== expectedSha256)
+            refuse("retained_project_source_changed");
+        return result;
+    }
+    blobs() { return new Map([...this.#blobs].map(([name, bytes]) => [name, Buffer.from(bytes)])); }
+    scope() { return structuredClone(this.#scope); }
+    descriptorReference() { const name = this.#facts.descriptorPath; return { path: name, sha256: hash(this.#blobs.get(name)) }; }
+    projectPackProvenance() { return { sha256: hybridDigest([...this.#blobs].map(([name, bytes]) => ({ path: name === manifestPath ? "dd-flow/manifest.json" : `dd-flow/${name}`, sha256: hash(bytes) })).sort((a, b) => a.path.localeCompare(b.path, "en"))), source_commit: this.#facts.manifest.source_commit }; }
+    canonSource() { return { version: this.#facts.manifest.canon_version_at_source_commit, commit: this.#facts.manifest.source_commit }; }
+    /** Declared project base, not a claim that customized instructions are bytes
+     * from an installed canonical archive. Actual data identity is the pack hash. */
+    canonProvenance() { return { ...this.canonSource(), archive_sha256: null }; }
+    resolveRegisteredFlow() { const ref = this.descriptorReference(); return admitBundledFlow(this.#blobs.get(ref.path), ref.sha256, this.#blobs); }
+    assertEngineCompatibility(engine) {
+        const value = this.#facts.compatibility;
+        if (engine.package_name !== value.engine.package_name || engine.package_name !== value.dd_flow_cli.package_name
+            || !semver.valid(engine.package_version) || !semver.valid(engine.engine_version)
+            || !semver.validRange(value.engine.version_range) || !semver.valid(value.dd_flow_cli.min_version)
+            || !semver.satisfies(engine.engine_version, value.engine.version_range, { includePrerelease: true })
+            || !semver.gte(engine.package_version, value.dd_flow_cli.min_version))
+            refuse("project_pack_engine_incompatible");
+    }
+    revalidate() {
+        if (!this.#fresh) {
+            validate(this.#scope, this.#blobs);
+            return;
+        }
+        if (PreparedProjectFlowSource.fromProject(this.#scope).sha256 !== this.sha256)
+            refuse("project_source_changed_before_retention");
+    }
+}

package/dist/services/project-git-integration.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { interactiveWorkPathAllowed } from "./interactive-work-batch.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+import { assertMemoryGitRemovalSources } from "./memory-git-integration.js";
+function refuse(reason) {
+    throw new AppError("project_git_integration_invalid", "Reviewed project files lack exact local Git integration", 2, { reason, effect: "no_effect" });
+}
+export function assertReviewedProjectGitInventory(references, removals) {
+    const valid = (ref) => ref?.root === "workspace" && interactiveWorkPathAllowed(ref.path)
+        && /^[a-f0-9]{64}$/.test(ref.sha256) && (Object.keys(ref).sort().join() === "path,root,sha256"
+        || Object.keys(ref).sort().join() === "git_mode,path,root,sha256" && ["100644", "100755"].includes(ref.git_mode));
+    if (!Array.isArray(references) || !Array.isArray(removals) || !references.length && !removals.length
+        || references.length + removals.length > 4096 || [...references, ...removals].some(ref => !valid(ref))
+        || new Set([...references, ...removals].map(ref => ref.path)).size !== references.length + removals.length)
+        refuse("invalid_reviewed_project_inventory");
+}
+/** Physical selected-file readback only, not review, policy or commit authority.
+ * Unrelated dirty files/index entries are deliberately neither committed nor
+ * treated as failures. The terminal owner must admit the original dirty input. */
+export function observeReviewedProjectGitIntegration(input, environment, references, removals = []) {
+    assertReviewedProjectGitInventory(references, removals);
+    for (const root of [input.projectRoot, input.workspaceRoot]) {
+        if (!path.isAbsolute(root) || fs.realpathSync(root) !== root || !fs.lstatSync(root).isDirectory())
+            refuse("canonical_repository_root_required");
+    }
+    if (!path.isAbsolute(input.gitExecutable) || typeof input.integrationBranch !== "string" || !input.integrationBranch)
+        refuse("explicit_git_selection_required");
+    const env = { ...Object.fromEntries(Object.entries(environment).filter(([key]) => !key.startsWith("GIT_"))), GIT_OPTIONAL_LOCKS: "0", GIT_LITERAL_PATHSPECS: "1" };
+    const git = (root, args) => {
+        const result = spawnSync(input.gitExecutable, ["-c", "core.fsmonitor=false", "-C", root, ...args], { env, 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 text = (root, args) => git(root, args).toString("utf8").trim();
+    const source = input.workspaceRoot, target = input.projectRoot, integrationRef = `refs/heads/${input.integrationBranch}`;
+    git(target, ["check-ref-format", integrationRef]);
+    const common = (root) => fs.realpathSync(path.resolve(root, text(root, ["rev-parse", "--git-common-dir"])));
+    const repository = common(source);
+    if (common(target) !== repository || [source, target].some(root => text(root, ["rev-parse", "--show-toplevel"]) !== root))
+        refuse("foreign_repository");
+    const workspaceBranch = text(source, ["symbolic-ref", "--short", "HEAD"]);
+    if (text(target, ["symbolic-ref", "--short", "HEAD"]) !== input.integrationBranch)
+        refuse("integration_branch_changed");
+    const head = text(source, ["rev-parse", "--verify", "HEAD^{commit}"]), integrated = text(target, ["rev-parse", "--verify", `${integrationRef}^{commit}`]);
+    git(target, ["merge-base", "--is-ancestor", head, integrated]);
+    const paths = [...references, ...removals].map(ref => ref.path);
+    const observations = [...new Set([source, target])].map(root => {
+        const visibility = git(root, ["ls-files", "-v", "-z", "--", ...paths]).toString("utf8");
+        if (visibility.split("\0").filter(Boolean).some(entry => !entry.startsWith("H ")))
+            refuse("selected_index_visibility_override");
+        git(root, ["diff", "--cached", "--exit-code", "--", ...paths]);
+        assertMemoryGitRemovalSources(root, removals);
+        const observed = ObservedMemorySources.capture({ workspace: root }, references.map(({ root, path }) => ({ root, path })));
+        const hashes = observed.hashes();
+        for (const ref of references) {
+            if (hashes.get(memorySourceKey("workspace", ref.path)) !== ref.sha256)
+                refuse("reviewed_workspace_bytes_changed");
+            if (process.platform !== "win32" && ((fs.lstatSync(path.join(root, ref.path)).mode & 0o111) !== 0) !== (ref.git_mode === "100755"))
+                refuse("reviewed_workspace_mode_changed");
+        }
+        return observed;
+    });
+    // ponytail: at most 4096 selected paths; batch Git reads if real interactive
+    // inventories make per-file subprocess latency material.
+    for (const [root, revision] of [[source, head], [target, integrated]]) {
+        for (const ref of references) {
+            const entry = git(root, ["ls-tree", "-z", revision, "--", ref.path]).toString("utf8");
+            if (!entry.startsWith(`${ref.git_mode ?? "100644"} blob `) || !entry.endsWith(`\t${ref.path}\0`))
+                refuse("reviewed_regular_git_blob_required");
+            if (createHash("sha256").update(git(root, ["cat-file", "blob", `${revision}:${ref.path}`])).digest("hex") !== ref.sha256)
+                refuse("reviewed_git_bytes_changed");
+        }
+        for (const ref of removals)
+            if (git(root, ["ls-tree", "-z", revision, "--", ref.path]).length)
+                refuse("removed_file_still_committed");
+    }
+    for (const observation of observations)
+        observation.revalidate();
+    if (text(source, ["rev-parse", "HEAD"]) !== head || text(target, ["rev-parse", integrationRef]) !== integrated)
+        refuse("integration_changed_during_observation");
+    return { schema_id: "dd-flow/project-git-integration-observation@1", project_root: target, workspace_root: source,
+        repository, workspace_branch: workspaceBranch, integration_ref: integrationRef, workspace_head: head, integration_head: integrated,
+        reviewed_files_sha256: hybridDigest([...references].sort((a, b) => a.path.localeCompare(b.path, "en"))),
+        removed_files_sha256: hybridDigest([...removals].sort((a, b) => a.path.localeCompare(b.path, "en"))) };
+}

package/dist/services/repair-intents.js

@@ -2,15 +2,10 @@ import crypto from "node:crypto";
 import { stageAttempt, stageCycle, bindStageWork } from "./stage-work-graph.js";
 import { assertRunMutationAllowed } from "./run-recovery.js";
 import { AppError } from "../shared/errors.js";
-import { assertSourceRepairEligible } from "./code-checks.js";
+import { assertCheckDiagnosisEligible } from "./code-checks.js";
 /** Checks finish before entering this synchronous registration transaction. */
 export function ensureAggregateRepair(context, input, create) {
-    if (!input.failures.length)
-        throw new AppError("repair_intent_invalid", "Repair requires candidate-source-backed failed receipts", 1);
-    const workspace = context.db.get("SELECT workspace_root FROM runs WHERE project_id=? AND id=?", [input.projectId, input.runId]);
-    if (!workspace?.workspace_root && input.failures.some(receipt => receipt.candidate_library_inputs?.length))
-        throw new AppError("repair_intent_invalid", "Library-backed repair requires the current RUN workspace", 1);
-    assertSourceRepairEligible(input.failures, workspace?.workspace_root);
+    assertCheckDiagnosisEligible(input.failures);
     const causes = input.failures.map(receipt => ({ id: receipt.id, epoch: receipt.verification_epoch, fingerprint: receipt.fingerprint_scope === "check_inputs" ? receipt.before_fingerprint : receipt.workspace_fingerprint })).sort((a, b) => a.id.localeCompare(b.id));
     return ensureRepairIntent(context, { ...input, causes: { receipts: causes, origins: [...(input.origins ?? [])].sort() } }, create);
 }