@deksden-com/dd-flow-cli 0.9.0-beta.10 → 0.9.0-beta.103

package/dist/services/runs.js

@@ -5,7 +5,7 @@ import { spawnSync } from "node:child_process";
 import { formatFullId, isFullEntityId, isShortEntityId, parseFullEntityId } from "../domain/entity-ids.js";
 import { checksumForFlowFlagValues, isFlowFlagDowngrade, loadCanonicalFlowContract, loadProjectFlowContract, resolveFlowFlags } from "../domain/flow-contract.js";
 import { AppError } from "../shared/errors.js";
-import { ensureDir, projectRunHome, projectRunJsonPath, resolveProjectRoot } from "../storage/paths.js";
+import { ensureDir, canonicalPath, projectRunHome, projectRunJsonPath, resolveProjectRoot } from "../storage/paths.js";
 import { appendAudit } from "./audit.js";
 import { registerProject, requireProjectByRoot } from "./projects.js";
 import { buildRunFlowGuidance } from "./flow-guidance.js";
@@ -15,8 +15,10 @@ import { refreshRunSessionProjection } from "./run-projection.js";
 import { resolveCanonRoot } from "./canon.js";
 import { bindCurrentEngineToRun } from "./engines.js";
 import { executionProfilePath, loadVnextExecutionProfile } from "./vnext-execution-profile.js";
-import { isLegalVnextTransition, vnextStages } from "../domain/stage-catalog.js";
+import { assertSameSessionMerge, loadExecutionRoutingInput, resolveStageTransition, snapshotAgentProfiles } from "./execution-policy.js";
+import { isLegalVnextTransition, vnextStageDirectory, vnextStages } from "../domain/stage-catalog.js";
 import { publicSessionIdentity } from "./session-identity.js";
+import { flowCommand } from "./stage-pause.js";
 const runSchemaId = "dd-flow/flow-run@3";
 const runtimeSchemaId = "dd-flow/flow-run@3";
 const runIdType = "RUN";
@@ -35,22 +37,26 @@ const allowedRunFlowKinds = [
     "review",
     "custom"
 ];
