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

package/dist/services/run-control-worker.js

@@ -80,40 +80,45 @@ async function launchControlWorker(context, input) {
         fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
         const log = path.join(directory, "control.log");
         const output = fs.openSync(log, "a", 0o600);
+        let launched = null;
         try {
             const env = { ...context.env, DD_FLOW_HOME: context.ddFlowHome, DD_FLOW_RESOURCE_HOME: home, DD_FLOW_ENGINE_MODE: "1", DD_FLOW_CONTROL_TOKEN: token };
             delete env.DD_FLOW_CONTROLLER_TOKEN;
             delete env.DD_FLOW_SCOPE_CONTROL_TOKEN;
             const child = spawn(process.execPath, [entry, "run", "control", "serve", "--run", input.runId, "--project-root", project.root, "--control-id", input.controlId, "--json"], { cwd: run.workspace_root, detached: true, stdio: ["ignore", output, output], env });
             await new Promise((resolve, reject) => { child.once("spawn", resolve); child.once("error", reject); });
-            context.db.run("UPDATE run_control_operations SET receipt_json = json_set(receipt_json, '$.child', json(?)), updated_at = ? WHERE operation_id = ?", [JSON.stringify({ pid: child.pid, pid_started_at: child.pid ? processStartedAt(child.pid) : null }), context.now(), launchOperationId(input.controlId, token)]);
+            launched = { pid: child.pid, pid_started_at: child.pid ? processStartedAt(child.pid) : null };
+            context.db.run("UPDATE run_control_operations SET receipt_json = json_set(receipt_json, '$.child', json(?)), updated_at = ? WHERE operation_id = ?", [JSON.stringify(launched), context.now(), launchOperationId(input.controlId, token)]);
             child.unref();
         }
         finally {
             fs.closeSync(output);
         }
         // The detached worker is the durable owner of the stop.  Do not let the
-        // caller tear down its RUN/home before that owner has either registered
-        // its managed-process lease or recorded a startup failure.
-        await waitForControlWorkerAdmission(context, input.controlId, token);
+        // caller treat an unadmitted but physically live child as a failed owner.
+        // Its durable intent/launch identity retains the RUN while it registers.
+        await waitForControlWorkerAdmission(context, input.controlId, token, 5_000, launched);
     }
     catch (error) {
         context.db.run("UPDATE run_control_workers SET status = 'failed', error_json = ?, updated_at = ? WHERE control_id = ? AND owner_token = ? AND status = 'starting' AND owner_pid IS NULL", [JSON.stringify(failure(error)), context.now(), input.controlId, token]);
         // The durable intent remains accepted even if its worker could not start.
     }
 }
-async function waitForControlWorkerAdmission(context, controlId, ownerToken, timeoutMs = 5_000) {
+export async function waitForControlWorkerAdmission(context, controlId, ownerToken, timeoutMs = 5_000, launched = null) {
     const deadline = Date.now() + timeoutMs;
     for (;;) {
         const worker = context.db.get("SELECT status, process_id, owner_token FROM run_control_workers WHERE control_id = ?", [controlId]);
         if (!worker || worker.owner_token !== ownerToken)
-            return;
-        // A running worker without a resource lease is still in the vulnerable
-        // registration gap; keep the parent alive until that gap closes.
+            return "admitted";
+        // A running worker without a resource lease is still in the registration
+        // gap; only a physically live retained child can remain pending at expiry.
         if (worker.process_id || ["failed", "completed", "superseded"].includes(worker.status))
-            return;
-        if (Date.now() >= deadline)
-            throw new AppError("run_control_worker_start_timeout", "Control worker did not publish its managed-process lease", 1, { control_id: controlId, timeout_ms: timeoutMs });
+            return "admitted";
+        if (Date.now() >= deadline) {
+            if (launched?.pid_started_at && processIsAlive(launched))
+                return "pending";
+            throw new AppError("run_control_worker_start_timeout", "Control worker did not publish its managed-process lease and is not alive", 1, { control_id: controlId, timeout_ms: timeoutMs });
+        }
         await delay(25);
     }
 }

package/dist/services/run-controller-adapter.js

@@ -119,6 +119,15 @@ async function recoverCompletedOperation(context, manifest, session, executable,
     }
     const target = args.includes("--session-id") ? args[args.indexOf("--session-id") + 1] : null;
     const result = observed.result;
+    const primary = observed.primary_error;
+    if (observed.operation_id === operationId && observed.operation === expectedMethod(args)
+        && observed.state !== "completed" && (!target || observed.session_id === target)
+        && primary && typeof primary === "object" && !Array.isArray(primary)) {
+        const failure = primary;
+        if (typeof failure.code === "string" && typeof failure.message === "string") {
+            throw new AppError(failure.code, failure.message, 1, { ...(failure.details && typeof failure.details === "object" && !Array.isArray(failure.details) ? failure.details : {}), operation_id: operationId, effect: "unknown" });
+        }
+    }
     if (observed.operation_id !== operationId || observed.operation !== expectedMethod(args) || observed.state !== "completed"
         || !result || typeof result !== "object" || Array.isArray(result)
         || target && (observed.session_id !== target || adapterSessionId(result) !== target))

package/dist/services/runs.js

@@ -576,6 +576,7 @@ export function attachFlowRunStage(context, input) {
         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
     };
@@ -638,11 +639,13 @@ export function prepareFlowRunStageCompletion(context, input) {
 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 } : {}),

