@deksden-com/dd-flow-cli 0.9.0-beta.124 → 0.9.0-beta.127

package/dist/services/codex-capacity.js

@@ -2,6 +2,34 @@ import { setTimeout as delay } from "node:timers/promises";
 import crypto from "node:crypto";
 import { CAPACITY_POLICY, capacityBackoff, nativeItemsSettled, normalizeCodexFailure, overloadBurst, parseCapacityOperation, refusalObservation, terminalCodexOverload } from "../harness-runtime/lib/codex-capacity-policy.mjs";
 import { AppError } from "../shared/errors.js";
+import { isObservationLoss } from "../harness-runtime/lib/operation-errors.mjs";
+export function eligibleCodexChildOverload(child, parentSessionId) {
+    return typeof child.session_id === "string" && child.session_id !== parentSessionId && child.parent_session_id === parentSessionId && child.provenance !== "parent_mismatch" && child.status === "failed" && typeof child.terminal_turn_id === "string" && nativeItemsSettled(child.native_turn_items)
+        && terminalCodexOverload({ code: "turn_interrupted", details: { provider_session_id: child.session_id, turn_id: child.terminal_turn_id, native_turn_id: child.terminal_turn_id, terminal_status: "failed", provider_error: child.provider_error } }, child.session_id, child.terminal_turn_id);
+}
+/** 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";
+}
 /** Permit acquisition must still belong to the original task, not merely an
  * open RUN. Controls/inspection and ordinary successor prompts are unaffected. */
 export function assertCapacityOwnerAdmission(context, record, operationId, binding) {
@@ -96,6 +124,20 @@ export async function continueCodexCapacity(input) {
     const promptSha = crypto.createHash("sha256").update(text).digest("hex");
     let ordinal = parsed.ordinal + 1;
     const conflict = (message) => { throw new AppError("capacity_continuation_conflict", message, 1, { operation_id: operationId, root_operation_id: rootId, session_id: input.sessionId }); };
+    const blocked = (message) => new AppError("capacity_continuation_blocked", message, 1, { capacity_uncertainty: true, operation_id: operationId, root_operation_id: rootId, provider_session_id: input.sessionId, primary_error: error });
+    const observe = async (action, observedOperationId = operationId) => {
+        try {
+            return await action();
+        }
+        catch (cause) {
+            let primary = cause;
+            for (let depth = 0; depth < 4 && primary?.code === "harness_adapter_failed"; depth++)
+                primary = (primary.cause ?? primary.details?.cause);
+            if (isObservationLoss(primary))
+                throw new AppError("operation_observation_lost", "Capacity native observation was lost; do not cancel or resend", 1, { capacity_uncertainty: true, root_operation_id: rootId, operation_id: observedOperationId, provider_session_id: input.sessionId, predecessor_error: error, cause });
+            throw cause;
+        }
+    };
     const refusals = [...(input.retainedFailures?.() ?? [])];
     if (parsed.ordinal > history.length)
         conflict("Continuation has no complete retained predecessor chain");
@@ -132,7 +174,7 @@ export async function continueCodexCapacity(input) {
             throw error;
         let observed;
         try {
-            observed = await input.inspectOperation(intent.operation_id);
+            observed = await observe(() => input.inspectOperation(intent.operation_id), intent.operation_id);
         }
         catch (cause) {
             let code = cause;
@@ -142,28 +184,51 @@ export async function continueCodexCapacity(input) {
                 throw cause;
             break;
         }
-        if (observed.operation_id !== intent.operation_id || observed.session_id !== input.sessionId || observed.operation !== "session.prompt" || observed.primary_error)
-            throw error;
+        if (observed.operation_id !== intent.operation_id || observed.session_id !== input.sessionId || observed.operation !== "session.prompt")
+            conflict("Retained native successor identity changed");
+        if (observed.primary_error)
+            throw observed.primary_error;
+        while (["prepared", "dispatching", "running", "awaiting_provider", "outcome_unknown"].includes(String(observed.state))) {
+            input.signal?.throwIfAborted();
+            input.assertCurrent();
+            const boundary = await observe(async () => await input.decision?.() ?? "continue", intent.operation_id);
+            if (boundary === "completed" || boundary === "paused")
+                return { provider_session_id: input.sessionId, capacity_decision: boundary };
+            if (boundary === "reconciliation_blocked")
+                throw new AppError("capacity_continuation_blocked", "Retained native successor has an unresolved owner boundary", 1, { operation_id: intent.operation_id, primary_error: error });
+            if (input.deadline !== undefined && Date.now() >= input.deadline)
+                throw new AppError("capacity_owner_deadline_exceeded", "Retained successor exhausted its original deadline", 1);
+            await delay(250, undefined, { signal: input.signal });
+            observed = await observe(() => input.inspectOperation(intent.operation_id), intent.operation_id);
+            input.signal?.throwIfAborted();
+            input.assertCurrent();
+            if (observed.operation_id !== intent.operation_id || observed.session_id !== input.sessionId || observed.operation !== "session.prompt")
+                conflict("Retained native successor identity changed");
+            if (observed.primary_error)
+                throw observed.primary_error;
+        }
         if (observed.state === "completed" && observed.result && typeof observed.result === "object") {
             input.signal?.throwIfAborted();
             input.assertCurrent();
-            const boundary = await input.decision?.() ?? "continue";
+            const boundary = await observe(async () => await input.decision?.() ?? "continue", intent.operation_id);
             input.signal?.throwIfAborted();
             input.assertCurrent();
             if (boundary === "reconciliation_blocked")
                 throw new AppError("capacity_continuation_blocked", "Retained completion cannot be reconciled with its owner boundary", 1);
             return boundary === "paused" || boundary === "completed" ? { provider_session_id: input.sessionId, capacity_decision: boundary } : observed.result;
         }
+        if (observed.state === "failed" && observed.error && !terminalCodexOverload(observed.error, input.sessionId))
+            throw observed.error;
         if (observed.state !== "failed" || !terminalCodexOverload(observed.error, input.sessionId))
-            throw error;
+            throw new AppError("operation_observation_lost", "Retained successor outcome is not proven; do not resend", 1, { operation_id: intent.operation_id, primary_error: error, observed });
         operationId = intent.operation_id;
         error = observed.error;
         ordinal += 1;
     }
-    const decide = async () => {
+    const decide = async (observedOperationId = operationId) => {
         input.signal?.throwIfAborted();
         input.assertCurrent();
-        const decision = await input.decision?.() ?? "continue";
+        const decision = await observe(async () => await input.decision?.() ?? "continue", observedOperationId);
         input.signal?.throwIfAborted();
         input.assertCurrent();
         if (decision === "reconciliation_blocked")
@@ -183,45 +248,30 @@ export async function continueCodexCapacity(input) {
         const completed = await decide();
         if (completed)
             return completed;
-        const prior = await input.inspectOperation(operationId);
+        const prior = await observe(() => input.inspectOperation(operationId));
         const failure = prior.error;
         const confirmed = normalizeCodexFailure(failure, input.sessionId);
         const turnId = confirmed?.turn_id;
         input.signal?.throwIfAborted();
         input.assertCurrent();
+        if (prior.primary_error)
+            throw prior.primary_error;
         if (prior.operation_id !== operationId || prior.operation !== "session.prompt" || prior.session_id !== input.sessionId
             || prior.state !== "failed" || prior.primary_error || !turnId || !terminalCodexOverload(failure, input.sessionId, turnId)) {
-            if (ordinal === 1)
-                return null;
-            throw error;
+            throw blocked("Retained predecessor does not prove the exact terminal overloaded Turn");
         }
-        const settled = async () => {
+        const readiness = async () => {
             input.signal?.throwIfAborted();
             input.assertCurrent();
-            const seen = await input.inspectSession(turnId);
+            const seen = await observe(() => input.inspectSession(turnId));
             input.signal?.throwIfAborted();
             input.assertCurrent();
-            if (seen.terminal_turn_id !== undefined && seen.terminal_turn_id !== turnId)
-                return false;
-            const items = seen.terminal_turn_id === turnId && seen.terminal_status === "failed" ? seen.native_turn_items : confirmed?.native_turn_items;
-            if (!nativeItemsSettled(items))
-                return false;
-            const settlement = seen.settlement;
-            const ids = Array.isArray(seen.tree_session_ids) ? seen.tree_session_ids : [];
-            const observations = Array.isArray(seen.tree_observations) ? seen.tree_observations : [];
-            const treeProven = input.allowSettledDescendants
-                ? ids.length > 0 && ids[0] === input.sessionId && observations.length === ids.length
-                    && ids.every(id => observations.some(item => item.provider_session_id === id && item.settled === true))
-                    && Array.isArray(seen.unsettled_sessions) && seen.unsettled_sessions.length === 0
-                : ids.length === 1 && ids[0] === input.sessionId;
-            return seen.provider_session_id === input.sessionId && seen.settled === true && treeProven
-                && (!settlement || settlement.state === "not_required" || settlement.state === "settled" && settlement.operation_ids?.includes(operationId) === true);
+            const items = (seen.terminal_turn_id === turnId && seen.terminal_status === "failed" ? seen.native_turn_items : confirmed?.native_turn_items);
+            return capacityReadiness(seen, input.sessionId, operationId, turnId, items, input.allowSettledDescendants);
         };
-        if (!await settled()) {
-            if (ordinal === 1)
-                return null;
-            throw error;
-        }
+        const ready = await readiness();
+        if (ready === "unproven")
+            throw blocked("Native predecessor readiness is unproven; do not cancel or replay to manufacture proof");
         const native = normalizeCodexFailure(failure, input.sessionId, turnId);
         let refusal = refusals.find(item => item.ordinal === ordinal - 1);
         if (refusal && (refusal.turn_id !== turnId || refusal.session_id !== input.sessionId || refusal.policy !== CAPACITY_POLICY))
@@ -239,27 +289,52 @@ export async function continueCodexCapacity(input) {
                 conflict("Retained continuation has no original failure time");
             const observedAt = typeof native.observed_at === "string" && Number.isFinite(Date.parse(native.observed_at)) ? native.observed_at : new Date().toISOString();
             refusal = refusalObservation(failure, ordinal - 1, observedAt);
-            input.retainFailure?.(operationId, refusal);
+            if (!input.atomicIntent)
+                input.retainFailure?.(operationId, refusal);
             refusals.push(refusal);
         }
         const burst = overloadBurst(refusals);
-        if (burst)
+        if (burst) {
+            if (input.atomicIntent)
+                input.retainFailure?.(operationId, refusal);
             throw new AppError("provider_overload_burst", "Two consecutive continuation Turns were overloaded within two minutes", 1, { ...burst, root_operation_id: rootId, provider_session_id: input.sessionId, continuation_count: ordinal - 1, primary_error: failure });
+        }
         const nextId = `${rootId}:capacity:${ordinal}:session.prompt`;
         const existing = history.find(item => item.operation_id === nextId);
         if (existing && (existing.predecessor !== operationId || existing.turn_id !== turnId || existing.prompt_sha256 !== promptSha || existing.ordinal !== ordinal))
             throw error;
         const wait = existing ? Math.max(0, Date.parse(existing.not_before) - Date.now()) : capacityDelay(failure, ordinal);
-        if (!Number.isFinite(wait) || Date.now() + wait > 8.64e15 || input.deadline !== undefined && Date.now() + wait >= input.deadline)
+        if (!Number.isFinite(wait) || Date.now() + wait > 8.64e15 || input.deadline !== undefined && Date.now() + wait >= input.deadline) {
+            if (input.atomicIntent)
+                input.retainFailure?.(operationId, refusal);
             throw new AppError("capacity_owner_deadline_exceeded", "Continuation wait exceeds its original owner deadline", 1, { primary_error: failure, deadline: input.deadline ?? null });
+        }
         if (!existing) {
             const intent = { predecessor: operationId, operation_id: nextId, turn_id: turnId, ordinal, prompt_sha256: promptSha, not_before: new Date(Date.now() + wait).toISOString(), policy: CAPACITY_POLICY, root_operation_id: rootId, session_id: input.sessionId, deadline: input.deadline ?? null, refusal };
             input.retainIntent(intent);
             history.push(intent);
         }
+        // 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);
+        if (childBoundary)
+            return childBoundary;
         // Node timers truncate large delays. Bounded slices preserve cancellation
         // and owner checks; monotonic elapsed time does not renew a Retry-After.
-        const until = performance.now() + wait;
+        const until = performance.now() + Math.max(0, Date.parse(history.find(item => item.operation_id === nextId).not_before) - Date.now());
         while (performance.now() < until) {
             await delay(Math.min(250, Math.max(0, until - performance.now())), undefined, { signal: input.signal });
             const boundary = await decide();
@@ -269,19 +344,20 @@ export async function continueCodexCapacity(input) {
         const afterWait = await decide();
         if (afterWait)
             return afterWait;
-        if (!await settled())
-            throw new AppError("capacity_continuation_blocked", "Native predecessor settlement changed during capacity wait", 1, { primary_error: failure });
+        const refreshedBoundary = await waitForOwnedChildren(await readiness());
+        if (refreshedBoundary)
+            return refreshedBoundary;
         const beforeDispatch = await decide();
         if (beforeDispatch)
             return beforeDispatch;
         try {
-            return await input.prompt(nextId, text, ordinal);
+            return await observe(() => input.prompt(nextId, text, ordinal), nextId);
         }
         catch (nextError) {
             // A task can complete/pause while the daemon queues for its permit.
             // Admission then refuses the stale prompt; accept that owner decision
             // before treating the transport's rejection as another provider failure.
-            const finished = await decide();
+            const finished = await decide(nextId);
             if (finished)
                 return finished;
             error = nextError;

package/dist/services/codex-hook-delivery.js

@@ -5,8 +5,8 @@ import { commandOption, lifecycleCommandFromPayload, parseLifecycleCommand, cont
 /** The hook asks the existing daemon about native evidence; it cannot mint it. */
 export async function verifyCodexHookDelivery(env, payload) {
     const command = lifecycleCommandFromPayload(payload);
-    const parsed = command ? parseLifecycleCommand(command) : { kind: "none" };
-    if (parsed.kind === "none" && !parsed.unresolved && !(command && continuationCommand(command)))
+    const parsed = command ? parseLifecycleCommand(command) : { kind: "none", participation: "none" };
+    if (parsed.kind === "none" && !["lifecycle", "auxiliary"].includes(parsed.participation) && !(command && continuationCommand(command)))
         return undefined;
     const managed = (parsed.kind !== "none" && commandOption(parsed.invocation, "invocation-id")) || env.DD_FLOW_DAEMON_ID;
     if (!managed)

package/dist/services/compatibility-preflight.js

@@ -11,7 +11,10 @@ export function preflightCliCompatibility(context, args, env = process.env, reso
     if (!projectRoot) {
         return { ok: true, classification, compatibility: null };
     }
-    const selection = selectEngine(context, { projectRoot, env }, { allowCurrentInProcess: true }, classification);
+    // Compatibility checks the executing build/manifest identity. Routing and
+    // binding validate snapshot bytes before dispatch; maintenance must not
+    // rehash the dependency closure or spawn health probes on every lease ACK.
+    const selection = selectEngine(context, { projectRoot, env }, { allowCurrentInProcess: true, verifyCurrentContent: false }, classification);
     const compatibility = compatibilityReport(selection, classification);
     if (classification.mode === "read_only_diagnostics" || classification.mode === "mb_upgrade") {
         return { ok: true, classification, compatibility };

package/dist/services/controller-fanout.js

@@ -1,4 +1,5 @@
-import { AppError } from "../shared/errors.js";
+import { AppError, errorRecord } from "../shared/errors.js";
+import { normalizeNativeChildren } from "../harness-runtime/lib/native-children.mjs";
 import { getVnextFanoutStatus, observeVnextNativeChildren, reconcileVnextFanout, subagentCapacityKey } from "./vnext-fanout.js";
 import { getFlowRunVariables } from "./runs.js";
 import { dispatchVnextPlanReview } from "./vnext-plan-review.js";
@@ -57,7 +58,7 @@ export async function nextControllerFanout(context, input) {
         throw new AppError("stage_graph_compatibility_required", "The retained graph cannot be dispatched by this controller; use the RUN's pinned engine", 1, { stage: input.stage, run_id: input.runId, graph: fanout });
     if (children.length) {
         const reconciled = await reconcileVnextFanout(context, { ...input, observations });
-        const issues = reconciled.issues.filter(issue => issue.code !== "child_check_in_progress");
+        const issues = reconciled.issues.filter(issue => !["child_check_in_progress", "child_capacity_pending"].includes(issue.code));
         if (issues.length)
             throw new AppError("fanout_reconciliation_required", "Native child outcome requires reconciliation, not replay", 1, { issues });
         if (children.some(child => child.status === "running" || child.status === "unknown"))
@@ -106,81 +107,13 @@ export async function nextControllerFanout(context, input) {
         throw new AppError("fanout_graph_stalled", "Created Work has no ready or running dependency path", 1);
     return prompt("semantic_completion", semanticCompletionPrompt(input.stage, fanout.works.completed));
 }
-/** Normalize provider-observed topology only; never parse assistant prose. */
+/** Shared pinned runtime normalization; preserve structured errors at the TS boundary. */
 export function controllerNativeChildren(receipt, rootSessionId) {
-    const candidates = [];
-    const object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
-    const list = (value) => Array.isArray(value) ? value : [];
-    const text = (value, keys) => { for (const key of keys)
-        if (typeof value[key] === "string" && value[key])
-            return value[key]; return null; };
-    const settledTree = new Set(list(receipt.tree_observations)
-        .filter(value => object(value).settled === true)
-        .map(value => text(object(value), ["provider_session_id", "session_id"]))
-        .filter((id) => id !== null));
-    const add = (raw, source, scopedParent = null, fallback = "unknown") => {
-        const value = object(raw);
-        const id = text(value, ["provider_session_id", "session_id", "sessionId", "childSessionId", "conversation_id", "conversationId", "id", "subagentId"]);
-        const parent = text(value, ["parent_provider_session_id", "parent_session_id", "parentSessionId", "parentID", "parentId"]) ?? scopedParent;
-        if (!id)
-            return;
-        const outcomeError = object(value.outcome_error);
-        if (typeof outcomeError.code === "string")
-            throw new AppError(outcomeError.code, String(outcomeError.message ?? "Native child outcome is unconfirmed"), 1, { ...object(outcomeError.details), session_id: id, source });
-        const state = String(value.status ?? value.state ?? fallback).toLowerCase();
-        if (state === "lost")
-            throw new AppError("native_child_outcome_lost", "Native child ended without a recoverable outcome", 1, { session_id: id, parent_session_id: parent, source, native_status: state });
-        // Provider idle means no current activity, not a Work result. Only an
-        // explicit terminal result or a separately proven root settlement may be
-        // terminal here; unknown states stay unknown for reconciliation.
-        const status = ["completed", "complete", "done", "success", "succeeded"].includes(state) ? "completed" : state === "settled_by_root" ? "settled_by_root" : ["failed", "error"].includes(state) ? "failed" : ["cancelled", "canceled", "interrupted"].includes(state) ? "cancelled" : ["running", "active", "pending"].includes(state) ? "running" : fallback;
-        const rootChild = parent === rootSessionId;
-        const settled = rootChild && status === "unknown" && settledTree.has(id) ? "settled_by_root" : status;
-        candidates.push({ session_id: id, parent_session_id: parent ?? "", status: settled, source, ...(rootChild ? {} : { provenance: "parent_mismatch" }),
-            ...(text(value, ["terminal_turn_id"]) ? { terminal_turn_id: text(value, ["terminal_turn_id"]) } : {}),
-            ...(text(value, ["terminal_observed_at"]) ? { terminal_observed_at: text(value, ["terminal_observed_at"]) } : {}),
-            ...(value.provider_error !== undefined ? { provider_error: value.provider_error } : {}),
-            ...(value.native_turn_items && typeof value.native_turn_items === "object" ? { native_turn_items: value.native_turn_items } : {}) });
-    };
-    for (const value of list(receipt.descendants))
-        add(value, "adapter.descendants");
-    for (const value of list(receipt.children))
-        add(value, "opencode.session.children");
-    const subagents = object(object(receipt.evidence).subagents ?? receipt.subagents);
-    for (const value of list(subagents.running))
-        add(value, "zcode/session/subagents", rootSessionId, "running");
-    for (const value of list(subagents.completed))
-        add(value, "zcode/session/subagents", rootSessionId, "completed");
-    for (const value of list(object(subagents.ended).items)) {
-        const status = String(object(value).status ?? "unknown");
-        if (!["success", "failed", "cancelled", "lost"].includes(status))
-            throw new AppError("native_child_outcome_unavailable", "ZCode ended child has no recognized native outcome", 1, { child: value });
-        add(value, "zcode/session/subagents", rootSessionId);
+    try {
+        return normalizeNativeChildren(receipt, rootSessionId);
     }
-    const unique = new Map();
-    const rank = { unknown: 0, running: 1, settled_by_root: 2, completed: 3, failed: 3, cancelled: 3 };
-    for (const child of candidates) {
-        const previous = unique.get(child.session_id);
-        if (previous && previous.parent_session_id !== child.parent_session_id) {
-            // Keep the contradictory parent visible to the existing provenance gate,
-            // independently of input order or which source happened to say success.
-            const foreign = [previous, child].filter(item => item.parent_session_id !== rootSessionId).sort((a, b) => a.parent_session_id.localeCompare(b.parent_session_id))[0];
-            unique.set(child.session_id, { ...foreign, provenance: "parent_mismatch" });
-            continue;
-        }
-        if (previous && rank[previous.status] === 3 && rank[child.status] === 3 && previous.status !== child.status)
-            throw new AppError("native_child_outcome_conflict", "Native child has contradictory terminal outcomes", 1, { session_id: child.session_id, observations: [previous, child] });
-        if (previous && previous.status === child.status && previous.terminal_turn_id && child.terminal_turn_id && previous.terminal_turn_id !== child.terminal_turn_id)
-            throw new AppError("native_child_turn_conflict", "Native child has contradictory terminal Turn identities", 1, { session_id: child.session_id, observations: [previous, child] });
-        if (previous && previous.status === child.status) {
-            unique.set(child.session_id, { ...previous, ...child,
-                ...(child.terminal_turn_id ?? previous.terminal_turn_id ? { terminal_turn_id: child.terminal_turn_id ?? previous.terminal_turn_id } : {}),
-                ...(child.provider_error ?? previous.provider_error ? { provider_error: child.provider_error ?? previous.provider_error } : {}),
-                ...(child.native_turn_items ?? previous.native_turn_items ? { native_turn_items: child.native_turn_items ?? previous.native_turn_items } : {}) });
-            continue;
-        }
-        if (!previous || rank[child.status] > rank[previous.status])
-            unique.set(child.session_id, child);
+    catch (error) {
+        const record = errorRecord(error);
+        throw Object.assign(new AppError(record.code, record.message, record.exitCode, record.details), record);
     }
-    return [...unique.values()].sort((left, right) => left.session_id.localeCompare(right.session_id));
 }

package/dist/services/engines.js

@@ -82,7 +82,7 @@ export function installCurrentEngine(context, input = {}) {
             packageVersion: build.version,
             integrityChecksum: stagedChecksum
         }) : null;
-        if (duplicate) {
+        if (duplicate && manifestDiagnostics(duplicate, { checkEntrypoint: false }).length === 0) {
             fs.rmSync(tmp, { recursive: true, force: true });
             return {
                 ok: true,
@@ -141,7 +141,7 @@ export function doctorEngines(context, input = {}) {
     const installed = readInstalledManifests(root);
     const checks = installed.map(manifest => {
         const diagnostics = manifestDiagnostics(manifest);
-        return { engine: manifestSummary(manifest, diagnostics), status: diagnostics.length ? "corrupt" : "ok", diagnostics };
+        return { engine: manifestSummary(manifest, diagnostics), status: diagnostics.includes("entrypoint_probe_unavailable") ? "unverified" : diagnostics.length ? "corrupt" : "ok", diagnostics };
     });
     const classification = input.classification ?? classifyCliOperation(["engine", "doctor"], input.env ?? context.env);
     const selection = selectEngine(context, input, {}, classification);
@@ -223,6 +223,8 @@ export function bindRunEngine(context, input, prepared = prepareRunEngineBind(co
         encoding: "utf8",
         timeout: 30_000
     });
+    if (probe.error || probe.signal)
+        throw new AppError("run_engine_probe_unavailable", "Selected engine observation could not complete; compatibility is unknown", 1, { run_id: located.run_id, cause: probe.error?.message, signal: probe.signal });
     if (probe.status !== 0) {
         throw new AppError("run_engine_probe_failed", "Selected engine cannot read the RUN authority", 1, {
             run_id: located.run_id,
@@ -291,6 +293,8 @@ export function upgradeForkedRunEngine(context, input) {
         env: { ...process.env, ...context.env, DD_FLOW_HOME: context.ddFlowHome, DD_FLOW_ENGINE_MODE: "1", DD_FLOW_ENGINE_HOME: manifest.snapshot_root },
         encoding: "utf8", timeout: 30_000
     });
+    if (probe.error || probe.signal)
+        throw new AppError("fork_engine_probe_unavailable", "Selected engine observation could not complete; compatibility is unknown", 1, { run_id: located.run_id, cause: probe.error?.message, signal: probe.signal });
     if (probe.status !== 0)
         throw new AppError("fork_engine_probe_failed", "Selected engine cannot read the forked RUN", 1, { run_id: located.run_id, engine: manifestSummary(manifest), stderr: probe.stderr.slice(0, 2000) });
     const binding = { schema_id: runEngineBindingSchemaId, run_id: located.run_id, project_root: projectRoot, bound_at: context.now(), source: "fork_upgrade", reason: requiredText(input.reason, "reason"), engine: requested, probe: { status: "passed", command: `dd-flow ${probeArgs.join(" ")}` } };
@@ -429,7 +433,11 @@ export function selectEngine(context, input, options = {}, classification = inpu
     const requiredRange = stringValue(compatibility?.engine?.version_range) ?? (classification.mode === "mb_upgrade" ? null : `>=${build.version} <9999.0.0`);
     const recommended = stringValue(compatibility?.engine?.recommended_version) ?? build.version;
     const installHintTemplate = stringValue(compatibility?.engine?.old_engine_install_hint) ?? `npx ${packageName}@<version> engine install`;
-    const manifests = readInstalledManifests(engineStoreRoot(context.ddFlowHome))
+    // An engine-mode caller already executes this module's build. Another
+    // installed engine cannot establish compatibility for its current writes.
+    // Keep full snapshot validation in routing/binding, not lease maintenance.
+    const executingCurrent = options.allowCurrentInProcess && isEngineMode(input.env ?? process.env);
+    const manifests = executingCurrent ? [] : readInstalledManifests(engineStoreRoot(context.ddFlowHome))
         .filter((manifest) => manifest.package_name === packageName)
         .filter((manifest) => requiredRange !== null && satisfiesRange(manifest.package_version, requiredRange))
         .filter((manifest) => manifestHealthy(manifest))
@@ -447,7 +455,7 @@ export function selectEngine(context, input, options = {}, classification = inpu
         requiredRange !== null &&
         packageName === build.package_name &&
         satisfiesRange(build.version, requiredRange)
-        ? currentBuildManifest(context, build)
+        ? currentBuildManifest(context, build, options.verifyCurrentContent !== false)
         : null);
     const diagnostics = [
         ...targetBlockers,
@@ -465,9 +473,38 @@ export function selectEngine(context, input, options = {}, classification = inpu
         diagnostics
     };
 }
-function currentBuildManifest(context, build) {
+function currentBuildManifest(context, build, verifyContent) {
     const packageRoot = findPackageRoot(path.dirname(sourceFile)) ?? process.cwd();
-    return buildManifest(context, build.package_name, build.version, packageRoot, packageRoot, packageRoot);
+    const manifestFile = path.join(packageRoot, "engine.json");
+    const installedLayout = path.basename(path.dirname(path.dirname(packageRoot))) === "engines"
+        && path.basename(path.dirname(packageRoot)) === path.basename(path.dirname(engineVersionRoot(context.ddFlowHome, build.package_name, build.version)));
+    if (fs.existsSync(manifestFile) || installedLayout) {
+        const installed = readManifest(manifestFile);
+        // Use the executing module's physical root, never an environment alias.
+        // A damaged installed manifest must not become a development fallback.
+        if (!installed || installed.package_name !== build.package_name || installed.package_version !== build.version
+            || installed.engine_version !== build.version || installed.engine_id !== "dd-flow-engine"
+            || typeof installed.snapshot_root !== "string" || !fs.existsSync(installed.snapshot_root)
+            || fs.realpathSync(installed.snapshot_root) !== fs.realpathSync(packageRoot)
+            || typeof installed.entrypoint !== "string" || installed.integrity?.source !== "package_snapshot"
+            || typeof installed.integrity?.checksum !== "string" || !/^[a-f0-9]{64}$/.test(installed.integrity.checksum)
+            || (installed.schema_registry && (!Array.isArray(installed.schema_registry.entries)
+                || installed.schema_registry.entries.some(entry => !entry || typeof entry.path !== "string"
+                    || typeof entry.id !== "string" || typeof entry.name !== "string" || !/^[a-f0-9]{64}$/.test(entry.checksum ?? ""))))) {
+            throw new AppError("unhealthy_engine", "Executing engine snapshot manifest does not match its build", 1, { manifest: manifestFile });
+        }
+        const diagnostics = manifestDiagnostics(installed, { checkEntrypoint: false, verifyContent });
+        if (diagnostics.length)
+            throw new AppError("unhealthy_engine", "Executing engine snapshot is unhealthy", 1, { manifest: manifestFile, diagnostics });
+        return installed;
+    }
+    // Only an unmaterialized package has no snapshot proof. Canon and
+    // package-manager aliases are expected in development checkouts.
+    const manifest = buildManifest(context, build.package_name, build.version, packageRoot, packageRoot, packageRoot, null);
+    // An ephemeral routing choice has no snapshot proof. Hash bytes only when
+    // materializing/validating an installed snapshot, never on every CLI call.
+    manifest.integrity.mode = "degraded_local_development";
+    return manifest;
 }
 export function compatibilityContexts(context, input = {}) {
     const env = input.env ?? process.env;
@@ -614,7 +651,7 @@ function option(parsed, key) {
 function positional(parsed, index) {
     return parsed.positional[index] ?? null;
 }
-function buildManifest(context, packageName, version, packageRoot, snapshotRoot, checksumRoot) {
+function buildManifest(context, packageName, version, packageRoot, snapshotRoot, checksumRoot, checksum = engineSnapshotChecksum(checksumRoot)) {
     return {
         schema_id: engineManifestSchemaId,
         package_name: packageName,
@@ -635,7 +672,7 @@ function buildManifest(context, packageName, version, packageRoot, snapshotRoot,
         schema_registry: buildSchemaRegistry(checksumRoot),
         integrity: {
             source: "package_snapshot",
-            checksum: engineSnapshotChecksum(checksumRoot),
+            checksum,
             mode: "full_content"
         }
     };
@@ -703,19 +740,23 @@ export function prepareForkEngine(engineVersion, integrityChecksum) {
         throw new AppError("harness_runtime_unbuilt", "Build the CLI before preparing a fork", 1);
     const files = packageSnapshotFiles(packageRoot);
     if (integrityChecksum !== undefined) {
-        const checksum = crypto.createHash("sha256");
-        for (const [relative, source] of [...files].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
-            if (path.basename(relative) === "engine.json")
-                continue;
-            checksum.update(relative);
-            checksum.update("\0");
-            checksum.update(fs.readFileSync(source));
-            checksum.update("\0");
-        }
-        if (checksum.digest("hex") !== integrityChecksum)
+        const checksum = snapshotFilesChecksum(files);
+        if (checksum !== integrityChecksum)
             throw new AppError("fork_engine_unavailable", "Requested engine checksum differs from the invoking CLI artifact", 2, { requested: integrityChecksum });
     }
 }
+function snapshotFilesChecksum(files) {
+    const checksum = crypto.createHash("sha256");
+    for (const [relative, source] of [...files].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+        if (path.basename(relative) === "engine.json")
+            continue;
+        checksum.update(relative);
+        checksum.update("\0");
+        checksum.update(fs.readFileSync(source));
+        checksum.update("\0");
+    }
+    return checksum.digest("hex");
+}
 function readProductionDependencies(packageRoot) {
     try {
         const manifest = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
@@ -795,6 +836,9 @@ function readInstalledManifests(root) {
         if (!fs.statSync(packageRoot).isDirectory())
             continue;
         for (const versionDir of fs.readdirSync(packageRoot)) {
+            // Failed staging, activation backups and locks are not installations.
+            if (versionDir.startsWith(".") || /\.previous-\d+-\d+$/.test(versionDir) || versionDir.endsWith(".lock"))
+                continue;
             const manifest = readManifest(path.join(packageRoot, versionDir, "engine.json"));
             if (manifest)
                 manifests.push(manifest);
@@ -847,7 +891,7 @@ function manifestDiagnostics(manifest, options = {}) {
     if (!manifest.integrity || manifest.integrity.mode !== "full_content" || !manifest.integrity.checksum) {
         diagnostics.push("content_checksum_missing");
     }
-    else if (fs.existsSync(snapshotRoot)) {
+    else if (options.verifyContent !== false && fs.existsSync(snapshotRoot)) {
         try {
             if (engineSnapshotChecksum(snapshotRoot) !== manifest.integrity.checksum)
                 diagnostics.push("content_checksum_mismatch");
@@ -861,6 +905,8 @@ function manifestDiagnostics(manifest, options = {}) {
             const schemaPath = safeResolveSnapshotPath(manifest, entry.path);
             if (!schemaPath || !fs.existsSync(schemaPath))
                 diagnostics.push(`schema_registry_missing:${entry.name}`);
+            else if (options.verifyContent === false)
+                continue;
             else if (fileChecksum(schemaPath) !== entry.checksum)
                 diagnostics.push(`schema_registry_checksum_mismatch:${entry.name}`);
             else {
@@ -887,7 +933,9 @@ function manifestDiagnostics(manifest, options = {}) {
             stdio: ["ignore", "pipe", "pipe"],
             timeout: 15_000
         });
-        if (health.status !== 0)
+        if (health.error || health.signal)
+            diagnostics.push("entrypoint_probe_unavailable");
+        else if (health.status !== 0)
             diagnostics.push("entrypoint_dependency_load_failed");
     }
     return diagnostics;
@@ -1072,6 +1120,8 @@ function collectFiles(root, current, files) {
         if (entry.name === "engine.json")
             continue;
         const full = path.join(current, entry.name);
+        if (entry.isSymbolicLink())
+            throw new AppError("engine_integrity_symlink", "Pinned engine snapshot contains an unhashed symbolic link", 1, { path: path.relative(root, full) });
         if (entry.isDirectory())
             collectFiles(root, full, files);
         else if (entry.isFile())