@guanlin4924/devflow-pi 0.1.96 → 0.1.97

package/plugins/devflow-core/skills/wireframe-render/SKILL.md

@@ -5,4 +5,4 @@ description: Render validated canonical wireframe JSON into deterministic Markdo
 
 # Wireframe Render
 
-Call the workflow-orchestrator wireframe_render.py script only with the current Core-built canonical JSON and the validation metadata. Generate preview Markdown, flow SVG, page SVGs under `wireframes/screens/<screen-id>/<platform>/default.svg`, and the optional static gallery under the wireframe output directory. The `wireframes/screens` directory is a required render output and is covered by the execution contract. The `canonical.meta.json` file is created later by the Core approval path and is not an input to this step. Never read proposal YAML as a substitute, mutate canonical JSON, write approval, or modify workflow state.
+Call the workflow-orchestrator wireframe_render.py script only with the current Core-built canonical JSON and the validation metadata. Generate preview Markdown, flow SVG, one SVG per declared state under `wireframes/screens/<screen-id>/<platform>/<state>.svg` (`default.svg` is always present), and the optional static gallery under the wireframe output directory. The `wireframes/screens` directory is a required render output and is covered by the execution contract. The `canonical.meta.json` file is created later by the Core approval path and is not an input to this step. Never read proposal YAML as a substitute, mutate canonical JSON, write approval, or modify workflow state.

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/acceptance_test_runner.py

@@ -480,7 +480,12 @@ def _run_locked(root: Path, feature: str, write: bool) -> dict[str, Any]:
         source = cases[tc_id]
         strategy = source.get("evidence_strategy")
         surface, legacy = derive_surface(source)
-        common = {"tc_id": tc_id, "mode": mode, "execution_surface": surface, "legacy_unclassified": legacy, "tc_sha256": tc_sha256(source)}
+        # Feature-development TCs historically omitted this field; the shared
+        # contract defines that legacy omission as requirement-origin. A
+        # regression suite is frozen only after Core has required it explicitly.
+        oracle_source = source.get("oracle_source") or "requirement"
+        common = {"tc_id": tc_id, "mode": mode, "execution_surface": surface, "legacy_unclassified": legacy,
+                  "oracle_source": oracle_source, "tc_sha256": tc_sha256(source)}
         frozen_mode = source.get("automation_mode")
         if mode != frozen_mode:
             common["downgrade"] = {"from": frozen_mode, "to": mode}
@@ -542,6 +547,8 @@ def _run_locked(root: Path, feature: str, write: bool) -> dict[str, Any]:
         passed = sum(1 for item in results if item.get("status") == "passed")
         failed = sum(1 for item in results if item.get("status") == "failed")
         blocked = sum(1 for item in results if item.get("status") == "blocked")