package/dist/services/runtime-scope-stop.js

@@ -42,6 +42,10 @@ export async function stopRuntimeScope(context, scopeId, requestId) {
             const receipt = await runHarnessAdapter({ executable: metadata.adapter_executable,
                 args: prior ? ["daemon", "operation", "--operation-id", operationId, "--state-dir", metadata.state_dir, "--json"] : ["daemon", "stop", "--cancel-tree", "--state-dir", metadata.state_dir, "--json"],
                 env, operationId: prior ? `${operationId}:observe` : operationId, timeoutMs: 30_000 });
+            if (prior && receipt.state === "failed" && receipt.operation_id === operationId && receipt.daemon_id === state.daemon_id) {
+                const failure = receipt.error;
+                throw new AppError(failure?.code ?? "runtime_scope_control_failed", failure?.message ?? "Native close operation failed", 1, failure?.details);
+            }
             if (prior && (receipt.operation_id !== operationId || receipt.daemon_id !== state.daemon_id || receipt.operation !== "daemon.stop" || receipt.state !== "completed"))
                 throw new AppError("runtime_scope_outcome_unknown", "Native close operation has not completed", 1);
             const result = (prior ? receipt.result : receipt);
@@ -52,10 +56,17 @@ export async function stopRuntimeScope(context, scopeId, requestId) {
             if (result?.stopped !== true || result.clean !== true || after.daemon_id !== state.daemon_id || after.shutdown_state !== "clean" || after.active_tree !== false || processTreeIsAlive(finalOwner))
                 throw new AppError("runtime_scope_not_settled", "Native close has not proved whole-tree settlement", 1);
             const processes = managedProcessStatus(context).filter(item => managedProviderBelongsToDaemon(item, finalOwner, after) && item.operation_id?.startsWith(`${owner.operation_id}:`) && !processTreeIsAlive(item)).map(item => ({ process_id: item.id, native_settled: true, binding: managedProcessBinding(item, resourceHome(context)) }));
-            return { process_id: record.id, state_dir: metadata.state_dir, settled: true, operation_id: operationId, owner_operation_id: owner.operation_id, processes };
+            return { process_id: record.id, state_dir: metadata.state_dir, settled: true, native_settled: true, physical_stopped: true, operation_id: operationId, owner_operation_id: owner.operation_id, processes };
         }
         catch (error) {
-            return { process_id: record.id, settled: false, reason: error instanceof AppError ? error.code : "runtime_scope_control_failed", message: String(error) };
+            const failure = error;
+            const native = failure.details?.cause && typeof failure.details.cause === "object" ? failure.details.cause : null;
+            const physical = await stopVerifiedNativeProcesses(context, scopeId, record);
+            const stateDir = JSON.parse(record.metadata_json).state_dir;
+            return { process_id: record.id, ...(stateDir ? { state_dir: stateDir } : {}), settled: false, native_settled: false, physical_stopped: physical.stopped,
+                reason: native?.code ?? failure.code ?? "runtime_scope_control_failed", message: native?.message ?? failure.message ?? String(error),
+                ...(native ? { cause: { code: native.code ?? null, message: native.message ?? null, details: native.details ?? null } } : {}), ...(physical.error ? { cleanup_error: physical.error } : {}),
+                ...(physical.provider ? { processes: [{ process_id: physical.provider.id, native_settled: false, binding: managedProcessBinding(physical.provider, resourceHome(context)) }] } : {}) };
         }
     }));
     const covered = new Set(nodes.map(node => node.process_id));
@@ -90,10 +101,59 @@ export async function stopRuntimeScope(context, scopeId, requestId) {
         const binding = JSON.stringify(managedProcessBinding(record, resourceHome(context)));
         const parent = nodes.find(node => node.settled && node.state_dir === metadata.state_dir && "processes" in node && node.processes?.some(item => item.process_id === record.id && item.native_settled && JSON.stringify(item.binding) === binding));
         if (parent && !processTreeIsAlive(record)) {
-            nodes.push({ process_id: record.id, state_dir: metadata.state_dir, settled: true, operation_id: parent.operation_id, owner_operation_id: parent.owner_operation_id });
+            nodes.push({ process_id: record.id, state_dir: metadata.state_dir, settled: true, physical_stopped: true, operation_id: parent.operation_id, owner_operation_id: parent.owner_operation_id });
+        }
+        else {
+            const retired = nodes.find(node => node.physical_stopped === true && node.state_dir === metadata.state_dir && node.processes?.some(item => item.process_id === record.id && JSON.stringify(item.binding) === binding));
+            if (retired && !processTreeIsAlive(record))
+                nodes.push({ process_id: record.id, ...(metadata.state_dir ? { state_dir: metadata.state_dir } : {}), settled: false, native_settled: false, physical_stopped: true, ...(retired.reason ? { reason: retired.reason } : {}) });
+            else
+                nodes.push({ process_id: record.id, settled: false, reason: "runtime_scope_resource_unsettled", message: "Resource needs its own settlement proof" });
         }
-        else
-            nodes.push({ process_id: record.id, settled: false, reason: "runtime_scope_resource_unsettled", message: "Resource needs its own settlement proof" });
     }
