@deksden-com/dd-flow-cli 0.9.0-beta.8 → 0.9.0-beta.81

package/dist/services/vnext-execution-profile.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { AppError } from "../shared/errors.js";
+import { isExecutionRouting } from "./execution-policy.js";
 const relativePath = path.join(".memory-bank", "dd-flow", "project-execution.json");
 /** The project owns defaults; a RUN snapshots them once and never re-infers them. */
 export function loadVnextExecutionProfile(projectRoot) {
@@ -13,7 +14,7 @@ export function loadVnextExecutionProfile(projectRoot) {
         throw new AppError("execution_profile_missing", "vNext flow requires .memory-bank/dd-flow/project-execution.json", 1, { file, cause: String(error) });
     }
     const profile = value;
-    if (profile.schema_id !== "dd-flow/project-execution@2"
+    if ((profile.schema_id !== "dd-flow/project-execution@2" && profile.schema_id !== "dd-flow/project-execution@3")
         || (profile.stage_session_mode !== undefined && profile.stage_session_mode !== "same_session" && profile.stage_session_mode !== "new_session")
         || !["auto", "off", "standard", "deep"].includes(String(profile.plan_review_mode))
         || (profile.code_review_mode !== undefined && !["auto", "off", "standard", "deep"].includes(String(profile.code_review_mode)))
@@ -22,8 +23,9 @@ export function loadVnextExecutionProfile(projectRoot) {
         || !["retain", "delete_after_success"].includes(String(profile.merge_cleanup?.source))
         || !["code_completed", "code_review_completed", "merge_completed"].includes(String(profile.stop_target))
         || !profile.code_bootstrap || typeof profile.code_bootstrap.command !== "string" || !profile.code_bootstrap.command.trim()
-        || typeof profile.code_bootstrap.policy_ref !== "string" || !profile.code_bootstrap.policy_ref.trim()) {
-        throw new AppError("execution_profile_invalid", "Project execution profile does not match dd-flow/project-execution@2", 1, { file });
+        || typeof profile.code_bootstrap.policy_ref !== "string" || !profile.code_bootstrap.policy_ref.trim()
+        || (profile.execution === undefined ? profile.schema_id === "dd-flow/project-execution@3" : !isExecutionRouting(profile.execution))) {
+        throw new AppError("execution_profile_invalid", "Project execution profile does not match its supported dd-flow schema", 1, { file });
     }
     return { ...profile, stage_session_mode: profile.stage_session_mode ?? "same_session", code_review_mode: profile.code_review_mode ?? "off" };
 }

package/dist/services/vnext-fanout.js

@@ -3,16 +3,32 @@ import path from "node:path";
 import { AppError } from "../shared/errors.js";
 import { resolveProjectRoot } from "../storage/paths.js";
 import { requireProjectByRoot } from "./projects.js";
-import { getFlowRunVariables } from "./runs.js";
-import { listWorks } from "./work-registry.js";
+import { getFlowRunVariables, appendFlowRunTimelineEvent } from "./runs.js";
+import { resolveExecutionPolicy } from "./execution-policy.js";
+import { listWorks, failWork, cancelWork } from "./work-registry.js";
+import { storageSessionId } from "./session-identity.js";
+import { reconcileUnfinishedChecks } from "./code-checks.js";
 import { vnextStageDirectory } from "../domain/stage-catalog.js";
 export const subagentCapacityKey = "runtime.subagent.available_slots";
-export const capacityProbe = {
-    fanout_size: 15,
-    probe_hold_seconds: 60,
-    cleanup_deadline_seconds: 180,
-    completion_token: "AGENT-NN"
-};
+/** External concurrency is policy, never evidence of native child qualification. */
+export function getStageFanoutCapacity(context, input) {
+    const projectRoot = resolveProjectRoot(input.projectRoot);
+    const project = requireProjectByRoot(context, projectRoot);
+    const run = context.db.get("SELECT index_json FROM runs WHERE project_id = ? AND id = ?", [project.id, input.runId]);
+    if (!run)
+        throw new AppError("not_found", "RUN is unavailable", 1);
+    const frozen = JSON.parse(run.index_json).execution_profile;
+    if (frozen?.settings.execution) {
+        if (!frozen.agent_profiles)
+            throw new AppError("execution_profile_not_frozen", "Fan-out needs the RUN's frozen profiles", 1);
+        const resolved = resolveExecutionPolicy({ ddFlowHome: context.ddFlowHome, policy: frozen.settings.execution, profiles: frozen.agent_profiles, stage: input.stage });
+        if (resolved.delegation.mode === "external")
+            return { run_key: null, available_slots: resolved.delegation.max_parallel, source: "external_policy" };
+    }
+    const variables = getFlowRunVariables(context, { projectRoot, runId: input.runId });
+    const available = variables.variables[subagentCapacityKey];
+    return { run_key: subagentCapacityKey, available_slots: typeof available === "number" && Number.isInteger(available) && available >= 0 ? available : null, source: "harness_qualification" };
+}
 export function fanoutState(input) {
     if (!input.hasWork)
         return input.dispatch === "none" ? "coordinator_required" : "dispatch_required";
@@ -43,21 +59,22 @@ export function getVnextFanoutStatus(context, input) {
     const projectRoot = resolveProjectRoot(input.projectRoot);
     const project = requireProjectByRoot(context, projectRoot);
     const run = context.db.get("SELECT run_root FROM runs WHERE project_id = ? AND id = ?", [project.id, input.runId]);
-    if (!run?.run_root)
-        throw new AppError("not_found", "RUN artifact root is unavailable", 1, { run_id: input.runId });
+    if (!run)
+        throw new AppError("not_found", "RUN is not registered", 1, { run_id: input.runId });
+    if (!run.run_root)
+        throw new AppError("runtime_artifact_missing", "RUN artifact root is unavailable", 1, { run_id: input.runId });
     const stageRoot = path.join(run.run_root, vnextStageDirectory(input.stage));
     const descriptor = readFanoutDescriptor(stageRoot);
     if (!descriptor)
         return { ok: true, run_id: input.runId, stage: input.stage, orchestration: null };
     if (descriptor.stage !== input.stage)
         throw new AppError("runtime_missing", "Stage fan-out descriptor belongs to another stage", 1, { requested_stage: input.stage, descriptor_stage: descriptor.stage });
-    const variables = getFlowRunVariables(context, { projectRoot, runId: input.runId });
-    const available = variables.variables[subagentCapacityKey];
+    const capacity = getStageFanoutCapacity(context, { projectRoot, runId: input.runId, stage: input.stage });
     const all = listWorks(context, { parentWorkId: descriptor.parent_work_id, includeResults: false });
     const ready = listWorks(context, { parentWorkId: descriptor.parent_work_id, ready: true, includeResults: false });
     const counts = Object.fromEntries(["created", "running", "completed", "failed", "cancelled"].map((status) => [status, all.works.filter((work) => work.status === status).length]));
     const hasWork = all.works.length > 0;
-    const capacityKnown = typeof available === "number" && Number.isInteger(available) && available >= 0;
+    const capacityKnown = capacity.available_slots !== null;
     return {
         ok: true,
         run_id: input.runId,
@@ -68,12 +85,110 @@ export function getVnextFanoutStatus(context, input) {
             // not: their coordinator first materializes the Work graph from its
             // authoritative prompt. An empty graph is therefore not a success.
             state: fanoutState({ dispatch: descriptor.dispatch, hasWork, capacityRequired: descriptor.capacity_required, capacityKnown, created: counts.created ?? 0, running: counts.running ?? 0 }),
-            capacity: {
-                run_key: subagentCapacityKey,
-                available_slots: capacityKnown ? available : null,
-                ...(descriptor.capacity_required && !capacityKnown ? { probe: capacityProbe } : {})
-            },
-            works: { ...counts, ready: ready.works.map((work) => ({ work_id: work.work_id, task: work.task, start_command: work.start_command })) }
+            capacity,
+            works: { ...counts, ready: ready.works.map((work) => ({ work_id: work.work_id, task: work.task, launch_policy: work.launch_policy, start_command: work.start_command })) }
         }
     };
 }
+/** Explicit controller mutation, separate from read-only fanout status.
+ * A native child may be mapped only by its registered identity. Reused native
+ * Sessions need a provider execution identity: without one we report ambiguity
+ * instead of applying a late event to the newest Work attempt. */
+export async function reconcileVnextFanout(context, input) {
+    const value = prepareNativeObservations(input.observations);
+    const status = getVnextFanoutStatus(context, input);
+    if (!status.orchestration)
+        return { ok: true, issues: [], reconciled: [] };
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const parent = storageSessionId({ harness_id: value.harness_id, session_id: value.parent_session_id });
+    const issues = [], reconciled = [];
+    for (const child of value.children) {
+        if (child.status === "running" || child.status === "unknown")
+            continue;
+        const sessionId = storageSessionId({ harness_id: value.harness_id, session_id: String(child.session_id) });
+        const links = context.db.all(`SELECT ws.id, ws.work_id, ws.status, w.status AS work_status, w.parent_work_id FROM work_sessions ws JOIN works w ON w.work_id = ws.work_id JOIN sessions s ON s.project_id = w.project_id AND s.session_id = ws.session_id WHERE w.project_id = ? AND w.run_id = ? AND ws.session_id = ? AND s.parent_session_id = ? ORDER BY ws.created_at`, [project.id, input.runId, sessionId, parent]);
+        const active = links.filter(link => link.status === "running" && link.work_status === "running" && link.parent_work_id === status.orchestration.parent_work_id);
+        if (!active.length) {
+            if (!links.length)
+                issues.push({ code: "child_launch_association_missing", session_id: child.session_id, outcome: child.status });
+            continue;
+        }
+        if (links.length !== 1 || active.length !== 1) {
+            issues.push({ code: "child_execution_ambiguous", session_id: child.session_id, work_ids: active.map(link => link.work_id) });
+            continue;
+        }
+        const link = active[0];
+        const pendingCheck = () => context.db.get("SELECT 1 FROM check_receipts WHERE project_id = ? AND run_id = ? AND work_id = ? AND status = 'running' LIMIT 1", [project.id, input.runId, link.work_id]);
+        if (pendingCheck()) {
+            const run = context.db.get("SELECT workspace_root, run_root FROM runs WHERE project_id = ? AND id = ?", [project.id, input.runId]);
+            try {
+                reconcileUnfinishedChecks(context, { projectId: project.id, runId: input.runId, workspaceRoot: run.workspace_root, runHome: run.run_root, workId: link.work_id });
+            }
+            catch (error) {
+                if (!(error instanceof AppError) || error.code !== "check_in_progress")
+                    throw error;
+            }
+            if (pendingCheck()) {
+                issues.push({ code: "child_check_in_progress", work_id: link.work_id });
+                continue;
+            }
+        }
+        if (context.db.get("SELECT 1 FROM works WHERE parent_work_id = ? AND status IN ('created','running','paused') LIMIT 1", [link.work_id])) {
+            issues.push({ code: "child_descendants_unsettled", work_id: link.work_id });
+            continue;
+        }
+        if (child.status === "completed") {
+            issues.push({ code: "execution_ended_without_work_result", work_id: link.work_id, session_id: child.session_id });
+            continue;
+        }
+        const reason = JSON.stringify({ source: "native_child_observation", harness_id: value.harness_id, session_id: child.session_id, work_session_id: link.id, outcome: child.status });
+        const result = await (child.status === "failed" ? failWork : cancelWork)(context, link.work_id, reason);
+        reconciled.push({ work_id: link.work_id, work_session_id: link.id, outcome: child.status, result });
+    }
+    appendFlowRunTimelineEvent(context, project.id, input.runId, { type: "native_child_reconciliation", stage: input.stage, observations: value, issues, reconciled });
+    return { ok: true, issues, reconciled };
+}
+/**
+ * Records every terminal native child at the Stage where it is first observed.
+ * This is separate from fan-out settlement: a historical child can be valid
+ * evidence for an earlier Work, while an unbound terminal child is retained
+ * as an inconsistency instead of being rediscovered in a later review wave.
+ */
+export function prepareNativeObservations(observations) {
+    const value = observations;
+    if (!value || typeof value.harness_id !== "string" || !value.harness_id.trim() || typeof value.parent_session_id !== "string" || !value.parent_session_id.trim() || !Array.isArray(value.children)
+        || value.children.some(child => !child || typeof child.session_id !== "string" || !child.session_id.trim() || typeof child.status !== "string" || !["running", "unknown", "completed", "failed", "cancelled"].includes(child.status)))
+        throw new AppError("usage", "Expected native observations: harness_id, parent_session_id and children[{session_id,status}]", 2);
+    if (new Set(value.children.map(child => child.session_id)).size !== value.children.length)
+        throw new AppError("usage", "Native observations must contain each child Session exactly once", 2);
+    return { harness_id: value.harness_id, parent_session_id: value.parent_session_id, children: value.children };
+}
+export function observeVnextNativeChildren(context, input) {
+    const value = prepareNativeObservations(input.observations);
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const parent = storageSessionId({ harness_id: value.harness_id, session_id: value.parent_session_id });
+    const issues = [], history = [], pending = [];
+    for (const child of value.children) {
+        const sessionId = storageSessionId({ harness_id: value.harness_id, session_id: String(child.session_id) });
+        const links = context.db.all(`SELECT ws.id, ws.work_id, ws.status, w.status AS work_status, w.parent_work_id, s.current_stage
+         FROM work_sessions ws JOIN works w ON w.work_id = ws.work_id
+         JOIN sessions s ON s.project_id = w.project_id AND s.session_id = ws.session_id
+        WHERE w.project_id = ? AND w.run_id = ? AND ws.session_id = ? AND s.parent_session_id = ? ORDER BY ws.created_at`, [project.id, input.runId, sessionId, parent]);
+        if (child.status === "running" || child.status === "unknown") {
+            pending.push({ session_id: child.session_id, outcome: child.status, links: links.map(link => ({ work_id: link.work_id, work_session_id: link.id })) });
+            continue;
+        }
+        if (!links.length) {
+            issues.push({ code: "unbound_native_delegation_detected", session_id: child.session_id, outcome: child.status, detected_at_stage: input.stage, origin_stage: "unknown" });
+            continue;
+        }
+        if (links.length !== 1) {
+            issues.push({ code: "child_execution_ambiguous", session_id: child.session_id, outcome: child.status, detected_at_stage: input.stage, work_ids: links.map(link => link.work_id) });
+            continue;
+        }
+        const link = links[0];
+        history.push({ session_id: child.session_id, outcome: child.status, work_id: link.work_id, work_session_id: link.id, work_status: link.work_status, origin_stage: link.current_stage ?? "unknown", detected_at_stage: input.stage });
+    }
+    appendFlowRunTimelineEvent(context, project.id, input.runId, { type: "native_child_observation", stage: input.stage, observations: value, issues, history, pending });
+    return { ok: true, issues, history, pending };
+}