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

package/dist/schemas/protocol-plan.schema.json

@@ -0,0 +1,197 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "dd-flow/protocol-plan@1",
+  "title": "Canonical semantic protocol plan",
+  "description": "The repository-owned semantic plan. Runtime progress, workers, timestamps and mechanical evidence do not belong here.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["$schema", "schema_id", "plan_id", "protocol_id", "revision", "title", "summary", "specifications", "protocol_reference", "goal", "task_assessment", "route_decision", "policy_context", "sdlc_contours", "items", "verification", "code_handoff"],
+  "properties": {
+    "$schema": {"type": "string", "minLength": 1},
+    "schema_id": {"const": "dd-flow/protocol-plan@1"},
+    "plan_id": {"type": "string", "pattern": "^PLAN-[A-Za-z0-9][A-Za-z0-9._-]*$"},
+    "protocol_id": {"type": "string", "pattern": "^PRT-[A-Za-z0-9][A-Za-z0-9._-]*$"},
+    "revision": {"type": "integer", "minimum": 1},
+    "title": {"type": "string", "minLength": 1},
+    "summary": {"type": "string", "minLength": 1},
+    "specifications": {
+      "type": "array", "minItems": 1, "uniqueItems": true,
+      "items": {
+        "type": "object", "additionalProperties": false,
+        "required": ["id", "version", "path", "sha256", "requirements"],
+        "properties": {
+          "id": {"type": "string", "pattern": "^SPC-[0-9]{3}$"},
+          "version": {"type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$"},
+          "path": {"type": "string", "pattern": "^\\.memory-bank/"},
+          "sha256": {"type": "string", "pattern": "^[a-f0-9]{64}$"},
+          "requirements": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "pattern": "^R-[0-9]+$"}}
+        }
+      }
+    },
+    "protocol_reference": {
+      "type": "object", "additionalProperties": false, "required": ["path", "sha256"],
+      "properties": {
+        "path": {"type": "string", "pattern": "^\\.memory-bank/protocol/"},
+        "sha256": {"type": "string", "pattern": "^[a-f0-9]{64}$"}
+      }
+    },
+    "goal": {
+      "type": "object", "additionalProperties": false, "required": ["outcome", "constraints", "non_goals"],
+      "properties": {
+        "outcome": {"type": "string", "minLength": 1},
+        "constraints": {"type": "array", "items": {"type": "string", "minLength": 1}},
+        "non_goals": {"type": "array", "items": {"type": "string", "minLength": 1}}
+      }
+    },
+    "task_assessment": {"$ref": "#/definitions/taskAssessment"},
+    "route_decision": {
+      "type": "object", "additionalProperties": false,
+      "required": ["initial_state", "selected_route", "selected_execution_mode", "reason", "capacity_probe", "packing"],
+      "properties": {
+        "initial_state": {"const": "orchestrator_local"},
+        "selected_route": {"enum": ["local_compact", "single_wave_grouped", "multi_wave_grouped", "external_handoff"]},
+        "selected_execution_mode": {"type": "string", "minLength": 1},
+        "reason": {"type": "string", "minLength": 1},
+        "capacity_probe": {"type": "string", "minLength": 1},
+        "packing": {"type": "string", "minLength": 1}
+      }
+    },
+    "policy_context": {
+      "type": "object", "additionalProperties": false,
+      "required": ["target_language", "source_authority", "current_truth_boundary", "validation", "lint"],
+      "properties": {
+        "target_language": {"type": "string", "minLength": 1},
+        "source_authority": {"type": "string", "minLength": 1},
+        "current_truth_boundary": {"type": "string", "minLength": 1},
+        "validation": {"type": "string", "minLength": 1},
+        "lint": {"type": "string", "minLength": 1}
+      }
+    },
+    "sdlc_contours": {
+      "type": "object", "additionalProperties": false, "required": ["summary", "contours"],
+      "properties": {
+        "summary": {"type": "string", "minLength": 1},
+        "contours": {
+          "type": "array", "minItems": 1,
+          "items": {
+            "type": "object", "additionalProperties": false,
+            "required": ["name", "applicability_status", "gate_status", "target_stage", "summary"],
+            "properties": {
+              "name": {"type": "string", "minLength": 1},
+              "applicability_status": {"enum": ["applicable", "external", "not_applicable"]},
+              "gate_status": {"enum": ["required", "deferred", "not_applicable"]},
+              "target_stage": {"enum": ["specify", "plan", "code", "readiness", "merge", "release"]},
+              "summary": {"type": "string", "minLength": 1}
+            }
+          }
+        }
+      }
+    },
+    "items": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"$ref": "#/definitions/planItem"}},
+    "verification": {
+      "type": "object", "additionalProperties": false, "required": ["scenario_seeds", "commands", "acceptance"],
+      "properties": {
+        "scenario_seeds": {"type": "array", "minItems": 1, "items": {"type": "string", "minLength": 1}},
+        "commands": {"type": "array", "minItems": 1, "items": {"type": "string", "minLength": 1}},
+        "acceptance": {"type": "string", "minLength": 1}
+      }
+    },
+    "code_handoff": {
+      "type": "object", "additionalProperties": false,
+      "required": ["must_read", "accepted_plan_ref", "companion_handoffs", "next_stage", "known_external_gate"],
+      "properties": {
+        "must_read": {"type": "array", "minItems": 1, "items": {"type": "string", "minLength": 1}},
+        "accepted_plan_ref": {
+          "type": "object", "additionalProperties": false, "required": ["path", "revision", "sha256"],
+          "properties": {
+            "path": {"type": "string", "pattern": "^\\.memory-bank/protocol/[^/]+/plan\\.json$"},
+            "revision": {"type": "integer", "minimum": 1},
+            "sha256": {"enum": ["computed_by_stage_finish"]}
+          }
+        },
+        "companion_handoffs": {
+          "type": "array",
+          "items": {
+            "type": "object", "additionalProperties": false, "required": ["protocol_id", "repository", "scope"],
+            "properties": {
+              "protocol_id": {"type": "string", "pattern": "^PRT-[A-Za-z0-9][A-Za-z0-9._-]*$"},
+              "repository": {"type": "string", "minLength": 1},
+              "scope": {"type": "string", "minLength": 1}
+            }
+          }
+        },
+        "next_stage": {"enum": ["code", "readiness", "merge", "release"]},
+        "known_external_gate": {"type": "string", "minLength": 1}
+      }
+    }
+  },
+  "definitions": {
+    "semanticSpine": {
+      "type": "object", "additionalProperties": false,
+      "required": ["user_outcome", "component_responsibility", "must_preserve", "non_goals", "acceptance_contribution"],
+      "properties": {
+        "user_outcome": {"type": "string", "minLength": 1},
+        "component_responsibility": {"type": "string", "minLength": 1},
+        "must_preserve": {"type": "array", "minItems": 1, "items": {"type": "string", "minLength": 1}},
+        "non_goals": {"type": "array", "items": {"type": "string", "minLength": 1}},
+        "acceptance_contribution": {"type": "string", "minLength": 1}
+      }
+    },
+    "executionContext": {
+      "type": "object", "additionalProperties": false,
+      "required": ["prompt_profile", "required_read", "discovery_boundary", "write_scope", "checks"],
+      "properties": {
+        "prompt_profile": {"enum": ["documentation_contract", "code_implementation", "verification"]},
+        "required_read": {"type": "array", "minItems": 1, "items": {"type": "string", "minLength": 1}},
+        "discovery_boundary": {"type": "array", "minItems": 1, "items": {"type": "string", "minLength": 1}},
+        "write_scope": {"type": "array", "minItems": 1, "items": {"type": "string", "minLength": 1}},
+        "checks": {"type": "array", "minItems": 1, "items": {"type": "string", "minLength": 1}}
+      }
+    },
+    "verificationContract": {
+      "type": "object", "additionalProperties": false, "required": ["checks", "evidence"],
+      "properties": {
+        "checks": {"type": "array", "minItems": 1, "items": {"type": "string", "minLength": 1}},
+        "evidence": {"type": "array", "minItems": 1, "items": {"type": "string", "minLength": 1}}
+      }
+    },
+    "planItem": {
+      "type": "object", "additionalProperties": false,
+      "required": ["id", "kind", "title", "summary", "depends_on", "owner", "target_stage", "required", "requirements", "semantic_spine", "execution_context", "verification_contract"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^P[0-9]+$"},
+        "kind": {"type": "string", "minLength": 1},
+        "title": {"type": "string", "minLength": 1},
+        "summary": {"type": "string", "minLength": 1},
+        "details": {"type": "string", "minLength": 1},
+        "depends_on": {"type": "array", "uniqueItems": true, "items": {"type": "string", "pattern": "^P[0-9]+$"}},
+        "owner": {"type": "string", "minLength": 1},
+        "target_stage": {"enum": ["specify", "plan", "code", "readiness", "merge", "release"]},
+        "required": {"type": "boolean"},
+        "requirements": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "pattern": "^SPC-[0-9]{3}@[0-9]+\\.[0-9]+\\.[0-9]+/R-[0-9]+$"}},
+        "semantic_spine": {"$ref": "#/definitions/semanticSpine"},
+        "execution_context": {"$ref": "#/definitions/executionContext"},
+        "verification_contract": {"$ref": "#/definitions/verificationContract"}
+      }
+    },
+    "taskAssessment": {
+      "type": "object", "additionalProperties": false,
+      "required": ["scope_breadth", "solution_novelty", "solution_uncertainty", "failure_impact", "plan_floor"],
+      "properties": {
+        "scope_breadth": {"$ref": "#/definitions/assessmentAxis"},
+        "solution_novelty": {"$ref": "#/definitions/assessmentAxis"},
+        "solution_uncertainty": {"$ref": "#/definitions/assessmentAxis"},
+        "failure_impact": {"$ref": "#/definitions/assessmentAxis"},
+        "plan_floor": {"$ref": "#/definitions/assessmentAxis"}
+      }
+    },
+    "assessmentAxis": {
+      "type": "object", "additionalProperties": false, "required": ["level", "surfaces", "reason"],
+      "properties": {
+        "level": {"type": "string", "minLength": 1},
+        "surfaces": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "minLength": 1}},
+        "reason": {"type": "string", "minLength": 1}
+      }
+    }
+  }
+}

