devflow-engine 1.1.28__tar.gz → 1.2.1__tar.gz

{devflow_engine-1.1.28 → devflow_engine-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devflow-engine
-Version: 1.1.28
+Version: 1.2.1
 Summary: DevFlow v2 CLI-first engine (projects, stories, execution store, review packets)
 Author: DevFlow
 License: Proprietary

{devflow_engine-1.1.28 → devflow_engine-1.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devflow-engine"
-version = "1.1.28"
+version = "1.2.1"
 description = "DevFlow v2 CLI-first engine (projects, stories, execution store, review packets)"
 readme = "README.md"
 requires-python = ">=3.11"

{devflow_engine-1.1.28 → devflow_engine-1.2.1}/src/devflow_engine/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "1.1.28"
+__version__ = "1.2.1"

{devflow_engine-1.1.28 → devflow_engine-1.2.1}/src/devflow_engine/errors/error_solver_dag.py

@@ -114,6 +114,152 @@ def _append_error_solver_journal(
     return md
 
 
+def _as_dict(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _ui_proof_required(context: dict[str, Any]) -> bool:
+    runtime_context = _as_dict(context.get("runtimeContext"))
+    if runtime_context.get("source_kind") != "user_report":
+        return False
+
+    user_report = _as_dict(runtime_context.get("user_report"))
+    report_context = _as_dict(user_report.get("report_context"))
+    ui_keys = ("page_url", "pathname", "component", "route", "url")
+    if any(str(report_context.get(k) or "").strip() for k in ui_keys):
+        return True
+
+    surface = " ".join(
+        str(v or "").lower()
+        for v in (
+            user_report.get("source_app"),
+            report_context.get("source_app"),
+            report_context.get("app_surface"),
+            report_context.get("surface"),
+        )
+    )
+    return any(token in surface for token in ("frontend", "admin", "browser", "ui", "web"))
+
+
+def _proof_candidate(verification: dict[str, Any] | None) -> dict[str, Any]:
+    if not isinstance(verification, dict):
+        return {}
+    for key in ("fix_proof", "proof", "verification_proof"):
+        candidate = verification.get(key)
+        if isinstance(candidate, dict):
+            return candidate
+    return {}
+
+
+def _resolve_artifact_path(repo_root: Path, artifact_path: Any) -> Path | None:
+    raw = str(artifact_path or "").strip()
+    if not raw:
+        return None
+    path = Path(raw)
+    if not path.is_absolute():
+        path = repo_root / path
+    try:
+        return path.resolve()
+    except OSError:
+        return path
+
+
+def _validate_ui_fix_proof(
+    *,
+    repo_root: Path,
+    verification: dict[str, Any] | None,
+) -> tuple[bool, dict[str, Any] | None, str | None]:
+    proof = _proof_candidate(verification)
+    if not proof:
+        return False, None, "missing_ui_playwright_video_proof"
+
+    kind = str(proof.get("kind") or "").strip()
+    tool = str(proof.get("tool") or "").strip()
+    if kind != "playwright_video" or (tool and tool != "playwright"):
+        return False, proof, "invalid_ui_proof_kind"
+
+    artifact_path = (
+        proof.get("artifact_path")
+        or proof.get("video_path")
+        or proof.get("path")
+    )
+    resolved_artifact = _resolve_artifact_path(repo_root, artifact_path)
+    if resolved_artifact is None:
+        return False, proof, "missing_ui_proof_artifact_path"
+    if resolved_artifact.suffix.lower() not in {".webm", ".mp4"}:
+        return False, proof, "invalid_ui_proof_artifact_type"
+    if not resolved_artifact.is_file():
+        return False, proof, "ui_proof_artifact_not_found"
+
+    run_command = str(proof.get("run_command") or proof.get("command") or "").strip()
+    if not run_command:
+        return False, proof, "missing_ui_proof_run_command"
+
+    oracles = proof.get("oracles") or proof.get("oracle")
+    if isinstance(oracles, str):
+        oracles = [oracles]
+    if not isinstance(oracles, list) or not any(str(o or "").strip() for o in oracles):
+        return False, proof, "missing_ui_proof_oracle"
+
+    result = str(proof.get("result") or proof.get("status") or "").strip().lower()
+    if result and result not in {"passed", "pass", "green", "success", "succeeded"}:
+        return False, proof, "ui_proof_result_not_passing"
+
+    normalized = dict(proof)
+    normalized["kind"] = "playwright_video"
+    normalized["tool"] = "playwright"
+    normalized["artifact_path"] = str(artifact_path)
+    normalized["resolved_artifact_path"] = str(resolved_artifact)
+    normalized["run_command"] = run_command
+    normalized["oracles"] = [str(o) for o in oracles if str(o or "").strip()]
+    normalized["result"] = result or "passed"
+    return True, normalized, None
+
+
+def _validate_ui_observability_repro(observation: dict[str, Any]) -> tuple[bool, str | None]:
+    artifact = str(observation.get("repro_artifact_path") or "").strip()
+    command = str(observation.get("repro_run_command") or "").strip()
+    output = str(observation.get("repro_output") or "").strip()
+    oracles = observation.get("repro_oracles") or observation.get("oracles")
+    if isinstance(oracles, str):
+        oracles = [oracles]
+
+    if not artifact:
+        return False, "ui_observability_missing_playwright_repro_artifact"
+    if "playwright" not in command.lower():
+        return False, "ui_observability_requires_playwright_repro_command"
+    if not output:
+        return False, "ui_observability_missing_repro_output"
+    if not isinstance(oracles, list) or not any(str(o or "").strip() for o in oracles):
+        return False, "ui_observability_missing_repro_oracle"
+    return True, None
+
+
+def _persist_fix_proof(
+    *,
+    store: ExecutionStore,
+    error_task_id: str,
+    proof: dict[str, Any],
+    now: int,
+) -> None:
+    with store._connect() as conn:
+        row = conn.execute(
+            "SELECT observability_json FROM error_tasks WHERE error_task_id=?",
+            (error_task_id,),
+        ).fetchone()
+        try:
+            observation = json.loads(row["observability_json"]) if row and row["observability_json"] else {}
+        except (TypeError, ValueError):
+            observation = {}
+        if not isinstance(observation, dict):
+            observation = {}
+        observation["fix_proof"] = proof
+        conn.execute(
+            "UPDATE error_tasks SET observability_json=?, updated_at=? WHERE error_task_id=?",
+            (json.dumps(observation, ensure_ascii=False, sort_keys=True), now, error_task_id),
+        )
+
+
 def _read_recent_journal(repo_root: Path, *, limit_files: int = 3, max_chars: int = 6000) -> dict[str, Any]:
     journal_dir = repo_root / ".devflow" / "journal"
     if not journal_dir.exists():
@@ -576,7 +722,7 @@ class BuildObservabilityNode(Node):
                 row = conn.execute(
                     "SELECT title, error_type, fingerprint, source_kind, message, "
                     "expected_behavior, steps_to_reproduce_json, report_context_json "
-                    "FROM error_tasks WHERE error_task_id=?",
+                    ", source_app FROM error_tasks WHERE error_task_id=?",
                     (error_task_id,),
                 ).fetchone()
             title = None
@@ -604,6 +750,7 @@ class BuildObservabilityNode(Node):
                         "expected_behavior": row[5],
                         "steps_to_reproduce": steps,
                         "report_context": report_ctx,
+                        "source_app": row[8],
                     }
             runtime_context = task_context.event.runtime_context if isinstance(task_context.event.runtime_context, dict) else None
             if source_kind is not None or user_report_fields:
@@ -693,6 +840,15 @@ class BuildObservabilityNode(Node):
             if isinstance(observation, dict):
                 observed_flag = bool(observation.get("observed"))
                 deferred = observation.get("deferred_questions") or []
+                ui_repro_ok = True
+                ui_repro_failure_reason: str | None = None
+                user_report_context_for_ui = (
+                    context.get("runtimeContext")
+                    if isinstance(context.get("runtimeContext"), dict)
+                    else {}
+                )
+                if observed_flag and _ui_proof_required({"runtimeContext": user_report_context_for_ui}):
+                    ui_repro_ok, ui_repro_failure_reason = _validate_ui_observability_repro(observation)
 
                 # Split deferred questions via LLM classifier (v1.1.22).
                 # An injectable hook is used when present so tests can
@@ -749,6 +905,16 @@ class BuildObservabilityNode(Node):
                 else:
                     blocking_questions, advisory_questions = [], []
 
+                if ui_repro_failure_reason:
+                    observation["observed"] = False
+                    observation["observability_error"] = ui_repro_failure_reason
+                    observation["required_next_action"] = (
+                        "Create or extend a Playwright test during observability "
+                        "that reproduces the reported browser behavior, run it "
+                        "against current code, capture the failing output, and "
+                        "record repro_oracles."
+                    )
+
                 # Annotate the observation in-place so the persisted JSON
                 # carries both buckets — the dashboard / portal / email
                 # dispatch downstream can render them separately.
@@ -757,10 +923,11 @@ class BuildObservabilityNode(Node):
 
                 gates_passed = (
                     observed_flag
+                    and ui_repro_ok
                     and not blocking_questions
                     and bool((observation.get("repro_run_command") or "").strip())
                 )
-                next_status = "observed" if observed_flag else "observation_inconclusive"
+                next_status = "observed" if (observed_flag and ui_repro_ok) else "observation_inconclusive"
                 with store._connect() as conn:
                     conn.execute(
                         "UPDATE error_tasks SET observability_json=?, observability_error=NULL, "
@@ -980,7 +1147,16 @@ class ResolveNode(Node):
         if isinstance(bo, dict):
             bo_out = bo.get("output") if isinstance(bo.get("output"), dict) else {}
             observation_was_red = bool(bo_out.get("observable"))
-        verified = bool((verification or {}).get("green_gate")) and observation_was_red
+        green_gate = bool((verification or {}).get("green_gate"))
+        proof_verified = True
+        fix_proof: dict[str, Any] | None = None
+        proof_failure_reason: str | None = None
+        if _ui_proof_required(context):
+            proof_verified, fix_proof, proof_failure_reason = _validate_ui_fix_proof(
+                repo_root=persistor.repo_root,
+                verification=verification if isinstance(verification, dict) else None,
+            )
+        verified = green_gate and observation_was_red and proof_verified
         runtime_context = context.get("runtimeContext") if isinstance(context.get("runtimeContext"), dict) else None
         prior_runs = context.get("priorRuns") if isinstance(context.get("priorRuns"), dict) else None
         fingerprint = None
@@ -989,10 +1165,22 @@ class ResolveNode(Node):
             fingerprint = runtime_context.get("fingerprint") or current_record.get("fingerprint")
         title = context.get("metadata", {}).get("title") if isinstance(context.get("metadata"), dict) else None
 
-        persistor.persist(context=context, node_name="Resolve", output={"verification": verification, "verified": verified})
+        resolve_output: dict[str, Any] = {"verification": verification, "verified": verified}
+        if proof_failure_reason:
+            resolve_output["proof_failure_reason"] = proof_failure_reason
+        if fix_proof:
+            resolve_output["fix_proof"] = fix_proof
+        persistor.persist(context=context, node_name="Resolve", output=resolve_output)
         self.save_output(ResolveNode.OutputType(verified=verified, verification=verification))
 
         if verified:
+            if fix_proof:
+                _persist_fix_proof(
+                    store=store,
+                    error_task_id=error_task_id,
+                    proof=fix_proof,
+                    now=int(time.time()),
+                )
             commit_result = _commit_resolution(
                 persistor.repo_root,
                 error_task_id=error_task_id,
@@ -1029,6 +1217,8 @@ class ResolveNode(Node):
             task_context.metadata["outcome"] = "in_progress"
             if not observation_was_red:
                 task_context.metadata["reason"] = "observation_was_not_red_at_intake"
+            elif proof_failure_reason:
+                task_context.metadata["reason"] = proof_failure_reason
             else:
                 task_context.metadata["reason"] = "verification_failed"
 

{devflow_engine-1.1.28 → devflow_engine-1.2.1}/src/devflow_engine/errors/runtime_observability.py

@@ -107,7 +107,7 @@ _FINAL_REQUIRED_KEYS = (
     "summary", "reported_symptom", "affected_files", "candidate_causes",
     "evidence", "likely_location", "repro_tests", "deferred_questions",
     "confidence", "observed", "repro_artifact_path", "repro_run_command",
-    "repro_output",
+    "repro_output", "repro_oracles",
 )
 
 
@@ -158,6 +158,39 @@ def _looks_like_file_hit(item: Any) -> bool:
     )
 
 
+def _ui_repro_required(user_report: dict[str, Any]) -> bool:
+    report_context = user_report.get("report_context")
+    if not isinstance(report_context, dict):
+        report_context = {}
+    if any(str(report_context.get(k) or "").strip() for k in ("page_url", "pathname", "component", "route", "url")):
+        return True
+    surface = " ".join(
+        str(v or "").lower()
+        for v in (
+            user_report.get("source_app"),
+            report_context.get("source_app"),
+            report_context.get("app_surface"),
+            report_context.get("surface"),
+        )
+    )
+    return any(token in surface for token in ("frontend", "admin", "browser", "ui", "web"))
+
+
+def _ui_repro_contract_failure(state: dict[str, Any]) -> str | None:
+    command = str(state.get("repro_run_command") or "").strip()
+    output = str(state.get("repro_output") or "").strip()
+    oracles = state.get("repro_oracles") or state.get("oracles")
+    if isinstance(oracles, str):
+        oracles = [oracles]
+    if "playwright" not in command.lower():
+        return "ui_observability_requires_playwright_repro_command"
+    if not output:
+        return "ui_observability_missing_repro_output"
+    if not isinstance(oracles, list) or not any(str(o or "").strip() for o in oracles):
+        return "ui_observability_missing_repro_oracle"
+    return None
+
+
 def _normalize_user_report_payload(parsed: Any) -> Any:
     """Wrap MiniMax's recurring bare-list-of-file-hits response in the
     expected envelope. Tolerance is visible in the output (low confidence,
@@ -310,6 +343,7 @@ def _loop_observe_and_resolve(
     repo_root: Path,
     analysis: dict[str, Any],
     error_task_id: str,
+    user_report: dict[str, Any],
 ) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
     """Combined gate loop: question-resolution and bug-observation are
     co-equal exit conditions — each iteration may need the other. Pi
@@ -327,6 +361,7 @@ def _loop_observe_and_resolve(
     sandbox = repo_root / ".devflow" / "observability" / error_task_id
     sandbox.mkdir(parents=True, exist_ok=True)
     sandbox_rel = str(sandbox.relative_to(repo_root))
+    ui_repro_required = _ui_repro_required(user_report)
 
     state: dict[str, Any] = {
         "summary": analysis.get("summary"),
@@ -344,6 +379,7 @@ def _loop_observe_and_resolve(
         "repro_artifact_path": None,
         "repro_run_command": None,
         "repro_output": None,
+        "repro_oracles": [],
         "refinement_notes": None,
     }
     iteration_history: list[dict[str, Any]] = []
@@ -371,6 +407,12 @@ def _loop_observe_and_resolve(
                 "exercises the USER'S REPORTED ACTION and asserts the USER'S "
                 "REPORTED WRONG RESULT, you ran it, and the captured output "
                 "shows that exact failure reproducing against current code. "
+                "If ui_repro_required=true, the repro MUST be a Playwright "
+                "browser test written or extended for this exact report; "
+                "component tests, Jest-only tests, API-only checks, static "
+                "inspection, or source grep do not satisfy observability. "
+                "For UI repros, include repro_oracles describing the visible "
+                "browser assertion(s) and any authoritative read-back used. "
                 "FIDELITY CHECK before you may set observed=true: does your "
                 "repro exercise the same action and assert the same result "
                 "the user reported? If it tests a different action or a "
@@ -407,12 +449,22 @@ def _loop_observe_and_resolve(
                 "action, asserts the user's reported wrong result, was run, "
                 "and the captured output shows that failure reproducing), "
                 "repro_artifact_path (str|null — e.g. "
-                "'.devflow/observability/<id>/repro.py'), repro_run_command "
+                "'.devflow/observability/<id>/repro.py'; for UI reports this "
+                "must identify the Playwright spec created or extended), repro_run_command "
                 "(str|null — the bash command), repro_output (str|null — "
                 "captured stdout/stderr of the last run, ~3000 chars), "
+                "repro_oracles (list of str — REQUIRED for UI reports; each "
+                "entry states the browser-visible behavior or durable read-back "
+                "that proves the user's reported failure), "
                 "refinement_notes (str — what you did this iteration and "
                 "why)."
             ),
+            "ui_repro_required": ui_repro_required,
+            "ui_repro_rule": (
+                "When true, observed=true is valid only after a Playwright "
+                "test reproduces the user's browser interaction and fails for "
+                "the reported wrong result with captured output."
+            ),
             "current_state": state,
             "iteration": iteration,
             "iteration_budget": _LOOP_MAX_ITERATIONS,
@@ -462,7 +514,7 @@ def _loop_observe_and_resolve(
                   "repro_tests", "confidence", "open_questions",
                   "answered_questions", "deferred_questions", "observed",
                   "repro_artifact_path", "repro_run_command", "repro_output",
-                  "refinement_notes"):
+                  "repro_oracles", "refinement_notes"):
             if k in parsed:
                 state[k] = parsed[k]
         # Defensive: never let the model shrink the cumulative lists.
@@ -476,6 +528,17 @@ def _loop_observe_and_resolve(
                 merged_deferred.append(item)
         state["answered_questions"] = merged_answered
         state["deferred_questions"] = merged_deferred
+        if ui_repro_required and bool(state.get("observed")):
+            ui_failure = _ui_repro_contract_failure(state)
+            if ui_failure:
+                state["observed"] = False
+                state["observability_error"] = ui_failure
+                state["refinement_notes"] = (
+                    "UI observability is not complete: create or extend a "
+                    "Playwright browser repro for the reported interaction, "
+                    "run it, capture failing output, and record repro_oracles. "
+                    f"Current contract failure: {ui_failure}."
+                )
 
     state["_loop_iterations_used"] = len(iteration_history)
     state["_loop_history"] = iteration_history
@@ -553,7 +616,10 @@ def build_user_report_observability(
     # Phase 2 — combined gate loop. Non-fatal: if it errors mid-loop,
     # we still have phase 1's analysis to surface.
     looped, _ = _loop_observe_and_resolve(
-        repo_root=repo_root, analysis=analysis, error_task_id=error_task_id,
+        repo_root=repo_root,
+        analysis=analysis,
+        error_task_id=error_task_id,
+        user_report=user_report,
     )
     assert looped is not None
 
@@ -569,6 +635,7 @@ def build_user_report_observability(
         "repro_artifact_path": looped.get("repro_artifact_path"),
         "repro_run_command": looped.get("repro_run_command"),
         "repro_output": looped.get("repro_output"),
+        "repro_oracles": looped.get("repro_oracles") or [],
         "refinement_notes": looped.get("refinement_notes"),
         "loop_iterations_used": looped.get("_loop_iterations_used"),
         "loop_history": looped.get("_loop_history"),

{devflow_engine-1.1.28 → devflow_engine-1.2.1}/src/devflow_engine/errors/user_report_fix.py

@@ -51,6 +51,25 @@ def _load_observation(*, observation: dict[str, Any] | None) -> dict[str, Any]:
     }
 
 
+def _ui_proof_required(error_task: dict[str, Any]) -> bool:
+    report_context = error_task.get("report_context")
+    if not isinstance(report_context, dict):
+        report_context = {}
+    ui_keys = ("page_url", "pathname", "component", "route", "url")
+    if any(str(report_context.get(k) or "").strip() for k in ui_keys):
+        return True
+    surface = " ".join(
+        str(v or "").lower()
+        for v in (
+            error_task.get("source_app"),
+            report_context.get("source_app"),
+            report_context.get("app_surface"),
+            report_context.get("surface"),
+        )
+    )
+    return any(token in surface for token in ("frontend", "admin", "browser", "ui", "web"))
+
+
 def build_first_pass_fix_payload(
     *,
     error_task: dict[str, Any],
@@ -60,6 +79,7 @@ def build_first_pass_fix_payload(
     """Render the prompt payload for pi. Separate from the invoke so
     tests can pin the prompt shape without spinning a model."""
     obs = _load_observation(observation=observation)
+    ui_requires_playwright_video = _ui_proof_required(error_task)
     return {
         "task": "fix_user_reported_bug",
         "instruction": (
@@ -76,8 +96,10 @@ def build_first_pass_fix_payload(
             "changes. Do NOT add new files unless strictly necessary. "
             "(4) Re-run repro_run_command. Exit 0 = fixed. (5) If the "
             "repro still fails, refine your fix and try again. You "
-            "have at most {iter} attempts within this turn. (6) Emit "
-            "the final JSON."
+            "have at most {iter} attempts within this turn. (6) For UI "
+            "bugs, run the Playwright proof script after the fix with "
+            "video recording enabled, and keep the generated video "
+            "artifact. (7) Emit the final JSON."
         ).format(iter=iteration_budget),
         "output_contract": (
             "Emit ONE final JSON OBJECT (and nothing else after it) "
@@ -88,20 +110,41 @@ def build_first_pass_fix_payload(
             "the LAST repro run, truncated ~3000 chars), iterations_used "
             "(int — how many fix attempts you made, 1..{iter}), "
             "refinement_notes (str — what you tried, what worked, "
-            "what didn't, and any caveats the reviewer should know)."
+            "what didn't, and any caveats the reviewer should know), "
+            "fix_proof (object or null). For UI bugs fix_proof is REQUIRED "
+            "and must include: kind='playwright_video', tool='playwright', "
+            "artifact_path (workspace-relative .webm or .mp4 video), "
+            "run_command, oracles (list of human-readable assertions that "
+            "prove the reported behavior), and result='passed'."
         ).format(iter=iteration_budget),
         "bug_report": {
             "title": error_task.get("title"),
             "message": error_task.get("message"),
             "expected_behavior": error_task.get("expected_behavior"),
+            "report_context": error_task.get("report_context") or {},
+            "source_app": error_task.get("source_app"),
         },
         "observation": obs,
         "workspace_root": "/workspace",
         "iteration_budget": iteration_budget,
+        "proof_requirements": {
+            "ui_requires_playwright_video": ui_requires_playwright_video,
+            "ui_rule": (
+                "If true, the bug is not complete until the same browser-level "
+                "workflow has a passing Playwright run, a retained video file, "
+                "and explicit oracles. Component/unit/Jest output alone is not "
+                "sufficient proof for UI behavior."
+            ),
+        },
         "rules": [
             "If repro_run_command is empty, you cannot verify a fix — emit "
             "fixed=false with refinement_notes explaining the gap.",
             "Do NOT modify the repro test file itself to make it pass.",
+            "For UI bugs, write or extend a Playwright test that demonstrates "
+            "the reported error; after the implementation fix, rerun it green "
+            "with video recording and return the video path in fix_proof.",
+            "For UI bugs, use real browser-visible assertions and authoritative "
+            "read-back where the workflow changes persisted state.",
             "Do NOT commit, push, or run git operations.",
             "Stay inside the workspace; do not touch .devflow/ except "
             "to read prior analysis artifacts.",
@@ -200,6 +243,7 @@ def run_user_report_first_pass_fix(
         "verification": {
             "repro_run_command": observation.get("repro_run_command"),
             "verification_output": (parsed.get("verification_output") or "")[:3000],
+            "fix_proof": parsed.get("fix_proof") if isinstance(parsed.get("fix_proof"), dict) else None,
             "passed": fixed,
             # ResolveNode reads `green_gate` as the "did verification
             # succeed" signal — for user_report rows the repro test
@@ -291,6 +335,7 @@ def run_user_report_iterative_fix(
         "verification": {
             "repro_run_command": observation.get("repro_run_command"),
             "verification_output": (parsed.get("verification_output") or "")[:3000],
+            "fix_proof": parsed.get("fix_proof") if isinstance(parsed.get("fix_proof"), dict) else None,
             "passed": fixed,
             "green_gate": fixed,
         },

{devflow_engine-1.1.28 → devflow_engine-1.2.1}/tests/area8_errors/test_us85_error_solver_dag_contract.py

@@ -144,7 +144,7 @@ def test_build_observability_user_report_writes_observation_to_row(tmp_path: Pat
         message="Clicked save, nothing happened",
         expected_behavior="Save and close",
         steps_to_reproduce=["Open form", "Click Save"],
-        report_context={"page_url": "/admin/profile"},
+        report_context={},
     )
 
     observation = {

{devflow_engine-1.1.28 → devflow_engine-1.2.1}/tests/area8_errors/test_us85_observability_gate_relaxation.py

@@ -31,7 +31,7 @@ def _make_user_report(store: ExecutionStore, external_id: str) -> str:
         message="engagements count shows 0",
         expected_behavior="engagements count shows >0",
         steps_to_reproduce=["Open admin dashboard", "Look at engagements stat"],
-        report_context={"page_url": "/admin/dashboard"},
+        report_context={},
     )