-    return { scope_id: scopeId, fence, settled: nodes.every(node => node.settled), nodes };
+    return { scope_id: scopeId, fence, settled: nodes.every(node => node.settled),
+        physical_stopped: nodes.every(node => node.physical_stopped === true || node.settled && node.physical_stopped !== null)
+            ? true : nodes.some(node => node.physical_stopped === null) ? null : false, nodes };
+}
+async function stopVerifiedNativeProcesses(context, scopeId, daemon) {
+    const metadata = JSON.parse(daemon.metadata_json);
+    if (!metadata.state_dir || !path.isAbsolute(metadata.state_dir))
+        return { stopped: null };
+    let state;
+    try {
+        state = JSON.parse(fs.readFileSync(path.join(metadata.state_dir, "daemon.json"), "utf8"));
+    }
+    catch {
+        return { stopped: null };
+    }
+    const owner = state.config?.runtime_owner;
+    const current = managedProcessStatus(context).find(item => item.id === daemon.id);
+    if (!owner || !current || current.lease_token !== daemon.lease_token || current.pid !== daemon.pid || current.pid_started_at !== daemon.pid_started_at
+        || !daemon.pid || !daemon.pid_started_at || owner.budget?.scope_id !== scopeId || owner.owner_id !== daemon.owner_id
+        || owner.state_dir !== metadata.state_dir || owner.role !== metadata.role || owner.adapter_executable !== metadata.adapter_executable
+        || owner.dd_flow_home !== metadata.dd_flow_home || owner.resource_home !== resourceHome(context)
+        || state.resource_process?.id !== daemon.id || state.resource_process.lease_token !== daemon.lease_token
+        || (state.pid !== daemon.pid && !(state.pid == null && state.shutdown_state === "starting")))
+        return { stopped: null };
+    const registered = managedProcessStatus(context);
+    const providers = registered.filter(item => managedProviderBelongsToDaemon(item, daemon, state));
+    const unpublished = !state.provider_process && !state.provider_pid ? registered.filter(item => {
+        const child = JSON.parse(item.metadata_json);
+        return item.kind === daemon.kind.replace(/-daemon$/, "-provider") && item.owner_id === daemon.owner_id && item.project_id === daemon.project_id && item.run_id === daemon.run_id && item.work_id === daemon.work_id
+            && item.operation_id?.startsWith(`${owner.operation_id}:`) && item.pid && item.pid_started_at && child.owner_pid === daemon.pid && child.owner_pid_started_at === daemon.pid_started_at
+            && child.state_dir === metadata.state_dir && child.role === metadata.role && child.adapter_executable === metadata.adapter_executable && child.dd_flow_home === metadata.dd_flow_home
+            && child.dispatch_barrier === "run-generation@1" && child.budget?.scope_id === scopeId;
+    }) : [];
+    const provider = providers.length === 1 ? providers[0] : unpublished.length === 1 ? unpublished[0] : undefined;
+    if (providers.length > 1 || unpublished.length > 1 || state.provider_pid && !provider || !provider && state.shutdown_state !== "starting")
+        return { stopped: null };
+    try {
+        if (provider)
+            await stopManagedProcess(context, { id: provider.id, leaseToken: provider.lease_token, force: false, graceMs: 500, reason: `scope-stop:${scopeId}` });
+        await stopManagedProcess(context, { id: daemon.id, leaseToken: daemon.lease_token, force: false, graceMs: 500, reason: `scope-stop:${scopeId}` });
+        return { stopped: !provider ? null : !processTreeIsAlive(daemon) && !processTreeIsAlive(provider), ...(provider ? { provider } : {}) };
+    }
+    catch (cleanup) {
+        return { stopped: false, ...(provider ? { provider } : {}), error: { code: cleanup.code ?? "physical_stop_failed", message: String(cleanup) } };
+    }
 }

package/dist/services/vnext-code-review.js

@@ -75,10 +75,14 @@ export function startVnextCodeReview(context, input, prepared = prepareVnextCode
         return { ok: true, resumed: true, run_id: run.id, stage, stage_status: prepared.prior, id: binding.work_session_id, prompt_path: existingPrompt, worker_prompt_markdown: prompt, ...(externalContext ? { external_context: externalContext } : {}), ...(orchestration ? { orchestration } : {}), next: { finish_command: finishCommand(context, run.id, projectRoot, path.join(root, "decision.json")) } };
     }
     const { mode, cycle, groups, batch, items, template, checks, codeReportSha256 } = prepared;
+    const aspectMapChecksums = mode.mode === "off" ? [] : fs.readdirSync(path.join(run.run_root, "03-plan"), { withFileTypes: true })
+        .filter(entry => entry.isDirectory() && fs.existsSync(path.join(run.run_root, "03-plan", entry.name, "aspect-map.json")))
+        .map(entry => ({ path: `03-plan/${entry.name}/aspect-map.json`, sha256: sha256File(path.join(run.run_root, "03-plan", entry.name, "aspect-map.json")) }))
+        .sort((a, b) => a.path.localeCompare(b.path));
     freezeFlowRunReviewMode(context, { projectRoot, runId: run.id, review: "code", mode: mode.mode, source: mode.source, reason: mode.reason });
     const promptPath = path.join(root, "stage-prompt.md");
     const reviewContextPath = path.join(root, "review-context.json");
