@deksden-com/dd-flow-cli 0.9.0-beta.144 → 0.9.0-beta.149

package/dist/services/run-recovery.js

@@ -1,5 +1,6 @@
 import { hasLifecyclePacketAssignments, managedLifecycleCommand, recoverLifecycleCommands } from "./lifecycle-invocations.js";
-import { recoveryGuard, assertRunMutationAllowed } from "./run-recovery-guard.js";
+import { recoveryGuard, recoveryPacketReceipt } from "./run-recovery-guard.js";
+export { assertStageSettlementAllowed, assertWorkSettlementAllowed, recoveryPacketReceipt } from "./run-recovery-guard.js";
 export { recoveryGuard, assertRunMutationAllowed, assertRunRecoveryAllowed } from "./run-recovery-guard.js";
 import crypto from "node:crypto";
 import fs from "node:fs";
@@ -19,11 +20,6 @@ import { findRecentMatchingHookEvent, hookSessionIdentity, recoveryAcceptMatchKe
 import { flowCommand } from "./stage-pause.js";
 import { materializePendingWorkResults } from "./work-registry.js";
 import { currentStagePrompt } from "./stage-context.js";
-export function recoveryPacketReceipt(binding) {
-    if (!binding.packet_json || !binding.packet_sha256 || crypto.createHash("sha256").update(binding.packet_json).digest("hex") !== binding.packet_sha256)
-        throw new AppError("recovery_packet_missing", "Recovery requires its original verified Work packet", 1);
-    return { packet_json: binding.packet_json, packet_sha256: binding.packet_sha256, packet: JSON.parse(binding.packet_json) };
-}
 /** Read-only custody permission for one prepared recovery ACK, not lifecycle admission. */
 export class PreparedRecoveryCoordinatorRead {
     #scope;
@@ -90,12 +86,16 @@ export function recoveredCoordinatorBinding(original, input) {
 export function capturedStageDelivery(capture, scope, originalPrompt) {
     const db = new DatabaseSync(path.join(capture, "runtime", "db.sqlite"), { readOnly: true });
     try {
+        const resumed = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='audit_events'").get()
+            ? db.prepare("SELECT json_extract(payload_json, '$.pause_id') AS pause_id FROM audit_events WHERE event_type = 'flow_run.stage_resumed' AND json_extract(payload_json, '$.run_id') = ? AND json_extract(payload_json, '$.work_id') = ? AND json_extract(payload_json, '$.stage') = ? ORDER BY id DESC LIMIT 1").get(scope.runId, scope.workId, scope.stage) : undefined;
         const rows = db.prepare("SELECT command, outcome_json FROM lifecycle_invocations WHERE status = 'settled' AND json_extract(scope_json, '$.projectRoot') = ? AND json_extract(scope_json, '$.runId') = ? AND json_extract(scope_json, '$.rootSessionId') = ? AND json_extract(scope_json, '$.generation') < ? ORDER BY rowid DESC").all(scope.projectRoot, scope.runId, scope.sessionId, scope.generation);
         for (const row of rows) {
             const result = row.outcome_json ? JSON.parse(row.outcome_json).result : null;
             const parsed = parseLifecycleCommand(row.command);
-            if (parsed.kind === "none" || !parsed.supported || parsed.invocation.operation !== "stage_start" || parsed.invocation.args.options.get("stage")?.[0] !== scope.stage
-                || result?.stage !== scope.stage || result.attempt !== scope.attempt || result.work_id !== scope.workId || typeof result.worker_prompt_markdown !== "string")
+            if (parsed.kind === "none" || !parsed.supported || !["stage_start", "stage_resume"].includes(parsed.invocation.operation) || parsed.invocation.args.options.get("stage")?.[0] !== scope.stage
+                || result?.stage !== scope.stage || parsed.invocation.operation === "stage_start" && result.attempt !== scope.attempt || result.work_id !== scope.workId || typeof result.worker_prompt_markdown !== "string")
+                continue;
+            if (resumed && (parsed.invocation.operation !== "stage_resume" || result.pause_id !== resumed.pause_id))
                 continue;
             const text = result.worker_prompt_markdown;
             if (!text.startsWith(originalPrompt))
@@ -105,6 +105,8 @@ export function capturedStageDelivery(capture, scope, originalPrompt) {
                 throw new AppError("recovery_packet_missing", "Captured Stage delivery has no committed lifecycle assignment", 1);
             return { text, sha256 };
         }
+        if (resumed)
+            throw new AppError("recovery_packet_missing", "Accepted HITL answer has no captured settled current delivery; reconcile its retained resume receipt, never fall back to the pre-answer prompt", 1, { work_id: scope.workId, pause_id: resumed.pause_id });
         return null;
     }
     finally {
@@ -174,42 +176,7 @@ export function prepareRecoveryPayload(value, label) {
         throw new AppError("recovery_not_settled", "Recovery capture requires an explicit settled tree receipt", 1);
     return payload;
 }
-/** A cooperative drain permits only the WorkSession present at its fence. */
-export function assertWorkSettlementAllowed(context, projectId, runId, workId) {
-    const guard = recoveryGuard(context, projectId, runId);
-    if (guard?.status === "draining" && context.db.get("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'run_controls'")) {
-        const admission = context.db.get("SELECT a.work_session_id FROM run_control_admissions a JOIN run_controls c ON c.control_id = a.control_id JOIN work_sessions ws ON ws.id = a.work_session_id JOIN works w ON w.work_id = a.work_id WHERE c.project_id = ? AND c.run_id = ? AND c.recovery_id = ? AND c.action = 'pause' AND c.status = 'requested' AND a.work_id = ? AND ws.work_id = a.work_id AND ws.session_id = a.session_id AND ws.status = 'running' AND w.status = 'running' AND w.project_id = c.project_id AND w.run_id = c.run_id LIMIT 1", [projectId, runId, guard.recovery_id, workId]);
-        if (admission)
-            return;
-    }
-    assertRunMutationAllowed(context, projectId, runId);
-}
-/** Completion rights are pinned to the Stage attempt present at the pause fence. */
-export function assertStageSettlementAllowed(context, projectId, runId, stage, expectedGeneration) {
-    const guard = recoveryGuard(context, projectId, runId);
-    const generation = guard?.generation ?? 0;
-    if (expectedGeneration !== undefined && generation !== expectedGeneration)
-        throw new AppError("run_recovery_generation_stale", "RUN execution generation changed while the operation was in flight", 1, { run_id: runId, expected_generation: expectedGeneration, generation });
-    if (guard?.status === "draining" && context.db.get("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'run_control_stage_admissions'")) {
-        const admitted = context.db.get(`SELECT a.work_session_id FROM run_control_stage_admissions a JOIN run_controls c ON c.control_id = a.control_id JOIN run_control_admissions w ON w.control_id = a.control_id AND w.work_session_id = a.work_session_id JOIN work_sessions ws ON ws.id = w.work_session_id JOIN runs r ON r.project_id = c.project_id AND r.id = c.run_id, json_each(r.index_json, '$.stage_runs') live
-      WHERE c.project_id = ? AND c.run_id = ? AND c.recovery_id = ? AND c.action = 'pause' AND c.status = 'requested' AND a.stage = ? AND json_extract(live.value, '$.stage') = a.stage AND COALESCE(json_extract(live.value, '$.attempt'), 'try-001') = a.attempt AND ws.work_id = w.work_id AND ws.session_id = w.session_id AND NOT EXISTS (SELECT 1 FROM work_sessions newer WHERE newer.work_id = w.work_id AND newer.status = 'running' AND newer.id <> ws.id) LIMIT 1`, [projectId, runId, guard.recovery_id, stage]);
-        if (admitted)
-            return generation;
-    }
-    return assertRunMutationAllowed(context, projectId, runId, expectedGeneration);
-}
-/** A recovered RUN never grants the retired process a new execution segment. */
-export function assertRecoveryHookCurrent(context, projectId, runId, identity) {
-    const generation = assertRunMutationAllowed(context, projectId, runId);
-    if (!generation)
-        return;
-    const current = identity.daemonId && context.db.get("SELECT b.recovery_id FROM run_recovery_bindings b JOIN run_recovery_guards g ON g.recovery_id = b.recovery_id WHERE g.project_id = ? AND g.run_id = ? AND g.generation = ? AND g.status = 'recovered' AND b.status = 'accepted' AND b.daemon_id = ? LIMIT 1", [projectId, runId, generation, identity.daemonId]);
-    if (current)
-        return;
-    const retired = identity.daemonId && (context.db.get(`SELECT ws.id FROM work_sessions ws JOIN works w ON w.work_id = ws.work_id JOIN hook_events he ON he.project_id = w.project_id AND he.event_key = ws.hook_event_id WHERE w.project_id = ? AND w.run_id = ? AND he.daemon_id = ? LIMIT 1`, [projectId, runId, identity.daemonId]) || context.db.get("SELECT b.recovery_id FROM run_recovery_bindings b JOIN run_recovery_guards g ON g.recovery_id = b.recovery_id WHERE g.project_id = ? AND g.run_id = ? AND b.daemon_id = ? AND (g.generation <> ? OR b.status = 'abandoned') LIMIT 1", [projectId, runId, identity.daemonId, generation]));
-    if (!identity.daemonId || retired)
-        throw new AppError("recovery_daemon_stale", "Lifecycle receipt belongs to an unidentified or retired recovery daemon", 1, { run_id: runId, generation, daemon_id: identity.daemonId });
-}
+export { assertRecoveryHookCurrent } from "./hook-recovery-guard.js";
 export function beginRunRecovery(context, input, interruption = prepareRecoveryPayload(input.interruption, "interruption")) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const run = requireRecoveryRun(context, project.id, input.runId);

package/dist/services/run-start-custody.js

@@ -1,8 +1,12 @@
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { AppError } from "../shared/errors.js";
-import { hybridDigest } from "./hybrid-contracts.js";
+import { hybridDigest } from "./hybrid-digest.js";
+import { runContextRelocations, projectPacketLocators } from "./stage-context.js";
 export const runStartPayloadLimit = 64 * 1024 * 1024;
+// One exact immutable payload per database, not cached custody or returned
+// objects. Every read still checks current SQL hashes, markers and receipts.
+const validatedPayloadBytes = new WeakMap();
 export function runStartBytesSha256(bytes) { return createHash("sha256").update(bytes).digest("hex"); }
 export function refuseRunStart(reason) {
     throw new AppError("run_start_custody_invalid", "RUN creation requires its exact retained request", 1, { reason, effect: "no_effect", next_action: "reconcile_exact_request" });
@@ -59,8 +63,11 @@ export function validateRunStartPayload(value) {
                 || !entry.path || entry.path.includes("\\") || entry.path.includes("\0") || entry.path.split("/").some(part => !part || part === "." || part === "..")
                 || seen.has(entry.path) || !canonicalBase64(entry.base64))
                 refuseRunStart("invalid_allocation_assets");
-            if (key === "artifacts" && (!["engine-binding.json", "operational-policy.source.md", "operational-contract.json"].includes(entry.path)
-                || Buffer.from(entry.base64, "base64").length > 1024 * 1024))
+            const upgradeEvidence = value.initial_index.flow_kind === "mb-upgrade" && (["upgrade-baseline.json", "upgrade-target.json"].includes(entry.path)
+                || entry.path === `upgrade-target-${runStartBytesSha256(Buffer.from(entry.base64, "base64"))}.bin`
+                || entry.path === `upgrade-baseline-${runStartBytesSha256(Buffer.from(entry.base64, "base64"))}.bin`);
+            if (key === "artifacts" && (!["engine-binding.json", "operational-policy.source.md", "operational-contract.json"].includes(entry.path) && !upgradeEvidence
+                || Buffer.from(entry.base64, "base64").length > (upgradeEvidence ? 16 : 1) * 1024 * 1024))
                 refuseRunStart("invalid_allocation_artifact");
             seen.add(entry.path);
         }
@@ -96,7 +103,10 @@ function readRunStartRequestSnapshot(context, projectId, requestId) {
     catch {
         return refuseRunStart("invalid_allocation_json");
     }
-    validateRunStartPayload(payload);
+    if (validatedPayloadBytes.get(context.db) !== row.payload_json) {
+        validateRunStartPayload(payload);
+        validatedPayloadBytes.set(context.db, row.payload_json);
+    }
     if (!object(receipt))
         refuseRunStart("invalid_allocation_receipt");
     const run = context.db.get("SELECT project_root, workspace_root, run_root, flow_kind, subject_type, subject_id, index_json FROM runs WHERE project_id = ? AND id = ?", [projectId, row.run_id]);
@@ -114,6 +124,8 @@ function readRunStartRequestSnapshot(context, projectId, requestId) {
     if (!object(index))
         refuseRunStart("allocated_run_changed");
     const marker = index.start_request, initial = payload.initial_index;
+    const relocations = runContextRelocations(context, projectId, row.run_id);
+    const currentPath = (value) => projectPacketLocators(value, relocations);
     if (!payload || payload.schema_id !== "dd-flow/run-start-allocation@1" || payload.project_id !== projectId
         || payload.request_id !== requestId || payload.run_id !== row.run_id || !Array.isArray(payload.blobs) || !Array.isArray(payload.artifacts)
         || !initial || initial.run_id !== row.run_id || initial.project?.id !== projectId || initial.start_request !== undefined
@@ -121,7 +133,7 @@ function readRunStartRequestSnapshot(context, projectId, requestId) {
         || !marker || marker.schema_id !== "dd-flow/run-start-request@1" || marker.request_id !== requestId
         || marker.request_sha256 !== payload.request_sha256 || marker.allocation_sha256 !== row.payload_sha256
         || receipt.run_id !== row.run_id || receipt.request_id !== requestId || receipt.request_sha256 !== payload.request_sha256 || receipt.allocation_sha256 !== row.payload_sha256
-        || run.project_root !== payload.project_root || run.workspace_root !== payload.workspace_root || run.run_root !== payload.run_root
+        || run.project_root !== currentPath(payload.project_root) || run.workspace_root !== currentPath(payload.workspace_root) || run.run_root !== currentPath(payload.run_root)
         || run.flow_kind !== initial.flow_kind || run.subject_id !== payload.subject_id || run.subject_type !== payload.subject_type
         || !object(index.execution_bundle) || hybridDigest(index.execution_bundle) !== hybridDigest(initial.execution_bundle))
         refuseRunStart("allocated_run_changed");

package/dist/services/runs.js

@@ -27,6 +27,7 @@ import { RetainedExecutionBundle } from "./execution-bundles.js";
 import { admitBundledFlow, bundledHandlerContext } from "./stage-handlers.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { projectPacketLocators, runContextRelocations } from "./stage-context.js";
+import { readRunEngineBinding } from "./run-engine-bindings.js";
 const runSchemaId = "dd-flow/flow-run@3";
 const runtimeSchemaId = "dd-flow/flow-run@3";
 const allowedRunFlowKinds = [
@@ -36,6 +37,7 @@ const allowedRunFlowKinds = [
     "mb-init",
     "mb-upgrade",
     "mb-audit",
+    "project-review",
     "mb-distill",
     "mb-upgrade-review",
     "mb-sdlc-review",
@@ -1843,7 +1845,10 @@ export function readFlowRunExecutionBundle(context, input) {
         throw new AppError("run_bundle_authority_invalid", "RUN bundle admission authority changed", 1);
     }
     const admission = { ...retained, receipts: new Map(retained.receipts), descriptorContext: bundledHandlerContext(new Map()) };
-    const bundle = RetainedExecutionBundle.read(path.join(runArtifactRoot(run), "execution-bundle"), anchor.manifest_sha256, admission);
+    const relocations = runContextRelocations(context, run.project_id, run.id);
+    const binding = relocations.length ? readRunEngineBinding(path.join(runArtifactRoot(run), "engine-binding.json")) : null;
+    const relocation = binding?.source === "fork_upgrade" ? { binding, relocations } : undefined;
+    const bundle = RetainedExecutionBundle.read(path.join(runArtifactRoot(run), "execution-bundle"), anchor.manifest_sha256, admission, relocation);
     assertBundleRunIdentity(context, run, bundle);
     if (bundle.manifest.descriptor.sha256 !== anchor.descriptor_sha256 || bundle.manifest.flow_id !== anchor.flow_id) {
         throw new AppError("run_bundle_anchor_invalid", "RUN bundle descriptor identity changed", 1);

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

@@ -1,4 +1,5 @@
 import crypto from "node:crypto";
+import { nativeShutdownConfirmed } from "../harness-runtime/lib/native-children.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import { isDeepStrictEqual } from "node:util";
@@ -16,15 +17,19 @@ import { cleanupScopeWriters } from "./scope-writer-cleanup.js";
 import { harnessKey } from "./harness-config.js";
 import { canonicalNativeOperation } from "../harness-runtime/lib/adapter-timeouts.mjs";
 import { retainedDaemonReply } from "../harness-runtime/lib/daemon-observation.mjs";
+import { validateNativeLaunchEnvironment } from "../harness-runtime/lib/daemon-operations.mjs";
 const hash = (value) => crypto.createHash("sha256").update(value).digest("hex");
-const nativeLaunchEnvironmentKeys = ["CODEX_HOME", "DD_FLOW_CONFIG_HOME", "DD_FLOW_HOME", "DD_FLOW_BIN", "DD_FLOW_RESOURCE_HOME"];
 function nativeLaunchEnvironment(context, saved) {
     const env = { ...context.env };
     for (const name of ["DD_FLOW_CONTROLLER_TOKEN", "DD_FLOW_CONTROL_TOKEN", "DD_FLOW_SCOPE_CONTROL_TOKEN", "DD_FLOW_DAEMON_ID", "DD_FLOW_RUNTIME_OWNER"])
         delete env[name];
-    if (!saved || Object.keys(saved).some(name => !nativeLaunchEnvironmentKeys.includes(name)))
-        throw new AppError("runtime_scope_native_launch_required", "Native launch has an unsupported environment", 1);
-    for (const name of nativeLaunchEnvironmentKeys) {
+    try {
+        validateNativeLaunchEnvironment(saved);
+    }
+    catch {
+        throw new AppError("runtime_scope_native_launch_required", "Native launch has an unsupported or invalid configuration environment", 1);
+    }
+    for (const name of Object.keys(saved)) {
         if (saved[name] === null)
             delete env[name];
         else if (typeof saved[name] === "string")
@@ -460,8 +465,9 @@ async function retireScopeNative(context, intent, source, assertCurrent) {
     }
     if (!launch || launch.schema_id !== "dd-flow/native-launch@1" || launch.executable !== source.runtime_owner?.adapter_executable || !path.isAbsolute(launch.executable) || !path.isAbsolute(launch.cwd) || !Array.isArray(launch.args) || launch.args[0] !== "daemon" || launch.args[1] !== "start" || launch.args[launch.args.indexOf("--state-dir") + 1] !== source.state_dir || !isDeepStrictEqual(launchOwner, source.runtime_owner))
         throw new AppError("runtime_scope_native_launch_required", "Native recovery requires the original owned launch contract", 1);
-    if (!launch.env || Object.keys(launch.env).some(name => !nativeLaunchEnvironmentKeys.includes(name)) || nativeLaunchEnvironmentKeys.some(name => launch.env[name] !== null && typeof launch.env[name] !== "string") || launch.args.some(arg => typeof arg !== "string"))
+    if (launch.args.some(arg => typeof arg !== "string"))
         throw new AppError("runtime_scope_native_launch_required", "Native recovery requires explicit configuration presence before retiring its owner", 1);
+    nativeLaunchEnvironment(context, launch.env);
     let dispatch = false;
     const preparedInventory = db.get("SELECT 1 FROM managed_resources WHERE resource_kind = 'scope-resume-native' AND resource_key = ?", [key]) ? null : nativeInventoryVersion(source.state_dir);
     const operation = db.writeTransaction(() => {
@@ -494,7 +500,7 @@ async function retireScopeNative(context, intent, source, assertCurrent) {
         assertOwner();
         db.run("UPDATE managed_resources SET metadata_json = ?, updated_at = ? WHERE resource_kind = 'scope-resume-native' AND resource_key = ?", [JSON.stringify(operation), context.now(), key]);
     }
-    if (operation.receipt.stopped !== true || operation.receipt.clean !== true || state().shutdown_state !== "clean" || processTreeIsAlive(record))
+    if (operation.receipt.stopped !== true || !nativeShutdownConfirmed(operation.receipt, { daemonId: source.daemon_id }) || state().shutdown_state !== "clean" || processTreeIsAlive(record))
         return { ...source, ...operation, pending: true, reason: "native_retirement_settlement_required" };
     assertOwner();
     operation.status = "retired";

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

@@ -1,4 +1,5 @@
 import crypto from "node:crypto";
+import { nativeShutdownConfirmed } from "../harness-runtime/lib/native-children.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
@@ -30,7 +31,7 @@ export async function stopRuntimeScope(context, scopeId, requestId) {
             if (!state.daemon_id || !owner || owner.budget?.scope_id !== scopeId || owner.owner_id !== record.owner_id || owner.role !== metadata.role || owner.state_dir !== metadata.state_dir || owner.adapter_executable !== metadata.adapter_executable || !retainedResourceHomeMatches(context, owner.resource_home) || (owner.project_id ?? null) !== record.project_id || (owner.run_id ?? null) !== record.run_id || (owner.work_id ?? null) !== record.work_id || !record.operation_id?.startsWith(`${owner.operation_id}:`) || state.resource_process?.id !== record.id || state.resource_process.lease_token !== record.lease_token || state.pid !== record.pid)
                 throw new AppError("runtime_scope_owner_unknown", "Native owner does not match its registration", 1);
             const closed = state.shutdown_state === "clean" && state.active_tree === false && !processTreeIsAlive(record)
-                ? retainedDaemonOperations(metadata.state_dir).find(operation => operation.daemon_id === state.daemon_id && operation.operation === "daemon.stop" && operation.state === "completed" && operation.result?.stopped === true && operation.result?.clean === true) : undefined;
+                ? retainedDaemonOperations(metadata.state_dir).find(operation => operation.daemon_id === state.daemon_id && operation.operation === "daemon.stop" && operation.state === "completed" && operation.result?.stopped === true && nativeShutdownConfirmed(operation.result, { daemonId: state.daemon_id ?? "" })) : undefined;
             const operationId = closed ? String(closed.operation_id) : `scope-stop:${crypto.createHash("sha256").update(JSON.stringify([scopeId, record.id, state.daemon_id])).digest("hex")}`;
             const requested = path.join(metadata.state_dir, "operations", crypto.createHash("sha256").update(operationId).digest("hex"), "requested.json");
             const prior = fs.existsSync(requested);
@@ -56,7 +57,7 @@ export async function stopRuntimeScope(context, scopeId, requestId) {
             const finalOwner = managedProcessStatus(context).find(item => item.id === record.id);
             if (!finalOwner || finalOwner.lease_token !== record.lease_token || finalOwner.pid !== record.pid || finalOwner.pid_started_at !== record.pid_started_at || after.resource_process?.id !== record.id || after.resource_process.lease_token !== record.lease_token || JSON.stringify(after.config?.runtime_owner) !== JSON.stringify(owner))
                 throw new AppError("runtime_scope_owner_changed", "Native ownership changed during control", 1);
-            if (result?.stopped !== true || result.clean !== true || after.daemon_id !== state.daemon_id || after.shutdown_state !== "clean" || after.active_tree !== false || processTreeIsAlive(finalOwner))
+            if (result?.stopped !== true || !nativeShutdownConfirmed(result, { daemonId: state.daemon_id }) || 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, native_settled: true, physical_stopped: true, operation_id: operationId, owner_operation_id: owner.operation_id, processes };

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

@@ -8,6 +8,7 @@ import { AppError, errorRecord } from "../shared/errors.js";
 import { getResourceDatabase } from "../storage/database.js";
 import { assertManagedProcessLease, confirmManagedProcess, finishManagedProcess, renewManagedProcess, processIsAlive, processStartedAt, registerManagedProcess, resourceHome } from "./managed-processes.js";
 import { managedLeaseMonitor } from "./managed-lease-monitor.js";
+import { physicalStartup } from "./physical-startup.js";
 import { publicRuntimeScopeWorker, requestRuntimeScopeControl, runtimeBudgetStatus, prepareRuntimeScopeFence, parseRuntimeBudget } from "./runtime-budget.js";
 import { controlRuntimeScopeRuns } from "./runtime-scope-control.js";
 import { prepareRuntimeScopeResume, recordRuntimeScopeResume } from "./runtime-scope-resume.js";
@@ -138,8 +139,7 @@ export function prepareRuntimeScopeServing(context, scopeId, generation) {
     }
     return { key, token };
 }
-function requireStartingScopeWorker(db, key, token) {
-    const row = db.get("SELECT metadata_json FROM managed_resources WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ?", [key, token]);
+function requireStartingScopeWorker(db, key, token, row = db.get("SELECT metadata_json FROM managed_resources WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ?", [key, token])) {
     if (!row)
         throw new AppError("runtime_scope_owner_unknown", "Scope worker claim changed", 1);
     const worker = JSON.parse(row.metadata_json);
@@ -150,29 +150,55 @@ function requireStartingScopeWorker(db, key, token) {
 export async function serveRuntimeScopeControl(context, scopeId, generation) {
     const { key, token } = prepareRuntimeScopeServing(context, scopeId, generation);
     const db = getResourceDatabase(resourceHome(context));
-    const owner = birth();
-    const worker = db.writeTransaction(() => {
-        const worker = requireStartingScopeWorker(db, key, token);
-        worker.owner = owner;
-        worker.status = "running";
-        db.run("UPDATE managed_resources SET metadata_json = ?, updated_at = ? WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ?", [JSON.stringify(worker), context.now(), key, token]);
-        return worker;
-    });
+    const startup = physicalStartup(context.databaseDeadlineAt);
+    let claimedOwner = undefined;
+    const assertStartupCurrent = () => {
+        const control = db.get("SELECT metadata_json FROM managed_resources WHERE resource_kind = 'scope-control' AND resource_key = ?", [scopeId]);
+        const fence = db.get("SELECT 1 FROM managed_resources WHERE resource_kind = 'provider-fence' AND resource_key = ?", [scopeId]);
+        const row = db.get("SELECT metadata_json FROM managed_resources WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ?", [key, token]);
+        const current = row ? JSON.parse(row.metadata_json) : null;
+        if (!control || JSON.parse(control.metadata_json).generation !== generation || fence || !current || current.token !== token || current.status !== (claimedOwner ? "running" : "starting") || current.owner?.pid !== claimedOwner?.pid || current.owner?.pid_started_at !== claimedOwner?.pid_started_at)
+            throw new AppError("runtime_scope_control_superseded", "Scope startup no longer owns this control", 1);
+    };
+    const starting = db.get("SELECT metadata_json FROM managed_resources WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ?", [key, token]);
+    let worker = requireStartingScopeWorker(db, key, token, starting);
+    let retainedMetadata = starting.metadata_json;
+    let claimedByThisServe = false;
+    const persistWorker = () => {
+        const next = JSON.stringify(worker);
+        if (db.run("UPDATE managed_resources SET metadata_json = ?, updated_at = ? WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ? AND metadata_json = ?", [next, context.now(), key, token, retainedMetadata]).changes !== 1)
+            throw new AppError("runtime_scope_owner_unknown", "Scope owner changed before its retained result could be saved", 1);
+        retainedMetadata = next;
+    };
     let heartbeat;
     let lease;
     // A fence must never be held indefinitely by an observer that cannot obtain
     // fresh provider evidence. A later operator request continues the retained
     // budget; this owner records why it stopped without claiming settlement.
-    const observation = recoveryObservationBudget(worker.snapshot);
-    worker.snapshot = { ...(worker.snapshot ?? {}), recovery_observation: observation.state() };
+    let observationCleanup;
     let cleanupFailure;
     const result = await (async () => {
         try {
+            const owner = await startup.birth(assertStartupCurrent);
+            const claim = db.writeTransaction(() => {
+                assertStartupCurrent();
+                const current = requireStartingScopeWorker(db, key, token);
+                current.owner = owner;
+                current.status = "running";
+                db.run("UPDATE managed_resources SET metadata_json = ?, updated_at = ? WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ?", [JSON.stringify(current), context.now(), key, token]);
+                return { worker: current, metadata: JSON.stringify(current) };
+            });
+            worker = claim.worker;
+            retainedMetadata = claim.metadata;
+            claimedOwner = owner;
+            claimedByThisServe = true;
+            const observation = observationCleanup = recoveryObservationBudget(worker.snapshot);
+            worker.snapshot = { ...(worker.snapshot ?? {}), recovery_observation: observation.state() };
             const record = registerManagedProcess(context, { kind: "scope-control", ownerId: key, operationId: `scope-control:${key}:${token}`, ownerPid: process.pid, metadata: { role: "control", scope_id: scopeId, generation } });
             worker.process_id = record.id;
             worker.process_lease_token = record.lease_token;
-            const confirmed = confirmManagedProcess(context, { id: record.id, leaseToken: record.lease_token, pid: process.pid, processGroupId: process.pid, ownerPid: process.pid });
-            db.run("UPDATE managed_resources SET metadata_json = ?, updated_at = ? WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ?", [JSON.stringify(worker), context.now(), key, token]);
+            const confirmed = await startup.observe(() => confirmManagedProcess(context, { id: record.id, leaseToken: record.lease_token, pid: process.pid, processGroupId: process.pid, ownerPid: process.pid }), assertStartupCurrent, record.lease_expires_at);
+            persistWorker();
             lease = managedLeaseMonitor(attemptMs => renewManagedProcess({ ...context, resourceDatabaseMode: "prepared_existing", databaseDeadlineAt: Date.now() + attemptMs }, { id: record.id, leaseToken: record.lease_token }), confirmed.lease_expires_at);
             let timerFailure;
             const assertScopeCurrent = () => {
@@ -233,7 +259,7 @@ export async function serveRuntimeScopeControl(context, scopeId, generation) {
                 await lease.ensureConfirmed(assertScopeCurrent);
                 observation.observe(outcome);
                 worker.snapshot = { ...outcome, recovery_observation: observation.state() };
-                db.run("UPDATE managed_resources SET metadata_json = ?, updated_at = ? WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ?", [JSON.stringify(worker), context.now(), key, token]);
+                persistWorker();
                 if (worker.snapshot.drain?.physical_settled === true) {
                     worker.status = "completed";
                     break;
@@ -259,18 +285,19 @@ export async function serveRuntimeScopeControl(context, scopeId, generation) {
             lease?.close();
             if (heartbeat)
                 clearInterval(heartbeat);
-            observation.exhausted();
-            worker.snapshot = { ...(worker.snapshot ?? {}), recovery_observation: observation.state() };
+            observationCleanup?.exhausted();
+            worker.snapshot = { ...(worker.snapshot ?? {}), ...(observationCleanup ? { recovery_observation: observationCleanup.state() } : {}) };
             let persistenceFailure;
             try {
-                db.run("UPDATE managed_resources SET metadata_json = ?, updated_at = ? WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ?", [JSON.stringify(worker), context.now(), key, token]);
+                persistWorker();
             }
             catch (error) {
                 persistenceFailure = error;
                 process.stderr.write(`${JSON.stringify({ primary: worker.error, primary_error: worker.snapshot.error, phase: "persist_scope_owner", secondary: errorRecord(error) })}\n`);
             }
             try {
-                if (worker.process_id && worker.process_lease_token)
+                const current = claimedByThisServe && db.get("SELECT metadata_json FROM managed_resources WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ?", [key, token]);
+                if (current && current.metadata_json === retainedMetadata && !persistenceFailure && worker.process_id && worker.process_lease_token)
                     finishManagedProcess(context, { id: worker.process_id, leaseToken: worker.process_lease_token, state: worker.status === "failed" ? "failed" : "stopped", reason: "scope_owner_exited" });
             }
             catch (error) {

package/dist/services/runtime-service.js

@@ -7,6 +7,7 @@ import { assertRunMutationAllowed } from "./run-recovery.js";
 import { requireProjectByRoot } from "./projects.js";
 import { resolveRun } from "./runs.js";
 import { codeExecutionEnvironment, runCheck } from "./code-checks.js";
+import { retainedBrowserEnvironment } from "./check-environment.js";
 import { confirmManagedProcess, finishManagedProcess, renewManagedProcess, managedProcessStatus, processTreeIsAlive, registerManagedProcess, reservePorts, resourceHome, stopManagedProcess } from "./managed-processes.js";
 export function prepareRuntimeService(context, input) {
     validateObservationDuration(input.timeoutMs);
@@ -33,7 +34,7 @@ export async function startRuntimeService(context, input) {
     const save = () => { const temporary = `${receiptPath}.${process.pid}.tmp`; fs.writeFileSync(temporary, JSON.stringify(receipt, null, 2)); fs.renameSync(temporary, receiptPath); };
     try {
         const allocation = await reservePorts(context, { ownerId: record.owner_id, processId: record.id, names: input.ports });
-        const environment = { ...codeExecutionEnvironment(run.workspace_root), ...Object.fromEntries(Object.entries(allocation.ports).map(([name, port]) => [`DD_FLOW_PORT_${name.toUpperCase()}`, String(port)])), DD_FLOW_EVIDENCE_DIR: directory, DD_FLOW_CHECK_COMPLETION_FILE: path.join(directory, "completion.json") };
+        const environment = { ...codeExecutionEnvironment(run.workspace_root, retainedBrowserEnvironment(context.env)), ...Object.fromEntries(Object.entries(allocation.ports).map(([name, port]) => [`DD_FLOW_PORT_${name.toUpperCase()}`, String(port)])), DD_FLOW_EVIDENCE_DIR: directory, DD_FLOW_CHECK_COMPLETION_FILE: path.join(directory, "completion.json") };
         const quoted = (value) => `'${value.replaceAll("'", "'\\''")}'`;
         Object.assign(receipt, { ports: allocation.ports, environment: Object.fromEntries(Object.entries(environment).filter(([key]) => key.startsWith("DD_FLOW_PORT_"))), stop_command: `DD_FLOW_HOME=${quoted(context.ddFlowHome)} DD_FLOW_RESOURCE_HOME=${quoted(resourceHome(context))} dd-flow runtime process stop --id ${record.id} --lease-token ${record.lease_token} --json` });
         save();

package/dist/services/sessions.js

@@ -1,4 +1,5 @@
 import crypto from "node:crypto";
+import { recordFlowSessionObservation } from "./hook-session-observation.js";
 import { continuationPolicies, flowKinds } from "../domain/contracts.js";
 import { AppError } from "../shared/errors.js";
 import { hookSessionIdentity } from "./hooks.js";
@@ -23,25 +24,7 @@ export function publicFlowSession(context, session) {
     delete publicFields.parent_session_id;
     return { ...publicFields, harness_id: identity.harness_id, session_id: identity.session_id, parent_session: parent ? publicSessionIdentity(parent) : null };
 }
-export function recordFlowSessionObservation(context, input) {
-    const duplicate = context.db.get("SELECT id FROM flow_session_segments WHERE project_id = ? AND event_key = ?", [input.projectId, input.eventKey]);
-    if (duplicate)
-        return { changed: false, segment_id: duplicate.id };
-    const open = context.db.get(`SELECT id, run_id, protocol_id FROM flow_session_segments
-     WHERE project_id = ? AND session_id = ? AND ended_at IS NULL ORDER BY started_at DESC, id DESC LIMIT 1`, [input.projectId, input.sessionId]);
-    const now = context.now();
-    const runId = input.runId === undefined ? open?.run_id ?? null : input.runId;
-    const protocolId = input.protocolId === undefined ? open?.protocol_id ?? null : input.protocolId;
-    if (open && open.run_id === runId && open.protocol_id === protocolId) {
-        return { changed: false, segment_id: open.id };
-    }
-    if (open)
-        context.db.run("UPDATE flow_session_segments SET ended_at = ? WHERE id = ? AND ended_at IS NULL", [now, open.id]);
-    const result = context.db.run(`INSERT INTO flow_session_segments
-      (project_id, session_id, run_id, protocol_id, started_at, ended_at, cwd, tool_name, event_key)
-     VALUES (?, ?, ?, ?, ?, NULL, ?, ?, ?)`, [input.projectId, input.sessionId, runId, protocolId, now, input.cwd ?? null, input.toolName ?? null, input.eventKey]);
-    return { changed: true, segment_id: Number(result.lastInsertRowid) };
-}
+export { recordFlowSessionObservation } from "./hook-session-observation.js";
 export function registerFlowJob(context, input) {
     const jobId = input.jobId ?? `JOB-${input.runId}-${input.planItemId}`.replace(/[^A-Za-z0-9_-]+/g, "-");
     const now = context.now();
@@ -167,11 +150,7 @@ export function stoppedMergeWorkerState(context, projectId, workerId) {
         status: latest?.status ?? null
     };
 }
-export function activeFlowSessionsForProject(context, projectId) {
-    return context.db.all(`SELECT * FROM sessions
-     WHERE project_id = ? AND status IN ('pending', 'active', 'waiting_user', 'blocked', 'stopping')
-     ORDER BY updated_at DESC`, [projectId]);
-}
+export { activeFlowSessionsForProject } from "./hook-session-observation.js";
 export function flowSessionsForProject(context, projectId, filter = {}) {
     if (filter.sessionId) {
         return context.db.all("SELECT * FROM sessions WHERE project_id = ? AND (session_id = ? OR provider_session_id = ?) ORDER BY updated_at DESC", [projectId, filter.sessionId, filter.sessionId]);

package/dist/services/setup.js

@@ -60,7 +60,7 @@ function atomicJson(file, value) {
             fs.unlinkSync(temporary);
     }
 }
-function readSetupRequest(file) {
+function readSetupRequest(file, validateExecutor = true) {
     const value = regularJson(file);
     const required = ["schema_id", "request_id", "identity", "previous_selection", "phase", "installation"];
     if (!value || typeof value !== "object" || Array.isArray(value)
@@ -77,7 +77,7 @@ function readSetupRequest(file) {
         || !["prepared", "canon_cached", "engine_cached", "profiles_saved", "committed"].includes(request.phase)
         || !request.installation || typeof request.installation !== "object" || Array.isArray(request.installation))
         refuse("invalid_request_record");
-    if (Object.hasOwn(request, "executor") && request.executor !== null) {
+    if (validateExecutor && Object.hasOwn(request, "executor") && request.executor !== null) {
         try {
             prepareOperatorProfile(request.executor);
         }
@@ -85,7 +85,7 @@ function readSetupRequest(file) {
             refuse("invalid_request_executor");
         }
     }
-    if (Object.hasOwn(request, "profileCreation")) {
+    if (validateExecutor && Object.hasOwn(request, "profileCreation")) {
         try {
             validateProfileCreationIntent(request.profileCreation);
         }
@@ -225,22 +225,72 @@ export function commitSetupOnboarding(home, requestId, selection) {
     return result;
 }
 /** Read-only global readiness. No SQLite connection, migration, project registration or probes. */
+function validateInstallation(root, installation) {
+    if (!installation.manifest || typeof installation.manifest_bytes_base64 !== "string" || validateHybridShape("release-manifest", installation.manifest).length ||
+        installation.canon_root !== path.join(root, "release-cache", "canon", installation.manifest.canon.version, "payload") ||
+        installation.engine_root !== path.join(root, "release-cache", "engine", installation.manifest.engine.version, "payload"))
+        refuse("invalid_installation_selection");
+    const bytes = Buffer.from(installation.manifest_bytes_base64, "base64");
+    if (bytes.toString("base64") !== installation.manifest_bytes_base64 || bytesDigest(bytes) !== installation.manifest_sha256 ||
+        hybridDigest(manifestFromBytes(bytes)) !== hybridDigest(installation.manifest))
+        refuse("invalid_installation_selection");
+}
+/** Independently committed canonical data, never activation or old code
+ * admission. A missing old engine cache is irrelevant to comparing documents.
+ * Same canon commit/version with different archive bytes is not disambiguated
+ * by picking the newest CLI or whichever request happens to be listed first.
+ */
+export function readCommittedCanonRelease(home, version, commit, expectedInstallationSha256) {
+    const root = path.resolve(home), directory = path.join(root, "setup-requests");
+    if (!/^[0-9]+\.[0-9]+\.[0-9]+(?:-[A-Za-z0-9.-]+)?$/.test(version) || !/^[a-f0-9]{40}$/.test(commit)
+        || expectedInstallationSha256 !== undefined && !/^[a-f0-9]{64}$/.test(expectedInstallationSha256))
+        refuse("invalid_canonical_baseline_selection");
+    for (const target of [root, directory])
+        if (fs.existsSync(target) && !fs.lstatSync(target).isDirectory())
+            refuse("unsafe_setup_directory");
+    if (!fs.existsSync(directory))
+        return null;
+    const matches = [];
+    for (const name of fs.readdirSync(directory).filter(name => name.endsWith(".json")).sort()) {
+        const request = readSetupRequest(path.join(directory, name), false);
+        if (`${request.request_id}.json` !== name)
+            refuse("request_identity_conflict");
+        if (request.phase !== "committed" || request.installation.manifest?.canon?.version !== version || request.installation.manifest.canon.commit !== commit)
+            continue;
+        if (expectedInstallationSha256 !== undefined && request.installation.manifest_sha256 !== expectedInstallationSha256)
+            continue;
+        validateInstallation(root, request.installation);
+        const binding = { installation: request.installation,
+            ...(Object.hasOwn(request, "executor") ? { executor: request.executor } : {}),
+            ...(request.profileCreation ? { profileCreation: request.profileCreation } : {}),
+            ...(request.deferredOnboarding ? { deferredOnboarding: true } : {}) };
+        if (!["install", "update"].some(action => hybridDigest({ action, ...binding }) === request.identity))
+            refuse("request_identity_conflict");
+        matches.push(request.installation);
+    }
+    if (!matches.length)
+        return null;
+    if (new Set(matches.map(installation => `${installation.manifest.canon.archive.sha256}:${installation.manifest.canon.archive.bytes}`)).size !== 1)
+        refuse("ambiguous_canonical_baseline");
+    const selected = matches.sort((left, right) => left.manifest_sha256.localeCompare(right.manifest_sha256, "en"))[0];
+    try {
+        verifyPublishedReleaseCache(path.dirname(selected.canon_root), selected.manifest.canon.archive);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    return structuredClone(selected);
+}
 export function readSetupStatus(home) {
     const root = path.resolve(home);
     if (fs.existsSync(root) && !fs.lstatSync(root).isDirectory())
         refuse("unsafe_setup_home");
     const file = path.join(root, "installation.json");
     const installation = fs.existsSync(file) ? regularJson(file) : null;
-    if (installation) {
-        if (!installation.manifest || typeof installation.manifest_bytes_base64 !== "string" || validateHybridShape("release-manifest", installation.manifest).length ||
-            installation.canon_root !== path.join(root, "release-cache", "canon", installation.manifest.canon.version, "payload") ||
-            installation.engine_root !== path.join(root, "release-cache", "engine", installation.manifest.engine.version, "payload"))
-            refuse("invalid_installation_selection");
-        const bytes = Buffer.from(installation.manifest_bytes_base64, "base64");
-        if (bytes.toString("base64") !== installation.manifest_bytes_base64 || bytesDigest(bytes) !== installation.manifest_sha256 ||
-            hybridDigest(manifestFromBytes(bytes)) !== hybridDigest(installation.manifest))
-            refuse("invalid_installation_selection");
-    }
+    if (installation)
+        validateInstallation(root, installation);
     let readiness = installation ? "installed" : "not_installed";
     if (installation) {
         try {