devflow-engine 1.1.12__tar.gz → 1.1.13__tar.gz

{devflow_engine-1.1.12 → devflow_engine-1.1.13}/PKG-INFO

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

{devflow_engine-1.1.12 → devflow_engine-1.1.13}/pyproject.toml

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

{devflow_engine-1.1.12 → devflow_engine-1.1.13}/src/devflow_engine/errors/error_solver_dag.py

@@ -339,42 +339,59 @@ class BuildObservabilityNode(Node):
         persistor.persist(context=context, node_name="BuildObservability", output=out)
         self.save_output(BuildObservabilityNode.OutputType(**{"observable": bool(out.get("observable", True)), "details": out}))
 
-        # User-report rows skip the rest of the DAG (FirstPassFix etc are
-        # not appropriate for a human-filed bug). Persist the analysis
-        # result to the row's queryable columns and stop the workflow.
-        # `outcome` defaults to 'blocked' in run_error_solver_dag when
-        # unset — that's misleading for a successful analysis, so set
-        # it explicitly here.
+        # User-report rows: persist analysis, then decide whether to
+        # let the DAG continue into FirstPassFix.
+        #
+        # Gate-passed (observed=True AND no deferred_questions):
+        #   status → 'observed'. DO NOT stop_workflow — the DAG flows
+        #   into FirstPassFix, which uses the observation's
+        #   repro_run_command + likely_location to attempt a real fix.
+        #   (Without an analyst/fix worker split this all runs in the
+        #   same worker subprocess; that's fine while the analyst pool
+        #   isn't built yet.)
+        #
+        # Otherwise (observation_inconclusive, observation_failed, or
+        # any case with deferred_questions):
+        #   stop the workflow — the controller's post-observability hook
+        #   handles email/magic-link clarify; FirstPassFix would be
+        #   guessing without verified evidence.
         if source_kind == "user_report":
             now = int(time.time())
             observation = out.get("observation") if isinstance(out, dict) else None
             reason = out.get("reason") if isinstance(out, dict) else None
-            with store._connect() as conn:
-                if isinstance(observation, dict):
-                    # 'observed' = phase 3 actually reproduced the bug
-                    # (repro_output is the proof). 'observation_inconclusive'
-                    # = analysis succeeded but the repro attempt(s)
-                    # couldn't surface the failure — still useful, but
-                    # honestly flagged on the dashboard.
-                    observed_flag = bool(observation.get("observed"))
-                    next_status = "observed" if observed_flag else "observation_inconclusive"
-                    outcome_label = next_status
+            gates_passed = False
+            if isinstance(observation, dict):
+                observed_flag = bool(observation.get("observed"))
+                deferred = observation.get("deferred_questions") or []
+                gates_passed = observed_flag and not deferred and bool(
+                    (observation.get("repro_run_command") or "").strip()
+                )
+                next_status = "observed" if observed_flag else "observation_inconclusive"
+                with store._connect() as conn:
                     conn.execute(
                         "UPDATE error_tasks SET observability_json=?, observability_error=NULL, "
                         "status=?, updated_at=? WHERE error_task_id=?",
                         (json.dumps(observation, ensure_ascii=False, sort_keys=True),
                          next_status, now, error_task_id),
                     )
-                    task_context.metadata["outcome"] = outcome_label
-                elif reason:
+                task_context.metadata["outcome"] = next_status
+            elif reason:
+                with store._connect() as conn:
                     conn.execute(
                         "UPDATE error_tasks SET observability_error=?, updated_at=? "
                         "WHERE error_task_id=?",
                         (str(reason), now, error_task_id),
                     )
-                    task_context.metadata["outcome"] = "observation_failed"
-                    task_context.metadata["reason"] = str(reason)
-            task_context.stop_workflow()
+                task_context.metadata["outcome"] = "observation_failed"
+                task_context.metadata["reason"] = str(reason)
+
+            # Stash the observation in metadata so FirstPassFix can read
+            # it without re-querying the row.
+            if isinstance(observation, dict):
+                task_context.metadata["user_report_observation"] = observation
+
+            if not gates_passed:
+                task_context.stop_workflow()
 
         return task_context
 

devflow_engine-1.1.13/src/devflow_engine/errors/user_report_fix.py

