devflow-engine 1.1.21__tar.gz → 1.1.23__tar.gz

{devflow_engine-1.1.21 → devflow_engine-1.1.23}/PKG-INFO

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

{devflow_engine-1.1.21 → devflow_engine-1.1.23}/pyproject.toml

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

{devflow_engine-1.1.21 → devflow_engine-1.1.23}/src/devflow_engine/errors/error_solver_dag.py

@@ -665,7 +665,7 @@ class BuildObservabilityNode(Node):
         # User-report rows: persist analysis, then decide whether to
         # let the DAG continue into FirstPassFix.
         #
-        # Gate-passed (observed=True AND no deferred_questions):
+        # Gate-passed (observed=True AND no BLOCKING 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.
@@ -673,8 +673,15 @@ class BuildObservabilityNode(Node):
         #   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):
+        # v1.1.22: deferred_questions are split via the LLM classifier
+        # in errors/question_classifier.py into "blocking" (the engine
+        # needs the answer before it can code) and "advisory" (data-state
+        # / post-deploy verification / scoping — fine to ship anyway).
+        # Only blocking questions halt the gate; advisory ones ride
+        # forward to the RESOLVED email as "Things to verify post-deploy".
+        #
+        # Otherwise (observation_inconclusive, observation_failed, or any
+        # case with at least one BLOCKING deferred question):
         #   stop the workflow — the controller's post-observability hook
         #   handles email/magic-link clarify; FirstPassFix would be
         #   guessing without verified evidence.
@@ -686,8 +693,72 @@ class BuildObservabilityNode(Node):
             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()
+
+                # Split deferred questions via LLM classifier (v1.1.22).
+                # An injectable hook is used when present so tests can
+                # avoid live LLM calls. Pure-LLM in production — no regex
+                # fallback (see feedback_no_regex_first).
+                classifier_fn = (
+                    funcs.get("question_classifier_fn") if isinstance(funcs, dict) else None
+                )
+                user_report_ctx = (
+                    (context.get("runtimeContext") or {}).get("user_report")
+                    if isinstance(context.get("runtimeContext"), dict)
+                    else {}
+                )
+                classifier_context = {
+                    "user_report": user_report_ctx or {},
+                    "observation": observation,
+                }
+                # Skip the classifier when the gate is already going to
+                # halt for an unrelated reason (observed=False → status
+                # 'observation_inconclusive'). Saves an LLM round-trip
+                # we can never act on.
+                if deferred and observed_flag:
+                    try:
+                        if callable(classifier_fn):
+                            blocking_questions, advisory_questions = classifier_fn(
+                                deferred, classifier_context
+                            )
+                        else:
+                            from .question_classifier import classify_questions
+                            blocking_questions, advisory_questions = classify_questions(
+                                deferred, classifier_context, repo_root=repo_root,
+                            )
+                    except Exception as exc:  # safe-default = halt
+                        blocking_questions = [
+                            {"question": str(q) if not isinstance(q, dict) else
+                                 (q.get("question") or json.dumps(q, sort_keys=True)),
+                             "verdict": "blocking",
+                             "rationale": f"classifier_raised:{type(exc).__name__}"}
+                            for q in deferred
+                        ]
+                        advisory_questions = []
+                elif deferred:
+                    # observed=False — preserve the questions verbatim as
+                    # blocking-shaped records so downstream surfaces still
+                    # see them, but skip the LLM call.
+                    blocking_questions = [
+                        {"question": str(q) if not isinstance(q, dict) else
+                             (q.get("question") or json.dumps(q, sort_keys=True)),
+                         "verdict": "blocking",
+                         "rationale": "skipped_unobserved"}
+                        for q in deferred
+                    ]
+                    advisory_questions = []
+                else:
+                    blocking_questions, advisory_questions = [], []
+
+                # Annotate the observation in-place so the persisted JSON
+                # carries both buckets — the dashboard / portal / email
+                # dispatch downstream can render them separately.
+                observation["deferred_blocking"] = blocking_questions
+                observation["deferred_advisory"] = advisory_questions
+
+                gates_passed = (
+                    observed_flag
+                    and not blocking_questions
+                    and bool((observation.get("repro_run_command") or "").strip())
                 )
                 next_status = "observed" if observed_flag else "observation_inconclusive"
                 with store._connect() as conn:
@@ -698,6 +769,11 @@ class BuildObservabilityNode(Node):
                          next_status, now, error_task_id),
                     )
                 task_context.metadata["outcome"] = next_status
+                # Stash classifier output on the task_context so downstream
+                # nodes (FirstPassFix, ResolveNode, host email dispatch)
+                # can read it without re-classifying.
+                task_context.metadata["deferred_blocking"] = blocking_questions
+                task_context.metadata["deferred_advisory"] = advisory_questions
             elif reason:
                 with store._connect() as conn:
                     conn.execute(

devflow_engine-1.1.23/src/devflow_engine/errors/question_classifier.py

@@ -0,0 +1,250 @@
+"""Deferred-question classifier for the error-solver DAG (v1.1.22).
+
+When the user-report observability pass surfaces ``deferred_questions``,
+the engine historically halted to ``awaiting_human`` on ANY question. In
+practice the LLM is thorough — it raises advisory questions about cache
+state, role permissions, viewport variations, prod row counts — even when
+it already has a concrete fix candidate. Those advisory questions are
+verification scope, not coding blockers.
+
+This module splits ``deferred_questions`` into two buckets via a pure-LLM
+classifier:
+
+  * ``blocking``  → the engine genuinely needs the answer before it can
+                    decide what to code. Example: "Did you mean X or Y?"
+                    (affects which file to edit), "Should this be admin-only
+                    or all users?".
+  * ``advisory``  → data-state, post-deploy verification, scoping, or
+                    follow-up questions that don't block the code change.
+                    Example: "Does the cache exist?", "What's the row
+                    count in prod?", "Will this affect viewport-specific
+                    rendering?".
+
+Advisory questions ride along to the RESOLVED email under "Things to
+verify post-deploy". Blocking questions, if any, halt the DAG to
+``awaiting_human`` the same way the old gate did.
+
+Pure-LLM only — no regex or keyword fallback (see
+``feedback_no_regex_first``). The configured medium-tier provider is the
+source of truth (see ``feedback_no_provider_swap_suggestions``).
+"""
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+from ..llm.invoke import LlmInvocationRequest, invoke_llm
+
+logger = logging.getLogger(__name__)
+
+Verdict = Literal["blocking", "advisory"]
+
+
+class QuestionClassification(BaseModel):
+    question: str
+    verdict: Verdict
+    rationale: str = Field(default="")
+
+
+_PROMPT_INSTRUCTIONS = """\
+You are classifying questions that an LLM bug-analyst surfaced while
+investigating a user-reported bug. Each question is either:
+
+  * "blocking"  → the engineer genuinely needs the answer BEFORE they can
+                  decide what code to change. Without the answer the fix
+                  cannot be designed, or could be designed wrong and edit
+                  the wrong file. Examples:
+                    - "Did you mean the admin dashboard or the survey-taker
+                       dashboard? — they live in different routes."
+                    - "Should this restriction apply to all users, or only
+                       to admin/manager roles?"
+                    - "Is this a regression from PR #123 or has it never
+                       worked? — changes which commit to revert."
+
+  * "advisory"  → data-state, post-deploy verification, scoping, or
+                  follow-up. The fix can be shipped without the answer;
+                  the answer matters for confirming the fix works in prod
+                  or for understanding scope. Examples:
+                    - "Does the chi-score cache exist for this org?"
+                    - "What's the exact row count in production?"
+                    - "Will this affect viewport-specific rendering on
+                       mobile vs desktop?"
+                    - "Does the current role have access to this page?"
+                    - "Is there a downstream consumer of this field?"
+
+Heuristics that lean ADVISORY:
+  * Question is about runtime/DB state, cache presence, row counts.
+  * Question is about post-deploy verification ("how do we confirm…").
+  * Question is about edge-case scope (viewports, browsers, edge data).
+  * Question is about secondary impact ("does anything else read this?").
+
+Heuristics that lean BLOCKING:
+  * Question asks the user to pick between two code paths or two files.
+  * Question asks about intended permission/role semantics.
+  * Question asks about which version/commit introduced the bug when
+    the fix would be a revert.
+  * Without the answer, the analyst literally cannot pick a file/line.
+
+Return STRICT JSON with this exact shape (one entry per input question,
+in the same order):
+
+{
+  "classifications": [
+    {
+      "question": "<verbatim question text>",
+      "verdict": "<blocking|advisory>",
+      "rationale": "<one short sentence>"
+    },
+    ...
+  ]
+}
+
+No prose outside the JSON. No code fences. No additional top-level keys.
+"""
+
+
+def _coerce_question_text(item: Any) -> str:
+    """Accept either a bare string or {"question": ..., ...} dict."""
+    if isinstance(item, str):
+        return item
+    if isinstance(item, dict):
+        for key in ("question", "text", "q"):
+            val = item.get(key)
+            if isinstance(val, str) and val.strip():
+                return val
+        # Fall back to a stable JSON repr so the classifier still sees
+        # something deterministic instead of silently dropping the row.
+        return json.dumps(item, sort_keys=True, ensure_ascii=False)
+    return str(item)
+
+
+def _build_payload(
+    *, questions: list[str], context: dict[str, Any]
+) -> dict[str, Any]:
+    bug_report = context.get("user_report") if isinstance(context.get("user_report"), dict) else {}
+    observation = context.get("observation") if isinstance(context.get("observation"), dict) else {}
+    return {
+        "instructions": _PROMPT_INSTRUCTIONS,
+        "bug_report": {
+            "title": bug_report.get("title"),
+            "message": bug_report.get("message"),
+            "expected_behavior": bug_report.get("expected_behavior"),
+            "steps_to_reproduce": bug_report.get("steps_to_reproduce") or [],
+        },
+        "observation_summary": {
+            "summary": observation.get("summary"),
+            "likely_location": observation.get("likely_location"),
+            "observed": observation.get("observed"),
+        },
+        "questions": questions,
+    }
+
+
+def classify_questions(
+    questions: list[str | dict[str, Any]],
+    context: dict[str, Any] | None = None,
+    *,
+    repo_root: Path | str | None = None,
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    """Split ``questions`` into ``(blocking, advisory)`` via an LLM call.
+
+    Each returned element is a dict::
+
+        {"question": <str>, "verdict": "blocking"|"advisory", "rationale": <str>}
+
+    Behaviour:
+      * Empty input → ``([], [])`` with no LLM call.
+      * Transport failure or unparseable response → safe default: treat
+        every question as ``blocking`` (preserves the pre-1.1.22 halt
+        behaviour). Each entry carries ``rationale="classifier_unavailable"``
+        so downstream surfaces can see why.
+    """
+    if not questions:
+        return [], []
+
+    normalised: list[str] = [_coerce_question_text(q) for q in questions]
+    payload = _build_payload(questions=normalised, context=context or {})
+
+    request = LlmInvocationRequest(
+        purpose="error_solver.question_classifier",
+        repo_root=Path(repo_root) if repo_root is not None else Path.cwd(),
+        prompt="",
+        prompt_payload=payload,
+        strength="medium",
+        response_contract="json_only",
+        interaction_model="request_response",
+        timeout_seconds=120,
+    )
+
+    try:
+        result = invoke_llm(request)
+    except Exception as exc:  # pragma: no cover - surface-level transport failure
+        logger.warning("question_classifier invoke raised: %s", exc)
+        return _safe_default_blocking(normalised, reason="classifier_unavailable")
+
+    if not result.ok:
+        logger.warning(
+            "question_classifier llm not ok: rc=%s err=%s",
+            getattr(result, "returncode", None),
+            (getattr(result, "stderr", "") or "")[:200],
+        )
+        return _safe_default_blocking(normalised, reason="classifier_unavailable")
+
+    parsed = result.parsed_json
+    if not isinstance(parsed, dict):
+        return _safe_default_blocking(normalised, reason="classifier_unavailable")
+
+    raw_items = parsed.get("classifications")
+    if not isinstance(raw_items, list) or not raw_items:
+        return _safe_default_blocking(normalised, reason="classifier_unavailable")
+
+    # Build a lookup so order/length mismatches don't drop questions:
+    # any unmatched input question defaults to blocking (safe).
+    by_question: dict[str, dict[str, Any]] = {}
+    for entry in raw_items:
+        if not isinstance(entry, dict):
+            continue
+        q = entry.get("question")
+        verdict = entry.get("verdict")
+        if not isinstance(q, str) or verdict not in ("blocking", "advisory"):
+            continue
+        by_question[q] = {
+            "question": q,
+            "verdict": verdict,
+            "rationale": str(entry.get("rationale") or ""),
+        }
+
+    blocking: list[dict[str, Any]] = []
+    advisory: list[dict[str, Any]] = []
+    for q in normalised:
+        record = by_question.get(q)
+        if record is None:
+            # Classifier omitted this question — safe default = blocking.
+            blocking.append(
+                {"question": q, "verdict": "blocking", "rationale": "classifier_omitted"}
+            )
+            continue
+        if record["verdict"] == "advisory":
+            advisory.append(record)
+        else:
+            blocking.append(record)
+
+    return blocking, advisory
+
+
+def _safe_default_blocking(
+    questions: list[str], *, reason: str
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    """When the classifier can't run, preserve the old halt behaviour by
+    flagging every question as blocking."""
+    return (
+        [
+            {"question": q, "verdict": "blocking", "rationale": reason}
+            for q in questions
+        ],
+        [],
+    )

{devflow_engine-1.1.21 → devflow_engine-1.1.23}/src/devflow_engine/stores/execution_store.py

@@ -2212,6 +2212,7 @@ class ExecutionStore:
         bypass_mode: str | None = None,
         worker_role: str | None = None,
         repo_quality_judge_fn: Callable[[dict[str, Any]], dict[str, Any]] | None = None,
+        question_classifier_fn: Callable[..., Any] | None = None,
     ) -> dict[str, Any]:
         """Run the US-8.5 error solver DAG using an artifact-first process contract.
 
@@ -2264,6 +2265,12 @@ class ExecutionStore:
                 # BuildObservability persists out and before FirstPassFix.
                 # Pure-LLM gate — see errors/repo_quality_judge.py.
                 "repo_quality_judge_fn": repo_quality_judge_fn,
+                # v1.1.22: deferred-question classifier hook. When None,
+                # BuildObservabilityNode falls back to the in-process
+                # pure-LLM classify_questions() in
+                # errors/question_classifier.py. Tests inject a stub fn
+                # to avoid live LLM calls.
+                "question_classifier_fn": question_classifier_fn,
                 # Role propagation for BuildObservabilityNode:
                 # - analyst → always stop after observability
                 # - fix → skip pi observability (use cached observation_json),
@@ -3129,10 +3136,32 @@ class ExecutionStore:
         now = int(time.time())
         with self._connect() as conn:
             if queue_type == "error":
-                conn.execute(
-                    "UPDATE error_tasks SET status=?, updated_at=? WHERE error_task_id=?",
-                    (status, now, item_id),
-                )
+                # v1.1.23: persist failure_message + failure_context into
+                # observability_error so a 'failed' error_task carries the
+                # exception detail. Pre-1.1.23 a DAG-internal exception
+                # left the row at status=failed with NULL observability_*,
+                # producing the silent-ghost pattern (controller emits no
+                # email, dashboard shows 'failed' with no reason).
+                if status == "failed":
+                    err_blob = json.dumps(
+                        {
+                            "message": failure_message or "engine marked failed with no failure_message",
+                            "context": failure_context or {},
+                            "finalized_run_id": current_run_id,
+                            "finalized_node_exec_id": current_node_exec_id,
+                            "finalized_at": now,
+                        },
+                        sort_keys=True,
+                    )
+                    conn.execute(
+                        "UPDATE error_tasks SET status=?, observability_error=COALESCE(observability_error, ?), updated_at=? WHERE error_task_id=?",
+                        (status, err_blob, now, item_id),
+                    )
+                else:
+                    conn.execute(
+                        "UPDATE error_tasks SET status=?, updated_at=? WHERE error_task_id=?",
+                        (status, now, item_id),
+                    )
             elif queue_type == "recovery":
                 conn.execute(
                     "UPDATE recovery_queue SET status=?, finished_run_id=COALESCE(?, finished_run_id), failure_message=COALESCE(?, failure_message), failure_context_json=COALESCE(?, failure_context_json), updated_at=? WHERE recovery_queue_id=?",