+        oracle_source_counts = {source: sum(1 for item in results if (item.get("oracle_source") or "requirement") == source)
+                                for source in ("requirement", "contract", "invariant", "characterization")}
         write_json(meta_path, {
             "schema_version": 1,
             "feature": feature,
@@ -551,6 +558,7 @@ def _run_locked(root: Path, feature: str, write: bool) -> dict[str, Any]:
             "acceptance_tc_legacy_unclassified": sum(1 for item in results if item.get("legacy_unclassified")),
             "acceptance_tc_downgraded": sum(1 for item in results if item.get("downgrade")),
             "acceptance_tc_dsl_unapproved": sum(1 for item in results if item.get("dsl_approval") == "none"),
+            "oracle_source_counts": oracle_source_counts,
             "acceptance_suite_graph_revision": payload["test_suite"].get("graph_revision"),
             "acceptance_results_fingerprint": file_fingerprint(result_path),
             "built_by": "core_acceptance_test_runner",
@@ -576,7 +584,7 @@ def _result_summary(entry: dict[str, Any]) -> dict[str, Any]:
     elif approval not in {"approved", "none"}:
         approval = None
     return {key: entry.get(key) for key in (
-        "tc_id", "status", "mode", "adapter_kind", "execution_surface", "error_code"
+        "tc_id", "status", "mode", "adapter_kind", "execution_surface", "oracle_source", "error_code"
     )} | {"dsl_approval": approval, "legacy_unclassified": bool(entry.get("legacy_unclassified")),
         "downgrade": entry.get("downgrade")}
 
@@ -594,9 +602,12 @@ def report(root: Path, feature: str) -> dict[str, Any]:
     entries = [entry for entry in payload["results"] if isinstance(entry, dict)]
     statuses = {status: sum(1 for entry in entries if entry.get("status") == status)
                 for status in ("passed", "failed", "blocked")}
+    oracle_source_counts = {source: sum(1 for entry in entries if (entry.get("oracle_source") or "requirement") == source)
+                            for source in ("requirement", "contract", "invariant", "characterization")}
     counts = {"passed": statuses["passed"], "failed": statuses["failed"], "blocked": statuses["blocked"],
               "legacy_unclassified": sum(bool(entry.get("legacy_unclassified")) for entry in entries),
-              "downgraded": sum(bool(entry.get("downgrade")) for entry in entries)}
+              "downgraded": sum(bool(entry.get("downgrade")) for entry in entries),
+              "oracle_source": oracle_source_counts}
     gate = validate_results(root, feature)
     raw_errors = gate.get("errors", []) if isinstance(gate, dict) else []
     return {"ok": True, "feature": feature,
@@ -689,6 +700,10 @@ def result_entry_errors(root: Path, feature: str, tc_id: str, source: dict[str,
     """Re-verify one recorded result against the CURRENT binding, frozen TC, approvals and evidence files."""
     errors: list[str] = []
     surface, _legacy = derive_surface(source)
+    frozen_oracle_source = source.get("oracle_source") or "requirement"
+    recorded_oracle_source = entry.get("oracle_source")
+    if recorded_oracle_source != frozen_oracle_source:
+        errors.append(f"recorded oracle_source {recorded_oracle_source!r} does not match the frozen TC oracle_source {frozen_oracle_source!r}")
     mode = binding.get("mode")
     if entry.get("mode") != mode:
         errors.append(f"recorded mode {entry.get('mode')!r} does not match the current binding mode {mode!r}")

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/acceptance_test_suite.rb

@@ -7,6 +7,7 @@
 require "json"
 require "open3"
 require "optparse"
+require "yaml"
 require_relative "control_io"
 require_relative "requirement_graph"
 
@@ -46,6 +47,10 @@ begin
   lock = DevflowControlIO.acquire_project_lock(root) if command == "freeze"
   graph, path, relative = RequirementGraph.load_graph(root, options[:feature])
   cases = test_nodes(graph)
+  state_path = File.join(root, ".devflow/planning/STATE.md")
+  state_front = File.file?(state_path) ? File.read(state_path).match(/\A---\n(.*?)\n---\n/m)&.[](1) : nil
+  state = state_front ? YAML.safe_load(state_front, permitted_classes: [], aliases: false) : {}
+  regression = state.is_a?(Hash) && state["current_flow"].to_s == "regression-acceptance"
 
   if command == "inspect"
     view = RequirementGraph.view_payload(graph, "tests")
@@ -82,7 +87,7 @@ begin
     else
       matrix = api_test_matrix_check(root, options[:feature], graph)
       result = if matrix["ok"]
-                 RequirementGraph.freeze_test_cases!(root, graph, options[:cp_record], confirm_prerequisites: options[:confirm_prerequisites])
+                 RequirementGraph.freeze_test_cases!(root, graph, options[:cp_record], confirm_prerequisites: options[:confirm_prerequisites], regression: regression)
                else
                  { "ok" => false, "reason" => "api_test_matrix_incomplete", "message" => Array(matrix["errors"]).join("; "), "matrix" => matrix }
                end

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/advance_state.rb

@@ -565,6 +565,11 @@ HARD_FAILURE_REASONS = %w[
   dsl_not_approved
   environment_profile_not_approved
   runtime_integrity_error
+  acceptance_test_suite_freeze_failed
+  acceptance_test_suite_freeze_attestation_invalid
+  acceptance_test_suite_freeze_attestation_failed
+  acceptance_test_suite_candidate_binding_failed
+  acceptance_test_suite_freeze_recovery_failed
 ].freeze
 $devflow_advisories = []
 
@@ -724,7 +729,9 @@ def write_test_suite_freeze_attestation(root, feature, state_revision, candidate
   raise DevflowControlIO::InvalidControlPath, "candidate test suite pin missing from CP-3 binding check" unless candidate_suite.is_a?(Hash)
   raise DevflowControlIO::InvalidControlPath, "frozen test suite pin missing from CP-3 freeze" unless frozen_suite.is_a?(Hash)
   binding_hash = candidate_check["binding_sha256"]
-  raise DevflowControlIO::InvalidControlPath, "test binding hash missing from CP-3 binding check" unless binding_hash.is_a?(String) && !binding_hash.empty?
+  unless candidate_check["regression"] == true || (binding_hash.is_a?(String) && !binding_hash.empty?)
+    raise DevflowControlIO::InvalidControlPath, "test binding hash missing from CP-3 binding check"
+  end
 
   path, relative = test_suite_freeze_attestation_path(root, feature)
   payload = {
@@ -735,9 +742,9 @@ def write_test_suite_freeze_attestation(root, feature, state_revision, candidate
     "state_revision" => state_revision,
     "candidate_test_suite" => candidate_suite,
     "frozen_test_suite" => frozen_suite,
-    "test_binding_sha256" => binding_hash,
     "frozen_case_ids" => Array(freeze_result["frozen_case_ids"]).sort
   }
+  payload["test_binding_sha256"] = binding_hash unless candidate_check["regression"] == true
   DevflowControlIO.atomic_create(path, JSON.pretty_generate(payload) + "\n")
   DevflowControlIO.register_control_artifact(root, {
     "path" => relative, "type" => "test-suite-freeze-attestation", "feature" => feature,
@@ -746,6 +753,26 @@ def write_test_suite_freeze_attestation(root, feature, state_revision, candidate
   payload
 end
 
+def regression_freeze_attestation_check(graph, feature, attestation_path)
+  begin
+    attestation = JSON.parse(File.read(attestation_path))
+  rescue JSON::ParserError, Errno::ENOENT => error
+    return { "ok" => false, "errors" => ["invalid regression freeze attestation: #{error.message}"] }
+  end
+  current_view = graph.dig("views", "tests")
+  cases = Array(graph["nodes"]).select { |node| node.is_a?(Hash) && node["kind"] == "test_case" }
+  errors = []
+  errors << "attestation schema_version is invalid" unless attestation["schema_version"] == 1
+  errors << "attestation origin is invalid" unless attestation["origin"] == "core_acceptance_test_suite_freeze"
+  errors << "attestation feature does not match" unless attestation["feature"] == feature
+  errors << "attestation checkpoint is invalid" unless attestation["checkpoint"] == "CP-3"
+  errors << "attestation frozen suite does not match the graph" unless attestation["frozen_test_suite"] == frozen_test_suite_pin("tests_view" => current_view)
+  frozen_ids = attestation["frozen_case_ids"]
+  expected_ids = cases.map { |node| node["id"] }.sort
+  errors << "attestation does not cover exactly the frozen TC cases" unless frozen_ids.is_a?(Array) && frozen_ids.map(&:to_s).sort == expected_ids
+  { "ok" => errors.empty?, "errors" => errors }
+end
+
 def cp3_freeze_provenance?(graph, state_revision)
   expected = "CP-3: state revision #{state_revision} approved"
   cases = Array(graph["nodes"]).select { |node| node.is_a?(Hash) && node["kind"] == "test_case" }
@@ -754,6 +781,10 @@ def cp3_freeze_provenance?(graph, state_revision)
   end
 end
 
+def regression_workflow?(state, steps)
+  state["current_flow"].to_s == "regression-acceptance" || steps.any? { |step| step["id"] == "regression-test-design" }
+end
+
 # Return from a completed failure branch using its declared return_to contract.
 # The caller must still explicitly confirm the returned checkpoint before any
 # subsequent source-flow step can proceed.
@@ -1111,13 +1142,18 @@ result =
           # inside the checkpoint transition so the user does not have to
           # approve an extra model-issued dialog and a Skill cannot freeze its
           # own candidates early.
-          if result.nil? && state["checkpoint"] == "CP-3" && steps.any? { |step| step["id"] == "acceptance-test-design" }
+          if result.nil? && state["checkpoint"] == "CP-3" && steps.any? { |step| %w[acceptance-test-design regression-test-design].include?(step["id"]) }
             feature = state.fetch("current_feature")
             graph, = RequirementGraph.load_graph(root, feature)
+            regression = regression_workflow?(state, steps)
             attestation_path, = test_suite_freeze_attestation_path(root, feature)
 
             if File.exist?(attestation_path)
-              frozen_check = test_task_binding_check(root, feature, "frozen")
+              frozen_check = if regression
+                regression_freeze_attestation_check(graph, feature, attestation_path)
+              else
+                test_task_binding_check(root, feature, "frozen")
+              end
               unless frozen_check["ok"]
                 result = fail_result("acceptance_test_suite_freeze_attestation_invalid", "test_suite" => frozen_check)
               else
@@ -1128,7 +1164,11 @@ result =
               # attestation is published. Recover only if each TC proves that
               # this exact CP-3 already froze it; never use this path to bless
               # a generic confirmed suite.
-              recovery_check = test_task_binding_check(root, feature, "recovery")
+              recovery_check = if regression
+                { "ok" => true, "regression" => true, "candidate_test_suite" => graph.dig("views", "tests") }
+              else
+                test_task_binding_check(root, feature, "recovery")
+              end
               unless recovery_check["ok"]
                 result = fail_result("acceptance_test_suite_freeze_recovery_failed", "test_suite" => recovery_check)
               else
@@ -1139,7 +1179,11 @@ result =
                 }
                 begin
                   write_test_suite_freeze_attestation(root, feature, current_revision, recovery_check, recovered)
-                  frozen_check = test_task_binding_check(root, feature, "frozen")
+                  frozen_check = if regression
+                    regression_freeze_attestation_check(graph, feature, attestation_path)
+                  else
+                    test_task_binding_check(root, feature, "frozen")
+                  end
                   if frozen_check["ok"]
                     actions << "acceptance_test_suite_freeze_attestation_recovered"
                   else
@@ -1160,7 +1204,11 @@ result =
                 result = fail_result("execution_surface_mismatch", "execution_surface" => surface_check) unless surface_check["ok"]
               end
               if matrix_check["ok"] && surface_check["ok"]
-                candidate_check = test_task_binding_check(root, feature, "candidate")
+                candidate_check = if regression
+                  { "ok" => true, "regression" => true, "candidate_test_suite" => graph.dig("views", "tests") }
+                else
+                  test_task_binding_check(root, feature, "candidate")
+                end
                 unless candidate_check["ok"]
                   result = fail_result("acceptance_test_suite_candidate_binding_failed", "test_suite" => candidate_check)
                 else
@@ -1169,6 +1217,7 @@ result =
                     graph,
                     "CP-3: state revision #{current_revision} approved",
                     confirm_prerequisites: options[:confirm_test_prerequisites] && options[:runtime_confirmed],
+                    regression: regression,
                     persist: false
                   )
                   unless frozen["ok"]
@@ -1313,7 +1362,14 @@ result =
                 pending_freeze.fetch("candidate_check"),
                 pending_freeze.fetch("frozen")
               )
-              frozen_check = test_task_binding_check(root, pending_freeze.fetch("feature"), "frozen")
+              frozen_check = if pending_freeze.dig("candidate_check", "regression") == true
+                regression_freeze_attestation_check(
+                  pending_freeze.fetch("graph"), pending_freeze.fetch("feature"),
+                  test_suite_freeze_attestation_path(root, pending_freeze.fetch("feature")).first
+                )
+              else
+                test_task_binding_check(root, pending_freeze.fetch("feature"), "frozen")
+              end
               unless frozen_check["ok"]
                 result = fail_result("acceptance_test_suite_freeze_attestation_invalid", "test_suite" => frozen_check)
               end

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/dsl_coverage.py

@@ -46,6 +46,9 @@ def _count(data: dict[str, Any], key: str) -> int:
 
 def check(tc_data: dict[str, Any], dsl: dict[str, Any]) -> list[str]:
     errors: list[str] = []
+    for _phase, path, step in all_steps(dsl):
+        if step.get("action") == "assert_each_text" and step.get("min_count", 1) < 1:
+            errors.append(f"{path}.min_count must be >= 1")
     counts = {"preconditions": _count(tc_data, "preconditions"), "steps": _count(tc_data, "steps")}
     covered: dict[str, set[int]] = {"preconditions": set(), "steps": set()}
     oracle = tc_data.get("oracle")

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/dsl_v1.py

@@ -28,7 +28,14 @@ BUILTIN_VARIABLES = frozenset({"execution_id", "namespace"})
 VARIABLE_REF_RE = re.compile(r"\$\{([^}]*)\}")
 VARIABLE_NAME_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]{0,63}$")
 SECRET_HEADERS = frozenset({"authorization", "proxy-authorization", "cookie", "x-api-key", "x-auth-token"})
-UI_ASSERTIONS = frozenset({"assert_visible", "assert_text", "assert_url"})
+FRAGILE_CSS_PATTERNS = (
+    re.compile(r"el-table_\d+(?:_column_\d+)?"),
+    re.compile(r":nth-(?:last-)?(?:child|of-type)\("),
+    re.compile(r"\[data-v-[0-9a-fA-F]{8}\]"),
+    re.compile(r"[A-Za-z]+[-_][0-9a-fA-F]{6,}"),
+    re.compile(r"_[A-Za-z0-9]{5,}_"),
+)
+UI_ASSERTIONS = frozenset({"assert_visible", "assert_text", "assert_each_text", "assert_value", "assert_url"})
 UI_INTERACTIONS = frozenset({"click", "fill", "select", "check", "uncheck"})
 _IGNORED_KEYWORDS = {"$schema", "$id", "title", "description", "$defs", "default", "examples"}
 
@@ -111,7 +118,9 @@ class _Validator:
         if unknown:
             raise ValueError(f"unsupported schema keywords: {sorted(unknown)}")
         if "oneOf" in schema:
-            return self.one_of(value, schema["oneOf"], path)
+            one_of_errors = self.one_of(value, schema["oneOf"], path)
+            if one_of_errors:
+                return one_of_errors
         found: list[str] = []
         if "type" in schema:
             types = schema["type"] if isinstance(schema["type"], list) else [schema["type"]]
@@ -259,6 +268,8 @@ def semantic_errors(dsl: dict[str, Any]) -> list[str]:
         seen_ids.setdefault(step_id, path)
         payload = {key: value for key, value in step.items() if key not in {"id", "driver", "action", "covers", "extract", "assertions", "retry"}}
         _references(payload, path, known, errors)
+        if step.get("driver") == "ui" and isinstance(step.get("target"), dict):
+            _target_errors(step["target"], f"{path}.target", errors, action=step.get("action"))
         if step["driver"] != "api":
             continue
         for index, assertion in enumerate(step.get("assertions", [])):
@@ -281,9 +292,48 @@ def semantic_errors(dsl: dict[str, Any]) -> list[str]:
             known.add(name)
             if spec.get("sensitive") is True:
                 sensitive.add(name)
+            if "header" in spec and spec.get("sensitive", True):
+                sensitive.add(name)
     return errors
 
 
+def _target_errors(target: dict[str, Any], path: str, errors: list[str], depth: int = 0, action: Any = None) -> None:
+    """Semantic target rules shared with the Runtime's independent gate."""
+    locator_keys = {"testid", "role", "label", "placeholder", "text", "css"}
+    locators = locator_keys & target.keys()
+    if "role" in target and "name" not in target:
+        errors.append(f"{path} role target requires name")
+    if "name" in target and "role" not in target:
+        errors.append(f"{path} name is only valid with role")
+    if len(locators) > 1:
+        errors.append(f"{path} must contain exactly one locator form")
+    if "css" in target and any(pattern.search(str(target["css"])) for pattern in FRAGILE_CSS_PATTERNS):
+        errors.append(f"{path}.css uses a fragile generated/structural selector; use table/column, within, row, or a mapping anchor")
+    if "table" in target:
+        table = target["table"]
+        if not isinstance(table, dict) or sum(key in table for key in ("near_heading", "testid", "only")) != 1:
+            errors.append(f"{path}.table must select by exactly one of near_heading, testid, or only")
+        if "column" not in target and "row" not in target:
+            errors.append(f"{path}.table requires column or row")
+        if "table_kind" in target and target["table_kind"] not in {"html", "element-plus"}:
+            errors.append(f"{path}.table_kind must be html or element-plus")
+    if "column" in target and "table" not in target:
+        errors.append(f"{path}.column requires table")
+    if "row" in target:
+        row = target["row"]
+        if not isinstance(row, dict) or ("equals" in row) == ("contains" in row):
+            errors.append(f"{path}.row requires exactly one of equals or contains")
+        if isinstance(row, dict) and "column" not in row:
+            errors.append(f"{path}.row requires column")
+    if "table" in target and "row" not in target and action != "assert_each_text":
+        errors.append(f"{path} table/column targets require assert_each_text or a row restriction")
+    if "within" in target:
+        if depth >= 2:
+            errors.append(f"{path}.within exceeds maximum nesting depth 2")
+        elif isinstance(target["within"], dict):
+            _target_errors(target["within"], f"{path}.within", errors, depth + 1, action)
+
+
 def validate(dsl: Any) -> list[str]:
     try:
         errors = schema_errors(dsl)

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/execution_contract.rb

@@ -24,6 +24,7 @@ POLICY = {
   "api-supplement" => { "checkers" => %w[requirement-graph-check contract-coverage-check], "agents" => ["implementation-worker"], "budget" => 1, "allowed_graph_delta" => %w[api decision] },
   "integration-verify" => { "checkers" => %w[requirement-graph-check slice-independence-check contract-coverage-check change-impact-check cross-track-consistency-check business-claim-reference-check business-cross-model-check], "agents" => ["verification-runner"], "budget" => 1, "allowed_graph_delta" => %w[requirement risk decision] },
   "acceptance-test-design" => { "checkers" => %w[requirement-graph-check contract-coverage-check acceptance-coverage-check api-test-matrix-check test-coverage-check test-obligation-check change-impact-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[test_case] },
+  "regression-test-design" => { "checkers" => %w[test-coverage-check test-obligation-check change-impact-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[test_case] },
   "change-plan" => { "checkers" => %w[requirement-graph-check slice-independence-check contract-coverage-check api-test-matrix-check test-coverage-check test-obligation-check test-task-binding-check change-impact-check], "agents" => [], "budget" => 0, "allowed_graph_delta" => %w[acceptance] },
   "execute" => { "checkers" => %w[tdd-evidence-check change-impact-check], "agents" => ["implementation-worker"], "budget" => 1, "allowed_graph_delta" => %w[requirement rule boundary behavior] },
   "run-acceptance-tests" => { "checkers" => %w[api-test-matrix-check test-coverage-check acceptance-test-results-check change-impact-check], "agents" => ["verification-runner"], "budget" => 1, "allowed_graph_delta" => [] },
@@ -129,6 +130,7 @@ begin
       read grep find glob lsp search write edit apply_patch bash shell exec_command task todo
       devflow_api_test_matrix devflow_tdd_evidence devflow_run_acceptance_tests devflow_mainflow
       devflow_requirement_graph devflow_static_runtime_context
+      devflow_explore
       devflow_architecture_constraint devflow_architecture_feasibility devflow_architecture_brief
       devflow_approval
     ],

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/explore_preflight.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Read-only gate for the devflow_explore host.
+
+This deliberately shares the profile loader and approval-store reader used by
+the Playwright acceptance adapter.  It never reads secret values and never
+writes the control plane.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from approval_store import REQUIRES_DATABASE, valid_approval
+from environment_profile import load as load_profile, profile_path
+
+
+def preflight(root: Path, feature: str, name: str) -> dict[str, object]:
+    profile, sha256, errors = load_profile(root, name)
+    result: dict[str, object] = {
+        "ok": False,
+        "profile": name,
+        "profile_path": str(profile_path(root, name).resolve()),
+        "sha256": sha256,
+        "approved": False,
+        "secret_names": [],
+        "errors": list(errors),
+    }
+    if profile is None or sha256 is None:
+        return result
+    approval = valid_approval(root, feature, "environment_profile", name, {"profile_sha256": sha256})
+    if not approval.get("ok"):
+        reason = approval.get("reason")
+        message = str(approval.get("message") or "environment profile approval is missing or stale")
+        result["errors"] = [f"{reason}: {message}" if reason else message]
+        result["reason"] = reason
+        return result
+    secret_env = profile.get("secret_env", {})
+    if isinstance(secret_env, dict):
+        result["secret_names"] = sorted(str(value) for value in secret_env.values() if isinstance(value, str) and value)
+    result["approved"] = True
+    result["ok"] = True
+    return result
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root", type=Path, default=Path.cwd())
+    parser.add_argument("--feature", required=True)
+    parser.add_argument("--environment-profile", required=True)
+    args = parser.parse_args()
+    result = preflight(args.root.resolve(), args.feature, args.environment_profile)
+    print(json.dumps(result, ensure_ascii=False, sort_keys=True))
+    return 0 if result["ok"] else (3 if result.get("reason") == REQUIRES_DATABASE else 2)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/init_workflow.rb

@@ -59,6 +59,7 @@ end
 targets = {
   "feature-development.yaml" => ".devflow/planning/workflows/feature-development.yaml",
   "acceptance-remediation.yaml" => ".devflow/planning/workflows/acceptance-remediation.yaml",
+  "regression-acceptance.yaml" => ".devflow/planning/workflows/regression-acceptance.yaml",
   "workflows-README.md" => ".devflow/planning/workflows/README.md"
 }
 

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/locator_map.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""Load and strictly expand Devflow locator mapping files.
+
+The mapping is a planning artefact, never a runtime input.  Keeping this
+module independent of the compiler makes it useful to other generators while
+ensuring that an anchor can only expand to one of the DSL target forms.
+"""
+from __future__ import annotations
+
+import copy
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+
+class LocatorMapError(ValueError):
+    pass
+
+
+_PAGE_RE = re.compile(r"^[^/\\\x00-\x1f\x7f]+$")
+_ANCHOR_RE = re.compile(r"^anchor:([^/\\\x00-\x1f\x7f]+)/([^/\\\x00-\x1f\x7f]+)$")
+_TARGET_KEYS = {"testid", "role", "name", "label", "placeholder", "text", "css", "exact",
+                "within", "table", "column", "table_kind", "row"}
+
+
+def _error(path: str, message: str) -> LocatorMapError:
+    return LocatorMapError(f"{path}: {message}")
+
+
+def _target(value: Any, path: str) -> None:
+    if not isinstance(value, dict) or not value:
+        raise _error(path, "target must be a non-empty object")
+    unknown = set(value) - _TARGET_KEYS
+    if unknown:
+        raise _error(path, f"unsupported target keys {sorted(unknown)}")
+    forms = [key for key in ("testid", "role", "label", "placeholder", "text", "css", "table", "row") if key in value]
+    if "within" in value:
+        if len(forms) != 1:
+            raise _error(path, "within must wrap exactly one locator form")
+        _target(value["within"], f"{path}.within")
+    elif len(forms) != 1:
+        raise _error(path, "target must contain exactly one locator form")
+    if "role" in value and (not isinstance(value["role"], str) or not isinstance(value.get("name"), str)):
+        raise _error(path, "role target requires string role and name")
+    if "role" not in value and "name" in value:
+        raise _error(path, "name is only valid with role")
+    for key in ("testid", "label", "placeholder", "text", "css"):
+        if key in value and (not isinstance(value[key], str) or not value[key].strip()):
+            raise _error(path, f"{key} must be a non-empty string")
+    if "exact" in value and not isinstance(value["exact"], bool):
+        raise _error(path, "exact must be boolean")
+    if "table" in value:
+        table = value["table"]
+        if not isinstance(table, dict) or set(table) not in ({"near_heading"}, {"testid"}, {"only"}, {"ref"}):
+            raise _error(f"{path}.table", "must be near_heading, testid, only, or ref")
+        key = next(iter(table))
+        if key == "only" and table[key] is not True:
+            raise _error(f"{path}.table.only", "must be true")
+        if key != "only" and (not isinstance(table[key], str) or not table[key].strip()):
+            raise _error(f"{path}.table.{key}", "must be a non-empty string")
+        if "column" not in value or not isinstance(value["column"], str) or not value["column"].strip():
+            raise _error(path, "table target requires a non-empty column")
+        if value.get("table_kind", "html") not in {"html", "element-plus"}:
+            raise _error(path, "table_kind must be html or element-plus")
+    if "row" in value:
+        row = value["row"]
+        if not isinstance(row, dict) or set(row) != {"column", "equals"} and set(row) != {"column", "contains"}:
+            raise _error(f"{path}.row", "must be {column, equals} or {column, contains}")
+        if not isinstance(row.get("column"), str) or not row["column"].strip() or not isinstance(row[next(k for k in row if k != "column")], str):
+            raise _error(f"{path}.row", "column and match value must be strings")
+
+
+def validate_mapping(document: Any, source: str = "mapping") -> dict[str, Any]:
+    if not isinstance(document, dict):
+        raise _error(source, "must be an object")
+    unknown = set(document) - {"schema_version", "page", "anchors"}
+    if unknown:
+        raise _error(source, f"unsupported keys {sorted(unknown)}")
+    if document.get("schema_version") != 1:
+        raise _error(source, "schema_version must be 1")
+    page = document.get("page")
+    if not isinstance(page, str) or not _PAGE_RE.fullmatch(page):
+        raise _error(f"{source}.page", "must be a single non-empty path-safe string")
+    anchors = document.get("anchors")
+    if not isinstance(anchors, dict) or not anchors:
+        raise _error(f"{source}.anchors", "must be a non-empty object")
+    for name, target in anchors.items():
+        if not isinstance(name, str) or not name.strip() or "/" in name:
+            raise _error(f"{source}.anchors", "anchor names must be non-empty and must not contain '/'")
+        if isinstance(target, dict) and set(target) == {"ref"}:
+            if not isinstance(target["ref"], str) or not target["ref"].strip():
+                raise _error(f"{source}.anchors.{name}.ref", "must be a non-empty string")
+        else:
+            _target(target, f"{source}.anchors.{name}")
+    return copy.deepcopy(document)
+
+
+def load_locator_map(path: Path) -> dict[str, Any]:
+    try:
+        document = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError as error:
+        raise LocatorMapError(f"locator map not found: {path}") from error
+    except json.JSONDecodeError as error:
+        raise LocatorMapError(f"locator map is not valid JSON: {path}: {error}") from error
+    return validate_mapping(document, str(path))
+
+
+def expand_mapping(document: dict[str, Any], anchor: str) -> dict[str, Any]:
+    mapping = validate_mapping(document)
+    anchors = mapping["anchors"]
+    visiting: list[str] = []
+
+    def resolve(name: str) -> dict[str, Any]:
+        if name in visiting:
+            cycle = " -> ".join(visiting + [name])
+            raise LocatorMapError(f"anchor reference cycle: {cycle}")
+        if name not in anchors:
+            raise LocatorMapError(f"unknown anchor '{name}' (known: {', '.join(sorted(anchors))})")
+        visiting.append(name)
+        value = anchors[name]
+        if isinstance(value, dict) and set(value) == {"ref"}:
+            result = resolve(value["ref"])
+        else:
+            result = copy.deepcopy(value)
+            table = result.get("table") if isinstance(result, dict) else None
+            if isinstance(table, dict) and set(table) == {"ref"}:
+                referenced = resolve(table["ref"])
+                if "table" not in referenced:
+                    raise LocatorMapError(f"anchor '{table['ref']}' is not a table target")
+                result["table"] = copy.deepcopy(referenced["table"])
+                if "table_kind" not in result and "table_kind" in referenced:
+                    result["table_kind"] = referenced["table_kind"]
+        visiting.pop()
+        return result
+
+    result = resolve(anchor)
+    _target(result, f"anchor:{mapping['page']}/{anchor}")
+    return result
+
+
+def expand_anchor_reference(reference: str, locator_dir: Path) -> tuple[dict[str, Any], str]:
+    match = _ANCHOR_RE.fullmatch(reference.strip()) if isinstance(reference, str) else None
+    if not match:
+        raise LocatorMapError("anchor locator must be 'anchor:<page-key>/<anchor-name>'")
+    page, name = match.groups()
+    if not _PAGE_RE.fullmatch(page):
+        raise LocatorMapError("anchor page key is not path-safe")
+    path = locator_dir / f"{page}.json"
+    mapping = load_locator_map(path)
+    if mapping["page"] != page:
+        raise LocatorMapError(f"{path}: page must equal filename key '{page}'")
+    return expand_mapping(mapping, name), reference.strip()
+
+
+__all__ = ["LocatorMapError", "expand_anchor_reference", "expand_mapping", "load_locator_map", "validate_mapping"]

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/machine_evidence.rb

@@ -127,6 +127,7 @@ def configured_checkers(workflow, step_id)
                when "integration-verify" then %w[requirement-graph-check slice-independence-check contract-coverage-check change-impact-check]
                when "change-plan" then %w[requirement-graph-check slice-independence-check contract-coverage-check api-test-matrix-check test-coverage-check test-obligation-check test-task-binding-check change-impact-check]
                when "acceptance-test-design" then %w[requirement-graph-check contract-coverage-check acceptance-coverage-check api-test-matrix-check test-coverage-check test-obligation-check change-impact-check]
+               when "regression-test-design" then %w[test-coverage-check test-obligation-check change-impact-check]
                when "run-acceptance-tests" then %w[api-test-matrix-check test-coverage-check acceptance-test-results-check change-impact-check]
                when "verify" then %w[acceptance-coverage-check acceptance-test-results-check change-impact-check]
                when "execute" then %w[tdd-evidence-check change-impact-check]

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/playwright_adapter.py

@@ -43,7 +43,7 @@ ARTIFACT_KINDS = frozenset({"trace", "screenshot", "network"})
 EXECUTION_ID_RE = re.compile(r"^[0-9]{8}T[0-9]{6}Z-[0-9a-f]{8}$")
 SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
 KILL_GRACE_SECONDS = 5
-STEP_SUMMARY_KEYS = ("id", "phase", "driver", "action", "status", "duration_ms", "locator", "match_count", "http_status", "assertion", "error")
+STEP_SUMMARY_KEYS = ("id", "phase", "driver", "action", "status", "duration_ms", "locator", "locator_strategy", "locator_details", "match_count", "http_status", "assertion", "error")
 
 
 def utc_now() -> str: