@deksden-com/dd-flow-cli 0.9.0-beta.150 → 0.9.0-beta.151

package/dist/services/run-controller.js

@@ -45,14 +45,14 @@ import { assertNoCorrelatedRejection } from "./continuation-outcome.js";
 import { spawnController, recordControllerLauncher, claimControllerProcess, markControllerDispatchReady, assertControllerLeaseAllowed } from "./run-controller-process.js";
 import { controllerAdapter, controllerEnvironment, sessionArguments } from "./run-controller-adapter.js";
 import { retainedChildObserver } from "./controller-child-observer.js";
-import { capacityDelay, continueProviderCapacity, eligibleProviderChildOverload, providerChildFailure, ownedProviderBoundary } from "./provider-capacity.js";
+import { capacityDelay, continueProviderCapacity, eligibleProviderChildOverload, providerChildFailure, ownedProviderBoundary, unavailableProviderChildRecovery } from "./provider-capacity.js";
 import { resumeControllerSession, failControllerRecovery } from "./run-controller-recovery.js";
 import { captureControllerBoundary } from "./run-controller-capture.js";
 import { requestRunControl } from "./run-control-worker.js";
 import { storageSessionId } from "./session-identity.js";
-import { CAPACITY_POLICY, nativeItemsSettled, overloadExhausted, refusalObservation, terminalProviderOverload } from "../harness-runtime/lib/provider-overload-policy.mjs";
+import { RECOVERY_POLICY as CAPACITY_POLICY, nativeItemsSettled, recoveryExhausted as overloadExhausted, recoveryRefusal as refusalObservation, terminalProviderRecovery as terminalProviderOverload, normalizeRecoveryFailure } from "../harness-runtime/lib/provider-overload-policy.mjs";
 import { renderNativeChildFollowupInstruction } from "../harness-runtime/lib/delegation-instructions.mjs";
-import { closeSuccessfulChildCapacity } from "./controller-child-capacity.js";
+import { childCapacityDispatchAllowed, childCapacityRecoveryDecision, closeSuccessfulChildCapacity, reconcileChildCapacity } from "./controller-child-capacity.js";
 import { isObservationLoss } from "../harness-runtime/lib/operation-errors.mjs";
 export { resumeRunController } from "./run-controller-recovery.js";
 const preparedLaunchInputs = new WeakMap();
@@ -754,7 +754,8 @@ async function executeController(context, row, manifest, state, assertOwnership,
                         throw new AppError("capacity_continuation_conflict", "Retained capacity root has no failure receipt", 1);
                     throw JSON.parse(root.error_json);
                 }
-                if (childObserver(session)?.failed().length)
+                const failedChildren = childObserver(session)?.failed() ?? [];
+                if (failedChildren.length && !(kind === "child" && childCapacityDispatchAllowed(state, failedChildren, session.id, firstOperationId, digestBytes(text))))
                     throw new AppError("fanout_dispatch_fenced", "A retained child failure forbids another coordinator dispatch", 1);
                 promptPending = true;
                 observedPromptOperation = firstOperationId;