-    fs.writeFileSync(reviewContextPath, `${JSON.stringify({ schema_id: "dd-flow/code-review-context@1", cycle, mode: mode.mode, mode_source: mode.source, mode_reason: mode.reason, ...(mode.mode !== "off" ? { read_only_input: { parent_work_id: rootWork.work_id } } : {}), code_report_sha256: codeReportSha256 }, null, 2)}\n`);
+    fs.writeFileSync(reviewContextPath, `${JSON.stringify({ schema_id: "dd-flow/code-review-context@1", cycle, mode: mode.mode, mode_source: mode.source, mode_reason: mode.reason, ...(mode.mode !== "off" ? { read_only_input: { parent_work_id: rootWork.work_id, version: 3 } } : {}), code_report_sha256: codeReportSha256, review_batch_sha256: sha256Value(`${JSON.stringify(batch, null, 2)}\n`), aspect_map_checksums: aspectMapChecksums }, null, 2)}\n`);
     if (mode.mode === "off") {
         fs.writeFileSync(path.join(root, "decision.json"), `${JSON.stringify(disabledReviewDecision(), null, 2)}\n`);
         const prompt = `<stage_identity>\n- RUN: ${run.id}\n- stage: code-review\n- mode: off\n</stage_identity>\n\nCODE-REVIEW is disabled by the frozen RUN configuration. Finish with: ${finishCommand(context, run.id, projectRoot, path.join(root, "decision.json"))}\n`;
@@ -96,7 +100,7 @@ export function startVnextCodeReview(context, input, prepared = prepareVnextCode
     const binding = bindStageCoordinatorWork(context, { workId: rootWork.work_id, hookEventId: input.hookEventId, stage, promptPath, resultPath: path.join(root, "stage-report.json"), ...(input.contextSha256 ? { contextSha256: input.contextSha256 } : {}) });
     const registered = addWorkBatch(context, { parentWorkId: rootWork.work_id, value: batch, prepared: items, stage, cycle });
     const orchestration = writeFanoutDescriptor(root, { stage, parent_work_id: rootWork.work_id, dispatch: "none", capacity_required: true, scope: stageGraphScope(context, project.id, run.id, stage) });
-    attachFlowRunStage(context, { projectRoot, runId: run.id, stage, dir: stageDir, status: "running", dataSchemaId: "dd-flow/stage-report@1" });
+    attachFlowRunStage(context, { projectRoot, runId: run.id, stage, dir: stageDir, status: "running", dataSchemaId: "dd-flow/stage-report@1", inputSha256: sha256Value(JSON.stringify({ batch: sha256File(batchFile), aspect_maps: aspectMapChecksums })) });
     appendFlowRunTimelineEvent(context, project.id, run.id, { type: "code_review_started", work_id: rootWork.work_id, mode: mode.mode, mode_source: mode.source, groups, registered });
     return { ok: true, run_id: run.id, stage, mode: mode.mode, mode_source: mode.source, id: binding.work_session_id, prompt_path: promptPath, worker_prompt_markdown: fs.readFileSync(promptPath, "utf8"), ...(externalContext ? { external_context: externalContext } : {}), orchestration, review: { groups, works: registered }, next: { finish_command: finishCommand(context, run.id, projectRoot, path.join(root, "decision.json")) } };
 }

package/dist/services/vnext-code.js

@@ -502,6 +502,7 @@ function coordinatorPrompt(context, input) {
         `- RUN: ${input.run.id}`,
         `- root Work: ${input.rootWork.work_id}`,
         "- stage: code",
+        "Before any project edit, change into the immutable write workspace shown below with cd --. Write only that workspace and the named CODE verification artifacts under the stage workspace; never another RUN/native home or Git/worktree control data.",
         "</stage_identity>",
         "",
         "<trusted_runtime_context>",

package/dist/services/vnext-fanout.js

@@ -124,6 +124,10 @@ export async function reconcileVnextFanout(context, input) {
     const parent = storageSessionId({ harness_id: value.harness_id, session_id: value.parent_session_id });
     const issues = [], reconciled = [];
     for (const child of value.children) {
+        if (child.provenance === "parent_mismatch" || child.parent_session_id !== undefined && child.parent_session_id !== value.parent_session_id) {
+            issues.push({ code: "native_child_parent_mismatch", session_id: child.session_id, observed_parent_session_id: child.parent_session_id ?? null, expected_parent_session_id: value.parent_session_id, outcome: child.status });
+            continue;
+        }
         if (child.status === "running" || child.status === "unknown")
             continue;
         const sessionId = storageSessionId({ harness_id: value.harness_id, session_id: String(child.session_id) });
@@ -182,7 +186,7 @@ export async function reconcileVnextFanout(context, input) {
 export function prepareNativeObservations(observations) {
     const value = observations;
     if (!value || typeof value.harness_id !== "string" || !value.harness_id.trim() || typeof value.parent_session_id !== "string" || !value.parent_session_id.trim() || !Array.isArray(value.children)
-        || value.children.some(child => !child || typeof child.session_id !== "string" || !child.session_id.trim() || typeof child.status !== "string" || !["running", "unknown", "completed", "failed", "cancelled", "settled_by_root"].includes(child.status)))
+        || value.children.some(child => !child || typeof child.session_id !== "string" || !child.session_id.trim() || typeof child.status !== "string" || !["running", "unknown", "completed", "failed", "cancelled", "settled_by_root"].includes(child.status) || child.parent_session_id !== undefined && typeof child.parent_session_id !== "string" || child.provenance !== undefined && !["root_child", "parent_mismatch"].includes(String(child.provenance))))
         throw new AppError("usage", "Expected native observations: harness_id, parent_session_id and children[{session_id,status}]", 2);
     if (new Set(value.children.map(child => child.session_id)).size !== value.children.length)
         throw new AppError("usage", "Native observations must contain each child Session exactly once", 2);
@@ -194,6 +198,10 @@ export function observeVnextNativeChildren(context, input) {
     const parent = storageSessionId({ harness_id: value.harness_id, session_id: value.parent_session_id });
     const issues = [], history = [], pending = [];
     for (const child of value.children) {
+        if (child.provenance === "parent_mismatch" || child.parent_session_id !== undefined && child.parent_session_id !== value.parent_session_id) {
+            issues.push({ code: "native_child_parent_mismatch", session_id: child.session_id, observed_parent_session_id: child.parent_session_id ?? null, expected_parent_session_id: value.parent_session_id, outcome: child.status, detected_at_stage: input.stage });
+            continue;
+        }
         const sessionId = storageSessionId({ harness_id: value.harness_id, session_id: String(child.session_id) });
         const links = context.db.all(`SELECT ws.id, ws.work_id, ws.status, w.status AS work_status, w.parent_work_id, s.current_stage
          FROM work_sessions ws JOIN works w ON w.work_id = ws.work_id

package/dist/services/vnext-merge.js

@@ -16,7 +16,7 @@ import { runtimeCommand, checkRetryArgs, recoveryEvidenceInput } from "./runtime
 import { writeStageReport } from "./stage-report-renderer.js";
 import { bindStageCoordinatorWork, createChildWork, failWork, finishFanInWork, finishWork, refreshRunWorkProjection, startStageCoordinatorWork } from "./work-registry.js";
 import { addVnextCodeRepair } from "./vnext-code.js";
-import { checkReceiptEvidenceValid, checkReceipts, effectiveCheckDeclarations, readCodeCheckProfile, runCodeChecks, validateFailedCheckRetry, workspaceChangedPaths, workspaceFingerprint } from "./code-checks.js";
+import { checkReceiptEvidenceValid, checkReceipts, codeCheckProfileHash, effectiveCheckDeclarations, runCodeChecks, validateFailedCheckRetry, workspaceChangedPaths, workspaceFingerprint } from "./code-checks.js";
 import { applyExternalStageContext, prepareExternalStageContext } from "./stage-context.js";
 import { ensureLaneWorkspace, prepareLaneWorkspace, heartbeatLaneLock, releaseLaneLock, waitAcquireLaneLock } from "./lanes.js";
 import { assertRunMutationAllowed } from "./run-recovery.js";
@@ -67,7 +67,7 @@ export function prepareVnextMergeRequest(context, input) {
     const freezeFile = path.join(freezeRoot, "source-freeze.json");
     const gateFile = path.join(freezeRoot, "merge-gate.json");
     fs.mkdirSync(freezeRoot, { recursive: true });
-    freezeMergeGate(gateFile, { runId: run.id, protocols, checks: effective, acceptanceRefs, profileHash: readCodeCheckProfile(targetWorkspace).hash, now: context.now() });
+    freezeMergeGate(gateFile, { runId: run.id, protocols, checks: effective, acceptanceRefs, profileHash: codeCheckProfileHash(targetWorkspace, effective), now: context.now() });
     let sourceCommit;
     let sourcePaths;
     if (fs.existsSync(freezeFile)) {
@@ -105,7 +105,7 @@ export function prepareVnextMergeRequest(context, input) {
             return requestView(context, raced);
         const child = createChildWork(context, { parentWorkId: root.work_id, stage: "merge", slug: "merge", task: `Integrate frozen source ${sourceCommit} into ${targetBranch}, resolve material conflicts, and preserve accepted behavior.`, launchPolicy: route === "server" ? "fresh_agent_required" : "reuse_allowed", resultSchema: "dd-flow/merge-result@1", payload: { kind: "merge", checks: semantic, protocol_ids: protocols } });
         const requestId = nextMergeRequestId(context);
-        context.db.run("INSERT INTO merge_requests (merge_request_id, project_id, run_id, executor_work_id, protocol_ids_json, source_workspace, source_branch, source_commit, target_workspace, target_branch, enqueue_target_head, execution_target_head, integration_commit, execution_route, status, dispatch_owner, dispatch_lease_token, dispatch_lease_expires_at, lock_acquired_at, checkpoint, profile_hash, replacement_of_merge_request_id, adapter_receipt_json, result_json, last_error_json, created_at, updated_at, completed_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, 'queued', NULL, NULL, NULL, NULL, 'queued', ?, ?, NULL, NULL, NULL, ?, ?, NULL)", [requestId, project.id, run.id, child.work_id, JSON.stringify(protocols), run.workspace_root, sourceBranch, sourceCommit, targetWorkspace, targetBranch, enqueueTarget, route, readCodeCheckProfile(targetWorkspace).hash, replacementOf(run), now, now]);
+        context.db.run("INSERT INTO merge_requests (merge_request_id, project_id, run_id, executor_work_id, protocol_ids_json, source_workspace, source_branch, source_commit, target_workspace, target_branch, enqueue_target_head, execution_target_head, integration_commit, execution_route, status, dispatch_owner, dispatch_lease_token, dispatch_lease_expires_at, lock_acquired_at, checkpoint, profile_hash, replacement_of_merge_request_id, adapter_receipt_json, result_json, last_error_json, created_at, updated_at, completed_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, 'queued', NULL, NULL, NULL, NULL, 'queued', ?, ?, NULL, NULL, NULL, ?, ?, NULL)", [requestId, project.id, run.id, child.work_id, JSON.stringify(protocols), run.workspace_root, sourceBranch, sourceCommit, targetWorkspace, targetBranch, enqueueTarget, route, codeCheckProfileHash(targetWorkspace, effective), replacementOf(run), now, now]);
         appendFlowRunTimelineEvent(context, project.id, run.id, { type: "merge_request_queued", merge_request_id: requestId, work_id: child.work_id, route, source_commit: sourceCommit, target_branch: targetBranch });
         return requestView(context, requireRequest(context, requestId));
     });
@@ -532,7 +532,11 @@ function commitPendingSource(cwd, runId, ignored) { const paths = meaningfulStat
 function commitIntegration(cwd, runId, ignored) { const mergeHead = fs.existsSync(path.join(gitDirectory(cwd), "MERGE_HEAD")); const paths = meaningfulStatus(cwd, ignored); if (!mergeHead && !paths.length)
     return; if (paths.length)
     git(cwd, ["add", "-A", "--", ...paths]); git(cwd, ["commit", "-m", `merge(${runId.toLowerCase()}): integrate accepted source`]); }
-function ignoredGitPaths(context, projectId) { return [readProjectConfig(context, projectId).dashboard.markdown_path.replaceAll("\\", "/")]; }
+function ignoredGitPaths(context, projectId) {
+    // Shared workspace classification omits only the exact untracked qualified
+    // hook. Tracked or mixed user hooks remain ordinary product changes.
+    return [readProjectConfig(context, projectId).dashboard.markdown_path.replaceAll("\\", "/")];
+}
 function meaningfulStatus(cwd, ignored) { return workspaceChangedPaths(cwd).filter((item) => !ignored.includes(item)); }
 function unmerged(cwd) { const value = gitValue(cwd, ["diff", "--name-only", "--diff-filter=U"], true); return value.split(/\r?\n/).filter(Boolean); }
 function gitDirectory(cwd) { const value = gitValue(cwd, ["rev-parse", "--git-dir"]); return path.resolve(cwd, value); }

package/dist/services/vnext-plan-review.js

@@ -146,7 +146,7 @@ export function startVnextPlanReview(context, input, prepared = prepareVnextPlan
     const workSessionId = String(binding.work_session_id);
     const sessionId = String(binding.session_id);
     const orchestration = writeFanoutDescriptor(root, { stage, parent_work_id: workId, dispatch: "plan-review", capacity_required: true, scope: stageGraphScope(context, project.id, run.id, stage) });
-    writeJson(path.join(root, "work-context.json"), { schema_id: "dd-flow/plan-review-context@1", read_only_input: { parent_work_id: workId }, system: { run_id: run.id, work_id: workId, stage, requested_mode: requested, effective_mode: effective, plan_revision: prepared.revision, plan_checksum: planChecksum, batch_checksum: batchChecksum }, groups, workspace: { project_root: projectRoot, workspace_root: run.workspace_root, stage_root: root, plan_root: planRoot } });
+    writeJson(path.join(root, "work-context.json"), { schema_id: "dd-flow/plan-review-context@1", read_only_input: { parent_work_id: workId, version: 3 }, system: { run_id: run.id, work_id: workId, stage, requested_mode: requested, effective_mode: effective, plan_revision: prepared.revision, plan_checksum: planChecksum, batch_checksum: batchChecksum }, groups, workspace: { project_root: projectRoot, workspace_root: run.workspace_root, stage_root: root, plan_root: planRoot } });
     refreshRunWorkProjection(context, project.id, run.id);
     appendFlowRunTimelineEvent(context, project.id, run.id, { type: "work_session_started", stage, work_id: workId, id: workSessionId, session_id: sessionId });
     return { ok: true, run_id: run.id, stage, outcome: "review_required", work_id: workId, id: workSessionId, prompt_path: promptPath, worker_prompt_markdown: fs.readFileSync(promptPath, "utf8"), ...(externalContext ? { external_context: externalContext } : {}), orchestration, plan_review: { requested_mode: requested, effective_mode: effective, policy_source: policySource(run), groups }, next: { dispatch_command: dispatchCommand(context, run.id, projectRoot), finish_command: finishCommand(context, run.id, projectRoot, path.join(root, "decision.json")) } };
@@ -242,11 +242,11 @@ function finishPlanReviewOwned(context, input) {
     if (decision.outcome === "blocked") {
         throw new AppError("stage_pause_required", "A user or decision blocker must pause the current PLAN-REVIEW Work with `dd-flow stage pause`; do not finish the stage as blocked", 2, { run_id: run.id, stage, work_id: parent.work_id });
     }
+    if (children.some((child) => !["completed", "failed", "cancelled"].includes(child.status)))
+        throw new AppError("worker_jobs_incomplete", "PLAN-REVIEW finish requires all reviewer Works to settle", 1, { works: children.map((child) => ({ work_id: child.work_id, status: child.status })) });
     if (["failed", "cancelled"].includes(decision.outcome)) {
-        return withStageSettlement(context, () => { preserveDecisionReceipt(root, decision, input.decisionText); return finishTerminalReview(context, { projectRoot, projectId: project.id, run, root, planRoot, batch, parentWorkId: parent.work_id, children, contextFile, decision }); });
+        return withStageSettlement(context, () => { preserveDecisionReceipt(root, decision, input.decisionText); return finishTerminalReview(context, { projectRoot, projectId: project.id, run, root, planRoot, batch, parentWorkId: parent.work_id, contextFile, decision }); });
     }
-    if (children.some((child) => child.status === "created" || child.status === "running"))
-        throw new AppError("worker_jobs_incomplete", "PLAN-REVIEW finish requires all reviewer Works to settle", 1, { works: children.map((child) => ({ work_id: child.work_id, status: child.status })) });
     const latestChildren = latestReviewChildren(children);
     const evidenceFailures = reviewerEvidenceFailures(context, { projectId: project.id, parentWorkId: parent.work_id, children: latestChildren, groups, planRevision: reviewedPlanRevision, workspaceRoot: run.workspace_root, runHome: home, runId: run.id });
     if (evidenceFailures.length)
@@ -508,10 +508,6 @@ function settleReviewParent(context, input) {
 function finishTerminalReview(context, input) {
     const now = context.now();
     const childStatus = input.decision.outcome === "cancelled" ? "cancelled" : "failed";
-    // A terminal decision is structured cancellation of the review subtree. It
-    // must settle semantic reviewers before its parent Work can settle; otherwise
-    // the RUN contains abandoned active Work/Session links.
-    settleReviewChildren(context, { projectId: input.projectId, runId: input.run.id, parentWorkId: input.parentWorkId, status: childStatus, reason: `PLAN-REVIEW terminal decision: ${input.decision.summary}`, now });
     settleReviewParent(context, { projectRoot: input.projectRoot, projectId: input.projectId, runId: input.run.id, parentWorkId: input.parentWorkId, status: childStatus, result: input.decision.summary, reason: `plan_review_${input.decision.outcome}`, resultPath: path.join(input.root, "stage-report.json") });
     const rootWork = rootWorkId(context, input.projectId, input.run.id);
     context.db.run("UPDATE works SET status = ?, result = ?, completed_at = ?, updated_at = ? WHERE work_id = ? AND status = 'running'", [childStatus, input.decision.summary, now, now, rootWork]);
@@ -526,13 +522,6 @@ function finishTerminalReview(context, input) {
     appendFlowRunTimelineEvent(context, input.projectId, input.run.id, { type: "plan_review_terminal", outcome: input.decision.outcome, work_id: input.parentWorkId });
     return { ok: true, run_id: input.run.id, stage, outcome: input.decision.outcome, next_action: "resolve_plan_review_blocker" };
 }
-function settleReviewChildren(context, input) {
-    const active = context.db.all("SELECT work_id FROM works WHERE project_id = ? AND run_id = ? AND parent_work_id = ? AND status IN ('created', 'running')", [input.projectId, input.runId, input.parentWorkId]);
-    for (const child of active) {
-        context.db.run("UPDATE works SET status = ?, result = ?, completed_at = ?, updated_at = ? WHERE work_id = ?", [input.status, input.reason, input.now, input.now, child.work_id]);
-        closeRunningWorkSession(context, child.work_id, input.status, input.now);
-    }
-}
 function closeRunningWorkSession(context, workId, status, now) {
     context.db.run("UPDATE work_sessions SET status = ?, completed_at = ?, updated_at = ? WHERE work_id = ? AND status = 'running'", [status, now, now, workId]);
 }

package/dist/services/vnext-plan.js

@@ -168,6 +168,10 @@ function finishVnextPlanOwned(context, input) {
     refreshRunWorkProjection(context, project.id, run.id);
     const reviewCommand = managedLifecycleCommand(context, `${flowCommand(context)} stage start ${run.id} --stage plan-review --project-root ${JSON.stringify(projectRoot)} --json`);
     const report = { schema_id: "dd-flow/stage-report@1", run_id: run.id, stage: "plan", generated_at: now, verdict: "done", semantic: { result: `Accepted ${protocols.length} executable PLAN artifact${protocols.length === 1 ? "" : "s"}.`, acceptance: protocols, changed_files: [...planFiles.map((file) => path.relative(projectRoot, file)), ...mapFiles.map((file) => runRef(run.id, home, file)), runRef(run.id, home, batch)], checks: ["protocol-plan schema", "aspect-map schema", "cross-artifact references", "generated CODE batch"], evidence: [runRef(run.id, home, path.join(root, "stage-report.json"))], next_action: "start_plan_review", plans: planFiles.map((file) => path.relative(projectRoot, file)), aspect_maps: mapFiles.map((file) => runRef(run.id, home, file)), code_work_batch: runRef(run.id, home, batch), batch_checksum: batchChecksum }, mechanical: { started_at: stageStartedAt(home, now), finished_at: now, wall_clock_ms: Math.max(0, Date.parse(now) - Date.parse(stageStartedAt(home, now))), git: gitFacts(run.workspace_root), session_stats_command: `${flowCommand(context)} stat run sessions ls --run ${run.id} --project-root ${JSON.stringify(projectRoot)} --json`, usage_stats_command: `${flowCommand(context)} stat usage --run ${run.id} --project-root ${JSON.stringify(projectRoot)} --json`, next_command: reviewCommand }, artifacts: { json: "stage-report.json", markdown: "stage-report.md", html: "stage-report.html", summary: "stage-report.md" }, validation: { permission_scope: "known_targets_only", memory_bank_scope: "changed_files_and_links_only", status: "passed" } };
+    Object.assign(report.semantic, {
+        plan_checksums: planFiles.map((file) => ({ path: path.relative(run.workspace_root, file).split(path.sep).join("/"), sha256: checksum(file) })),
+        aspect_map_checksums: mapFiles.map((file) => ({ path: path.relative(home, file).split(path.sep).join("/"), sha256: checksum(file) }))
+    });
     const reportJson = writeStageReport(root, report).json;
     validateSchema({ schemaName: "stage-report", file: reportJson, projectRoot, ddFlowHome: context.ddFlowHome, runId: run.id, runRoot: home });
     completeFlowRunStage(context, { projectRoot, runId: run.id, stage: "plan", status: "done", data: "stage-report.json", dataSchemaId: "dd-flow/stage-report@1", report: "stage-report.md", stageReport: "stage-report.html" });

package/dist/services/vnext-protocolize.js

@@ -76,10 +76,12 @@ export function prepareVnextProtocolize(context, input, prepared = prepareVnextP
         writeJson(resultPath, resultTemplate(obligations));
     const pauseCommand = stagePauseCommand(context, { runId: run.id, stage, workId: work.work_id, projectRoot });
     const prompt = renderPrompt({ projectRoot, runId: run.id, workId: work.work_id, specifyPath, obligations, resultPath, handoff: input.handoff, catalog: projectCatalog, policy, template, pauseCommand, pauseCommandTemplate: stagePauseCommandTemplate(pauseCommand), finishCommand: managedLifecycleCommand(context, `${flowCommand(context)} stage finish ${run.id} --stage protocolize --project-root ${JSON.stringify(projectRoot)} --result-file ${JSON.stringify(resultPath)} --json`) });
-    fs.writeFileSync(promptPath, prompt);
+    const workspaceContract = ["<workspace_contract>", `- stage artifact directory: ${stageRoot}`, `- project workspace: ${policy.worktree_path ?? projectRoot}`, `- project root (read-only identity): ${projectRoot}`, `Before editing the result, change into the project workspace: cd -- ${JSON.stringify(policy.worktree_path ?? projectRoot)}. Write only the named result file in the stage artifact directory; do not write project files, another RUN, another native home, branches, worktrees or Git commits.`, "The CLI performs all protocol document materialization after the result is accepted.", "</workspace_contract>"].join("\n");
+    const promptWithWorkspaceContract = prompt.replace("</work_context>", `</work_context>\n\n${workspaceContract}`);
+    fs.writeFileSync(promptPath, promptWithWorkspaceContract);
     // Packet publication does not itself bind a Session or open the Stage.
     appendFlowRunTimelineEvent(context, project.id, run.id, { type: "stage_prepared", work_id: work.work_id, stage, handoff_mode: input.handoff.stage_handoff.effective });
-    const directive = input.handoff.stage_handoff.effective === "same_session" ? { kind: "continue_current_session", stage, prompt_path: promptPath, worker_prompt_markdown: prompt } : { kind: "await_new_session", stage, work_id: work.work_id, prompt_path: promptPath, resume_command: managedLifecycleCommand(context, `${flowCommand(context)} stage start ${run.id} --stage protocolize --project-root ${JSON.stringify(projectRoot)} --json`) };
+    const directive = input.handoff.stage_handoff.effective === "same_session" ? { kind: "continue_current_session", stage, prompt_path: promptPath, worker_prompt_markdown: promptWithWorkspaceContract } : { kind: "await_new_session", stage, work_id: work.work_id, prompt_path: promptPath, resume_command: managedLifecycleCommand(context, `${flowCommand(context)} stage start ${run.id} --stage protocolize --project-root ${JSON.stringify(projectRoot)} --json`) };
     return { directive, prompt_path: promptPath };
 }
 export function prepareVnextProtocolizeStart(context, input) {

package/dist/services/vnext-specify.js

@@ -383,6 +383,13 @@ function renderPrompt(input) {
         "```",
         "</trusted_runtime_context>",
         "",
+        "<workspace_contract>",
+        `- authoritative SPECIFY artifact directory: ${input.stageRoot}`,
+        `- result file to write: ${input.resultPath}`,
+        `- project root is read-only grounding for this Work: ${input.projectRoot}`,
+        "Write only the named result and stage-local artifacts. Do not switch cwd, create a worktree, or write another RUN/native home.",
+        "</workspace_contract>",
+        "",
         "<eval_input_boundary>",
         "Use only this prompt, the current project root, this stage workspace and project files reached through the supplied grounding. Do not read or search another RUN, transcript, prior result, reviewer material or other project under ~/.dd-flow or ~/.codex.",
         "If stage finish rejects the result, correct this same JSON result only from the returned validation error. Do not seek another schema or example outside this stage workspace.",