devflow-engine 1.1.4__tar.gz → 1.1.5__tar.gz

{devflow_engine-1.1.4 → devflow_engine-1.1.5}/PKG-INFO

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

{devflow_engine-1.1.4 → devflow_engine-1.1.5}/pyproject.toml

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

{devflow_engine-1.1.4 → devflow_engine-1.1.5}/src/devflow_engine/errors/user_report_observability.py

@@ -182,20 +182,35 @@ def _persist_context_section(repo_root: Path, error_task_id: str, *, section: st
     return ctx_path
 
 
+_OBS_ROW_UNCHANGED = object()
+
+
 def _update_error_task_row(
     *,
     store: Any,
     error_task_id: str,
-    observability_output: dict[str, Any] | None,
-    new_status: str | None,
+    observability_output: dict[str, Any] | None = _OBS_ROW_UNCHANGED,  # type: ignore[assignment]
+    new_status: str | None = None,
+    observability_error: str | None = _OBS_ROW_UNCHANGED,  # type: ignore[assignment]
 ) -> None:
     """Direct SQL because there isn't an existing helper on ExecutionStore
-    for these two fields. Same connection pattern the DAG nodes use."""
+    for these fields. Same connection pattern the DAG nodes use.
+
+    Sentinel ``_OBS_ROW_UNCHANGED`` means "don't touch this column";
+    passing ``None`` explicitly means "set this column to NULL." That
+    distinction matters for clearing observability_error on success.
+    """
     fields: list[str] = []
     args: list[Any] = []
-    if observability_output is not None:
+    if observability_output is not _OBS_ROW_UNCHANGED:
         fields.append("observability_json=?")
-        args.append(json.dumps(observability_output, ensure_ascii=False, sort_keys=True))
+        args.append(
+            json.dumps(observability_output, ensure_ascii=False, sort_keys=True)
+            if observability_output is not None else None
+        )
+    if observability_error is not _OBS_ROW_UNCHANGED:
+        fields.append("observability_error=?")
+        args.append(observability_error)
     if new_status is not None:
         fields.append("status=?")
         args.append(new_status)
@@ -435,13 +450,23 @@ def build_user_report_observability(
     outcome = _call_llm(repo_root=repo_root, prompt_payload=prompt_payload)
 
     if isinstance(outcome, str):
-        # LLM failure path: persist the reason under ObservabilityError, do
-        # NOT flip status — caller may re-trigger.
+        # LLM failure path: persist the reason under ObservabilityError in
+        # the per-error context.json AND in error_tasks.observability_error
+        # so the dashboard can render an honest "analysis failed: <reason>"
+        # without parsing a file on disk. Status stays 'open' so the caller
+        # (or a retry job) can re-trigger.
         _persist_context_section(
             repo_root, error_task_id,
             section="ObservabilityError",
             output={"reason": outcome, "artifactVersion": ARTIFACT_VERSION},
         )
+        _update_error_task_row(
+            store=store,
+            error_task_id=error_task_id,
+            observability_error=outcome,
+            # status untouched; observability_json untouched (may hold a
+            # prior success that we don't want to wipe).
+        )
         return ObservabilityRunResult(
             error_task_id=error_task_id, status="open", output=None, error_reason=outcome
         )
@@ -453,10 +478,13 @@ def build_user_report_observability(
         section="BuildObservability",
         output=output_dict,
     )
+    # Success clears any prior failure reason — the dashboard should stop
+    # showing the stale failure now that we have real data.
     _update_error_task_row(
         store=store,
         error_task_id=error_task_id,
         observability_output=output_dict,
+        observability_error=None,
         new_status="observed",
     )
     return ObservabilityRunResult(

{devflow_engine-1.1.4 → devflow_engine-1.1.5}/src/devflow_engine/stores/execution_store.py

@@ -658,6 +658,11 @@ class ExecutionStore:
             # First-pass observability analysis output (BuildObservability
             # node, user_report flavor). NULL until the analyzer runs.
             ("observability_json", "TEXT"),
+            # When the analyzer fails, the reason lands here so the
+            # dashboard can distinguish "in flight" (both NULL) from
+            # "failed" (observability_error populated) without parsing
+            # context.json. Cleared on subsequent success.
+            ("observability_error", "TEXT"),
             ("created_at", "INTEGER NOT NULL DEFAULT 0"),
             ("updated_at", "INTEGER NOT NULL DEFAULT 0"),
         ]
@@ -1577,7 +1582,7 @@ class ExecutionStore:
                     "source_kind, source_app, source_ref, fingerprint, occurrence_count, message, "
                     "expected_behavior, steps_to_reproduce_json, report_context_json, "
                     "notify_on_update, reporter_id, reporter_email, reporter_username, "
-                    "observability_json, "
+                    "observability_json, observability_error, "
                     "created_at, updated_at "
                     "FROM error_tasks WHERE status=? ORDER BY created_at DESC"
                 ),
@@ -1625,6 +1630,7 @@ class ExecutionStore:
                     "reporter_email": r["reporter_email"],
                     "reporter_username": r["reporter_username"],
                     "observability": (lambda s: (json.loads(s) if s else None))(r["observability_json"]),
+                    "observability_error": r["observability_error"],
                     "evidence": [{"run_id": r["run_id"]}] if r["run_id"] else [],
                     "created_at": r["created_at"],
                     "updated_at": r["updated_at"],

{devflow_engine-1.1.4 → devflow_engine-1.1.5}/tests/area8_errors/test_user_report_observability_llm_output_shapes.py

@@ -124,3 +124,87 @@ def test_garbage_response_surfaces_as_validation_failure(
         ).fetchone()
     assert row["status"] == "open"
     assert row["observability_json"] is None
+
+
+def test_analyzer_failure_persists_reason_to_error_tasks_row(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path,
+) -> None:
+    """When the LLM call fails (timeout, schema rejected, anything), the
+    reason must land in a queryable column on error_tasks so the dashboard
+    can tell 'failed' apart from 'still analyzing.' NULL on
+    observability_json + NULL on observability_error = genuinely pending.
+    Anything else lets the dashboard render an honest state."""
+    from devflow_engine.stores.execution_store import ExecutionStore
+    store = ExecutionStore(db_path=tmp_path / "devflow.db")
+    eid = store.create_error_task_from_user_report(
+        project_id="t", source_app="x", external_id="e1",
+        title="t", message="m",
+    )
+    fake_result = type("FakeResult", (), {
+        "ok": False, "contract_ok": False, "parsed_json": None,
+        "stdout": "", "stderr": "MiniMax: too many requests",
+        "returncode": 1, "contract_error": None,
+    })()
+    monkeypatch.setattr(obs, "invoke_llm", lambda req: fake_result)
+    res = obs.build_user_report_observability(
+        store=store, repo_root=tmp_path, error_task_id=eid,
+    )
+    assert res.status == "open"
+    assert res.error_reason is not None
+    # Inspect the row directly — the reason must be queryable, not just
+    # buried in context.json.
+    with store._connect() as conn:
+        row = conn.execute(
+            "SELECT status, observability_json, observability_error "
+            "FROM error_tasks WHERE error_task_id=?", (eid,),
+        ).fetchone()
+    assert row["status"] == "open"
+    assert row["observability_json"] is None
+    assert row["observability_error"] is not None
+    assert "too many requests" in row["observability_error"] or \
+           "llm_not_ok" in row["observability_error"]
+
+
+def test_analyzer_success_clears_previous_failure_reason(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path,
+) -> None:
+    """If a row previously failed analysis and the operator re-runs, a
+    success must clear observability_error so the dashboard stops
+    showing the stale failure alongside the new analysis."""
+    from devflow_engine.stores.execution_store import ExecutionStore
+    store = ExecutionStore(db_path=tmp_path / "devflow.db")
+    eid = store.create_error_task_from_user_report(
+        project_id="t", source_app="x", external_id="e1",
+        title="t", message="m",
+    )
+    fail_result = type("FakeResult", (), {
+        "ok": False, "contract_ok": False, "parsed_json": None,
+        "stdout": "", "stderr": "broken", "returncode": 1,
+        "contract_error": None,
+    })()
+    monkeypatch.setattr(obs, "invoke_llm", lambda req: fail_result)
+    obs.build_user_report_observability(store=store, repo_root=tmp_path, error_task_id=eid)
+    with store._connect() as conn:
+        before = conn.execute(
+            "SELECT observability_error FROM error_tasks WHERE error_task_id=?", (eid,),
+        ).fetchone()
+    assert before["observability_error"] is not None
+
+    # Now succeed.
+    ok_result = type("FakeResult", (), {
+        "ok": True, "contract_ok": True,
+        "parsed_json": {
+            "summary": "ok", "affected_files": [], "likely_location": None,
+            "repro_tests": [], "open_questions": [], "confidence": "low",
+        },
+        "stdout": "", "stderr": "", "returncode": 0, "contract_error": None,
+    })()
+    monkeypatch.setattr(obs, "invoke_llm", lambda req: ok_result)
+    res = obs.build_user_report_observability(store=store, repo_root=tmp_path, error_task_id=eid)
+    assert res.status == "observed"
+    with store._connect() as conn:
+        after = conn.execute(
+            "SELECT observability_json, observability_error FROM error_tasks WHERE error_task_id=?", (eid,),
+        ).fetchone()
+    assert after["observability_json"] is not None
+    assert after["observability_error"] is None, "previous failure reason not cleared on success"

{devflow_engine-1.1.4 → devflow_engine-1.1.5}/uv.lock

@@ -172,7 +172,7 @@ wheels = [
 
 [[package]]
 name = "devflow-engine"
-version = "1.1.3"
+version = "1.1.4"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },