@deksden-com/dd-flow-cli 0.4.2 → 0.6.0

package/dist/services/protocols.js

@@ -8,10 +8,11 @@ import { requireStage } from "../domain/validation.js";
 import { AppError } from "../shared/errors.js";
 import { parseJsonObject } from "../shared/json.js";
 import { ensureReadableFile } from "../storage/database.js";
-import { ensureDir, resolveProjectRoot, runtimePlanJsonPath, runtimeProtocolDir, runtimeStateJsonPath } from "../storage/paths.js";
+import { ensureDir, planJsonPath, resolveProjectRoot, runtimeProtocolDir, runtimeStateJsonPath } from "../storage/paths.js";
 import { appendAudit, getAuditEvents } from "./audit.js";
 import { requireProjectByRoot } from "./projects.js";
-import { ensureRuntimeProtocolFiles, readPlanFile, readStateFile, writeState } from "../protocol/local-files.js";
+import { ensureRuntimeProtocolFiles, readStateFile, writeState } from "../protocol/local-files.js";
+import { planSummary, planWithProgress, readCanonicalPlan } from "./plan-runtime.js";
 import { activeCodexSessionBindingsForProject, activeFlowSessionBindingsForProject, codexHomeProfilesForProject, codexHookEventsForProject, hookStatusForProject } from "./hooks.js";
 import { buildProtocolFlowGuidance } from "./flow-guidance.js";
 import { lifecycleIsTerminalFailure, lifecycleIsTerminalSuccess, normalizeProtocolLifecycle } from "./protocol-lifecycle.js";
@@ -46,7 +47,7 @@ export function registerProtocol(context, input) {
         JSON.stringify(state.blockers),
         JSON.stringify(state.active_def),
         runtimeStateJsonPath(context.ddFlowHome, project.id, protocolId),
-        runtimePlanJsonPath(context.ddFlowHome, project.id, protocolId),
+        planJsonPath(projectRoot, protocolId),
         existing?.created_at ?? now,
         now
     ];
