@guanlin4924/devflow-pi 0.1.95 → 0.1.97

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_draft.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""Validate an unapproved DSL draft without making it executable."""
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+from dsl_coverage import check as dsl_coverage_check
+from dsl_v1 import validate as validate_dsl
+
+
+MAX_INPUT_BYTES = 2 * 1024 * 1024
+
+
+def main() -> int:
+    raw = sys.stdin.buffer.read(MAX_INPUT_BYTES + 1)
+    if len(raw) > MAX_INPUT_BYTES:
+        result = {"ok": False, "errors": ["input exceeds 2 MiB"], "warnings": [],
+                  "eligible_for_execution": False,
+                  "note": "Draft validation never grants execution eligibility."}
+    else:
+        parse_error: str | None = None
+        try:
+            payload = json.loads(raw.decode("utf-8"))
+        except (UnicodeDecodeError, json.JSONDecodeError) as error:
+            payload = None
+            parse_error = f"input must be UTF-8 JSON: {error}"
+        errors: list[str] = []
+        if payload is None:
+            errors.append(parse_error or "input must be a JSON object")
+        elif not isinstance(payload, dict):
+            errors.append("input must be an object")
+        else:
+            dsl = payload.get("dsl")
+            tc_data = payload.get("tc_data")
+            if not isinstance(dsl, dict):
+                errors.append("dsl must be an object")
+            else:
+                errors.extend(f"DSL is invalid: {error}" for error in validate_dsl(dsl))
+            if not isinstance(tc_data, dict):
+                errors.append("tc_data must be an object")
+            elif isinstance(dsl, dict) and not validate_dsl(dsl):
+                errors.extend(f"DSL coverage: {error}" for error in dsl_coverage_check(tc_data, dsl))
+        result = {"ok": not errors, "errors": errors, "warnings": [],
+                  "eligible_for_execution": False,
+                  "note": "Draft validation never grants execution eligibility."}
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    return 0 if result["ok"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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:

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

@@ -65,6 +65,16 @@ module RequirementGraph
     nil
   end
 
+  def active_flow(root)
+    state_path = File.join(root, ".devflow/planning/STATE.md")
+    return nil unless File.file?(state_path)
+    front = File.read(state_path).match(/\A---\n(.*?)\n---/m)&.[](1)
+    return nil unless front
+    YAML.safe_load(front, permitted_classes: [], aliases: false)["current_flow"]
+  rescue Psych::Exception
+    nil
+  end
+
   def assert_active_feature!(root, feature)
     current = active_feature(root)
     return if current.nil? || current == feature
@@ -188,7 +198,7 @@ module RequirementGraph
     graph["stale"].reject! { |entry| entry.is_a?(Hash) && entry["node_id"] == node_id }
   end
 
-  def proposal(graph, delta, allowed_kinds = nil)
+  def proposal(graph, delta, allowed_kinds = nil, regression: false)
     raise ArgumentError, "delta must be an object" unless delta.is_a?(Hash)
     case delta["op"]
     when "add"
@@ -198,7 +208,7 @@ module RequirementGraph
       raise ArgumentError, "node kind #{kind} is not allowed by the execution contract" if allowed_kinds && !allowed_kinds.include?(kind)
       data = normalize_data(delta["data"])
       node = { "id" => next_id(graph, prefix), "kind" => kind, "status" => "candidate", "data" => data }
-      candidate_errors = workload_node_errors(graph, node) + metric_node_errors(graph, node) + read_model_node_errors(graph, node) + architecture_decision_errors(graph, node) + architecture_risk_errors(graph, node) + test_case_errors(graph, node)
+      candidate_errors = workload_node_errors(graph, node) + metric_node_errors(graph, node) + read_model_node_errors(graph, node) + architecture_decision_errors(graph, node) + architecture_risk_errors(graph, node) + test_case_errors(graph, node, regression: regression)
       raise ArgumentError, candidate_errors.join("; ") if candidate_errors.any?
       set_node_fingerprint!(node)
       graph["nodes"] << node
@@ -220,7 +230,7 @@ module RequirementGraph
       end
       data = normalize_data(delta["data"])
       node["data"] = node.fetch("data", {}).merge(data)
-      candidate_errors = workload_node_errors(graph, node) + metric_node_errors(graph, node) + read_model_node_errors(graph, node) + architecture_decision_errors(graph, node) + architecture_risk_errors(graph, node) + test_case_errors(graph, node)
+      candidate_errors = workload_node_errors(graph, node) + metric_node_errors(graph, node) + read_model_node_errors(graph, node) + architecture_decision_errors(graph, node) + architecture_risk_errors(graph, node) + test_case_errors(graph, node, regression: regression)
       raise ArgumentError, candidate_errors.join("; ") if candidate_errors.any?
       set_node_fingerprint!(node)
       clear_stale_for!(graph, id)
@@ -301,25 +311,50 @@ module RequirementGraph
   # causally proven without a deterministic replay.
   TEST_EVIDENCE_STRATEGIES = %w[replay causal observation].freeze
   REPLAY_SCOPES = %w[component page api integration].freeze
+  ORACLE_SOURCES = %w[requirement contract invariant characterization].freeze
+
+  def oracle_source_errors(node, data, regression: false)
+    errors = []
+    source = data["oracle_source"]
+    if source.nil? && !regression
+      source = "requirement"
+    elsif !ORACLE_SOURCES.include?(source)
+      errors << "#{node["id"]}: oracle_source must be requirement, contract, invariant, or characterization"
+      return errors
+    end
+    if regression && !data.key?("oracle_source")
+      errors << "#{node["id"]}: regression TC requires explicit oracle_source"
+    end
+    if source == "requirement"
+      errors << "#{node["id"]}: requirement oracle_source requires non-empty acceptance_refs" unless data["acceptance_refs"].is_a?(Array) && !data["acceptance_refs"].empty?
+    elsif !data["oracle_evidence"].is_a?(String) || data["oracle_evidence"].strip.empty?
+      errors << "#{node["id"]}: #{source} oracle_source requires oracle_evidence"
+    end
+    errors
+  end
 
   # TC nodes are derived verification intent. They deliberately store only
   # externally observable setup, operation and oracle; implementation paths,
   # selectors and agent summaries belong to later execution bindings.
-  def test_case_errors(graph, node, require_edges: false, require_confirmed_inputs: false)
+  def test_case_errors(graph, node, require_edges: false, require_confirmed_inputs: false, regression: false)
     return [] unless node["kind"] == "test_case"
 
     data = node["data"].is_a?(Hash) ? node["data"] : {}
     errors = []
-    %w[acceptance_refs requirement_refs test_type target preconditions steps oracle automation_mode evidence_strategy].each do |field|
+    %w[test_type target preconditions steps oracle automation_mode evidence_strategy].each do |field|
       errors << "#{node["id"]}: missing #{field}" unless present?(data[field])
     end
-    errors << "#{node["id"]}: acceptance_refs must be a non-empty array" unless data["acceptance_refs"].is_a?(Array) && !data["acceptance_refs"].empty?
-    errors << "#{node["id"]}: requirement_refs must be a non-empty array" unless data["requirement_refs"].is_a?(Array) && !data["requirement_refs"].empty?
+    allow_empty_refs = regression && data["oracle_source"] && data["oracle_source"] != "requirement"
+    errors << "#{node["id"]}: acceptance_refs must be present" unless data.key?("acceptance_refs")
+    errors << "#{node["id"]}: acceptance_refs must be a non-empty array" unless data["acceptance_refs"].is_a?(Array) && (!data["acceptance_refs"].empty? || allow_empty_refs)
+    errors << "#{node["id"]}: requirement_refs must be present" unless data.key?("requirement_refs")
+    errors << "#{node["id"]}: requirement_refs must be a non-empty array" unless data["requirement_refs"].is_a?(Array) && (!data["requirement_refs"].empty? || allow_empty_refs)
     errors << "#{node["id"]}: preconditions must be a non-empty array" unless data["preconditions"].is_a?(Array) && !data["preconditions"].empty?
     errors << "#{node["id"]}: steps must be a non-empty array" unless data["steps"].is_a?(Array) && !data["steps"].empty?
     errors << "#{node["id"]}: invalid test_type" unless TEST_CASE_TYPES.include?(data["test_type"])
     errors << "#{node["id"]}: invalid automation_mode" unless TEST_AUTOMATION_MODES.include?(data["automation_mode"])
     errors << "#{node["id"]}: invalid evidence_strategy" unless TEST_EVIDENCE_STRATEGIES.include?(data["evidence_strategy"])
+    errors.concat(oracle_source_errors(node, data, regression: regression))
     case data["evidence_strategy"]
     when "replay"
       errors << "#{node["id"]}: replay tests require replay_scope" unless REPLAY_SCOPES.include?(data["replay_scope"])
@@ -447,7 +482,7 @@ module RequirementGraph
   # CP-3 is the single freeze point. Keep it here instead of in a Skill so the
   # graph revision, TC statuses, views and audit entry commit atomically under
   # the caller's control-plane lock.
-  def freeze_test_cases!(root, graph, cp_record, confirm_prerequisites: false, persist: true)
+  def freeze_test_cases!(root, graph, cp_record, confirm_prerequisites: false, persist: true, regression: false)
     cases = Array(graph["nodes"]).select { |node| node.is_a?(Hash) && node["kind"] == "test_case" }
     return { "ok" => false, "reason" => "test_suite_empty", "message" => "cannot freeze an empty TC suite" } if cases.empty?
     return { "ok" => false, "reason" => "test_suite_already_frozen", "message" => "confirmed test cases require a new candidate suite" } if cases.any? { |node| node["status"] == "confirmed" }
@@ -460,10 +495,10 @@ module RequirementGraph
                                 end
     return prerequisite_confirmation unless prerequisite_confirmation["ok"]
 
-    checkers = checker_results(graph)
+    checkers = checker_results(graph, regression: regression)
     errors = checkers.fetch("test-coverage-check", []).dup
     errors.concat(checkers.fetch("test-obligation-check", []))
-    cases.each { |node| errors.concat(test_case_errors(graph, node, require_edges: true, require_confirmed_inputs: true)) }
+    cases.each { |node| errors.concat(test_case_errors(graph, node, require_edges: true, require_confirmed_inputs: true, regression: regression)) }
     return { "ok" => false, "reason" => "test_suite_incomplete", "message" => errors.uniq.join("; "), "errors" => errors.uniq } if errors.any?
 
     cases.each do |node|
@@ -528,14 +563,14 @@ module RequirementGraph
         comparable = node.dig("data", "execution") == candidate_data["execution"] && node.dig("data", "test_obligation_refs") == candidate_data["test_obligation_refs"]
         raise ArgumentError, "#{item["key"]}: existing generated TC does not match matrix" unless comparable
       else
-        applied = proposal(graph, { "op" => "add", "kind" => "test_case", "data" => candidate_data }, ["test_case"])
+        applied = proposal(graph, { "op" => "add", "kind" => "test_case", "data" => candidate_data }, ["test_case"], regression: active_flow(root).to_s == "regression-acceptance")
         node = applied.fetch("node")
         refs = Array(candidate_data["acceptance_refs"]) + Array(candidate_data["requirement_refs"]) + Array(candidate_data["api_refs"])
         refs.each do |ref|
           edge = { "from" => ref, "to" => node["id"], "relation" => "verified_by" }
           graph["edges"] << edge unless graph["edges"].include?(edge)
         end
-        errors = test_case_errors(graph, node, require_edges: true, require_confirmed_inputs: true)
+        errors = test_case_errors(graph, node, require_edges: true, require_confirmed_inputs: true, regression: active_flow(root).to_s == "regression-acceptance")
         raise ArgumentError, errors.join("; ") if errors.any?
         existing[item["key"]] = node
         imported << node["id"]
@@ -827,7 +862,7 @@ module RequirementGraph
     !node.nil? && node["status"] == "confirmed"
   end
 
-  def checker_results(graph)
+  def checker_results(graph, regression: false)
     results = {
       "requirement-graph-check" => [], "slice-independence-check" => [], "contract-coverage-check" => [],
       "change-impact-check" => [], "acceptance-coverage-check" => [], "test-coverage-check" => [], "test-obligation-check" => [], "risk-derivation-check" => []
@@ -886,7 +921,7 @@ module RequirementGraph
         end
       when "test_case"
         results["test-coverage-check"].concat(
-          test_case_errors(graph, node, require_edges: true, require_confirmed_inputs: node["status"] == "confirmed")
+          test_case_errors(graph, node, require_edges: true, require_confirmed_inputs: node["status"] == "confirmed", regression: regression)
         )
       end
     end
@@ -1137,7 +1172,7 @@ if __FILE__ == $PROGRAM_NAME
                  delta = JSON.parse(options[:delta_json].to_s)
                  allowed_kinds = options[:allowed_kinds]&.split(",")&.map(&:strip)
                  candidate = RequirementGraph.deep_clone(graph)
-                 applied = RequirementGraph.proposal(candidate, delta, allowed_kinds)
+        applied = RequirementGraph.proposal(candidate, delta, allowed_kinds, regression: RequirementGraph.active_flow(root).to_s == "regression-acceptance")
                  candidate["revision"] += 1
                  stale = Array(candidate["stale"]).any?
                  if options[:write]