@@ -0,0 +1,290 @@
+"""Pi-driven fix for source_kind='user_report' rows that passed the
+observability gates (observed=true + no deferred questions).
+
+The observability gate loop already produced:
+- ``repro_artifact_path`` — a real test file inside the workspace
+  that exercises the bug.
+- ``repro_run_command`` — the exact bash invocation; currently exits
+  non-zero (the bug reproduces).
+- ``likely_location`` — file:line of the suspected root cause.
+- ``affected_files`` — paths the model expects the fix to touch.
+
+This module wires those into a focused pi invocation that:
+
+1. Reads the observation + the affected files.
+2. Writes the smallest change that makes the repro pass.
+3. Runs ``repro_run_command``; success = exit 0.
+4. Iterates up to a small budget if the first attempt doesn't flip
+   the repro.
+5. Returns the standard ErrorSolverWorkflow fix-fn shape
+   (``{"fixed": bool, "fix_results": [...], "verification": {...}}``).
+
+Shared between worker.py (queue-driven) and any future per-row CLI;
+keeps the prompt + tool wiring out of both call sites."""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+
+logger = logging.getLogger(__name__)
+
+
+_MAX_FIX_ITERATIONS = 3
+_PI_TIMEOUT_SECONDS = 1800
+
+
+def _load_observation(*, observation: dict[str, Any] | None) -> dict[str, Any]:
+    """Pull the observation fields we care about, with defaults so the
+    prompt always has something coherent to render."""
+    obs = observation or {}
+    return {
+        "summary": obs.get("summary") or "",
+        "likely_location": obs.get("likely_location") or "",
+        "affected_files": obs.get("affected_files") or [],
+        "repro_artifact_path": obs.get("repro_artifact_path") or "",
+        "repro_run_command": obs.get("repro_run_command") or "",
+        "repro_output_when_bug_present": obs.get("repro_output") or "",
+    }
+
+
+def build_first_pass_fix_payload(
+    *,
+    error_task: dict[str, Any],
+    observation: dict[str, Any],
+    iteration_budget: int = _MAX_FIX_ITERATIONS,
+) -> dict[str, Any]:
+    """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)
+    return {
+        "task": "fix_user_reported_bug",
+        "instruction": (
+            "Fix this user-reported bug. The observability pass already "
+            "identified the location AND produced a repro test that "
+            "currently FAILS (reproducing the bug). Your job is to "
+            "make the smallest change that flips that repro from FAIL "
+            "to PASS. Workflow (use your tools — read/edit/write/bash):"
+            " (1) Read the affected files listed below. (2) Verify the "
+            "current repro failure by running the supplied "
+            "repro_run_command — confirm the bug is still reproducing. "
+            "(3) Edit the smallest scope of code that addresses the "
+            "root cause; prefer `edit` over `write` for surgical "
+            "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."
+        ).format(iter=iteration_budget),
+        "output_contract": (
+            "Emit ONE final JSON OBJECT (and nothing else after it) "
+            "with these keys: fixed (bool — true ONLY if your last "
+            "repro_run_command exited 0), files_changed (list of str — "
+            "workspace-relative paths you edited or wrote), "
+            "verification_output (str — captured stdout+stderr from "
+            "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)."
+        ).format(iter=iteration_budget),
+        "bug_report": {
+            "title": error_task.get("title"),
+            "message": error_task.get("message"),
+            "expected_behavior": error_task.get("expected_behavior"),
+        },
+        "observation": obs,
+        "workspace_root": "/workspace",
+        "iteration_budget": iteration_budget,
+        "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.",
+            "Do NOT commit, push, or run git operations.",
+            "Stay inside the workspace; do not touch .devflow/ except "
+            "to read prior analysis artifacts.",
+        ],
+    }
+
+
+def run_user_report_first_pass_fix(
+    *,
+    repo_root: Path,
+    error_task: dict[str, Any],
+    observation: dict[str, Any],
+) -> dict[str, Any]:
+    """Single fix attempt via pi (medium tier). Returns the
+    ErrorSolverWorkflow fix-fn contract:
+    ``{"fixed": bool, "fix_results": [...], "verification": {...}}``.
+
+    Pi handles its own iteration within ``_MAX_FIX_ITERATIONS`` per the
+    prompt (it can write → run → refine inside one turn). The outer
+    DAG handles failover into IterativeFixNode if this returns
+    ``fixed=False``.
+    """
+    # Local import — keeps the module cheap when only the observability
+    # path is exercised (tests, smoke).
+    from ..llm.invoke import LlmInvocationRequest, invoke_llm
+
+    if not observation:
+        return {
+            "fixed": False,
+            "fix_results": [],
+            "verification": {"reason": "no_observation"},
+        }
+
+    if not (observation.get("repro_run_command") or "").strip():
+        return {
+            "fixed": False,
+            "fix_results": [],
+            "verification": {"reason": "no_repro_command"},
+        }
+
+    payload = build_first_pass_fix_payload(
+        error_task=error_task, observation=observation,
+    )
+
+    try:
+        result = invoke_llm(
+            LlmInvocationRequest(
+                purpose="user_report_first_pass_fix",
+                repo_root=repo_root,
+                prompt="",
+                prompt_payload=payload,
+                delivery_model="final_only",
+                interaction_model="agentic",
+                response_contract="json_only",
+                timeout_seconds=_PI_TIMEOUT_SECONDS,
+                strength="medium",
+            )
+        )
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("first_pass_fix invoke raised: %s", exc)
+        return {
+            "fixed": False,
+            "fix_results": [],
+            "verification": {"reason": f"invoke_raised: {type(exc).__name__}: {exc}"},
+        }
+
+    if not result.ok:
+        return {
+            "fixed": False,
+            "fix_results": [],
+            "verification": {
+                "reason": f"llm_not_ok: rc={result.returncode}",
+                "stderr": (result.stderr or "")[:500],
+            },
+        }
+
+    parsed = result.parsed_json
+    if not isinstance(parsed, dict):
+        return {
+            "fixed": False,
+            "fix_results": [],
+            "verification": {
+                "reason": "schema_invalid",
+                "raw_stdout": (result.stdout or "")[:500],
+            },
+        }
+
+    fixed = bool(parsed.get("fixed"))
+    return {
+        "fixed": fixed,
+        "fix_results": [{
+            "files_changed": parsed.get("files_changed") or [],
+            "iterations_used": parsed.get("iterations_used"),
+            "refinement_notes": parsed.get("refinement_notes"),
+        }],
+        "verification": {
+            "repro_run_command": observation.get("repro_run_command"),
+            "verification_output": (parsed.get("verification_output") or "")[:3000],
+            "passed": fixed,
+        },
+    }
+
+
+def run_user_report_iterative_fix(
+    *,
+    repo_root: Path,
+    error_task: dict[str, Any],
+    observation: dict[str, Any],
+) -> dict[str, Any]:
+    """Second-line fix attempt when FirstPassFix returns fixed=False.
+
+    Same shape as the first pass but with a "you've already tried once
+    and it didn't work" framing, encouraging pi to consider whether the
+    analysis itself was wrong (in which case it should flag the
+    misanalysis rather than thrash on a wrong-angle fix)."""
+    if not observation:
+        return {"fixed": False, "attempts": [], "verification": {"reason": "no_observation"}}
+
+    from ..llm.invoke import LlmInvocationRequest, invoke_llm
+
+    payload = build_first_pass_fix_payload(
+        error_task=error_task, observation=observation,
+        iteration_budget=_MAX_FIX_ITERATIONS,
+    )
+    payload["task"] = "iterative_fix_user_reported_bug"
+    payload["instruction"] = (
+        "The first-pass fix attempt for this bug did NOT make the repro "
+        "pass. Reconsider before spending more attempts: was the "
+        "analysis correct about the root cause? If you think the "
+        "likely_location is wrong, say so in refinement_notes and emit "
+        "fixed=false with a misanalysis_suspected flag. Otherwise: try "
+        "a different angle (different file, different approach). "
+        "Re-run repro_run_command after every change. Same tool set "
+        "(read/edit/write/bash) and same iteration budget."
+    )
+    payload["output_contract"] = (
+        "Emit ONE final JSON OBJECT with: fixed (bool), files_changed "
+        "(list), verification_output (str), iterations_used (int), "
+        "refinement_notes (str), misanalysis_suspected (bool — true if "
+        "you concluded the observability analysis pointed at the wrong "
+        "root cause)."
+    )
+
+    try:
+        result = invoke_llm(
+            LlmInvocationRequest(
+                purpose="user_report_iterative_fix",
+                repo_root=repo_root,
+                prompt="",
+                prompt_payload=payload,
+                delivery_model="final_only",
+                interaction_model="agentic",
+                response_contract="json_only",
+                timeout_seconds=_PI_TIMEOUT_SECONDS,
+                strength="medium",
+            )
+        )
+    except Exception as exc:  # noqa: BLE001
+        return {"fixed": False, "attempts": [], "verification": {"reason": f"invoke_raised: {exc}"}}
+
+    if not result.ok or not isinstance(result.parsed_json, dict):
+        return {
+            "fixed": False, "attempts": [],
+            "verification": {
+                "reason": "llm_not_ok" if not result.ok else "schema_invalid",
+                "rc": result.returncode,
+                "stderr": (result.stderr or "")[:500],
+            },
+        }
+
+    parsed = result.parsed_json
+    fixed = bool(parsed.get("fixed"))
+    return {
+        "fixed": fixed,
+        "attempts": [{
+            "files_changed": parsed.get("files_changed") or [],
+            "iterations_used": parsed.get("iterations_used"),
+            "refinement_notes": parsed.get("refinement_notes"),
+            "misanalysis_suspected": bool(parsed.get("misanalysis_suspected")),
+        }],
+        "verification": {
+            "repro_run_command": observation.get("repro_run_command"),
+            "verification_output": (parsed.get("verification_output") or "")[:3000],
+            "passed": fixed,
+        },
+    }

{devflow_engine-1.1.12 → devflow_engine-1.1.13}/src/devflow_engine/worker.py

@@ -17,6 +17,10 @@ from .source_doc_mutation_dag import run_source_doc_mutation_dag
 from .source_docs_updater import process_source_doc_update_once
 from .stores.execution_store import ExecutionStore
 from .errors.runtime_observability import build_runtime_observability, build_user_report_observability
+from .errors.user_report_fix import (
+    run_user_report_first_pass_fix,
+    run_user_report_iterative_fix,
+)
 from .worker_guard import ensure_worker_start_allowed
 
 
@@ -570,12 +574,91 @@ def process_once(*, project_id: str, repo_root: Path, store: ExecutionStore) ->
                     store=store,
                 )
 
+            def _worker_first_pass_fix(ctx: dict[str, Any]) -> dict[str, Any]:
+                # The observability node stashes the observation in
+                # context.metadata; we read it back here so the fix
+                # function knows what to fix and how to verify.
+                rctx = ctx.get("runtimeContext") if isinstance(ctx.get("runtimeContext"), dict) else None
+                source_kind = (rctx or {}).get("source_kind") if isinstance(rctx, dict) else None
+                if source_kind != "user_report":
+                    # Non-user_report rows still go through the legacy
+                    # stubbed path until those flows have their own
+                    # real fix implementations.
+                    return {"fixed": False}
+                observation: dict[str, Any] = {}
+                # Persisted observation lives under context["BuildObservability"]["output"]["observation"]
+                bo = ctx.get("BuildObservability") if isinstance(ctx, dict) else None
+                if isinstance(bo, dict):
+                    out = bo.get("output") if isinstance(bo.get("output"), dict) else {}
+                    obs = out.get("observation") if isinstance(out, dict) else {}
+                    if isinstance(obs, dict):
+                        observation = obs
+                # Fallback: read straight off the row.
+                if not observation:
+                    error_id = str(claimed["item_id"])
+                    with store._connect() as conn:
+                        row = conn.execute(
+                            "SELECT observability_json FROM error_tasks WHERE error_task_id=?",
+                            (error_id,),
+                        ).fetchone()
+                        if row and row["observability_json"]:
+                            try:
+                                observation = json.loads(row["observability_json"])
+                            except (TypeError, ValueError):
+                                observation = {}
+                error_task = {
+                    "error_task_id": str(claimed["item_id"]),
+                    "title": ctx.get("title") if isinstance(ctx, dict) else None,
+                    "message": ctx.get("message") if isinstance(ctx, dict) else None,
+                    "expected_behavior": (rctx or {}).get("user_report", {}).get("expected_behavior") if isinstance(rctx, dict) else None,
+                }
+                return run_user_report_first_pass_fix(
+                    repo_root=repo_root,
+                    error_task=error_task,
+                    observation=observation,
+                )
+
+            def _worker_iterative_fix(ctx: dict[str, Any]) -> dict[str, Any]:
+                rctx = ctx.get("runtimeContext") if isinstance(ctx.get("runtimeContext"), dict) else None
+                source_kind = (rctx or {}).get("source_kind") if isinstance(rctx, dict) else None
+                if source_kind != "user_report":
+                    return {"fixed": False}
+                observation: dict[str, Any] = {}
+                bo = ctx.get("BuildObservability") if isinstance(ctx, dict) else None
+                if isinstance(bo, dict):
+                    out = bo.get("output") if isinstance(bo.get("output"), dict) else {}
+                    obs = out.get("observation") if isinstance(out, dict) else {}
+                    if isinstance(obs, dict):
+                        observation = obs
+                if not observation:
+                    error_id = str(claimed["item_id"])
+                    with store._connect() as conn:
+                        row = conn.execute(
+                            "SELECT observability_json FROM error_tasks WHERE error_task_id=?",
+                            (error_id,),
+                        ).fetchone()
+                        if row and row["observability_json"]:
+                            try:
+                                observation = json.loads(row["observability_json"])
+                            except (TypeError, ValueError):
+                                observation = {}
+                error_task = {
+                    "error_task_id": str(claimed["item_id"]),
+                    "title": ctx.get("title") if isinstance(ctx, dict) else None,
+                    "message": ctx.get("message") if isinstance(ctx, dict) else None,
+                }
+                return run_user_report_iterative_fix(
+                    repo_root=repo_root,
+                    error_task=error_task,
+                    observation=observation,
+                )
+
             result = store.run_error_solver_dag(
                 error_task_id=str(claimed["item_id"]),
                 repo_root=repo_root,
                 build_observability_fn=_worker_build_observability,
-                first_pass_fix_fn=lambda _ctx: {"fixed": False},
-                iterative_fix_fn=lambda _ctx: {"fixed": False},
+                first_pass_fix_fn=_worker_first_pass_fix,
+                iterative_fix_fn=_worker_iterative_fix,
                 needs_user_input_fn=lambda _ctx: True,
                 runtime_context=None,
             )

{devflow_engine-1.1.12 → devflow_engine-1.1.13}/tests/area8_errors/test_us85_error_solver_dag_contract.py

@@ -120,12 +120,18 @@ def test_US_8_5__error_solver_dag_routes_to_block_when_user_input_needed(tmp_pat
 @pytest.mark.story_id("US-8.5")
 @pytest.mark.plane("ops")
 def test_build_observability_user_report_writes_observation_to_row(tmp_path: Path) -> None:
-    """For source_kind='user_report', a successful build_observability_fn
-    (returning {observable:True, observation:{...}}) must:
+    """For source_kind='user_report' where the gates passed
+    (observed=true + no deferred_questions + repro_run_command present):
     - persist the observation dict to error_tasks.observability_json
     - flip status to 'observed'
     - clear observability_error
-    - cause the workflow to stop (FirstPassFix etc. don't run)
+    - DO NOT stop the workflow — FirstPassFix runs against the
+      observation's repro_run_command (1.1.13+ behavior).
+
+    Pre-1.1.13 always stopped after BuildObservability for user_report
+    rows. From 1.1.13 onward, gate-passing rows continue into the fix
+    pipeline; only inconclusive/awaiting-human rows stop (see
+    test_build_observability_user_report_unobserved_writes_inconclusive).
     """
     repo_root = tmp_path
     db_path = repo_root / ".devflow" / "execution.sqlite"