@@ -88,7 +89,7 @@ export function getProtocolStatus(context, input) {
     const protocol = requireProtocol(context, input.protocolId, project.id);
     const runtime = readProtocolRuntimeState(context, protocol);
     const state = runtime.state;
-    const plan = readPlanFile(protocol.plan_path);
+    const plan = canonicalPlanIfPresent(context, protocol);
     const runDiagnostics = protocolRunDiagnostics(context, protocol, state);
     const queue = context.db.get("SELECT * FROM merge_queue WHERE project_id = ? AND protocol_id = ?", [protocol.project_id, protocol.id]);
     const lifecycle = normalizeProtocolLifecycle({ state, queueStatus: queue?.status ?? null });
@@ -99,7 +100,7 @@ export function getProtocolStatus(context, input) {
         diagnostics: [...runtime.diagnostics, ...runDiagnostics.diagnostics, ...lifecycle.diagnostics],
         latest_run: runDiagnostics.latest_run,
         state,
-        plan: plan ? summarizePlan(plan) : state.plan,
+        plan: plan ? planSummary(context, { projectId: protocol.project_id, protocolId: protocol.id, planPath: protocol.plan_path }) : state.plan,
         merge_queue: queue,
         branch_context: getProtocolBranchContext(context, { protocolId: protocol.id, projectRoot: project.root }).branch_context,
         flow_guidance: buildProtocolFlowGuidance({ state, latestRun: runDiagnostics.latest_run, queueStatus: queue?.status ?? null }),
@@ -334,11 +335,15 @@ export function readyForMerge(context, input) {
     if (missing.length > 0) {
         throw new AppError("readiness_missing_fields", "Protocol is missing explicit readiness fields", 1, { missing });
     }
-    if (state.active_def.length > 0) {
-        throw new AppError("readiness_blocked", "Protocol has open deferrals", 1, { active_def: state.active_def });
+    const blockingDefs = state.active_def.filter(isBlockingDeferral);
+    if (blockingDefs.length > 0) {
+        throw new AppError("readiness_blocked", "Protocol has open blocking deferrals", 1, { active_def: blockingDefs });
     }
-    const plan = readPlanFile(protocol.plan_path);
-    const openRequired = plan?.items.filter((item) => item.required && !["done", "skipped"].includes(item.status)) ?? [];
+    const plan = canonicalPlanIfPresent(context, protocol);
+    const openRequired = plan
+        ? planWithProgress(context, { projectId: protocol.project_id, protocolId: protocol.id, planPath: protocol.plan_path }).plan.items
+            .filter((item) => item.required && !["done", "skipped"].includes(item.status))
+        : [];
     if (openRequired.length > 0) {
         throw new AppError("readiness_plan_open", "Protocol has open required plan items", 1, {
             items: openRequired.map((item) => ({ id: item.id, status: item.status }))
@@ -374,6 +379,11 @@ export function readyForMerge(context, input) {
         flow_guidance: buildProtocolFlowGuidance({ state: nextState, latestRun: runDiagnostics.latest_run, queueStatus: "ready" })
     };
 }
+function isBlockingDeferral(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return true;
+    return value.blocking !== false;
+}
 export function syncProtocolFromRun(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const protocol = requireProtocol(context, input.protocolId, project.id);
@@ -738,7 +748,7 @@ export function readProtocolRuntimeState(context, protocol) {
                 source: "stable_runtime_state",
                 recommended_action: "legacy protocol state_path was moved to stable runtime storage"
             });
-            const stablePlanPath = runtimePlanJsonPath(context.ddFlowHome, protocol.project_id, protocol.id);
+            const stablePlanPath = planJsonPath(protocol.project_root, protocol.id);
             context.db.run("UPDATE protocols SET state_path = ?, plan_path = ? WHERE project_id = ? AND id = ?", [stableStatePath, stablePlanPath, protocol.project_id, protocol.id]);
             protocol.state_path = stableStatePath;
             protocol.plan_path = stablePlanPath;
@@ -752,9 +762,9 @@ export function readProtocolRuntimeState(context, protocol) {
             recommended_action: "runtime state reconstructed from SQLite; run cleanup scan/apply if this persists"
         });
     }
-    const plan = context.db.get("SELECT plan_json FROM plans WHERE project_id = ? AND protocol_id = ?", [protocol.project_id, protocol.id]);
-    const planSummary = plan
-        ? planSummaryForState(JSON.parse(plan.plan_json))
+    const plan = canonicalPlanIfPresent(context, protocol);
+    const summary = plan
+        ? planSummary(context, { projectId: protocol.project_id, protocolId: protocol.id, planPath: protocol.plan_path })
         : { plan_id: null, total: 0, done: 0, blocked: 0 };
     const flowContract = loadProjectFlowContract(protocol.project_root);
     const state = {
@@ -766,14 +776,14 @@ export function readProtocolRuntimeState(context, protocol) {
         next_action: protocol.next_action,
         route: JSON.parse(protocol.route_json),
         workspace: JSON.parse(protocol.workspace_json),
-        plan: planSummary,
+        plan: summary,
         blockers: JSON.parse(protocol.blockers_json),
         active_def: JSON.parse(protocol.active_def_json),
         flow_contract: flowContract,
         updated_at: protocol.updated_at
     };
     const stableStatePath = runtimeStateJsonPath(context.ddFlowHome, protocol.project_id, protocol.id);
-    const stablePlanPath = runtimePlanJsonPath(context.ddFlowHome, protocol.project_id, protocol.id);
+    const stablePlanPath = planJsonPath(protocol.project_root, protocol.id);
     ensureDir(path.dirname(stableStatePath));
     writeState(stableStatePath, state);
     context.db.run("UPDATE protocols SET state_path = ?, plan_path = ? WHERE project_id = ? AND id = ?", [stableStatePath, stablePlanPath, protocol.project_id, protocol.id]);
@@ -1162,16 +1172,10 @@ function protocolStatusPayload(protocol) {
         updated_at: protocol.updated_at
     };
 }
-function summarizePlan(plan) {
-    return planSummaryForState(plan);
-}
-function planSummaryForState(plan) {
-    return {
-        plan_id: plan.plan_id,
-        total: plan.items.length,
-        done: plan.items.filter((item) => item.status === "done").length,
-        blocked: plan.items.filter((item) => item.status === "blocked").length
-    };
+function canonicalPlanIfPresent(context, protocol) {
+    if (!fs.existsSync(protocol.plan_path))
+        return undefined;
+    return readCanonicalPlan(protocol.plan_path, protocol.id).plan;
 }
 function readinessMissingFields(state) {
     const missing = [];

package/dist/services/run-projection.js

@@ -1,29 +1,109 @@
 import fs from "node:fs";
 import path from "node:path";
+import { reconcileSessionCoverageRows } from "../domain/session-coverage.js";
 export function refreshRunSessionProjection(context, projectId, runId) {
-    const run = context.db.get("SELECT id, runtime_path, run_index_path, index_json FROM flow_runs WHERE project_id = ? AND id = ?", [projectId, runId]);
+    const run = context.db.get("SELECT id, status, project_root, subject_type, subject_id, runtime_path, run_index_path, index_json FROM flow_runs WHERE project_id = ? AND id = ?", [projectId, runId]);
     if (!run)
         return;
     const index = JSON.parse(run.index_json);
-    const sessions = context.db.all(`SELECT session_id, parent_session_id, role, session_kind, worker_id, current_stage, status,
+    const sessionRows = context.db.all(`SELECT session_id, parent_session_id, role, session_kind, worker_id, current_stage, status,
             created_at, updated_at, stopped_at, coverage_units_json
-       FROM flow_sessions WHERE project_id = ? AND run_id = ? ORDER BY created_at, session_id`, [projectId, runId]).map(sessionProjection);
-    if (JSON.stringify(index.sessions ?? []) === JSON.stringify(sessions))
+       FROM flow_sessions WHERE project_id = ? AND run_id = ? ORDER BY created_at, session_id`, [projectId, runId]);
+    const sessions = sessionRows.map(sessionProjection);
+    const coverage = reconcileSessionCoverageRows(sessionRows);
+    const sessionCoverage = {
+        status: coverage.status,
+        expected: coverage.expected_unit_ids,
+        observed: coverage.observed_unit_ids,
+        missing: coverage.missing_unit_ids,
+        diagnostics: coverage.diagnostics
+    };
+    const plan = run.subject_type === "protocol" ? planProjection(context, projectId, run.subject_id, run.project_root) : {};
+    const workers = workerProjection(context, projectId, runId);
+    if (JSON.stringify(index.sessions ?? []) === JSON.stringify(sessions)
+        && JSON.stringify(index.session_coverage) === JSON.stringify(sessionCoverage)
+        && JSON.stringify(index.plan_ref) === JSON.stringify(plan.plan_ref)
+        && JSON.stringify(index.plan_progress) === JSON.stringify(plan.plan_progress)
+        && JSON.stringify(index.workers ?? {}) === JSON.stringify(workers))
         return;
     index.sessions = sessions;
+    index.session_coverage = sessionCoverage;
+    if (plan.plan_ref)
+        index.plan_ref = plan.plan_ref;
+    if (plan.plan_progress)
+        index.plan_progress = plan.plan_progress;
+    index.workers = workers;
     index.updated_at = context.now();
-    const runtimeRevision = typeof index.runtime_revision === "number" ? index.runtime_revision + 1 : 1;
-    index.runtime_revision = runtimeRevision;
     const runtime = readJson(run.runtime_path);
-    if (runtime) {
-        runtime.sessions = sessions;
-        runtime.updated_at = index.updated_at;
-        runtime.runtime_revision = runtimeRevision;
-    }
-    writeJson(run.run_index_path, index);
-    writeJson(run.runtime_path, runtime ?? index);
+    const runtimeRevision = typeof runtime?.runtime_revision === "number"
+        ? runtime.runtime_revision + 1
+        : typeof index.runtime_revision === "number"
+            ? index.runtime_revision + 1
+            : 1;
+    index.runtime_revision = runtimeRevision;
+    const authoritative = runtime ?? { ...index, schema_id: "dd-flow/flow-run@2" };
+    authoritative.sessions = sessions;
+    authoritative.session_coverage = sessionCoverage;
+    if (plan.plan_ref)
+        authoritative.plan_ref = plan.plan_ref;
+    if (plan.plan_progress)
+        authoritative.plan_progress = plan.plan_progress;
+    authoritative.workers = workers;
+    authoritative.updated_at = index.updated_at;
+    authoritative.runtime_revision = runtimeRevision;
+    if (run.status !== "discarded" || fs.existsSync(run.runtime_path))
+        writeJson(run.runtime_path, authoritative);
     context.db.run("UPDATE flow_runs SET index_json = ?, updated_at = ? WHERE project_id = ? AND id = ?", [JSON.stringify(index), index.updated_at, projectId, runId]);
 }
+function planProjection(context, projectId, protocolId, projectRoot) {
+    const binding = context.db.get("SELECT plan_path, plan_revision, plan_sha256 FROM plan_bindings WHERE project_id = ? AND protocol_id = ?", [projectId, protocolId]);
+    if (!binding)
+        return {};
+    const planPath = path.relative(projectRoot, binding.plan_path).split(path.sep).join("/");
+    const planId = readPlanId(binding.plan_path);
+    const progress = Object.fromEntries(context.db.all("SELECT item_id, status, summary, evidence_json FROM plan_progress WHERE project_id = ? AND protocol_id = ? ORDER BY item_id", [projectId, protocolId]).map((row) => [row.item_id, {
+            status: row.status,
+            ...(row.summary ? { summary: row.summary } : {}),
+            ...(parseStringArray(row.evidence_json).length > 0 ? { evidence: parseStringArray(row.evidence_json) } : {})
+        }]));
+    return {
+        plan_ref: {
+            path: planPath,
+            plan_id: planId,
+            revision: binding.plan_revision,
+            sha256: binding.plan_sha256
+        },
+        plan_progress: progress
+    };
+}
+function readPlanId(planPath) {
+    try {
+        const value = JSON.parse(fs.readFileSync(planPath, "utf8"));
+        if (value && typeof value === "object" && !Array.isArray(value) && typeof value.plan_id === "string") {
+            return value.plan_id;
+        }
+    }
+    catch {
+        // The canonical validator owns malformed-plan errors; projection stays bounded.
+    }
+    return "unknown-plan";
+}
+function workerProjection(context, projectId, runId) {
+    return Object.fromEntries(context.db.all("SELECT job_id, plan_item_id, status, worker_session_id FROM flow_jobs WHERE project_id = ? AND run_id = ? ORDER BY job_id", [projectId, runId]).map((job) => [job.job_id, {
+            units: [job.plan_item_id],
+            status: { pending: "registered", done: "completed" }[job.status] ?? job.status,
+            ...(job.worker_session_id ? { session_id: job.worker_session_id } : {})
+        }]));
+}
+function parseStringArray(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) && parsed.every((entry) => typeof entry === "string") ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
 function sessionProjection(row) {
     return {
         session_id: row.session_id,