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

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

@@ -1,11 +1,11 @@
 import fs from "node:fs";
 import path from "node:path";
-import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { readBoundedReleaseFile } from "./release-source.js";
 import { defaultMemoryLintConfiguration, validateMemoryLintConfig } from "./memory-lint-config.js";
+import { runMemoryToolProbe } from "./memory-tool-probe.js";
 function refuse(reason, diagnostics) {
     throw new AppError("memory_init_preflight_failed", "Memory init prerequisites are not admitted", 1, { reason, phase: "prepare", effect: "no_effect", next_action: reason === "existing_memory_bank" ? "audit_or_upgrade" : "repair_prerequisite_then_retry", ...(diagnostics ? { tool_probe: diagnostics } : {}) });
 }
@@ -56,20 +56,14 @@ function probeTools(tools, env) {
     const facts = Object.create(null);
     const probeEnv = Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_")));
     for (const name of Object.keys(tools)) {
-        const diagnostics = { name, executable: tools[name], args: ["--version"], timeout_ms: 5000, phase: "executable_read" };
+        const diagnostics = { name, executable: tools[name], args: ["--version"], phase: "executable_read" };
         try {
             const digest = () => createHash("sha256").update(readBoundedReleaseFile(tools[name], 64 * 1024 * 1024)).digest("hex");
             const executableSha256 = digest();
-            const started = performance.now();
-            const result = spawnSync(tools[name], ["--version"], { cwd: path.dirname(tools[name]), env: probeEnv,
-                timeout: 5000, maxBuffer: 64 * 1024, windowsHide: true, shell: false });
-            Object.assign(diagnostics, { phase: "version_probe", elapsed_ms: Math.round(performance.now() - started), status: result.status, signal: result.signal,
-                error_code: result.error?.code ?? null,
-                timed_out: result.error?.code === "ETIMEDOUT",
-                stdout_bytes: result.stdout?.length ?? null, stderr_bytes: result.stderr?.length ?? null,
-                // Tool output can contain environment secrets; retain bounded custody
-                // hashes rather than echoing uncontrolled stderr into public receipts.
-                stderr_sha256: result.stderr ? createHash("sha256").update(result.stderr).digest("hex") : null });
+            const { result, diagnostics: observed } = runMemoryToolProbe(tools[name], ["--version"], {
+                cwd: path.dirname(tools[name]), env: probeEnv, maxBuffer: 64 * 1024
+            });
+            Object.assign(diagnostics, observed, { name, phase: "version_probe" });
             if (result.error || result.signal || result.status !== 0 || !result.stdout || !result.stderr)
                 refuse(`tool_probe_failed:${name}`, diagnostics);
             const output = new TextDecoder("utf-8", { fatal: true }).decode(result.stdout);
@@ -155,12 +149,12 @@ function inspect(input, env, ownedPublication = false, qualifyTools = true, obse
     const toolProbes = qualifyTools ? probeTools(tools, env) : undefined;
     const gitEnv = Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_")));
     const git = (directory, args, optional = false) => {
-        const result = spawnSync(tools.git, ["-c", "core.fsmonitor=false", "-c", "core.untrackedCache=false", "-C", directory, ...args], {
-            env: { ...gitEnv, GIT_OPTIONAL_LOCKS: "0" }, encoding: "utf8", timeout: 5000, maxBuffer: 1024 * 1024,
+        const { result, diagnostics } = runMemoryToolProbe(tools.git, ["-c", "core.fsmonitor=false", "-c", "core.untrackedCache=false", "-C", directory, ...args], {
+            cwd: directory, env: { ...gitEnv, GIT_OPTIONAL_LOCKS: "0" }, maxBuffer: 1024 * 1024,
         });
         if (result.error || result.signal || result.status !== 0 && !optional)
-            refuse("git_observation_failed");
-        return result.status === 0 ? result.stdout : null;
+            refuse("git_observation_failed", { ...diagnostics, phase: "git_observation" });
+        return result.status === 0 ? result.stdout.toString("utf8") : null;
     };
     for (const directory of new Set([project, workspace])) {
         if (git(directory, ["rev-parse", "--is-bare-repository"])?.trim() !== "false"

package/dist/services/memory-init-worktrunk-capability.js

@@ -1,12 +1,12 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { PreparedMemoryInitTarget } from "./memory-init-preflight.js";
 import { readBoundedReleaseFile } from "./release-source.js";
+import { runMemoryToolProbe } from "./memory-tool-probe.js";
 const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
 function refuse(reason, diagnostics) {
     throw new AppError("memory_init_worktrunk_capability_failed", "Selected Worktrunk cannot create the required workspace", 1, { reason, effect: "no_effect", next_action: "repair_prerequisite_then_retry", ...(diagnostics ? { tool_probe: diagnostics } : {}) });
@@ -83,14 +83,10 @@ export class PreparedMemoryInitWorktrunkCapability {
             const run = (file, args) => {
                 ownRoot();
                 unchanged();
-                const started = performance.now();
-                const result = spawnSync(file, args, { cwd: repo, env: probeEnv, shell: false, windowsHide: true, timeout: 5000, maxBuffer: 256 * 1024 });
+                const { result, diagnostics } = runMemoryToolProbe(file, args, { cwd: repo, env: probeEnv });
                 if (result.error || result.signal || result.status !== 0)
                     refuse("worktrunk_probe_execution_failed", {
-                        name: path.basename(file), phase: "workspace_probe", timeout_ms: 5000, elapsed_ms: Math.round(performance.now() - started),
-                        status: result.status, signal: result.signal, error_code: result.error?.code ?? null,
-                        timed_out: result.error?.code === "ETIMEDOUT",
-                        stdout_bytes: result.stdout?.length ?? null, stderr_bytes: result.stderr?.length ?? null
+                        ...diagnostics, name: path.basename(file), phase: "workspace_probe", expected_status: 0
                     });
                 ownRoot();
                 unchanged();

package/dist/services/memory-layer.js

@@ -11,12 +11,13 @@ import { normalizeFlowContract } from "../domain/flow-contract.js";
 import { inspectReleaseArchive } from "./release-archive.js";
 import { canonicalOnlyFlowNames } from "./version-status.js";
 export function isCanonicalOnlyMemoryPath(logical) {
-    return canonicalOnlyFlowNames.some(name => logical === `dd-flow/${name}` || logical.startsWith(`dd-flow/${name.slice(0, -3)}/`));
+    return logical.startsWith("dd-flow/project-review/")
+        || canonicalOnlyFlowNames.some(name => logical === `dd-flow/${name}` || logical.startsWith(`dd-flow/${name.slice(0, -3)}/`));
 }
 const rootFiles = ["README.md", "index.md", "compatibility.json", "flow-contract.json", "go.md", "f.md", "prime.md", "protocol.md",
     "protocol-implement.md", "plan.md", "code.md", "merge.md", "merge-start.md", "merge-stop.md", "release.md", "deploy.md", "publish.md",
-    "review.md", "review-fix.md", "mb-audit.md", "mb-fix.md", "mb-lint.md", "interactive.md", "finish.md", "fix-def.md"];
-const supportDirectories = ["common", "prime", "mb-sdlc", "aspects", "def", "workers", "mb-audit", "schemas", "vnext", "specify", "stage-reports", "dashboard", "plan", "code", "merge"];
+    "review-fix.md", "mb-fix.md", "mb-lint.md", "interactive.md", "finish.md", "fix-def.md"];
+const supportDirectories = ["common", "prime", "mb-sdlc", "aspects", "def", "workers", "schemas", "vnext", "specify", "stage-reports", "dashboard", "plan", "code", "merge"];
 const required = ["README.md", "index.md", "flow-contract.json", "compatibility.json", "prime.md", "go.md",
     "common/style.md", "common/runtime-contract.md", "common/lifecycle-guards.md", "common/workspace-bootstrap.md", "common/worker-session.md",
     "vnext/start.md", "vnext/specify.md", "vnext/protocolize.md", "vnext/plan.md", "vnext/plan-review.md", "vnext/code.md", "vnext/code-review.md", "vnext/merge.md",

package/dist/services/memory-tool-probe.js

@@ -0,0 +1,25 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { SETUP_STARTUP_MS, setupReporter } from "../harness-runtime/lib/setup-progress.mjs";
+/** Silent, local prerequisite tools are not agent Turns. Reuse the CLI setup
+ * startup budget; do not invent heartbeat progress or retry a failed probe. */
+export function runMemoryToolProbe(executable, args, options) {
+    const started = performance.now();
+    const report = setupReporter(options.env.DD_EVAL_OPERATION_ID);
+    const step = createHash("sha256").update(JSON.stringify([executable, args])).digest("hex");
+    report("probe_started", step);
+    const result = spawnSync(executable, args, { ...options, shell: false, windowsHide: true,
+        timeout: SETUP_STARTUP_MS, maxBuffer: options.maxBuffer ?? 256 * 1024 });
+    report("probe_completed", step);
+    const error = result.error?.code ?? null;
+    const output = (bytes) => ({ bytes: bytes?.length ?? null,
+        sha256: bytes ? createHash("sha256").update(bytes).digest("hex") : null });
+    const stdout = output(result.stdout), stderr = output(result.stderr);
+    // Arbitrary tool output may contain credentials. Public errors retain typed
+    // outcomes and bounded custody facts, never the uncontrolled output itself.
+    return { result, diagnostics: { executable, args, timeout_ms: SETUP_STARTUP_MS,
+            elapsed_ms: Math.round(performance.now() - started), status: result.status,
+            signal: result.signal, error_code: error, timed_out: error === "ETIMEDOUT",
+            stdout_bytes: stdout.bytes, stdout_sha256: stdout.sha256,
+            stderr_bytes: stderr.bytes, stderr_sha256: stderr.sha256 } };
+}

package/dist/services/memory-verification-checks.js

@@ -20,6 +20,7 @@ import { readMemoryUpgradeBootstrapReadiness } from "./memory-upgrade-bootstrap-
 import { readUpgradeStorageReadiness } from "./memory-upgrade-storage-readiness.js";
 import { PreparedAcceptedMemoryComposition } from "./memory-accepted-composition.js";
 import { RetainedExecutionBundle } from "./execution-bundles.js";
+import { retainedBrowserEnvironment, validateCheckEnvironment } from "./check-environment.js";
 const token = Symbol("memory-verification-checks");
 const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
 const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
@@ -40,9 +41,19 @@ export function assertRetainedMemoryVerificationPolicy(previous, current) {
 /** Finite project checks use the original Codex home, never a temporary
  * provider Session overlay. Keep every other application environment input. */
 export function memoryCheckEnvironment(context, projectId, runId) {
+    let browser = retainedBrowserEnvironment(context.env);
     if (!context.db.get("SELECT 1 FROM sqlite_schema WHERE type='table' AND name='run_controllers'"))
-        return undefined;
-    const controllers = context.db.all("SELECT state_json FROM run_controllers WHERE project_id=? AND run_id=?", [projectId, runId]);
+        return browser;
+    const controllers = context.db.all("SELECT state_json,manifest_json FROM run_controllers WHERE project_id=? AND run_id=?", [projectId, runId]);
+    const retained = new Set(controllers.flatMap(controller => {
+        const manifest = JSON.parse(controller.manifest_json);
+        const value = validateCheckEnvironment(manifest.check_environment)?.PLAYWRIGHT_BROWSERS_PATH;
+        return value === undefined ? [] : [value];
+    }));
+    if (retained.size > 1)
+        refuse("ambiguous_check_browser_resource");
+    if (retained.size)
+        browser = { PLAYWRIGHT_BROWSERS_PATH: [...retained][0] };
     const targets = new Set();
     for (const controller of controllers) {
         const state = JSON.parse(controller.state_json);
@@ -51,7 +62,7 @@ export function memoryCheckEnvironment(context, projectId, runId) {
             targets.add(session.codex_home);
     }
     if (!targets.size)
-        return undefined;
+        return browser;
     const current = process.env.CODEX_HOME;
     if (current && !targets.has(current) && context.db.get("SELECT 1 FROM sqlite_schema WHERE type='table' AND name='work_launches'")) {
         const launches = context.db.all("SELECT l.state_dir FROM work_launches l JOIN works w ON w.work_id=l.work_id WHERE w.project_id=? AND w.run_id=?", [projectId, runId]);
@@ -74,7 +85,7 @@ export function memoryCheckEnvironment(context, projectId, runId) {
     const base = [...sources][0];
     if (current === undefined ? base !== path.join(os.homedir(), ".codex") : current !== base && !targets.has(current))
         refuse("foreign_check_home");
-    return { CODEX_HOME: base };
+    return { ...browser, CODEX_HOME: base };
 }
 function lintConfig(workspace) {
     const file = path.join(workspace, ".mb-lint.json");

package/dist/services/native-daemon-history.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 { AppError } from "../shared/errors.js";
@@ -29,7 +30,7 @@ export function historicalDaemonSettlement(context, scopeId, record) {
     if (!state.daemon_id || path.basename(file) !== `${state.daemon_id}.json` || !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 || owner.dd_flow_home !== metadata.dd_flow_home || !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?.lease_token !== record.lease_token || state.pid !== record.pid)
         throw new AppError("runtime_scope_owner_unknown", "Archived daemon does not match its registration", 1);
     const closed = state.shutdown_state === "clean" && state.active_tree === false
-        ? 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 fresh = managedProcessStatus(context).find(item => item.id === record.id);
     if (!closed || !fresh || fresh.lease_token !== record.lease_token || fresh.pid !== record.pid || fresh.pid_started_at !== record.pid_started_at || fresh.metadata_json !== record.metadata_json || fresh.state !== "stopped" || fresh.termination_reason !== "daemon_stopped" || processTreeIsAlive(fresh) || fs.readFileSync(file, "utf8") !== bytes)
         throw new AppError("runtime_scope_outcome_unknown", "Previous daemon lacks stable clean shutdown evidence", 1);

package/dist/services/provider-capacity.js

@@ -4,6 +4,8 @@ import { CAPACITY_POLICY, MAX_OVERLOAD_RETRIES, capacityBackoff, nativeItemsSett
 import { AppError } from "../shared/errors.js";
 import { isObservationLoss } from "../harness-runtime/lib/operation-errors.mjs";
 import { parseLifecycleCommand, commandOption } from "./lifecycle-command.js";
+import { nativeTreeReadiness } from "../harness-runtime/lib/native-children.mjs";
+import { ObservationClock } from "../harness-runtime/lib/observation-clock.mjs";
 /** Native output is evidence, not authority: match the committed current scope. */
 export function ownedProviderBoundary(context, input, boundary) {
     if (typeof boundary.native_hook_event_key !== "string" || typeof boundary.daemon_instance !== "string"
@@ -54,26 +56,9 @@ export function eligibleProviderChildOverload(child, parentSessionId) {
 }
 /** A terminal root is not a settled tree. Only the daemon's exact owned tree
  * with a settled root and positively live descendants permits waiting. */
-export function capacityReadiness(seen, sessionId, operationId, turnId, items, allowDescendants = false) {
-    if (seen.provider_session_id !== sessionId || seen.terminal_turn_id !== undefined && seen.terminal_turn_id !== turnId || !nativeItemsSettled(items))
-        return "unproven";
-    const ids = Array.isArray(seen.tree_session_ids) ? seen.tree_session_ids : [];
-    if (!ids.length || ids[0] !== sessionId || ids.some(id => typeof id !== "string" || !id) || new Set(ids).size !== ids.length)
-        return "unproven";
-    const observations = Array.isArray(seen.tree_observations) ? seen.tree_observations : [];
-    const exactTree = observations.length === ids.length && ids.every(id => observations.filter(item => item.provider_session_id === id).length === 1);
-    const settlement = seen.settlement;
-    const budgetSettled = !settlement || settlement.state === "not_required" || settlement.state === "settled" && settlement.operation_ids?.includes(operationId) === true;
-    const treeSettled = allowDescendants ? exactTree && observations.every(item => item.settled === true) && Array.isArray(seen.unsettled_sessions) && seen.unsettled_sessions.length === 0 : ids.length === 1;
-    if (seen.settled === true && treeSettled && budgetSettled)
-        return "ready";
-    if (!allowDescendants || seen.settled !== false || !exactTree || ids.length < 2 || observations[0]?.provider_session_id !== sessionId || observations[0].settled !== true
-        || settlement && settlement.state !== "not_required" && !(settlement.state === "pending" && settlement.reason === "tree_unsettled"))
-        return "unproven";
-    const live = observations.filter(item => item.settled === false);
-    const unsettled = seen.unsettled_sessions;
-    const knownLive = live.length > 0 && live.every(item => item.provider_session_id !== sessionId && ["active", "running", "inProgress"].includes(String(typeof item.status === "object" && item.status ? item.status.type : item.status)));
-    return knownLive && observations.every(item => typeof item.settled === "boolean") && Array.isArray(unsettled) && unsettled.length === live.length && live.every(item => unsettled.includes(item.provider_session_id)) ? "owned_children_live" : "unproven";
+export function capacityReadiness(seen, sessionId, operationId, turnId, items, allowDescendants = false, requestProof) {
+    const readiness = nativeTreeReadiness(seen, { sessionId, operationId, turnId, allowDescendants, requestProof });
+    return readiness === "inspection_pending" ? readiness : nativeItemsSettled(items) ? readiness : "unproven";
 }
 /** Permit acquisition must still belong to the original task, not merely an
  * open RUN. Controls/inspection and ordinary successor prompts are unaffected. */
@@ -318,6 +303,7 @@ export async function continueProviderCapacity(input) {
             || confirmed?.request_proof.kind === "stream_request" && confirmed.request_proof.operation_id !== operationId) {
             throw blocked("Retained predecessor does not prove the exact terminal overloaded Turn");
         }
+        let pendingClock;
         const readiness = async () => {
             input.signal?.throwIfAborted();
             input.assertCurrent();
@@ -327,16 +313,48 @@ export async function continueProviderCapacity(input) {
             // An unloaded exact-Turn snapshot is not conflicting tool evidence.
             // Preserve the bound failure receipt, but never hide a pending item.
             const freshItems = seen.native_turn_items;
-            const items = (seen.terminal_turn_id === turnId && seen.terminal_status === "failed"
+            const stream = confirmed?.request_proof.kind === "stream_request";
+            const streamMetadata = seen.terminal_metadata;
+            const exactFresh = stream ? streamRequestKey(streamMetadata?.request_proof) === turnId : seen.terminal_turn_id === turnId && seen.terminal_status === "failed";
+            const items = (exactFresh
                 && !(freshItems?.observed === false && freshItems.pending !== true) ? freshItems : confirmed?.native_turn_items);
             if (confirmed?.request_proof.kind === "stream_request") {
                 const metadata = seen.terminal_metadata;
                 if (streamRequestKey(metadata?.request_proof) !== turnId)
                     return "unproven";
             }
-            return capacityReadiness(seen, input.sessionId, operationId, turnId, items, input.allowSettledDescendants);
+            const current = capacityReadiness(seen, input.sessionId, operationId, turnId, items, input.allowSettledDescendants, confirmed?.request_proof);
+            if (current === "inspection_pending") {
+                const saved = seen.native_settlement.observation_clock;
+                pendingClock ??= new ObservationClock({ timeoutMs: saved.timeout_ms, saved, snapshotIsLive: true });
+                if (pendingClock.sample(saved.cursor, saved.observed_at ?? undefined))
+                    return "unproven";
+            }
+            return current;
+        };
+        // Pending is a bound observer, not a refusal or an intent to write. Resolve
+        // it before retaining a productive retry. Its producer owns the old clock.
+        const waitForReadiness = async (initial) => {
+            let current = initial;
+            while (current === "owned_children_live" || current === "inspection_pending") {
+                await delay(250, undefined, { signal: input.signal });
+                const boundary = await decide();
+                if (boundary)
+                    return boundary;
+                current = await readiness();
+            }
+            if (current !== "ready")
+                throw blocked("Native predecessor readiness became unproven");
+            return null;
         };
-        const ready = await readiness();
+        let ready = await readiness();
+        while (ready === "inspection_pending") {
+            await delay(250, undefined, { signal: input.signal });
+            const boundary = await decide();
+            if (boundary)
+                return boundary;
+            ready = await readiness();
+        }
         if (ready === "unproven")
             throw blocked("Native predecessor readiness is unproven; do not cancel or replay to manufacture proof");
         if (ready === "ready") {
@@ -399,20 +417,7 @@ export async function continueProviderCapacity(input) {
         }
         // Intent/refusal are durable before the first wait; no permit or writer is
         // held here, and live siblings are never cancelled as a settlement proof.
-        const waitForOwnedChildren = async (initial) => {
-            let current = initial;
-            while (current === "owned_children_live") {
-                await delay(250, undefined, { signal: input.signal });
-                const boundary = await decide();
-                if (boundary)
-                    return boundary;
-                current = await readiness();
-            }
-            if (current !== "ready")
-                throw blocked("Owned native child readiness became unproven");
-            return null;
-        };
-        const childBoundary = await waitForOwnedChildren(ready);
+        const childBoundary = await waitForReadiness(ready);
         if (childBoundary)
             return childBoundary;
         // Node timers truncate large delays. Bounded slices preserve cancellation
@@ -427,7 +432,7 @@ export async function continueProviderCapacity(input) {
         const afterWait = await decide();
         if (afterWait)
             return afterWait;
-        const refreshedBoundary = await waitForOwnedChildren(await readiness());
+        const refreshedBoundary = await waitForReadiness(await readiness());
         if (refreshedBoundary)
             return refreshedBoundary;
         const beforeDispatch = await decide();

package/dist/services/release-cache.js

@@ -6,7 +6,9 @@ import { inspectReleaseArchive } from "./release-archive.js";
 import { verifyReleaseArchive } from "./release-manifest.js";
 import { acquireInstallationLock } from "./installation-lock.js";
 import { hybridDigest } from "./hybrid-contracts.js";
+import { publishSetup } from "../harness-runtime/lib/setup-progress.mjs";
 const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
+let cacheVerificationPass = 0;
 function refuse(reason) {
     throw new AppError("cache_integrity", "Release cache cannot be published", 1, { reason, phase: "cache_publication", effect: "no_effect", help: "setup" });
 }
@@ -33,6 +35,8 @@ function write(target, bytes, mode) {
     }
 }
 function retained(target, archive, entries) {
+    const observation = `release-cache:${++cacheVerificationPass}:${target}`;
+    publishSetup("probe_started", observation);
     if (!fs.lstatSync(target).isDirectory())
         refuse("unsafe_retained_cache");
     const archiveFile = path.join(target, "archive.tgz");
@@ -53,6 +57,7 @@ function retained(target, archive, entries) {
             directories.add(parts.slice(0, index).join("/"));
     }
     const seen = new Set();
+    let checked = 0;
     const visit = (root, relative) => {
         if (!fs.lstatSync(root).isDirectory())
             refuse("unsafe_retained_cache");
@@ -70,12 +75,15 @@ function retained(target, archive, entries) {
                 if (!stat.isFile() || entry?.kind !== "file" || stat.size !== entry.bytes.length || digest(fs.readFileSync(full)) !== digest(entry.bytes) || (stat.mode & 0o111) !== (entry.mode & 0o111))
                     refuse("retained_cache_changed");
                 seen.add(logical);
+                if (++checked % 64 === 0)
+                    publishSetup("identity_digest_progress", `${observation}:${checked}`);
             }
         }
     };
     visit(payload, "");
     if (seen.size !== entries.length)
         refuse("retained_cache_changed");
+    publishSetup("identity_digest_completed", observation);
 }
 /** Verify retained compressed and expanded bytes without executing or activating them. */
 export function verifyPublishedReleaseCache(target, archive) {

package/dist/services/run-control.js

@@ -1,5 +1,6 @@
 import { setFlowRunRecoveryPaused } from "./runs.js";
 import crypto from "node:crypto";
+import { nativeShutdownConfirmed } from "../harness-runtime/lib/native-children.mjs";
 import fs from "node:fs";
 import { ensureRunControlStorage } from "../storage/database.js";
 import { canonicalPath, resolveProjectRoot } from "../storage/paths.js";
@@ -414,7 +415,7 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
             const unfinished = receipts.filter(receipt => !["completed", "failed", "interrupted"].includes(String(receipt.state)));
             if (unfinished.some(receipt => receipt.daemon_id !== daemonId || String(receipt.operation) !== "session.create" || receipt.session_id !== null))
                 throw new AppError("shutdown_operation_unsettled", "Closed daemon retains an unfinished non-create operation", 1);
-            const stopped = receipts.find(receipt => receipt.daemon_id === daemonId && receipt.operation === "daemon.stop" && receipt.state === "completed" && receipt.result?.stopped === true && receipt.result?.clean === true);
+            const stopped = receipts.find(receipt => receipt.daemon_id === daemonId && receipt.operation === "daemon.stop" && receipt.state === "completed" && receipt.result?.stopped === true && nativeShutdownConfirmed(receipt.result, { daemonId }));
             if (!stopped)
                 throw new AppError("shutdown_receipt_required", "Closed daemon has no clean native shutdown receipt for its current identity", 1);
             closedDaemons.set(directory, { source: "retained_clean_shutdown", daemon_id: daemonId, operation_id: stopped.operation_id, session_ids: state.sessions.map(item => typeof item === "string" ? item : adapterSessionId(item)), stopped: true, settled: true, processes: records.map(record => ({ process_id: record.id, pid: record.pid, pid_started_at: record.pid_started_at })), result: stopped.result });

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

@@ -12,6 +12,7 @@ import { canonicalNativeOperation } from "../harness-runtime/lib/adapter-timeout
 import { retainedDaemonReply } from "../harness-runtime/lib/daemon-observation.mjs";
 import { readOperationRecord } from "../harness-runtime/lib/operation-progress.mjs";
 import { readNativeDaemonState } from "./managed-daemon-binding.js";
+import { validateCheckEnvironment } from "./check-environment.js";
 /** A paused RUN admits only its controller's exact accepted answer Turn. */
 export function controllerHitlAdmission(context, record, input) {
     if (input.operation !== "session.prompt" || !input.operationId || !input.promptSha256)
@@ -76,7 +77,7 @@ export function sessionArguments(context, manifest, session) {
     return ["--dd-flow-bin", manifest.flow_executable, "--dd-flow-home", context.ddFlowHome, "--project-root", manifest.request.project_root, "--state-dir", session.state_dir, "--journal", session.journal, "--cwd", session.cwd, "--provider", profile.provider, "--model", profile.model, "--reasoning", profile.reasoning, "--mode", profile.mode, "--permission", profile.permission, ...manifest.adapters[runtimeHarness(profile)].runtime_args, "--json"];
 }
 export function controllerEnvironment(context, manifest, session) {
-    const env = { ...context.env, DD_FLOW_HOME: context.ddFlowHome, DD_FLOW_BIN: manifest.flow_executable, DD_FLOW_RESOURCE_HOME: manifest.resource_home, DD_FLOW_RUNTIME_BUDGET: manifest.budget ? JSON.stringify(manifest.budget) : undefined };
+    const env = { ...context.env, ...validateCheckEnvironment(manifest.check_environment), DD_FLOW_HOME: context.ddFlowHome, DD_FLOW_BIN: manifest.flow_executable, DD_FLOW_RESOURCE_HOME: manifest.resource_home, DD_FLOW_RUNTIME_BUDGET: manifest.budget ? JSON.stringify(manifest.budget) : undefined };
     for (const key of ["DD_FLOW_CONTROLLER_TOKEN", "DD_FLOW_CONTROL_TOKEN", "DD_FLOW_DAEMON_ID", "DD_FLOW_RUNTIME_OWNER", "DD_FLOW_WORK_ID", "DD_FLOW_SESSION_ID", "CODEX_THREAD_ID"])
         delete env[key];
     if (session?.codex_home)

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

@@ -3,6 +3,7 @@ import crypto from "node:crypto";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { AppError } from "../shared/errors.js";
+import { validateCheckEnvironment } from "./check-environment.js";
 import { getResourceDatabase } from "../storage/database.js";
 import { finishManagedProcess, managedProcessRuntimeHome, managedProcessStatus, processIsAlive, processStartedAt, processTreeIsAlive, registerManagedProcess } from "./managed-processes.js";
 import { setFlowRunRecoveryPaused } from "./runs.js";
@@ -175,7 +176,7 @@ export async function spawnController(context, row) {
         const entry = (await import("./engines.js")).boundRunEngineEntrypoint(context, { projectRoot: run.project_root, runId: run.id });
         const output = fs.openSync(path.join(root, "controller.log"), "a", 0o600);
         try {
-            const child = spawn(process.execPath, [entry, "run", "drive", "serve", "--run", run.id, "--project-root", run.project_root, "--controller-id", controllerId, "--json"], { cwd: run.workspace_root, detached: true, stdio: ["ignore", output, output], env: { ...context.env, DD_FLOW_HOME: context.ddFlowHome, DD_FLOW_RESOURCE_HOME: manifest.resource_home, DD_FLOW_ENGINE_MODE: "1", DD_FLOW_CONTROLLER_TOKEN: token } });
+            const child = spawn(process.execPath, [entry, "run", "drive", "serve", "--run", run.id, "--project-root", run.project_root, "--controller-id", controllerId, "--json"], { cwd: run.workspace_root, detached: true, stdio: ["ignore", output, output], env: { ...context.env, ...validateCheckEnvironment(manifest.check_environment), DD_FLOW_HOME: context.ddFlowHome, DD_FLOW_RESOURCE_HOME: manifest.resource_home, DD_FLOW_ENGINE_MODE: "1", DD_FLOW_CONTROLLER_TOKEN: token } });
             await new Promise((resolve, reject) => { child.once("spawn", resolve); child.once("error", reject); });
             context.db.run("UPDATE run_controller_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(), launchId(row)]);
             child.unref();

package/dist/services/run-controller-recovery.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 { setTimeout as delay } from "node:timers/promises";
@@ -148,7 +149,7 @@ export async function resumeControllerSession(context, row, manifest, state, ass
     const call = (args, operationId) => controllerAdapter(executionContext, row, manifest, session, args, assertRecoveryOwner, operationId);
     if (processTreeIsAlive(record)) {
         const stopped = await call(["daemon", "stop", "--state-dir", session.state_dir, "--json"]);
-        if (stopped.stopped !== true || stopped.clean !== true)
+        if (!retired.daemon_id || stopped.stopped !== true || !nativeShutdownConfirmed(stopped, { daemonId: retired.daemon_id }))
             throw new AppError("recovery_native_shutdown_unproven", "Recovery requires a clean native close before replacing its daemon", 1);
         const deadline = Date.now() + 30_000;
         while (processTreeIsAlive(record) && Date.now() < deadline) {