-export function startFlowRun(context, input) {
+export function prepareFlowRunStart(context, input) {
+    const subjectId = requiredPlain(input.subjectId, "subject-id");
+    const subjectType = requiredPlain(input.subjectType, "subject-type");
+    const slug = normalizeSlug(input.slug);
+    for (const [name, value] of [["task profile", input.taskProfile], ["protocol overrides", input.protocolOverrides], ["RUN overrides", input.runOverrides]]) {
+        if (value !== undefined && (!value || typeof value !== "object" || Array.isArray(value)))
+            throw new AppError("validation", `${name} must be a JSON object`, 2);
+    }
     const projectRoot = resolveProjectRoot(input.projectRoot);
+    const flowKind = parseRunFlowKind(input.flowKind);
+    const vnext = flowKind === "vnext_protocolize" || flowKind === "vnext_specify";
+    if (input.executionRoutingFile !== undefined && !vnext)
+        throw new AppError("usage", "Execution routing input is supported only for vNext RUNs", 2);
+    const routingInput = input.executionRoutingFile !== undefined ? loadExecutionRoutingInput(input.executionRoutingFile) : undefined;
+    const executionProfile = vnext ? snapshotVnextExecutionProfile(projectRoot, context.ddFlowHome, routingInput) : undefined;
     const flowContract = input.flowKind === "mb-upgrade"
         ? loadUpgradeFlowContract(context, projectRoot)
         : loadProjectFlowContract(projectRoot);
-    registerProject(context, { root: projectRoot });
-    const project = requireProjectByRoot(context, projectRoot);
     const workspaceRoot = resolveWorkspaceRoot(input.workspaceRoot ?? projectRoot);
-    const flowKind = parseRunFlowKind(input.flowKind);
-    const slug = normalizeSlug(input.slug);
-    const runId = nextRunId(context, project.id, slug);
-    const { shortId } = parseFullEntityId(runId);
     const now = context.now();
-    const executionProfile = (flowKind === "vnext_protocolize" || flowKind === "vnext_specify")
-        ? snapshotVnextExecutionProfile(projectRoot)
-        : undefined;
     const flowFlags = resolveFlowFlags(flowContract, {
         flowKind,
         ...(input.preset ? { preset: input.preset } : {}),
@@ -60,6 +66,14 @@ export function startFlowRun(context, input) {
         snapshotRevision: 1,
         now
     });
+    return { projectRoot, flowKind, routingInput, executionProfile, workspaceRoot, slug, subjectId, subjectType, now, flowFlags };
+}
+export function startFlowRun(context, input, prepared = prepareFlowRunStart(context, input)) {
+    const { projectRoot, flowKind, routingInput, executionProfile, workspaceRoot, slug, subjectId, subjectType, now, flowFlags } = prepared;
+    registerProject(context, { root: projectRoot });
+    const project = requireProjectByRoot(context, projectRoot);
+    const runId = nextRunId(context, project.id, slug);
+    const { shortId } = parseFullEntityId(runId);
     const runHome = projectRunHome(context.ddFlowHome, project.id, runId);
     const runDirRelative = path.posix.join("runs", runId);
     const runtimePath = projectRunJsonPath(context.ddFlowHome, project.id, runId);
@@ -69,8 +83,8 @@ export function startFlowRun(context, input) {
         short_id: shortId,
         flow_kind: flowKind,
         subject: {
-            id: requiredPlain(input.subjectId, "subject-id"),
-            title: requiredPlain(input.subjectId, "subject-id")
+            id: subjectId,
+            title: subjectId
         },
         project: {
             id: project.id,
@@ -126,6 +140,8 @@ export function startFlowRun(context, input) {
     };
     ensureDir(path.dirname(runtimePath));
     ensureDir(runHome);
+    if (routingInput)
+        fs.writeFileSync(path.join(runHome, "execution-routing.input.json"), routingInput.bytes, { flag: "wx", mode: 0o600 });
     bindCurrentEngineToRun(context, { projectRoot, runId, runRoot: runHome });
     const persistedIndex = persistedVnextIndex(index);
     writeJsonFile(runtimePath, runtimeSnapshotForIndex(persistedIndex, 1));
@@ -141,7 +157,7 @@ export function startFlowRun(context, input) {
         project.root,
         workspaceRoot,
         flowKind,
-        requiredPlain(input.subjectType, "subject-type"),
+        subjectType,
         index.subject.id,
         index.status,
         index.verdict,
@@ -173,10 +189,10 @@ export function startFlowRun(context, input) {
     });
     return { ok: true, run: flowRunSummary(requireRunById(context, project.id, runId)), index };
 }
-function snapshotVnextExecutionProfile(projectRoot) {
+function snapshotVnextExecutionProfile(projectRoot, ddFlowHome, routingInput) {
     const profile = loadVnextExecutionProfile(projectRoot);
     const sourcePath = executionProfilePath(projectRoot);
-    return {
+    return freezeRunExecutionRouting(ddFlowHome, {
         schema_id: "dd-flow/run-execution-profile@1",
         source_path: sourcePath,
         source_checksum: crypto.createHash("sha256").update(fs.readFileSync(sourcePath)).digest("hex"),
@@ -188,9 +204,41 @@ function snapshotVnextExecutionProfile(projectRoot) {
             merge_delivery: profile.merge_delivery,
             merge_cleanup: profile.merge_cleanup,
             stop_target: profile.stop_target,
-            code_bootstrap: profile.code_bootstrap
+            code_bootstrap: profile.code_bootstrap,
+            ...(profile.execution ? { execution: profile.execution } : {})
         }
-    };
+    }, routingInput);
+}
+/** Fresh RUN and fresh stage-entry experiments freeze through the same resolver. */
+export function freezeRunExecutionRouting(ddFlowHome, base, input) {
+    const execution = input?.execution ?? base.settings.execution;
+    const profiles = execution ? snapshotAgentProfiles(ddFlowHome, execution) : undefined;
+    if (execution && profiles && base.settings.merge_mode === "same_session" && base.settings.stop_target === "merge_completed") {
+        const mode = base.settings.code_review_mode;
+        assertSameSessionMerge({ ddFlowHome, policy: execution, profiles, previousStages: mode === "off" ? ["code"] : mode === "auto" ? ["code", "code-review"] : ["code-review"] });
+    }
+    return { ...base, ...(profiles ? { agent_profiles: profiles } : {}),
+        ...(input ? { routing_input: { source_path: input.source_path, source_checksum: input.source_checksum, artifact: "execution-routing.input.json" } } : {}),
+        settings: { ...base.settings, ...(execution ? { execution } : {}) } };
+}
+/** Called only after a stage-entry import has archived and detached source owners. */
+export function importFlowRunExecutionProfile(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
+    const index = authoritativeIndex(run);
+    const lineage = JSON.parse(fs.readFileSync(input.lineageFile, "utf8"));
+    if (lineage.schema_id !== "dd-flow/snapshot-runtime-lineage@1" || lineage.run_id !== run.id || path.resolve(lineage.restored_runtime ?? "") !== path.resolve(context.ddFlowHome)
+        || !vnextStages.some(stage => stage.id === input.stage)
+        || (context.db.get("SELECT 1 FROM sqlite_schema WHERE type = 'table' AND name = 'run_controllers'") && context.db.get("SELECT 1 FROM run_controllers WHERE project_id = ? AND run_id = ? LIMIT 1", [project.id, run.id]))
+        || index.stage_runs.some(stage => stage.stage === input.stage || !["done", "skipped"].includes(stage.status))
+        || context.db.get("SELECT 1 FROM sessions WHERE project_id = ? AND run_id = ? AND status IN ('active','idle') LIMIT 1", [project.id, run.id])) {
+        throw new AppError("snapshot_execution_active", "Execution policy can be selected only at a detached stage-entry import", 1);
+    }
+    index.execution_profile = { ...input.profile, stage_entry_import: { stage: input.stage, lineage_file: input.lineageFile } };
+    index.updated_at = context.now();
+    persistRunState(context, project, run, index);
+    appendRunTimeline(run.run_root, { at: index.updated_at, type: "execution_policy_imported", stage: input.stage, lineage_file: input.lineageFile, source_checksum: input.profile.routing_input?.source_checksum });
 }
 /**
  * A vNext route may materialize a feature checkout after its semantic
@@ -200,6 +248,7 @@ function snapshotVnextExecutionProfile(projectRoot) {
 export function rebindFlowRunWorkspace(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
     const workspaceRoot = resolveWorkspaceRoot(input.workspaceRoot);
     const index = authoritativeIndex(run);
     const now = context.now();
@@ -229,7 +278,41 @@ export function getFlowRunStatus(context, input) {
     const run = resolveRun(context, project.id, input.runId);
     const index = authoritativeIndex(run);
     const runtime = readRuntimeSnapshot(run.runtime_path);
-    return { ok: true, run: flowRunSummary(run), index, ...(runtime ? { runtime } : {}), flow_guidance: guidanceForRun(context, run, index) };
+    return { ok: true, run: flowRunSummary(run), index, continuation: runContinuation(context, run, index), ...(runtime ? { runtime } : {}), flow_guidance: guidanceForRun(context, run, index) };
+}
+/** A read-only projection of the next legal lifecycle action.
+ * It is derived from the persisted RUN/Work facts so controllers never infer a
+ * transition from a model's prose or a hard-coded stage array. */
+function runContinuation(context, run, index) {
+    if (["done", "failed", "cancelled"].includes(run.status))
+        return { kind: "terminal", stage: null, attempt: null, work_id: null, reason: run.status, command: null };
+    const control = runControlDirective(context, run.project_id, run.id);
+    if (control)
+        return { kind: "wait", stage: index.current_stage ?? null, attempt: null, work_id: null, reason: "operator_control", command: null, control };
+    const active = index.stage_runs.find((stage) => !["done", "skipped"].includes(stage.status));
+    if (active) {
+        const runningWork = context.db.get("SELECT work_id FROM works WHERE project_id = ? AND run_id = ? AND status = 'running' ORDER BY updated_at DESC LIMIT 1", [run.project_id, run.id]);
+        const kind = active.status === "running" ? "continue_stage" : active.status === "paused" || active.status === "waiting_for_user" ? "paused" : "blocked";
+        return { kind, stage: active.stage, attempt: active.attempt ?? null, work_id: active.pause?.work_id ?? runningWork?.work_id ?? null, reason: active.status, command: null };
+    }
+    if (run.status === "waiting_for_user" || run.status === "paused")
+        return { kind: "paused", stage: index.current_stage ?? null, attempt: null, work_id: null, reason: run.status, command: null };
+    if (run.status === "blocked")
+        return { kind: "blocked", stage: index.current_stage ?? null, attempt: null, work_id: null, reason: run.status, command: null };
+    if (run.flow_kind === "vnext_specify" || run.flow_kind === "vnext_protocolize") {
+        const completed = index.stage_runs.filter((stage) => stage.status === "done" || stage.status === "skipped").sort((left, right) => right.order - left.order)[0];
+        const next = completed ? vnextStages.find((stage) => stage.id === completed.stage)?.next.find((candidate) => candidate !== "plan-review" || index.settings?.plan_review?.mode !== "off") : "specify";
+        if (!next)
+            return { kind: "terminal", stage: null, attempt: null, work_id: null, reason: "flow_complete", command: null };
+        const command = `${flowCommand(context)} stage start ${run.id} --stage ${next} --project-root ${JSON.stringify(run.project_root)} --json`;
+        const profile = index.execution_profile;
+        const execution = profile?.settings.execution ? profile.agent_profiles
+            ? { status: "resolved", ...resolveStageTransition({ ddFlowHome: context.ddFlowHome, policy: profile.settings.execution, profiles: profile.agent_profiles, ...(completed ? { fromStage: completed.stage } : {}), stage: next, stageSessionMode: profile.settings.stage_session_mode, mergeMode: profile.settings.merge_mode }) }
+            : { status: "unfrozen", reason: "execution_profile_not_frozen" }
+            : undefined;
+        return { kind: "start_stage", stage: next, attempt: null, work_id: null, reason: "legal_successor", command, ...(execution ? { execution } : {}) };
+    }
+    return { kind: "wait", stage: index.current_stage ?? null, attempt: null, work_id: null, reason: "no_vnext_continuation", command: null };
 }
 export function getFlowRunConfig(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
@@ -250,9 +333,12 @@ export function getFlowRunVariables(context, input) {
     return { ok: true, run_id: run.id, variables };
 }
 export function setFlowRunVariable(context, input) {
+    return setRunVariable(context, input, input.value, prepareFlowRunVariable(context, input));
+}
+export function prepareFlowRunVariable(context, input) {
     if (!input.key.startsWith("user."))
         throw new AppError("validation", "Only user.* RUN variables may be set directly", 2, { key: input.key });
-    return setRunVariable(context, input, input.value);
+    return prepareRunVariable(context, input);
 }
 /** Controllers own policy.* and runtime.* values; agents never call this directly. */
 export function setRuntimeRunVariable(context, input) {
@@ -261,20 +347,7 @@ export function setRuntimeRunVariable(context, input) {
     return setRunVariable(context, input, input.value);
 }
 export function setFlowRunConfig(context, input) {
-    if (input.key !== "plan_review.mode" && input.key !== "code_review.mode") {
-        throw new AppError("validation", `Unknown RUN config key: ${input.key}`, 2);
-    }
-    if (!["auto", "off", "standard", "deep"].includes(input.value)) {
-        throw new AppError("validation", "--value for review mode must be auto, off, standard, or deep", 2);
-    }
-    const reason = requiredPlain(input.reason, "reason");
-    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
-    const run = resolveRun(context, project.id, input.runId);
-    const index = authoritativeIndex(run);
-    const stageName = input.key === "plan_review.mode" ? "plan-review" : "code-review";
-    if (index.stage_runs.some((stage) => stage.stage === stageName)) {
-        throw new AppError("invalid_run_config_state", `${input.key} is frozen after ${stageName} starts`, 2, { run_id: run.id });
-    }
+    const { reason, project, run, index } = prepareFlowRunConfig(context, input);
     const now = context.now();
     const settings = runSettings(index);
     const previous = input.key === "plan_review.mode" ? settings.plan_review : settings.code_review;
@@ -292,10 +365,29 @@ export function setFlowRunConfig(context, input) {
     appendRunTimeline(runArtifactRoot(run), { at: now, type: "run_config_set", run_id: run.id, key: input.key, value: mode, source, reason });
     return { ok: true, run_id: run.id, settings: runSettings(index), idempotent: false };
 }
+export function prepareFlowRunConfig(context, input) {
+    if (input.key !== "plan_review.mode" && input.key !== "code_review.mode") {
+        throw new AppError("validation", `Unknown RUN config key: ${input.key}`, 2);
+    }
+    if (!["auto", "off", "standard", "deep"].includes(input.value)) {
+        throw new AppError("validation", "--value for review mode must be auto, off, standard, or deep", 2);
+    }
+    const reason = requiredPlain(input.reason, "reason");
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
+    const index = authoritativeIndex(run);
+    const stageName = input.key === "plan_review.mode" ? "plan-review" : "code-review";
+    if (index.stage_runs.some((stage) => stage.stage === stageName)) {
+        throw new AppError("invalid_run_config_state", `${input.key} is frozen after ${stageName} starts`, 2, { run_id: run.id });
+    }
+    return { reason, project, run, index };
+}
 /** Freeze an automatic review request once from already accepted policy or PLAN facts. */
 export function freezeFlowRunReviewMode(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
     const index = authoritativeIndex(run);
     const settings = runSettings(index);
     const key = input.review === "plan" ? "plan_review" : "code_review";
@@ -337,8 +429,9 @@ export function getFlowRunFlagsStatus(context, input) {
 export function reviseFlowRunFlags(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
     const idempotencyKey = requiredPlain(input.idempotencyKey, "idempotency-key");
-    context.db.exec("BEGIN IMMEDIATE");
+    context.db.beginWriteTransaction();
     let committed = false;
     try {
         const existingMutation = context.db.get("SELECT result_json FROM flow_run_flag_mutations WHERE project_id = ? AND run_id = ? AND idempotency_key = ?", [project.id, run.id, idempotencyKey]);
@@ -459,24 +552,31 @@ export function listFlowRuns(context, input) {
         .map(flowRunSummary);
     return { ok: true, project, runs };
 }
-export function attachFlowRunStage(context, input) {
+export function prepareFlowRunStageAttachment(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
     const index = authoritativeIndex(run);
-    const now = context.now();
     const stage = requiredPlain(input.stage, "stage");
-    const dir = requiredStageDir(input.dir);
+    const dir = prepareStageDirectory(input.dir);
     const status = parseStageStatus(input.status);
     const existing = index.stage_runs.find((item) => item.stage === stage);
     assertVnextStageStart(run, index, stage, status, existing);
+    return { project, run, index, stage, dir, status, existing };
+}
+export function attachFlowRunStage(context, input) {
+    // Mutable stage state is re-read immediately before archiving/persisting.
+    const { project, run, index, stage, dir, status, existing } = prepareFlowRunStageAttachment(context, input);
+    const now = context.now();
     if (status === "running" && existing) {
-        archiveExistingStageAttempt(runArtifactRoot(run), dir);
+        archiveExistingStageAttempt(context, project.id, run.id, runArtifactRoot(run), dir);
     }
     const stageRun = {
         ...(existing ?? { order: index.stage_runs.length + 1 }),
         stage,
         dir,
         status,
+        ...(input.inputSha256 ? { input_sha256: input.inputSha256 } : {}),
         ...(input.dataSchemaId ? { data_schema_id: input.dataSchemaId } : existing?.data_schema_id ? { data_schema_id: existing.data_schema_id } : {}),
         updated_at: now
     };
@@ -506,24 +606,49 @@ export function attachFlowRunStage(context, input) {
     const updatedRun = requireRunById(context, project.id, run.id);
     return { ok: true, run: flowRunSummary(updatedRun), stage_run: stageRun, index, flow_guidance: guidanceForRun(context, updatedRun, index) };
 }
-export function completeFlowRunStage(context, input) {
+/** Keep synchronous stage settlement atomic; files are projections, SQLite is authoritative. */
+export function withStageSettlement(context, operation) {
+    return context.db.writeTransaction(operation);
+}
+export function prepareFlowRunStageCompletion(context, input) {
+    for (const [name, value] of Object.entries({ stageReport: input.stageReport, data: input.data, dataSchemaId: input.dataSchemaId, report: input.report })) {
+        if (value !== undefined)
+            requiredPlain(value, name);
+    }
+    if (input.aliases !== undefined) {
+        if (!Array.isArray(input.aliases))
+            throw new AppError("validation", "artifact aliases must be an array", 2);
+        for (const alias of input.aliases)
+            requiredPlain(alias, "artifact alias");
+    }
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
+    if (["done", "failed", "skipped"].includes(input.status))
+        assertStageSettlementAllowed(context, project.id, run.id, input.stage);
+    else
+        assertRunMutationAllowed(context, project.id, run.id);
     const index = authoritativeIndex(run);
-    const now = context.now();
     const stage = requiredPlain(input.stage, "stage");
     const status = parseStageStatus(input.status);
     const existing = index.stage_runs.find((item) => item.stage === stage);
     if (!existing) {
         throw new AppError("not_found", `Run stage is not attached: ${stage}`, 1, { run_id: run.id, stage });
     }
+    return { project, run, index, stage, status, existing };
+}
+export function completeFlowRunStage(context, input) {
+    const { project, run, index, stage, status, existing } = prepareFlowRunStageCompletion(context, input);
+    const now = context.now();
+    const dataPath = input.data ? path.join(runArtifactRoot(run), existing.dir, input.data) : null;
     const stageRun = {
         ...existing,
         status,
         ...(input.stageReport ? { stage_report: input.stageReport } : {}),
         ...(input.data ? { data: input.data } : {}),
+        ...(dataPath && fs.existsSync(dataPath) ? { data_sha256: crypto.createHash("sha256").update(fs.readFileSync(dataPath)).digest("hex") } : {}),
         ...(input.dataSchemaId ? { data_schema_id: input.dataSchemaId } : {}),
         ...(input.report ? { report: input.report } : {}),
+        ...(input.usage ? { usage: input.usage } : {}),
         ...(input.aliases && input.aliases.length > 0 ? { artifact_aliases: input.aliases } : {}),
         updated_at: now,
         ...(status === "done" || status === "waiting_for_user" || status === "blocked" || status === "failed" || status === "skipped"
@@ -566,6 +691,7 @@ export function completeFlowRunStage(context, input) {
 export function pauseFlowRunStage(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
     const index = authoritativeIndex(run);
     const stage = requiredPlain(input.stage, "stage");
     const stageRun = index.stage_runs.find((item) => item.stage === stage);
@@ -601,6 +727,7 @@ export function pauseFlowRunStage(context, input) {
 export function resumeFlowRunStage(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
     const index = authoritativeIndex(run);
     const stage = requiredPlain(input.stage, "stage");
     const stageRun = index.stage_runs.find((item) => item.stage === stage);
@@ -629,14 +756,23 @@ export function resumeFlowRunStage(context, input) {
     return { run: flowRunSummary(requireRunById(context, project.id, run.id)), stage_run: stageRun, index };
 }
 /** Pause the current stage for a non-user runtime blocker. */
-export function blockFlowRunStage(context, input) {
+export function prepareFlowRunStageBlock(context, input) {
+    if (!["engine", "harness", "environment"].includes(input.kind) || typeof input.retryable !== "boolean")
+        throw new AppError("validation", "stage block requires a valid kind and boolean retryable", 2);
+    requiredPlain(input.code, "code");
+    requiredPlain(input.summary, "summary");
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
     const index = authoritativeIndex(run);
     const stage = requiredPlain(input.stage, "stage");
     const stageRun = index.stage_runs.find((item) => item.stage === stage);
     if (!stageRun || stageRun.status !== "running")
         throw new AppError("invalid_stage_state", "Only a running stage can be blocked", 1, { run_id: run.id, stage, status: stageRun?.status ?? "missing" });
+    return { project, run, index, stage, stageRun };
+}
+export function blockFlowRunStage(context, input, prepared = prepareFlowRunStageBlock(context, input)) {
+    const { project, run, index, stage, stageRun } = prepared;
     const now = context.now();
     stageRun.status = "blocked";
     stageRun.updated_at = now;
@@ -654,16 +790,20 @@ export function blockFlowRunStage(context, input) {
     return { run: flowRunSummary(requireRunById(context, project.id, run.id)), stage_run: stageRun, index };
 }
 /** Continue the same stage after its non-user blocker was repaired externally. */
-export function unblockFlowRunStage(context, input) {
+export function prepareFlowRunStageUnblock(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
     const index = authoritativeIndex(run);
     const stage = requiredPlain(input.stage, "stage");
     const stageRun = index.stage_runs.find((item) => item.stage === stage);
     if (!stageRun || stageRun.status !== "blocked" || !stageRun.blocker || stageRun.blocker.work_id !== input.workId)
         throw new AppError("invalid_stage_state", "Stage unblock requires its matching runtime blocker", 1, { run_id: run.id, stage, work_id: input.workId, status: stageRun?.status ?? "missing" });
+    return { project, run, index, stage, stageRun, blocker: stageRun.blocker };
+}
+export function unblockFlowRunStage(context, input, prepared = prepareFlowRunStageUnblock(context, input)) {
+    const { project, run, index, stage, stageRun, blocker } = prepared;
     const now = context.now();
-    const blocker = stageRun.blocker;
     const blockedMs = durationMs(blocker.blocked_at, now) ?? 0;
     stageRun.status = "running";
     stageRun.updated_at = now;
@@ -687,11 +827,36 @@ function operationalRunStatus(context, projectId, runId) {
     const leaves = unfinished.filter((work) => !parents.has(work.work_id));
     return leaves.length > 0 && leaves.every((work) => work.status === "paused") ? "paused" : "running";
 }
-export function completeFlowRun(context, input) {
-    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+/** Keep the logical RUN projection aligned with recovery authority. Stage/Work
+ * evidence and verdicts survive a reversible stop; terminal runs never reopen. */
+export function setFlowRunRecoveryPaused(context, projectId, runId, paused) {
+    const run = resolveRun(context, projectId, runId);
+    if (!["running", "paused"].includes(run.status))
+        return;
+    const index = authoritativeIndex(run);
+    const status = paused || index.stage_runs.some(stage => ["paused", "waiting_for_user", "blocked"].includes(stage.status))
+        ? "paused" : operationalRunStatus(context, projectId, runId);
+    if (run.status === status && index.status === status)
+        return;
+    index.status = status;
+    index.updated_at = context.now();
+    const project = requireProjectByRoot(context, run.project_root);
+    persistRunState(context, project, run, index);
+}
+export function prepareFlowRunCompletion(context, input) {
+    if (input.manualOverrideReason !== undefined) {
+        requiredPlain(input.manualOverrideReason, "override reason");
+        if (!["cancelled", "failed"].includes(input.status))
+            throw new AppError("validation", "Manual RUN override may only cancel or fail a RUN", 2);
+    }
+    if (input.verdict !== undefined)
+        requiredPlain(input.verdict, "verdict");
+    if (input.nextAction !== undefined)
+        requiredPlain(input.nextAction, "next action");
+    const project = requireProjectByRoot(context, input.manualOverrideReason ? canonicalPath(input.projectRoot, false) : resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
     const index = authoritativeIndex(run);
-    const now = context.now();
     const status = parseRunStatus(input.status);
     if (!['done', 'cancelled', 'failed'].includes(status)) {
         throw new AppError('validation', 'completeFlowRun accepts only done, cancelled, or failed; use stage block/unblock for a recoverable blocker', 2, { status });
@@ -701,6 +866,11 @@ export function completeFlowRun(context, input) {
         if (activeWork)
             throw new AppError("active_work", "RUN cannot complete while Work remains active", 2, { run_id: run.id, work_id: activeWork.work_id, status: activeWork.status });
     }
+    return { project, run, index, status };
+}
+export function completeFlowRun(context, input) {
+    const { project, run, index, status } = prepareFlowRunCompletion(context, input);
+    const now = context.now();
     if (input.manualOverrideReason && (status === "cancelled" || status === "failed")) {
         closeOpenStagesForOverride(index, status, now);
         closeOpenWorksForOverride(context, project.id, run.id, status, now);
@@ -743,16 +913,85 @@ export function advanceFlowRun(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
     const index = authoritativeIndex(run);
+    if (input.settlementStage && input.status === "running" && index.current_stage === input.settlementStage && index.stage_runs.some(stage => stage.stage === input.settlementStage && ["done", "skipped"].includes(stage.status)))
+        assertStageSettlementAllowed(context, project.id, run.id, input.settlementStage);
+    else
+        assertRunMutationAllowed(context, project.id, run.id);
+    const control = runControlDirective(context, project.id, run.id);
     const now = context.now();
     index.status = input.status;
     index.verdict = input.verdict;
-    index.next_action = input.nextAction ?? null;
+    index.next_action = control ? null : input.nextAction ?? null;
     index.updated_at = now;
     persistRunState(context, project, run, index);
-    appendAudit(context, { projectId: project.id, eventType: "flow_run.progressed", payload: { run_id: run.id, status: input.status, verdict: input.verdict, next_action: index.next_action } });
-    appendRunTimeline(runArtifactRoot(run), { at: now, type: "run_progressed", run_id: run.id, status: input.status, next_action: index.next_action });
+    appendAudit(context, { projectId: project.id, eventType: "flow_run.progressed", payload: { run_id: run.id, status: index.status, verdict: input.verdict, next_action: index.next_action } });
+    appendRunTimeline(runArtifactRoot(run), { at: now, type: "run_progressed", run_id: run.id, status: index.status, next_action: index.next_action });
     const updatedRun = requireRunById(context, project.id, run.id);
-    return { ok: true, run: flowRunSummary(updatedRun), index, flow_guidance: guidanceForRun(context, updatedRun, index) };
+    return { ok: true, ...(control ? { control } : {}), run: flowRunSummary(updatedRun), index, flow_guidance: guidanceForRun(context, updatedRun, index) };
+}
+/**
+ * The only legal backward edge in vNext: an integration gate exposed a
+ * product defect, so the source must be repaired and reviewed again.  Normal
+ * stage start remains fail-closed for completed stages.
+ */
+export function prepareVnextMergeSourceRepairAttempt(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
+    const index = authoritativeIndex(run);
+    const priorRepair = index.variables?.["merge.source_repair"];
+    if (priorRepair?.merge_request_id === input.mergeRequestId && priorRepair.cycle)
+        return { run_id: run.id, cycle: priorRepair.cycle };
+    const code = index.stage_runs.find((item) => item.stage === "code");
+    const review = index.stage_runs.find((item) => item.stage === "code-review");
+    const merge = index.stage_runs.find((item) => item.stage === "merge");
+    if (!code || code.status !== "done" || !review || review.status !== "done" || !merge || merge.status !== "running") {
+        throw new AppError("invalid_merge_repair_state", "Source repair requires accepted CODE/CODE-REVIEW and a running MERGE attempt", 2, {
+            run_id: run.id,
+            code: code?.status ?? null,
+            code_review: review?.status ?? null,
+            merge: merge?.status ?? null
+        });
+    }
+    const root = runArtifactRoot(run);
+    for (const stage of ["code", "code-review", "merge"])
+        archiveExistingStageAttempt(context, project.id, run.id, root, vnextStageDirectory(stage));
+    const now = context.now();
+    const restarted = {
+        ...code,
+        status: "running",
+        started_at: now,
+        updated_at: now,
+        attempt: nextAttempt(code)
+    };
+    delete restarted.completed_at;
+    delete restarted.duration_ms;
+    delete restarted.stage_report;
+    delete restarted.data;
+    delete restarted.report;
+    delete restarted.artifact_aliases;
+    const cycle = `MRR-${input.mergeRequestId}`;
+    index.stage_runs = index.stage_runs.filter((item) => item.stage !== "code" && item.stage !== "code-review" && item.stage !== "merge");
+    index.stage_runs.push(restarted);
+    index.variables = { ...(index.variables ?? {}), "merge.source_repair": { cycle, merge_request_id: input.mergeRequestId, prepared_at: now } };
+    index.status = "running";
+    index.verdict = "merge_source_repair";
+    index.next_action = "start_code_repair";
+    index.current_stage = "code";
+    index.updated_at = now;
+    index.attempts = index.stage_runs.map((item) => ({
+        stage: item.stage,
+        attempt_number: Number((item.attempt ?? "try-001").replace("try-", "")) || 1,
+        root: item.dir,
+        archive: null,
+        status: item.status,
+        started_at: item.started_at ?? now,
+        finished_at: item.completed_at ?? null
+    }));
+    persistRunState(context, project, run, index);
+    appendAudit(context, { projectId: project.id, eventType: "flow_run.merge_source_repair_prepared", payload: { run_id: run.id, merge_request_id: input.mergeRequestId, cycle } });
+    appendRunTimeline(root, { at: now, type: "merge_source_repair_prepared", run_id: run.id, merge_request_id: input.mergeRequestId, cycle });
+    return { run_id: run.id, cycle };
 }
 function closeOpenStagesForOverride(index, status, now) {
     const stageStatus = status === "cancelled" ? "skipped" : "failed";
@@ -1018,6 +1257,10 @@ function vnextSpecifyGuidance(run, index) {
     };
 }
 function persistRunState(context, project, run, index, options = {}) {
+    // Fenced productive admission is a logical pause, even while physical work
+    // drains. Late admitted Stage results must not revive a stopped RUN.
+    if (index.status === "running" && ["draining", "sealed", "resuming"].includes(recoveryGuard(context, project.id, run.id)?.status ?? ""))
+        index.status = "paused";
     const runtimePath = run.runtime_path || projectRunJsonPath(context.ddFlowHome, project.id, run.id);
     const previousRuntime = readRuntimeSnapshot(runtimePath);
     const runtimeRevision = Math.max(index.runtime_revision ?? 0, previousRuntime?.runtime_revision ?? 0) + 1;
@@ -1028,22 +1271,30 @@ function persistRunState(context, project, run, index, options = {}) {
     }
     const persistedIndex = persistedVnextIndex(index);
     ensureDir(path.dirname(runtimePath));
-    writeJsonFile(runtimePath, runtimeSnapshotForIndex(persistedIndex, runtimeRevision, history));
-    context.db.run(`UPDATE runs
+    context.db.exec("SAVEPOINT persist_run_state");
+    try {
+        context.db.run(`UPDATE runs
      SET status = ?, verdict = ?, next_action = ?, index_json = ?, runtime_path = ?, run_index_path = ?,
        updated_at = ?, completed_at = ?
      WHERE project_id = ? AND id = ?`, [
-        index.status,
-        index.verdict,
-        index.next_action,
-        JSON.stringify(persistedIndex),
-        runtimePath,
-        runtimePath,
-        index.updated_at,
-        index.completed_at ?? null,
-        project.id,
-        run.id
-    ]);
+            index.status,
+            index.verdict,
+            index.next_action,
+            JSON.stringify(persistedIndex),
+            runtimePath,
+            runtimePath,
+            index.updated_at,
+            index.completed_at ?? null,
+            project.id,
+            run.id
+        ]);
+        writeJsonFile(runtimePath, runtimeSnapshotForIndex(persistedIndex, runtimeRevision, history));
+        context.db.exec("RELEASE persist_run_state");
+    }
+    catch (error) {
+        context.db.exec("ROLLBACK TO persist_run_state; RELEASE persist_run_state");
+        throw error;
+    }
 }
 /** vNext stores derived stage/work state only once: stage_runs, Works and Sessions. */
 function persistedVnextIndex(index) {
@@ -1085,10 +1336,15 @@ function materializedRunVariables(index) {
         ...(index.variables ?? {})
     };
 }
-function setRunVariable(context, input, value) {
+function prepareRunVariable(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = resolveRun(context, project.id, input.runId);
+    assertRunMutationAllowed(context, project.id, run.id);
     const index = authoritativeIndex(run);
+    return { project, run, index };
+}
+function setRunVariable(context, input, value, prepared = prepareRunVariable(context, input)) {
+    const { project, run, index } = prepared;
     if (index.variables?.[input.key] === value)
         return { ok: true, run_id: run.id, key: input.key, value, idempotent: true };
     index.variables = { ...(index.variables ?? {}), [input.key]: value };
@@ -1139,10 +1395,12 @@ function readRuntimeSnapshot(file) {
 function authoritativeIndex(run) {
     try {
         const state = JSON.parse(run.index_json);
+        if (!state || typeof state !== "object" || Array.isArray(state) || !Array.isArray(state.stage_runs))
+            throw new Error("RUN index must contain stage_runs");
         return { ...state, schema_id: runSchemaId };
     }
     catch (error) {
-        throw new AppError("validation", "RUN mechanical state in SQLite is missing or invalid", 2, { run_id: run.id, cause: String(error) });
+        throw new AppError("runtime_state_invalid", "RUN mechanical state in SQLite is missing or invalid", 1, { run_id: run.id, cause: String(error) });
     }
 }
 function sanitizeTimelineValue(value, key) {
@@ -1203,7 +1461,7 @@ function upsertStage(index, stageRun) {
     }
     index.stage_runs.sort((a, b) => a.order - b.order);
 }
-function resolveRun(context, projectId, idOrAlias) {
+export function resolveRun(context, projectId, idOrAlias) {
     if (isFullEntityId(idOrAlias)) {
         return requireRunById(context, projectId, idOrAlias);
     }
@@ -1297,7 +1555,7 @@ function parseStageStatus(value) {
     }
     return value;
 }
-function requiredStageDir(value) {
+export function prepareStageDirectory(value) {
     const dir = requiredPlain(value, "dir");
     if (!/^\d{2}-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(dir)) {
         throw new AppError("validation", "--dir must use NN-stage-slug format", 2, { dir });
@@ -1305,6 +1563,8 @@ function requiredStageDir(value) {
     return dir;
 }
 function requiredPlain(value, label) {
+    if (typeof value !== "string")
+        throw new AppError("validation", `${label} must be a string`, 2);
     const trimmed = value.trim();
     if (!trimmed) {
         throw new AppError("validation", `${label} must not be empty`, 2);
@@ -1312,6 +1572,8 @@ function requiredPlain(value, label) {
     return trimmed;
 }
 function normalizeSlug(value) {
+    if (typeof value !== "string")
+        throw new AppError("validation", "--slug must be a string", 2);
     const slug = value
         .normalize("NFKD")
         .replace(/[\u0300-\u036f]/g, "")
@@ -1329,26 +1591,59 @@ function resolveWorkspaceRoot(workspaceRoot) {
     if (!fs.existsSync(absolute)) {
         throw new AppError("not_found", `Workspace root does not exist: ${absolute}`, 1);
     }
+    if (!fs.statSync(absolute).isDirectory())
+        throw new AppError("validation", "Workspace root must be a directory", 2, { workspace_root: absolute });
     return fs.realpathSync(absolute);
 }
-function archiveExistingStageAttempt(runRoot, stageDir) {
+/** Move one completed stage attempt and update only known durable path columns.
+ * Receipt bytes remain immutable; readers resolve their new location through the DB. */
+export function archiveExistingStageAttempt(context, projectId, runId, runRoot, stageDir) {
     const currentStageDir = path.join(runRoot, stageDir);
     if (!fs.existsSync(currentStageDir) || !fs.statSync(currentStageDir).isDirectory()) {
         return;
     }
-    const entries = fs.readdirSync(currentStageDir).filter((entry) => !/^try-\d{3}$/.test(entry));
-    if (entries.length === 0) {
+    const journal = path.join(runRoot, `.archive-${stageDir}.json`);
+    const pending = fs.existsSync(journal) ? JSON.parse(fs.readFileSync(journal, "utf8")) : null;
+    const entries = pending?.entries ?? fs.readdirSync(currentStageDir).filter((entry) => !/^try-\d{3}$/.test(entry));
+    if (entries.length === 0 && !pending) {
         return;
     }
     let attempt = 1;
     while (fs.existsSync(path.join(currentStageDir, `try-${String(attempt).padStart(3, "0")}`))) {
         attempt += 1;
     }
-    const archiveDir = path.join(currentStageDir, `try-${String(attempt).padStart(3, "0")}`);
+    const archiveDir = pending?.archiveDir ?? path.join(currentStageDir, `try-${String(attempt).padStart(3, "0")}`);
+    if (!pending) {
+        const stored = context.db.get("SELECT index_json FROM runs WHERE project_id = ? AND id = ?", [projectId, runId]);
+        const prior = stored ? JSON.parse(stored.index_json) : null;
+        writeJsonFile(journal, { archiveDir, entries, stage_run: prior?.stage_runs.find((stage) => stage.dir === stageDir) ?? null });
+    }
     ensureDir(archiveDir);
     for (const entry of entries) {
-        fs.renameSync(path.join(currentStageDir, entry), path.join(archiveDir, entry));
+        const source = path.join(currentStageDir, entry);
+        const target = path.join(archiveDir, entry);
+        if (fs.existsSync(source)) {
+            if (fs.existsSync(target))
+                throw new AppError("archive_conflict", "Both live and archived artifact exist; preserve both for recovery", 2, { source, target });
+            fs.renameSync(source, target);
+        }
+        else if (!fs.existsSync(target))
+            throw new AppError("archive_artifact_missing", "Artifact is absent from both archive locations", 2, { source, target });
     }
+    const oldPrefix = `${currentStageDir}${path.sep}`;
+    const newPrefix = `${archiveDir}${path.sep}`;
+    const rewrite = (table, column, where, values) => {
+        context.db.run(`UPDATE ${table} SET ${column} = ? || substr(${column}, ?) WHERE ${column} LIKE ? AND substr(${column}, ?, 4) != 'try-' AND ${where}`, [newPrefix, oldPrefix.length + 1, `${oldPrefix}%`, oldPrefix.length + 1, ...values]);
+    };
+    const workScope = "work_id IN (SELECT work_id FROM works WHERE project_id = ? AND run_id = ?)";
+    rewrite("work_sessions", "prompt_path", workScope, [projectId, runId]);
+    rewrite("work_sessions", "result_path", workScope, [projectId, runId]);
+    const receiptScope = "project_id = ? AND run_id = ?";
+    for (const column of ["stdout_path", "stderr_path", "receipt_path"])
+        rewrite("check_receipts", column, receiptScope, [projectId, runId]);
+    // Retain the original stage facts with its immutable artifacts; current
+    // stage_runs stays a projection of the current attempt, not a second ledger.
+    fs.renameSync(journal, path.join(archiveDir, "archive.json"));
 }
 function writeJsonFile(file, value) {
     const tmpFile = `${file}.tmp-${process.pid}-${Date.now()}`;
@@ -1373,3 +1668,5 @@ export function gitFacts(workspaceRoot) {
         status: status === null ? "unavailable" : status.length > 0 ? "dirty" : "clean"
     };
 }
+import { assertRunMutationAllowed, assertStageSettlementAllowed, recoveryGuard } from "./run-recovery.js";
+import { runControlDirective } from "./run-control.js";