package/dist/schemas/release-impact.schema.json

@@ -7,10 +7,14 @@
   "required": ["schema_id", "from_version", "to_version", "minimum_upgrade_mode", "domains", "path_migration", "runtime_migration", "required_checks"],
   "properties": {
     "schema_id": {"const": "dd-flow/release-impact@1"},
-    "from_version": {"type": "string"}, "to_version": {"type": "string"},
+    "from_version": {"type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$"},
+    "to_version": {"type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$"},
     "minimum_upgrade_mode": {"enum": ["patch", "targeted_minor", "full_migration"]},
-    "domains": {"type": "array", "items": {"type": "string"}},
-    "path_migration": {"type": "boolean"}, "runtime_migration": {"type": "boolean"},
-    "required_checks": {"type": "array", "items": {"type": "string"}, "minItems": 1}, "notes": {"type": "string"}
-  }
+    "domains": {"type": "array", "items": {"enum": ["canonical_layer", "root_structure", "product", "system", "engineering", "operations", "adr", "plans", "scenarios", "ui", "guides", "protocol_evidence", "skills", "archive", "code_traceability"]}, "uniqueItems": true},
+    "path_migration": {"type": "boolean"},
+    "runtime_migration": {"type": "boolean"},
+    "required_checks": {"type": "array", "items": {"type": "string"}, "minItems": 1},
+    "notes": {"type": "string"}
+  },
+  "allOf": [{"if": {"properties": {"minimum_upgrade_mode": {"const": "patch"}}}, "then": {"properties": {"path_migration": {"const": false}, "runtime_migration": {"const": false}}}}]
 }