@@ -785,15 +786,15 @@ async function executeController(context, row, manifest, state, assertOwnership,
                     assertCurrent: () => {
                         assertOwner();
                     },
-                    decision: async (boundary) => {
+                    decision: async (boundary, currentFailure) => {
                         if (kind === "child") {
-                            const target = Object.entries(state.child_capacity ?? {}).find(([, retained]) => retained.operation_id === firstOperationId);
-                            if (!target)
-                                return "reconciliation_blocked";
                             const seen = await inspect(["session", "inspect", "--session-id", session.id, ...sessionArguments(context, manifest, session)], `${firstOperationId}:child-followup-observe`);
-                            const child = controllerNativeChildren(seen, session.id).find(item => item.session_id === target[0]);
-                            if (child?.parent_session_id === session.id && (child.status === "running" || child.terminal_turn_id && child.terminal_turn_id !== target[1].turn_id))
-                                return "completed";
+                            const parent = normalizeRecoveryFailure(currentFailure, session.id);
+                            const decision = childCapacityRecoveryDecision(state, controllerNativeChildren(seen, session.id), session.id, firstOperationId, parent?.request_proof.kind === "native_turn" ? parent.turn_id : undefined);
+                            if (decision !== "continue") {
+                                saveState(context, row, state);
+                                return decision;
+                            }
                         }
                         const view = getFlowRunStatus(executionContext, { projectRoot: manifest.request.project_root, runId: row.run_id });
                         const next = view.continuation;
@@ -1081,7 +1082,32 @@ async function executeController(context, row, manifest, state, assertOwnership,
             const session = state.sessions[state.current_session];
             const childHarness = runtimeHarness(session.profile);
             const baseline = new Set(state.native_baseline ?? []);
+            for (const intent of Object.values(state.child_capacity ?? {})) {
+                if (!intent.dispatched || !intent.operation_id || intent.parent_turn_id || !intent.prompt_sha256)
+                    continue;
+                let saved = context.db.get("SELECT input_json,receipt_json,status FROM run_controller_operations WHERE operation_id = ? AND controller_id = ? AND generation = ?", [intent.operation_id, row.controller_id, row.generation]);
+                if (!saved)
+                    continue;
+                const dispatch = JSON.parse(saved.input_json);
+                if (!saved.receipt_json && saved.status === "outcome_unknown" && dispatch.dispatch_phase !== "prepared" && dispatch.prompt_sha256 === intent.prompt_sha256 && Array.isArray(dispatch.args)) {
+                    // Existing adapter recovery reads its durable operation; it cannot
+                    // redispatch a productive operation past external_dispatch_possible.
+                    await controllerAdapter(executionContext, row, manifest, session, dispatch.args, assertOwner, intent.operation_id, cancellation.signal, renewLease);
+                    saved = context.db.get("SELECT input_json,receipt_json,status FROM run_controller_operations WHERE operation_id = ? AND controller_id = ? AND generation = ?", [intent.operation_id, row.controller_id, row.generation]);
+                }
+                if (!saved?.receipt_json)
+                    continue;
+                const receipt = JSON.parse(saved.receipt_json);
+                if ((saved.status === "completed" || dispatch.dispatch_phase === "receipt_observed") && dispatch.prompt_sha256 === intent.prompt_sha256
+                    && receipt.provider_session_id === session.id && receipt.turn?._meta?.zcode?.ddFlowRecovery?.operation_id === intent.operation_id
+                    && typeof receipt.turn._meta.zcodeNativeTurnId === "string" && receipt.turn._meta.zcodeNativeTurnId) {
+                    intent.parent_turn_id = receipt.turn._meta.zcodeNativeTurnId;
+                    saveState(context, row, state);
+                }
+            }
             let children = controllerNativeChildren(state.last_receipt ?? {}, session.id).filter(child => !baseline.has(child.session_id));
+            if (reconcileChildCapacity(state, children, session.id))
+                saveState(context, row, state);
             childObserver(session)?.observeSettledChildren(children);
             const retainedFailures = childObserver(session)?.failed() ?? [];
             children = controllerNativeChildren({ descendants: [...children, ...retainedFailures] }, session.id);
@@ -1091,7 +1117,35 @@ async function executeController(context, row, manifest, state, assertOwnership,
                     saveState(context, row, state);
                     appendEvent(context, row.controller_id, "capacity_child_episodes_completed", { child_session_ids: closedChildEpisodes });
                 });
-            if (children.some(child => child.status === "failed" && renderNativeChildFollowupInstruction(childHarness, child.session_id))) {
+            const queuedChild = children.find(child => state.child_capacity?.[child.session_id]?.phase === "native_message_accepted"
+                && (child.status === "failed" && state.child_capacity[child.session_id].turn_id === child.terminal_turn_id
+                    || child.status === "running" && child.continuation_admission?.proof_kind === "parent_tool_admission"));
+            if (queuedChild) {
+                const observedAt = Date.parse(state.child_capacity[queuedChild.session_id].last_signal_at ?? "");
+                if (!Number.isFinite(observedAt) || Date.now() - observedAt >= 600_000)
+                    throw new AppError("operation_observation_lost", "Accepted native child continuation has no new observed signal", 1, { child_session_id: queuedChild.session_id });
+                setStatus("waiting_for_children");
+                await delay(1000, undefined, { signal: cancellation.signal });
+                state.last_receipt = await call(session, ["session", "inspect", "--session-id", session.id, ...sessionArguments(context, manifest, session)], false);
+                saveState(context, row, state);
+                continue;
+            }
+            const recoveryUnavailable = children.map(child => {
+                const links = context.db.all("SELECT w.status FROM work_sessions ws JOIN works w ON w.work_id = ws.work_id WHERE w.project_id = ? AND w.run_id = ? AND ws.session_id = ?", [row.project_id, row.run_id, storageSessionId({ harness_id: childHarness, session_id: child.session_id })]);
+                return links.length > 1 || links.some(link => link.status !== "running") ? null : unavailableProviderChildRecovery(child, session.id);
+            }).find(Boolean);
+            if (recoveryUnavailable) {
+                if (children.every(child => ["completed", "failed", "cancelled", "settled_by_root"].includes(child.status)))
+                    throw recoveryUnavailable;
+                // A blocked child does not cancel healthy siblings. Observe their own
+                // native completion before reporting the unavailable continuation.
+                setStatus("waiting_for_children");
+                await delay(1000, undefined, { signal: cancellation.signal });
+                state.last_receipt = await call(session, ["session", "inspect", "--session-id", session.id, ...sessionArguments(context, manifest, session)], false);
+                saveState(context, row, state);
+                continue;
+            }
+            if (children.some(child => child.status === "failed" && renderNativeChildFollowupInstruction(childHarness, child))) {
                 const inspected = await call(session, ["session", "inspect", "--session-id", session.id, ...sessionArguments(context, manifest, session)], false);
                 state.last_receipt = inspected;
                 saveState(context, row, state);
@@ -1104,6 +1158,8 @@ async function executeController(context, row, manifest, state, assertOwnership,
                     if (linked.length > 1 || linked.some(link => link.status !== "running"))
                         continue;
                     const retained = state.child_capacity?.[failedChild.session_id];
+                    if (retained?.policy && retained.policy !== CAPACITY_POLICY)
+                        throw new AppError("capacity_policy_mismatch", "Retained child episode requires its original pinned recovery policy", 1);
                     const refusals = [...(retained?.refusals ?? [])];
                     if (refusals.some(item => item.turn_id === failedChild.terminal_turn_id))
                         continue;
@@ -1114,11 +1170,11 @@ async function executeController(context, row, manifest, state, assertOwnership,
                     await prepareMutation(() => { saveState(context, row, state); appendEvent(context, row.controller_id, "capacity_child_refusal", { child_session_id: failedChild.session_id, refusal: refusals.at(-1) }); });
                     const exhausted = overloadExhausted(refusals);
                     if (exhausted)
-                        throw new AppError("provider_unavailable", "Native child exhausted its overload continuation attempts", 1, { ...exhausted, reason: "overload_retries_exhausted", child_session_id: failedChild.session_id, primary_error: nativeFailure });
+                        throw new AppError("provider_unavailable", "Native child exhausted its provider continuation attempts", 1, { ...exhausted, child_session_id: failedChild.session_id, primary_error: nativeFailure });
                 }
                 // Continue one existing child at a time; another failed child does not
                 // create a second fanout wave or share this child's refusal counter.
-                const child = children.every(item => item.status === "failed" || item.status === "completed") ? failed.find(item => renderNativeChildFollowupInstruction(childHarness, item.session_id) && eligibleProviderChildOverload(item, session.id)) : undefined;
+                const child = children.every(item => item.status === "failed" || item.status === "completed") ? failed.find(item => renderNativeChildFollowupInstruction(childHarness, item) && eligibleProviderChildOverload(item, session.id)) : undefined;
                 const turnId = child?.terminal_turn_id;
                 const native = child && turnId ? providerChildFailure(child) : null;
                 const prior = child && state.child_capacity?.[child.session_id];
@@ -1143,7 +1199,7 @@ async function executeController(context, row, manifest, state, assertOwnership,
                     }
                     const exhausted = overloadExhausted(refusals);
                     if (exhausted)
-                        throw new AppError("provider_unavailable", "Native child exhausted its overload continuation attempts", 1, { ...exhausted, reason: "overload_retries_exhausted", child_session_id: child.session_id, primary_error: native });
+                        throw new AppError("provider_unavailable", "Native child exhausted its provider continuation attempts", 1, { ...exhausted, child_session_id: child.session_id, primary_error: native });
                     let wait;
                     try {
                         wait = prepared ? Math.max(0, Date.parse(prepared.not_before) - Date.now()) : capacityDelay(native, attempt);
@@ -1157,7 +1213,8 @@ async function executeController(context, row, manifest, state, assertOwnership,
                     const rootOperationId = prior?.root_operation_id ?? `${row.controller_id}:child:${digest([child.session_id, turnId]).slice(0, 16)}`;
                     const operationId = prepared?.operation_id ?? `${rootOperationId}:followup:${attempt}`;
                     state.child_capacity ??= {};
-                    state.child_capacity[child.session_id] = { turn_id: turnId, attempts: attempt, operation_id: operationId, root_operation_id: rootOperationId, policy: CAPACITY_POLICY, refusals, not_before: prepared?.not_before ?? new Date(Date.now() + wait).toISOString(), dispatched: false };
+                    const followupText = renderNativeChildFollowupInstruction(childHarness, child);
+                    state.child_capacity[child.session_id] = { turn_id: turnId, attempts: attempt, operation_id: operationId, root_operation_id: rootOperationId, policy: CAPACITY_POLICY, refusals, not_before: prepared?.not_before ?? new Date(Date.now() + wait).toISOString(), dispatched: false, phase: "prepare", prompt_sha256: digestBytes(followupText), ...(child.continuation_ref ? { continuation_ref: child.continuation_ref } : {}) };
                     await prepareMutation(() => { saveState(context, row, state); appendEvent(context, row.controller_id, "capacity_child_followup", { child_session_id: child.session_id, turn_id: turnId, attempt, operation_id: operationId }); });
                     const until = performance.now() + wait;
                     while (performance.now() < until) {
@@ -1186,15 +1243,27 @@ async function executeController(context, row, manifest, state, assertOwnership,
                         throw new AppError("capacity_child_followup_blocked", "Native child or Work changed during capacity wait", 1, { child_session_id: child.session_id, turn_id: turnId });
                     await renewLease();
                     assertOwner();
-                    const text = renderNativeChildFollowupInstruction(childHarness, child.session_id);
+                    const text = renderNativeChildFollowupInstruction(childHarness, child);
+                    // Fence dispatch before awaiting the parent: a lost ack must never
+                    // resend SendMessage into a child which may already be running.
+                    state.child_capacity[child.session_id].dispatched = true;
+                    state.child_capacity[child.session_id].phase = "dispatched";
+                    saveState(context, row, state);
                     await prompt(session, text, operationId, "child");
+                    const parentTurnId = state.last_receipt?.turn?._meta?.zcodeNativeTurnId;
+                    if (typeof parentTurnId === "string" && parentTurnId)
+                        state.child_capacity[child.session_id].parent_turn_id = parentTurnId;
                     state.child_capacity[child.session_id].dispatched = true;
                     saveState(context, row, state);
                     const after = await call(session, ["session", "inspect", "--session-id", session.id, ...sessionArguments(context, manifest, session)], false);
+                    const afterChildren = controllerNativeChildren(after, session.id);
+                    reconcileChildCapacity(state, afterChildren, session.id);
+                    if (after.descendants)
+                        after.descendants = afterChildren;
                     state.last_receipt = after;
                     saveState(context, row, state);
                     const observed = controllerNativeChildren(after, session.id).find(item => item.session_id === child.session_id);
-                    if (!observed || observed.status === "failed" && observed.terminal_turn_id === turnId)
+                    if (!observed || observed.status === "failed" && observed.terminal_turn_id === turnId && state.child_capacity[child.session_id].phase !== "native_message_accepted")
                         throw new AppError("capacity_child_followup_unconfirmed", "Native child did not advance to a new Turn after parent followup", 1, { child_session_id: child.session_id, turn_id: turnId });
                     continue;
                 }

package/dist/services/run-recovery-guard.js

@@ -1,6 +1,6 @@
 import crypto from "node:crypto";
 import { AppError } from "../shared/errors.js";
-import { CAPACITY_POLICY, MAX_OVERLOAD_RETRIES, overloadExhausted } from "../harness-runtime/lib/provider-overload-policy.mjs";
+import { RECOVERY_POLICY as CAPACITY_POLICY, MAX_OVERLOAD_RETRIES, recoveryExhausted as overloadExhausted } from "../harness-runtime/lib/provider-overload-policy.mjs";
 import { assertRunStartupSettled } from "./run-start-custody.js";
 export function recoveryPacketReceipt(binding) {
     if (!binding.packet_json || !binding.packet_sha256 || crypto.createHash("sha256").update(binding.packet_json).digest("hex") !== binding.packet_sha256)

package/dist/services/run-recovery-runtime.js

@@ -8,7 +8,7 @@ import { managedProcessBinding, processIsAlive, resourceHome } from "./managed-p
 import { getResourceDatabase } from "../storage/database.js";
 import { requireManagedDaemonBinding } from "./managed-daemon-binding.js";
 import { lifecycleRetryInstruction } from "../harness-runtime/lib/delegation-instructions.mjs";
-import { CAPACITY_POLICY, MAX_OVERLOAD_RETRIES, overloadExhausted } from "../harness-runtime/lib/provider-overload-policy.mjs";
+import { RECOVERY_POLICY as CAPACITY_POLICY, MAX_OVERLOAD_RETRIES, recoveryExhausted as overloadExhausted } from "../harness-runtime/lib/provider-overload-policy.mjs";
 /** Pin retained Session loading and its first acknowledgement Turn, never a general fence bypass. */
 export function prepareRunRecoveryDispatch(context, input) {
     if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/.test(input.operationId) || !path.isAbsolute(input.stateDir))

package/dist/services/stage-context.js

@@ -16,6 +16,16 @@ function assertContextRelocation(receipt) {
         || !Array.isArray(receipt.path_mapping) || receipt.path_mapping.some(item => !item || typeof item.from !== "string" || typeof item.to !== "string" || !path.isAbsolute(item.from) || !path.isAbsolute(item.to)))
         throw new AppError("context_relocation_invalid", "Stage context relocation lacks a verified import binding", 2);
 }
+function relocateDeclaredPath(source, receipts) {
+    let mapped = source;
+    for (const receipt of receipts) {
+        assertContextRelocation(receipt);
+        const selected = [...receipt.path_mapping].sort((a, b) => b.from.length - a.from.length).find(item => mapped === item.from || mapped.startsWith(`${item.from}${path.sep}`));
+        if (selected)
+            mapped = path.join(selected.to, path.relative(selected.from, mapped));
+    }
+    return mapped;
+}
 /** Physical packet locators may move; accepted decision/provenance blocks may not. */
 export function projectPacketLocators(text, receipts) {
     receipts.forEach(assertContextRelocation);
@@ -89,13 +99,7 @@ export function renderRetainedStageContext(input) {
         || !/^[a-f0-9]{64}$/.test(input.workspaceView.source_sha256) || !/^[a-f0-9]{64}$/.test(input.workspaceView.copy_sha256)))
         throw new AppError("context_workspace_view_invalid", "Stage context workspace view lacks its bound review-copy proof", 2);
     const mapPath = (source, workspaceSource = true) => {
-        let mapped = source;
-        for (const receipt of input.receipts) {
-            assertContextRelocation(receipt);
-            const selected = [...receipt.path_mapping].sort((a, b) => b.from.length - a.from.length).find(item => mapped === item.from || mapped.startsWith(`${item.from}${path.sep}`));
-            if (selected)
-                mapped = path.join(selected.to, path.relative(selected.from, mapped));
-        }
+        let mapped = relocateDeclaredPath(source, input.receipts);
         const view = input.workspaceView;
         if (view && workspaceSource && (mapped === view.from || mapped.startsWith(`${view.from}${path.sep}`)))
             mapped = path.join(view.to, path.relative(view.from, mapped));
@@ -149,6 +153,7 @@ export function loadExternalStageContextBytes(input) {
     return { value, sourcePath, materializedSha256, bytes };
 }
 export function prepareExternalStageContext(input) {
+    verifyImmutableContextSources(input.loaded.value);
     const destination = externalStageContextDestination(input);
     if (!fs.existsSync(destination))
         prepareOutputFile(destination);
@@ -206,6 +211,7 @@ export function applyExternalStageContext(input) {
     return installed;
 }
 export function renderExternalStageContext(input) {
+    verifyImmutableContextSources(input.loaded.value);
     const value = input.loaded.value;
     const sources = value.sources ?? [];
     const taskInput = value.task_input ?? [];
@@ -251,7 +257,7 @@ function validateContext(value, expectedStage) {
         for (const item of value[key]) {
             const valid = key === "accepted_decisions" ? text(item) || object(item) && (text(item.id) || text(item.statement)) && [item.id, item.statement].every(field => field === undefined || text(field))
                 : object(item) && text(item.role) && (key === "dynamic_roles" ? item.reason === undefined || text(item.reason)
-                    : text(item.path) && (key === "sources" ? text(item.reason) && (item.required === undefined || typeof item.required === "boolean") && (item.root === undefined || typeof item.root === "string" && ["project", "workspace", "run"].includes(item.root)) : item.sha256 === undefined || text(item.sha256)));
+                    : text(item.path) && (key === "sources" ? text(item.reason) && (item.sha256 === undefined || typeof item.sha256 === "string" && /^[a-f0-9]{64}$/.test(item.sha256)) && (item.required === undefined || typeof item.required === "boolean") && (item.root === undefined || typeof item.root === "string" && ["project", "workspace", "run"].includes(item.root)) : item.sha256 === undefined || text(item.sha256)));
             if (!valid)
                 throw new AppError("validation", `Invalid stage context ${key} item`, 2, { parameter: key });
         }
@@ -261,4 +267,46 @@ function validateContext(value, expectedStage) {
             throw new AppError("validation", `Stage context ${key} must be a nonempty string`, 2);
     }
 }
+function verifyImmutableContextSources(value) {
+    for (const source of value.sources ?? []) {
+        if (!source.sha256)
+            continue; // Ordinary mutable project documents are not frozen.
+        try {
+            const info = fs.lstatSync(source.path);
+            if (!info.isFile() || info.isSymbolicLink() || info.size > 2 * 1024 * 1024 || sha256(fs.readFileSync(source.path)) !== source.sha256)
+                throw new Error("changed");
+        }
+        catch {
+            throw new AppError("context_source_checksum_mismatch", "Immutable stage source is unavailable or changed", 2, { role: source.role });
+        }
+    }
+}
+/** Only an accepted CODE context may bind a diagnostic capability to checks. */
+export function browserCheckCapabilityEnvironment(context, runId, runHome) {
+    const row = context.db.get("SELECT project_id, index_json FROM runs WHERE id = ?", [runId]);
+    const ref = row ? JSON.parse(row.index_json).execution_profile?.stage_context_inputs?.code : null;
+    if (!ref)
+        return {};
+    const file = path.resolve(runHome, ref.path), relative = path.relative(runHome, file);
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        throw new AppError('context_source_checksum_mismatch', 'Stage context escaped RUN', 2);
+    const loaded = loadExternalStageContext({ file, expectedSha256: ref.sha256, stage: 'code' });
+    const sources = loaded.value.sources?.filter(item => item.role === 'browser_environment_capabilities' && item.root === 'run') ?? [];
+    if (!sources.length)
+        return {};
+    if (sources.length !== 1)
+        throw new AppError('context_source_checksum_mismatch', 'Browser capability source is ambiguous', 2);
+    const source = { ...sources[0], path: relocateDeclaredPath(sources[0].path, runContextRelocations(context, row.project_id, runId)) };
+    const filename = path.basename(source.path), namedHash = filename.match(/^browser-capabilities(?:-([a-f0-9]{64}))?\.json$/);
+    const expected = path.join(runHome, 'environment', filename);
+    let owned = false;
+    try {
+        owned = fs.realpathSync(source.path) === path.join(fs.realpathSync(runHome), 'environment', filename);
+    }
+    catch { /* Missing proof is not a foreign host lookup. */ }
+    if (!source.sha256 || !namedHash || namedHash[1] && namedHash[1] !== source.sha256 || path.resolve(source.path) !== expected || !owned)
+        throw new AppError('context_source_checksum_mismatch', 'Browser capability lacks its RUN binding', 2);
+    verifyImmutableContextSources({ ...loaded.value, sources: [source] });
+    return { DD_FLOW_BROWSER_CAPABILITY_PATH: source.path, DD_FLOW_BROWSER_CAPABILITY_SHA256: source.sha256 };
+}
 function sha256(value) { return crypto.createHash("sha256").update(value).digest("hex"); }

package/dist/services/vnext-fanout.js

@@ -305,7 +305,7 @@ export async function reconcileVnextFanout(context, input) {
             continue;
         }
         const link = active[0];
-        if (renderNativeChildFollowupInstruction(String(value.harness_id), String(child.session_id)) && eligibleProviderChildOverload(child, value.parent_session_id)) {
+        if (renderNativeChildFollowupInstruction(String(value.harness_id), child) && eligibleProviderChildOverload(child, value.parent_session_id)) {
             issues.push({ code: "child_capacity_pending", work_id: link.work_id, session_id: child.session_id });
             continue;
         }

package/dist/verification-components.json

@@ -0,0 +1,299 @@
+{
+  "schema_id": "dd-flow/verification-components@1",
+  "scope": "technical-matrix-publication-not-native-execution",
+  "matrix": {
+    "roots": [
+      "services/verification-matrix.js",
+      "services/stage-report-renderer.js",
+      "services/accepted-intent.js",
+      "services/check-runner-evidence.js",
+      "services/check-runner-proof.js"
+    ],
+    "runner_proof_contract": "dd-flow/check-runner-proof@1",
+    "files": [
+      "cli/command-inputs.js",
+      "cli/command-metadata.js",
+      "cli/command-option-descriptions.js",
+      "cli/help.js",
+      "cli/input-preparation.js",
+      "cli/native-hook-preparation.js",
+      "domain/contracts.js",
+      "domain/diagnostic-aspects.js",
+      "domain/diagnostic-flows.js",
+      "domain/entity-ids.js",
+      "domain/flow-contract.js",
+      "domain/session-coverage.js",
+      "domain/stage-catalog.js",
+      "domain/stage-handler-identities.js",
+      "domain/validation.js",
+      "protocol/local-files.js",
+      "runtime/context.js",
+      "schemas/merge-result.schema.json",
+      "schemas/merge-stage-report-legacy-0.4.2.schema.json",
+      "schemas/merge-stage-report.schema.json",
+      "schemas/plan-aspect-map.schema.json",
+      "schemas/plan-review-decision.schema.json",
+      "schemas/plan-review-result.schema.json",
+      "schemas/plan-stage-report.schema.json",
+      "schemas/protocol-dashboard-data.schema.json",
+      "schemas/protocol-plan.schema.json",
+      "schemas/run-control-receipt.schema.json",
+      "schemas/run-control-request.schema.json",
+      "schemas/run-engine-binding.schema.json",
+      "schemas/stage-finish-input.schema.json",
+      "schemas/stage-prompt.schema.json",
+      "schemas/stage-report.schema.json",
+      "schemas/stage-start-response.schema.json",
+      "services/accepted-intent.js",
+      "services/audit.js",
+      "services/branch-context.js",
+      "services/build-info.js",
+      "services/canon.js",
+      "services/check-environment.js",
+      "services/check-runner-evidence.js",
+      "services/check-runner-proof.js",
+      "services/cli-operation-classifier.js",
+      "services/cli-upgrade-allowlist.js",
+      "services/code-checks.js",
+      "services/command-context.js",
+      "services/config.js",
+      "services/descriptor-coordinator-session.js",
+      "services/descriptor-root-work.js",
+      "services/descriptor-run-settlement.js",
+      "services/descriptor-run-start.js",
+      "services/descriptor-stage-coordinator.js",
+      "services/descriptor-stage-settlement.js",
+      "services/descriptor-stage-start.js",
+      "services/diagnostic-evidence.js",
+      "services/diagnostic-report-publication.js",
+      "services/diagnostic-report.js",
+      "services/diagnostic-snapshot.js",
+      "services/diagnostic-stage-handlers.js",
+      "services/diagnostic-stage-results.js",
+      "services/diagnostic-work-batch.js",
+      "services/diagnostic-work-collection.js",
+      "services/diagnostic-work-registration.js",
+      "services/diagnostic-work-results.js",
+      "services/engines.js",
+      "services/eval-snapshots.js",
+      "services/execution-bundles.js",
+      "services/execution-policy.js",
+      "services/executor-onboarding.js",
+      "services/external-work-launch.js",
+      "services/flow-descriptors.js",
+      "services/flow-guidance.js",
+      "services/frozen-engine.js",
+      "services/generic-execution.js",
+      "services/hook-memory-routing.js",
+      "services/hook-recovery-guard.js",
+      "services/hook-session-observation.js",
+      "services/hooks.js",
+      "services/hybrid-contracts.js",
+      "services/hybrid-digest.js",
+      "services/ids.js",
+      "services/installation-lock.js",
+      "services/installed-flow-source.js",
+      "services/lanes.js",
+      "services/lifecycle-command.js",
+      "services/lifecycle-contract.js",
+      "services/lifecycle-invocations.js",
+      "services/managed-daemon-binding.js",
+      "services/managed-processes.js",
+      "services/memory-accepted-composition.js",
+      "services/memory-baseline-preservation.js",
+      "services/memory-completed-correction-wave.js",
+      "services/memory-compose-handler.js",
+      "services/memory-composition-acceptance.js",
+      "services/memory-composition-graph.js",
+      "services/memory-composition-registration.js",
+      "services/memory-composition-work-custody.js",
+      "services/memory-composition-work-results.js",
+      "services/memory-corrected-review-acceptance.js",
+      "services/memory-corrected-review-batch.js",
+      "services/memory-corrected-review-findings.js",
+      "services/memory-corrected-review-inputs.js",
+      "services/memory-corrected-review-projection.js",
+      "services/memory-corrected-review-receipt.js",
+      "services/memory-corrected-review-registration.js",
+      "services/memory-correction-check-receipt.js",
+      "services/memory-correction-input-owner.js",
+      "services/memory-custody-snapshot.js",
+      "services/memory-discover-handler.js",
+      "services/memory-finish-evidence.js",
+      "services/memory-finish-handler.js",
+      "services/memory-finish-integration.js",
+      "services/memory-finish-readiness.js",
+      "services/memory-git-integration.js",
+      "services/memory-historical-corrected-review.js",
+      "services/memory-historical-original-review.js",
+      "services/memory-historical-repair-registration.js",
+      "services/memory-historical-second-review.js",
+      "services/memory-init-bootstrap-readiness.js",
+      "services/memory-init-engine-release.js",
+      "services/memory-init-git-policy.js",
+      "services/memory-init-lint-capability.js",
+      "services/memory-init-preflight.js",
+      "services/memory-init-project-bootstrap.js",
+      "services/memory-init-request-candidate.js",
+      "services/memory-init-request-input.js",
+      "services/memory-init-resource-storage.js",
+      "services/memory-init-run-allocation.js",
+      "services/memory-init-startup-custody.js",
+      "services/memory-init-storage.js",
+      "services/memory-init-worktrunk-capability.js",
+      "services/memory-layer-publication.js",
+      "services/memory-layer.js",
+      "services/memory-lint-config.js",
+      "services/memory-native-review-copy.js",
+      "services/memory-normal-flow-entry.js",
+      "services/memory-ordinary-defaults.js",
+      "services/memory-permissions.js",
+      "services/memory-preflight-bootstrap-custody.js",
+      "services/memory-preflight-handler.js",
+      "services/memory-repair-current-view.js",
+      "services/memory-repair-document-delta.js",
+      "services/memory-repair-history.js",
+      "services/memory-repair-physical-binding.js",
+      "services/memory-repair-publication-files.js",
+      "services/memory-repair-publication-intent.js",
+      "services/memory-repair-publication-plan.js",
+      "services/memory-repair-publication-source.js",
+      "services/memory-repair-publication.js",
+      "services/memory-repair-registration.js",
+      "services/memory-repair-work-baseline.js",
+      "services/memory-repair-work-completion.js",
+      "services/memory-repair-work-custody.js",
+      "services/memory-repair-work-results.js",
+      "services/memory-repair-workspace.js",
+      "services/memory-repair-writer-copy.js",
+      "services/memory-result-binding.js",
+      "services/memory-retained-review-authority.js",
+      "services/memory-retained-review-results.js",
+      "services/memory-retained-second-baseline.js",
+      "services/memory-retained-second-repairs.js",
+      "services/memory-review-acceptance.js",
+      "services/memory-review-correction-plan.js",
+      "services/memory-review-handler.js",
+      "services/memory-review-inputs.js",
+      "services/memory-review-limits.js",
+      "services/memory-review-receipt.js",
+      "services/memory-review-registration.js",
+      "services/memory-review-work-custody.js",
+      "services/memory-review-work-input.js",
+      "services/memory-review-work-results.js",
+      "services/memory-second-corrected-review-inputs.js",
+      "services/memory-second-correction-plan.js",
+      "services/memory-second-repair-baseline.js",
+      "services/memory-second-repair-launch.js",
+      "services/memory-second-repair-registration.js",
+      "services/memory-second-repair-source.js",
+      "services/memory-second-review-acceptance.js",
+      "services/memory-source-observations.js",
+      "services/memory-stage-dispatch.js",
+      "services/memory-stage-results.js",
+      "services/memory-tool-probe.js",
+      "services/memory-upgrade-analysis-handler.js",
+      "services/memory-upgrade-bootstrap-readiness.js",
+      "services/memory-upgrade-evidence.js",
+      "services/memory-upgrade-inventory.js",
+      "services/memory-upgrade-publication-custody.js",
+      "services/memory-upgrade-publication.js",
+      "services/memory-upgrade-selection.js",
+      "services/memory-upgrade-storage-readiness.js",
+      "services/memory-verification-acceptance.js",
+      "services/memory-verification-checks.js",
+      "services/memory-verification-receipt.js",
+      "services/memory-verify-handler.js",
+      "services/memory-work-result-json.js",
+      "services/memory-work-result-preparation.js",
+      "services/merge-queue.js",
+      "services/migrations.js",
+      "services/native-session-control.js",
+      "services/operator-profiles.js",
+      "services/plan-runtime.js",
+      "services/portable-refs.js",
+      "services/project-registry.js",
+      "services/project-summary.js",
+      "services/projects.js",
+      "services/prompt-delivery.js",
+      "services/protocol-lifecycle.js",
+      "services/protocols.js",
+      "services/provider-capacity.js",
+      "services/recovery-snapshot-database.js",
+      "services/release-archive.js",
+      "services/release-cache.js",
+      "services/release-download.js",
+      "services/release-envelope.js",
+      "services/release-manifest.js",
+      "services/release-payload.js",
+      "services/release-source.js",
+      "services/repair-intents.js",
+      "services/repair-receipt.js",
+      "services/review-copy.js",
+      "services/review-deferral.js",
+      "services/run-control-receipt.js",
+      "services/run-control.js",
+      "services/run-controller-state.js",
+      "services/run-engine-bindings.js",
+      "services/run-observations.js",
+      "services/run-projection.js",
+      "services/run-recovery-guard.js",
+      "services/run-recovery.js",
+      "services/run-start-custody.js",
+      "services/runs.js",
+      "services/runtime-budget.js",
+      "services/runtime-command.js",
+      "services/schema-validation.js",
+      "services/scope-writer-cleanup.js",
+      "services/session-identity.js",
+      "services/sessions.js",
+      "services/setup.js",
+      "services/stage-context.js",
+      "services/stage-handlers.js",
+      "services/stage-lifecycle.js",
+      "services/stage-pause.js",
+      "services/stage-report-renderer.js",
+      "services/stage-work-graph.js",
+      "services/tooling.js",
+      "services/usage.js",
+      "services/verification-matrix.js",
+      "services/version-status.js",
+      "services/vnext-code-review.js",
+      "services/vnext-code.js",
+      "services/vnext-contracts.js",
+      "services/vnext-execution-profile.js",
+      "services/vnext-fanout.js",
+      "services/vnext-merge.js",
+      "services/vnext-plan-review.js",
+      "services/vnext-plan.js",
+      "services/vnext-protocolize.js",
+      "services/vnext-specify.js",
+      "services/vnext-workspace-policy.js",
+      "services/work-registry.js",
+      "services/workspace-bootstrap.js",
+      "services/workspace-files.js",
+      "services/worktrees.js",
+      "shared/entity-references.js",
+      "shared/errors.js",
+      "shared/json.js",
+      "storage/agent-output.js",
+      "storage/database.js",
+      "storage/foreign-key-transaction.js",
+      "storage/immutable-input.js",
+      "storage/import-guard.js",
+      "storage/native-cleanup.js",
+      "storage/paths.js",
+      "storage/projection-lock.js",
+      "storage/work-references.js",
+      "storage/writer-contract.js"
+    ],
+    "dependencies": [
+      "ajv/dist/2020.js",
+      "ajv/dist/ajv.js",
+      "semver",
+      "shell-quote",
+      "smol-toml",
+      "yaml"
+    ]
+  }
+}