@deksden-com/dd-flow-cli 0.9.0-beta.38 → 0.9.0-beta.40

package/dist/services/controller-fanout.js

@@ -0,0 +1,105 @@
+import { AppError } from "../shared/errors.js";
+import { getVnextFanoutStatus, observeVnextNativeChildren, reconcileVnextFanout, subagentCapacityKey } from "./vnext-fanout.js";
+import { getFlowRunVariables } from "./runs.js";
+import { dispatchVnextPlanReview } from "./vnext-plan-review.js";
+import { resolveExecutionPolicy } from "./execution-policy.js";
+/** The shared controller owns this former eval-only Work-graph decision. */
+export async function nextControllerFanout(context, input) {
+    const children = input.children.filter(child => child.status !== "settled_by_root");
+    const observations = { harness_id: input.harness, parent_session_id: input.sessionId, children };
+    if (children.length) {
+        const observed = observeVnextNativeChildren(context, { ...input, observations });
+        const issues = observed.issues;
+        if (issues.length)
+            throw new AppError("fanout_reconciliation_required", "Native children have unresolved lifecycle ownership", 1, { issues });
+    }
+    let fanout = getVnextFanoutStatus(context, input).orchestration;
+    if (!fanout)
+        return { kind: "none" };
+    if (children.length) {
+        const reconciled = await reconcileVnextFanout(context, { ...input, observations });
+        const issues = reconciled.issues.filter(issue => issue.code !== "child_check_in_progress");
+        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"))
+            return { kind: "wait", reason: "native_children_unsettled" };
+        fanout = getVnextFanoutStatus(context, input).orchestration;
+    }
+    if (fanout.state === "dispatch_required") {
+        dispatchVnextPlanReview(context, input);
+        fanout = getVnextFanoutStatus(context, input).orchestration;
+        if (fanout.state === "dispatch_required" || fanout.state === "capacity_required")
+            return { kind: "wait", reason: "qualified_capacity_required" };
+    }
+    const prompt = (text) => ({ kind: "prompt", prompt: text, fingerprint: JSON.stringify({ stage: input.stage, parent: fanout.parent_work_id, works: fanout.works, text }) });
+    if (fanout.state === "coordinator_required")
+        return prompt(`Continue the current ${input.stage} Stage using its authoritative packet. Materialize only its required Work graph with real dependencies. Do not launch children, finish the Stage, or start a successor. Return after registering the graph; the runtime will dispatch its ready Work.`);
+    if (fanout.works.failed || fanout.works.cancelled)
+        return prompt(`Some ${input.stage} child Work failed or was cancelled. Inspect its recorded receipts. Choose a legal scoped repair/retry or block the Stage with the concrete reason. Do not relaunch settled siblings or infer success from a child that omitted work finish.`);
+    if (fanout.works.ready.length) {
+        const choices = fanout.works.ready.map(work => {
+            const payload = context.db.get("SELECT payload_json FROM works WHERE work_id = ?", [work.work_id])?.payload_json;
+            const override = payload ? JSON.parse(payload).execution_override : undefined;
+            return { work, resolved: resolveExecutionPolicy({ ddFlowHome: context.ddFlowHome, policy: input.policy, profiles: input.profiles, stage: input.stage, ...(override ? { work: override } : {}) }) };
+        });
+        const external = choices.filter(choice => choice.resolved.delegation.mode === "external");
+        if (external.length) {
+            const maximum = Math.min(...external.map(choice => choice.resolved.delegation.max_parallel ?? 1));
+            return { kind: "external", works: external.slice(0, maximum).map(choice => choice.work) };
+        }
+        const variables = getFlowRunVariables(context, input);
+        const capacity = variables.variables[subagentCapacityKey];
+        if (typeof capacity !== "number" || !Number.isInteger(capacity) || capacity < 1)
+            return { kind: "wait", reason: "qualified_capacity_required" };
+        const wave = choices.slice(0, capacity).map(choice => choice.work);
+        return prompt([
+            `Launch exactly ${wave.length} direct native children for the current ${input.stage} Stage; the recorded capacity is ${capacity}.`,
+            "Use this harness's native child mechanism, not external roots or forks. Wait for these children to settle; do not cancel siblings because one failed. Do not finish this Stage or start a successor in this Turn.",
+            ...wave.map(work => {
+                if (!work.work_id || !work.start_command)
+                    throw new AppError("fanout_contract_invalid", "Ready Work omits its trusted start command", 1);
+                return `Assign one leaf child Work ${work.work_id}. ${work.launch_policy === "fresh_agent_required" ? "Use empty, non-inherited context when supported; a new Session id alone does not prove empty context." : "Inherit context only through the harness's declared mechanism."}\nIts first technical action must be this exact standalone command:\n${work.start_command}\nUse only the Work packet returned by it. Complete its declared result and exact work finish command, then stop. Do not create children or start another Work. Missing facts go through the Work's failure/result contract; only the coordinator handles Stage HITL.`;
+            })
+        ].join("\n\n"));
+    }
+    if (fanout.works.running)
+        return { kind: "wait", reason: "work_receipts_pending" };
+    if (fanout.works.created)
+        throw new AppError("fanout_graph_stalled", "Created Work has no ready or running dependency path", 1);
+    return prompt(`All declared ${input.stage} child Work has settled (${fanout.works.completed} completed). Read the accepted result receipts and continue this Stage's semantic decision under its original packet. Execute an exact repair command returned by a rejected stage finish; a rejection alone does not create repair Work. Return after finish or after declaring a repair graph. Do not start a successor Stage.`);
+}
+/** Normalize provider-observed topology only; never parse assistant prose. */
+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 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 || parent !== rootSessionId)
+            return;
+        const state = String(value.status ?? value.state ?? fallback).toLowerCase();
+        const status = ["completed", "complete", "done", "idle", "success", "succeeded"].includes(state) ? "completed" : state === "settled_by_root" ? "settled_by_root" : ["failed", "error"].includes(state) ? "failed" : ["cancelled", "canceled"].includes(state) ? "cancelled" : ["running", "active", "pending"].includes(state) ? "running" : fallback;
+        candidates.push({ session_id: id, parent_session_id: parent, status, source });
+    };
+    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), ...list(object(subagents.ended).items)])
+        add(value, "zcode/session/subagents", rootSessionId, "completed");
+    const unique = new Map();
+    for (const child of candidates) {
+        const previous = unique.get(child.session_id);
+        if (!previous || previous.status === "unknown" || previous.status === "running" && child.status !== "running")
+            unique.set(child.session_id, child);
+    }
+    return [...unique.values()].sort((left, right) => left.session_id.localeCompare(right.session_id));
+}

package/dist/services/engines.js

@@ -276,6 +276,8 @@ function runIdForArgs(args) {
     const [family, command, ...rest] = args;
     const parsed = parseLightArgs(rest);
     if (family === "run" && command !== "start" && command !== "list") {
+        if (["drive", "control", "recovery", "capacity"].includes(command ?? ""))
+            return option(parsed, "run");
         if (command === "flags")
             return positional(parsed, 1);
         return positional(parsed, 0);