package/dist/schemas/session-usage.schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "dd-flow/session-usage@1",
+  "title": "Session and usage coverage",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_id", "session_coverage", "usage_coverage", "sessions", "usage"],
+  "properties": {
+    "schema_id": {"const": "dd-flow/session-usage@1"},
+    "session_coverage": {"$ref": "#/definitions/coverage"},
+    "usage_coverage": {"$ref": "#/definitions/coverage"},
+    "sessions": {"type": "array", "items": {"type": "object", "required": ["session_id", "kind", "status"], "properties": {"session_id": {"type": "string"}, "kind": {"type": "string"}, "status": {"type": "string"}}, "additionalProperties": true}},
+    "usage": {"type": "object", "required": ["input_tokens", "cache_read_input_tokens", "cache_write_input_tokens", "output_tokens", "reasoning_output_tokens"], "properties": {"input_tokens": {"type": ["integer", "null"]}, "cache_read_input_tokens": {"type": ["integer", "null"]}, "cache_write_input_tokens": {"type": ["integer", "null"]}, "output_tokens": {"type": ["integer", "null"]}, "reasoning_output_tokens": {"type": ["integer", "null"]}}, "additionalProperties": true}
+  },
+  "definitions": {"coverage": {"type": "object", "required": ["status", "expected", "observed", "missing_sessions"], "properties": {"status": {"enum": ["complete", "partial", "unavailable"]}, "expected": {"type": "array"}, "observed": {"type": "array"}, "missing_sessions": {"type": "array"}}, "additionalProperties": true}}
+}