@@ -171,10 +177,15 @@ def test_build_observability_user_report_writes_observation_to_row(tmp_path: Pat
         needs_user_input_fn=lambda _ctx: False,
     )
 
-    # stop_workflow should have prevented FirstPassFix from running.
-    assert first_pass_called["n"] == 0, "FirstPassFix ran despite stop_workflow"
-    assert result.get("outcome") == "observed", (
-        f"expected outcome='observed' for successful user_report analysis, got {result.get('outcome')!r}"
+    # 1.1.13+ contract: gates passed (observed + no deferred + repro
+    # command) means the DAG continues into FirstPassFix. The stubbed
+    # first_pass returns fixed=False, so the row routes through
+    # IterativeFix → BlockNode and the final outcome is 'blocked'
+    # (not 'observed'); observability status on the row is still
+    # 'observed' because BuildObservability set it before the DAG
+    # continued.
+    assert first_pass_called["n"] == 1, (
+        f"FirstPassFix did not run after gates passed (called={first_pass_called['n']})"
     )
 
     with sqlite3.connect(db_path) as conn:
@@ -185,7 +196,13 @@ def test_build_observability_user_report_writes_observation_to_row(tmp_path: Pat
             (error_task_id,),
         ).fetchone()
     assert row is not None
-    assert row["status"] == "observed", f"expected status='observed', got {row['status']!r}"
+    # Final status reflects DAG outcome — fix stub returned False so
+    # the DAG ended at BlockNode → status='blocked'. The observability
+    # data is still persisted (it was set by BuildObservability before
+    # the DAG continued); a successful fix path → 'resolved'.
+    assert row["status"] in ("blocked", "resolved"), (
+        f"expected blocked|resolved after DAG completion, got {row['status']!r}"
+    )
     assert row["observability_error"] is None
     assert row["observability_json"] is not None
     stored_obs = json.loads(row["observability_json"])

{devflow_engine-1.1.12 → devflow_engine-1.1.13}/uv.lock

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