package/dist/schemas/stage-finish-input.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "dd-flow/stage-finish-input@1",
+  "title": "Semantic stage finish input",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_id", "status", "result", "acceptance", "changed_files", "checks", "evidence", "next_action"],
+  "properties": {
+    "schema_id": {"const": "dd-flow/stage-finish-input@1"},
+    "status": {"enum": ["done", "blocked", "failed"]},
+    "result": {"type": "string", "minLength": 1},
+    "acceptance": {"type": "array", "items": {"type": "string", "minLength": 1}},
+    "changed_files": {"type": "array", "items": {"type": "string", "minLength": 1}},
+    "checks": {"type": "array", "items": {"type": "string", "minLength": 1}},
+    "evidence": {"type": "array", "items": {"type": "string", "minLength": 1}},
+    "reviewer_findings": {"type": "array", "items": {"type": "string"}},
+    "def_outcomes": {"type": "array", "items": {"type": "string"}},
+    "next_action": {"type": "string", "minLength": 1}
+  }
+}

package/dist/schemas/stage-prompt.schema.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "dd-flow/stage-prompt@1",
+  "title": "Generated stage prompt",
+  "type": "object",
+  "additionalProperties": false,
+  "allOf": [
+    {
+      "if": {"properties": {"stage": {"const": "plan"}}, "required": ["stage"]},
+      "then": {
+        "properties": {
+          "aliases": {
+            "required": ["plan", "aspect-map"]
+          }
+        }
+      }
+    }
+  ],
+  "required": ["schema_id", "run_id", "stage", "generated_at", "prompt_path", "sections", "aliases", "write_boundary", "source_fragments"],
+  "properties": {
+    "schema_id": {"const": "dd-flow/stage-prompt@1"},
+    "run_id": {"type": "string", "minLength": 1},
+    "stage": {"type": "string", "minLength": 1},
+    "generated_at": {"type": "string", "format": "date-time"},
+    "prompt_path": {"type": "string", "minLength": 1},
+    "sections": {"type": "array", "minItems": 7, "maxItems": 7, "items": {"enum": ["stage_identity", "runtime_context", "intake", "applicable_instructions", "stage_cli", "file_boundaries", "completion_contract"]}},
+    "aliases": {"type": "object", "required": ["project", "workspace", "run", "stage", "protocol", "intake"], "additionalProperties": {"type": "string"}},
+    "write_boundary": {"type": "object", "required": ["current", "archive", "archive_writable"], "properties": {"current": {"const": "@stage"}, "archive": {"pattern": "try-[0-9]{3}"}, "archive_writable": {"const": false}}, "additionalProperties": false},
+    "source_fragments": {"type": "array", "items": {"type": "string", "minLength": 1}}
+  }
+}

package/dist/schemas/stage-report.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "dd-flow/stage-report@1",
+  "title": "Generated stage report",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_id", "run_id", "stage", "generated_at", "verdict", "semantic", "mechanical", "artifacts", "validation"],
+  "properties": {
+    "schema_id": {"const": "dd-flow/stage-report@1"},
+    "run_id": {"type": "string", "minLength": 1},
+    "stage": {"type": "string", "minLength": 1},
+    "generated_at": {"type": "string", "format": "date-time"},
+    "verdict": {"enum": ["done", "blocked", "failed", "degraded"]},
+    "semantic": {"type": "object", "required": ["result", "acceptance", "changed_files", "checks", "evidence", "next_action"], "additionalProperties": true, "properties": {"result": {"type": "string"}, "acceptance": {"type": "array"}, "changed_files": {"type": "array"}, "checks": {"type": "array"}, "evidence": {"type": "array"}, "next_action": {"type": "string"}}},
+    "mechanical": {"type": "object", "required": ["started_at", "finished_at", "wall_clock_ms", "git", "session_coverage", "usage_coverage"], "additionalProperties": true, "properties": {"started_at": {"type": "string", "format": "date-time"}, "finished_at": {"type": "string", "format": "date-time"}, "wall_clock_ms": {"type": "integer", "minimum": 0}, "git": {"type": "object"}, "session_coverage": {"type": "object"}, "usage_coverage": {"type": "object"}}},
+    "artifacts": {"type": "object", "required": ["json", "markdown", "html", "summary"], "additionalProperties": false, "properties": {"json": {"type": "string"}, "markdown": {"type": "string"}, "html": {"type": "string"}, "summary": {"type": "string"}}},
+    "validation": {"type": "object", "required": ["permission_scope", "memory_bank_scope", "status"], "additionalProperties": true, "properties": {"permission_scope": {"const": "known_targets_only"}, "memory_bank_scope": {"const": "changed_files_and_links_only"}, "status": {"type": "string"}}},
+    "breadcrumbs": {"type": "array", "items": {"type": "object"}}
+  }
+}

package/dist/schemas/stage-start-response.schema.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "dd-flow/stage-start-response@1",
+  "title": "Stage start response",
+  "type": "object",
+  "additionalProperties": false,
+  "allOf": [
+    {
+      "if": {"properties": {"stage": {"const": "plan"}}, "required": ["stage"]},
+      "then": {"required": ["plan_ref", "aspect_map_ref"]}
+    }
+  ],
+  "required": ["schema_id", "run_id", "stage", "attempt_number", "stage_root", "prompt_path", "aliases", "next_command"],
+  "properties": {
+    "schema_id": {"const": "dd-flow/stage-start-response@1"},
+    "run_id": {"type": "string", "minLength": 1},
+    "stage": {"type": "string", "minLength": 1},
+    "attempt_number": {"type": "integer", "minimum": 1},
+    "stage_root": {"type": "string", "minLength": 1},
+    "archive_path": {"type": ["string", "null"]},
+    "prompt_path": {"type": "string", "minLength": 1},
+    "aliases": {"type": "object", "additionalProperties": {"type": "string"}},
+    "resolved_context": {"type": "object", "additionalProperties": true},
+    "plan_ref": {"type": "string", "pattern": "^\\.memory-bank/protocol/[^/]+/plan\\.json$"},
+    "aspect_map_ref": {"type": "string", "minLength": 1},
+    "next_command": {"const": "dd-flow stage finish"},
+    "permission_probe": {"type": "object", "additionalProperties": true}
+  }
+}

package/dist/schemas/timeline-event.schema.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "dd-flow/timeline-event@1",
+  "title": "Safe RUN timeline event",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_id", "timestamp", "event", "run_id", "payload"],
+  "properties": {
+    "schema_id": {"const": "dd-flow/timeline-event@1"},
+    "timestamp": {"type": "string", "format": "date-time"},
+    "event": {"type": "string", "minLength": 1},
+    "run_id": {"type": "string", "minLength": 1},
+    "stage": {"type": ["string", "null"]},
+    "attempt_number": {"type": ["integer", "null"], "minimum": 1},
+    "session_id": {"type": ["string", "null"]},
+    "job_id": {"type": ["string", "null"]},
+    "status": {"type": ["string", "null"]},
+    "payload": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "reason": {"type": "string"},
+        "source": {"type": "string"},
+        "count": {"type": "integer", "minimum": 0},
+        "redaction": {"const": "safe-structured-only"}
+      }
+    }
+  }
+}

package/dist/schemas/worktrunk-workspace.schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "dd-flow/worktrunk-workspace@1",
+  "title": "Verified Worktrunk workspace result",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_id", "command", "official_pinned_artifact", "workspace_path", "branch", "base", "tool_version", "bootstrap_status"],
+  "properties": {
+    "schema_id": {"const": "dd-flow/worktrunk-workspace@1"},
+    "command": {"const": "wt switch --create <branch> --base <base> --format json"},
+    "official_pinned_artifact": {"type": "object", "required": ["url", "version", "sha256", "verified"], "properties": {"url": {"type": "string"}, "version": {"type": "string"}, "sha256": {"pattern": "^[a-f0-9]{64}$"}, "verified": {"const": true}}, "additionalProperties": false},
+    "workspace_path": {"type": "string", "minLength": 1},
+    "branch": {"type": "string", "minLength": 1},
+    "base": {"type": "string", "minLength": 1},
+    "tool_version": {"type": "string", "minLength": 1},
+    "bootstrap_status": {"type": "string", "minLength": 1},
+    "hooks": {"type": "array", "items": {"type": "string"}}
+  }
+}

package/dist/services/branch-context.js

@@ -136,7 +136,7 @@ function summarizeProtocol(row, queue, worktree, activeSessions) {
     const worktreePath = normalizePath(stringValue(worktree?.worktree_path) ?? stringValue(workspace.worktree_path));
     const activeDef = parseJsonArray(row.active_def_json);
     const queueStatus = queue?.status ?? null;
-    const bundleBlockers = bundleBlockersFor(row.stage, queueStatus, activeDef.length);
+    const bundleBlockers = bundleBlockersFor(row.stage, queueStatus, activeDef.some(isBlockingDeferral));
     return {
         id: row.id,
         stage: row.stage,
@@ -148,7 +148,7 @@ function summarizeProtocol(row, queue, worktree, activeSessions) {
         integration_branch: stringValue(worktree?.integration_branch) ?? stringValue(workspace.integration_branch),
         feature_branch: featureBranch,
         worktree_path: worktreePath,
-        bundle_eligible: ["ready_for_merge", "queued_for_merge"].includes(row.stage) && ["ready", "requeued"].includes(queueStatus ?? "") && activeDef.length === 0,
+        bundle_eligible: ["ready_for_merge", "queued_for_merge"].includes(row.stage) && ["ready", "requeued"].includes(queueStatus ?? "") && !activeDef.some(isBlockingDeferral),
         bundle_blockers: bundleBlockers,
         updated_at: row.updated_at
     };
@@ -192,9 +192,9 @@ function branchDiagnostics(resolved) {
     }
     return diagnostics;
 }
-function bundleBlockersFor(stage, queueStatus, activeDefCount) {
+function bundleBlockersFor(stage, queueStatus, hasBlockingDef) {
     const blockers = [];
-    if (activeDefCount > 0)
+    if (hasBlockingDef)
         blockers.push("active_def");
     if (stage === "blocked")
         blockers.push("protocol_blocked");
@@ -202,6 +202,11 @@ function bundleBlockersFor(stage, queueStatus, activeDefCount) {
         blockers.push("already_claimed");
     return blockers;
 }
+function isBlockingDeferral(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return true;
+    return value.blocking !== false;
+}
 function bundleReason(eligible, notReady, claimed, blocked, diagnostics) {
     if (diagnostics.length > 0)
         return diagnostics[0] ?? "diagnostic_blocker";

package/dist/services/dashboard.js

@@ -12,6 +12,7 @@ import { protocolRunDiagnostics, protocolSetBoardForProtocol, protocolSetBoardsF
 import { activeFlowSessionsForProject } from "./sessions.js";
 import { usageForRun } from "./usage.js";
 import { normalizeProtocolLifecycle } from "./protocol-lifecycle.js";
+import { planSummary, planWithProgress } from "./plan-runtime.js";
 export function getCmuxStatus(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     return { ok: true, project_root: project.root, cmux: detectCmux(context) };
@@ -626,14 +627,20 @@ function buildProtocolDashboardData(context, project, protocolId, htmlPath) {
     const runs = context.db.all(`SELECT id, short_id, flow_kind, subject_type, subject_id, status, verdict, next_action, run_index_path, index_json, created_at, updated_at, completed_at
      FROM flow_runs WHERE project_id = ? AND subject_type = 'protocol' AND subject_id = ?
      ORDER BY updated_at DESC, id DESC`, [project.id, protocolId]);
-    const primaryRun = runs.find((run) => run.status === "running") ?? runs[0];
+    const warnings = [...runDiagnostics.diagnostics];
+    const canonicalRuns = runs.filter((run) => {
+        if (isCanonicalRun(run))
+            return true;
+        warnings.push({ code: "legacy_run_ignored", run_id: run.id });
+        return false;
+    });
+    const primaryRun = lifecycle.terminal ? canonicalRuns[0] : canonicalRuns.find((run) => run.status === "running") ?? canonicalRuns[0];
     const observability = primaryRun
         ? usageForRun(context, { projectId: project.id, runId: primaryRun.id, groupBy: "role" })
         : { status: "not_observable", reason: "no_protocol_run" };
-    const warnings = [...runDiagnostics.diagnostics];
     const protocolSetBoard = protocolSetBoardForProtocol(context, project.id, project.root, protocolId);
     const reviewRuns = recentReviewRunsForProtocol(context, project.id, protocolId, 8);
-    const runHistory = runs.map((run) => {
+    const runHistory = canonicalRuns.map((run) => {
         const index = safeRunIndex(run.index_json, warnings, run.id);
         return {
             id: run.id,
@@ -707,10 +714,10 @@ function buildProtocolDashboardData(context, project, protocolId, htmlPath) {
         run_history: runHistory,
         stage_pipeline: latestStages(runHistory),
         metrics: [
-            metric("runs", runs.length, "known", "flow_runs"),
+            metric("runs", canonicalRuns.length, "known", "flow_runs"),
             metric("open_defs", jsonArray(protocol.active_def_json).length, "known", "protocols.active_def_json"),
             metric("blockers", jsonArray(protocol.blockers_json).length, "known", "protocols.blockers_json"),
-            metric("completed_runs", runs.filter((run) => run.status === "done").length, "known", "flow_runs"),
+            metric("completed_runs", canonicalRuns.filter((run) => run.status === "done").length, "known", "flow_runs"),
             metric("review_runs", reviewRuns.length, "known", "flow_runs.flow_kind=mb-sdlc-review|review")
         ],
         warnings
@@ -881,34 +888,39 @@ function protocolsForProject(context, projectId) {
      FROM protocols WHERE project_id = ? ORDER BY updated_at DESC`, [projectId]);
 }
 function planSummaryForProtocol(context, projectId, protocolId) {
-    const row = context.db.get("SELECT plan_json FROM plans WHERE project_id = ? AND protocol_id = ?", [projectId, protocolId]);
-    if (!row) {
+    const protocol = context.db.get("SELECT plan_path FROM protocols WHERE project_id = ? AND id = ?", [projectId, protocolId]);
+    if (!protocol) {
         return { plan_id: "none", total: 0, done: 0, blocked: 0 };
     }
-    const plan = JSON.parse(row.plan_json);
-    const items = Array.isArray(plan.items) ? plan.items : [];
-    return {
-        plan_id: plan.plan_id ?? "unknown",
-        total: items.length,
-        done: items.filter((item) => item.status === "done").length,
-        blocked: items.filter((item) => item.status === "blocked").length
-    };
+    try {
+        const summary = planSummary(context, { projectId, protocolId, planPath: protocol.plan_path });
+        return { plan_id: summary.plan_id, total: summary.total, done: summary.done, blocked: summary.blocked };
+    }
+    catch {
+        return { plan_id: "stale", total: 0, done: 0, blocked: 0 };
+    }
 }
 function activePlanItems(context, projectId, protocols) {
     const items = [];
     for (const protocol of protocols) {
-        const row = context.db.get("SELECT plan_json FROM plans WHERE project_id = ? AND protocol_id = ?", [projectId, protocol.id]);
-        if (!row) {
+        const record = context.db.get("SELECT plan_path FROM protocols WHERE project_id = ? AND id = ?", [projectId, protocol.id]);
+        if (!record) {
             continue;
         }
-        const plan = JSON.parse(row.plan_json);
-        for (const item of Array.isArray(plan.items) ? plan.items : []) {
+        let plan;
+        try {
+            plan = planWithProgress(context, { projectId, protocolId: protocol.id, planPath: record.plan_path }).plan;
+        }
+        catch {
+            continue;
+        }
+        for (const item of plan.items) {
             if (["in_progress", "blocked"].includes(item.status ?? "")) {
                 items.push({
                     protocol: protocol.id,
-                    id: item.id ?? "unknown",
-                    status: item.status ?? "unknown",
-                    summary: item.block_reason ?? item.summary ?? item.title ?? ""
+                    id: item.id,
+                    status: item.status,
+                    summary: item.block_reason ?? item.summary ?? item.title
                 });
             }
         }
@@ -1040,9 +1052,10 @@ function buildProtocolCard(context, project, protocol, generatePage) {
     const summary = planSummaryForProtocol(context, project.id, protocol.id);
     const activeDefCount = jsonArray(protocol.active_def_json).length;
     const blockerCount = jsonArray(protocol.blockers_json).length;
-    const latestRun = context.db.get(`SELECT id, short_id, flow_kind, subject_type, subject_id, status, verdict, next_action, run_index_path, index_json, created_at, updated_at, completed_at
+    const runs = context.db.all(`SELECT id, short_id, flow_kind, subject_type, subject_id, status, verdict, next_action, run_index_path, index_json, created_at, updated_at, completed_at
      FROM flow_runs WHERE project_id = ? AND subject_type = 'protocol' AND subject_id = ?
-     ORDER BY updated_at DESC, id DESC LIMIT 1`, [project.id, protocol.id]);
+     ORDER BY updated_at DESC, id DESC`, [project.id, protocol.id]);
+    const latestRun = runs.find((run) => isCanonicalRun(run));
     let diagnostics = [];
     let lifecycle = normalizeProtocolLifecycle({ rawStage: protocol.stage, rawStatus: protocol.status });
     try {
@@ -1242,10 +1255,19 @@ function safeRunIndex(text, warnings, runId) {
         return null;
     }
 }
+function isCanonicalRun(run) {
+    try {
+        const parsed = JSON.parse(run.index_json);
+        return parsed?.schema_id === "dd-flow/flow-run@2";
+    }
+    catch {
+        return false;
+    }
+}
 function stageLink(projectRoot, run, stage) {
     const item = stage && typeof stage === "object" && !Array.isArray(stage) ? stage : {};
     const report = typeof item.stage_report === "string" ? item.stage_report : undefined;
-    const href = report ? path.join(path.dirname(run.run_index_path), report) : "";
+    const href = report ? runArtifactPath(run.run_index_path, report) : "";
     return {
         order: typeof item.order === "number" ? item.order : 0,
         stage: String(item.stage ?? "unknown"),
@@ -1253,10 +1275,13 @@ function stageLink(projectRoot, run, stage) {
         status: String(item.status ?? "unknown"),
         display_status: normalizeDisplayStatus(String(item.status ?? "unknown")),
         report: report ? link("Stage report", href, fs.existsSync(href) ? "available" : "missing", fs.existsSync(href) ? undefined : "stage_report_missing") : link("Stage report", "", "pending", "stage_report_not_created_yet"),
-        data: typeof item.data === "string" ? path.join(path.dirname(run.run_index_path), item.data) : null,
+        data: typeof item.data === "string" ? runArtifactPath(run.run_index_path, item.data) : null,
         run_index: path.relative(projectRoot, run.run_index_path)
     };
 }
+function runArtifactPath(runIndexPath, artifact) {
+    return path.isAbsolute(artifact) ? artifact : path.resolve(path.dirname(runIndexPath), artifact);
+}
 function latestStages(runHistory) {
     const byStage = new Map();
     for (const run of runHistory) {