devflow-engine 1.1.24__tar.gz → 1.1.25__tar.gz

{devflow_engine-1.1.24 → devflow_engine-1.1.25}/.gitignore

@@ -14,5 +14,9 @@ __pycache__/
 # DevFlow runtime
 .devflow/
 
+# Agent / tooling runtime logs
+.debug.log
+.tau/
+
 # OS
 .DS_Store

{devflow_engine-1.1.24 → devflow_engine-1.1.25}/PKG-INFO

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

{devflow_engine-1.1.24 → devflow_engine-1.1.25}/pyproject.toml

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

{devflow_engine-1.1.24 → devflow_engine-1.1.25}/src/devflow_engine/cli/app.py

@@ -1808,11 +1808,19 @@ def _resolve_worker_project(selector: str) -> tuple[str, Path]:
     candidate = Path(selector).expanduser()
     if candidate.exists():
         repo_root = candidate.resolve()
+        repo_root_aliases = tuple(dict.fromkeys([str(repo_root), str(candidate), "."]))
         db_path = repo_root / ".devflow" / "execution.sqlite"
         if db_path.exists():
             store = ExecutionStore(db_path)
             with store._connect() as conn:
-                row = conn.execute("SELECT project_id FROM projects WHERE repo_root IN (?, '.') ORDER BY created_at DESC LIMIT 1", (str(repo_root),)).fetchone()
+                placeholders = ",".join("?" for _ in repo_root_aliases)
+                row = conn.execute(
+                    f"SELECT project_id FROM projects WHERE repo_root IN ({placeholders}) ORDER BY created_at DESC LIMIT 1",
+                    repo_root_aliases,
+                ).fetchone()
+                if row is not None and row[0]:
+                    return str(row[0]), repo_root
+                row = conn.execute("SELECT project_id FROM quick_action_queue ORDER BY updated_at DESC LIMIT 1").fetchone()
                 if row is not None and row[0]:
                     return str(row[0]), repo_root
                 row = conn.execute("SELECT project_id FROM idea_creation_queue ORDER BY updated_at DESC LIMIT 1").fetchone()
@@ -1874,8 +1882,8 @@ def worker_start(
     """[CANONICAL] Start the queue-driven worker for a project.
 
     This is the primary automated execution path for DevFlow. The worker
-    processes the project queues, including error tasks, recovery, idea,
-    story, source-doc mutation, and integration work, without manual
+    processes the project queues, including quick actions, error tasks,
+    recovery, idea, story, source-doc mutation, and integration work, without manual
     intervention.
 
     Use `--once` to process a single queued item (useful for debugging or
@@ -2950,6 +2958,7 @@ def story_list(
             return {r["status"]: r["cnt"] for r in rows}
 
         payload = {
+            "quick_action_queue": queue_counts("quick_action_queue"),
             "story_queue": queue_counts("story_queue"),
             "idea_queue": queue_counts("idea_queue"),
             "integration_queue": queue_counts("integration_queue"),

{devflow_engine-1.1.24 → devflow_engine-1.1.25}/src/devflow_engine/errors/runtime_observability.py

@@ -67,18 +67,47 @@ def collect_runtime_evidence_bundle(
     )
 
 
+# The evidence doctrine — stated once, injected into every observability
+# prompt. This is the guardrail that stopped the engine from shipping a fix
+# off an unproven "the endpoint doesn't exist" hypothesis (error_task
+# 45475193): it read code, asserted a cause, and wrote a patch before ever
+# reproducing the user's actual symptom. Observability builds EVIDENCE, and
+# evidence has a strict definition.
+_EVIDENCE_DOCTRINE = (
+    "WHAT EVIDENCE MEANS (read this first):\n"
+    "- Evidence is ACTUAL PROGRAM OUTPUT you produced and captured: a command's "
+    "stdout/stderr, an HTTP status+body, a database query result, a log line, a "
+    "failing assertion. Reading source code is NOT evidence — it produces "
+    "HYPOTHESES, never confirmed facts. If you did not run something and capture "
+    "its output, you have not observed it.\n"
+    "- You REPRODUCE THE USER'S REPORTED SYMPTOM FIRST. The symptom is the exact "
+    "action the user took and the exact wrong result they got — not a nearby "
+    "condition you find interesting. A repro that exercises a different action, "
+    "or asserts a different result, than the user reported is NOT a reproduction "
+    "and does NOT count as observed.\n"
+    "- For every candidate cause you must state a NULL HYPOTHESIS (the claim that "
+    "this cause is NOT the problem — i.e. that this hop works correctly) and the "
+    "falsification test whose real output would disprove it. A cause is only "
+    "'evidenced' once its null hypothesis is FALSIFIED by captured output. Until "
+    "then it is a hypothesis, and you must label it as such.\n"
+    "- You may NOT name a confirmed root cause or 'where the bug lives' from "
+    "static reading. confidence stays 'low' until the symptom is reproduced with "
+    "captured output."
+)
+
 _PHASE1_REQUIRED_KEYS = (
-    "summary", "affected_files", "likely_location",
-    "repro_tests", "open_questions", "confidence",
+    "summary", "reported_symptom", "affected_files", "candidate_causes",
+    "likely_location", "repro_tests", "open_questions", "confidence",
 )
 
 # Phase 3 may answer some questions previously raised by phase 2;
 # 'deferred_questions' replaces phase 1's 'open_questions' for downstream
 # consumers. observed/repro_* fields are the actual observation payload.
 _FINAL_REQUIRED_KEYS = (
-    "summary", "affected_files", "likely_location",
-    "repro_tests", "deferred_questions", "confidence",
-    "observed", "repro_artifact_path", "repro_run_command", "repro_output",
+    "summary", "reported_symptom", "affected_files", "candidate_causes",
+    "evidence", "likely_location", "repro_tests", "deferred_questions",
+    "confidence", "observed", "repro_artifact_path", "repro_run_command",
+    "repro_output",
 )
 
 
@@ -173,30 +202,41 @@ def _phase1_initial_analysis(
     payload = {
         "task": "user_report_observability_phase1_analysis",
         "instruction": (
-            "You are diagnosing a user-reported bug in a real codebase. "
-            "Your working directory is the project repo — USE YOUR TOOLS "
-            "(ls, find, grep, read) to actually locate the relevant code "
-            "before answering. Do NOT guess paths or function names. "
-            "Workflow: (1) ls / find the area of the codebase the report "
-            "names; (2) grep for the symptoms (endpoint name, error "
-            "string, component name); (3) read the specific files that "
-            "match to confirm the root cause; (4) only then emit the "
-            "final JSON. Every entry in affected_files must be a path you "
-            "verified exists. likely_location must include a file path "
-            "AND the function/line where the bug lives. Every repro_test "
-            "must reference a real test file (read the existing test "
-            "tree to pick the right home). open_questions should ONLY "
-            "contain things you couldn't determine after reading the code "
-            "— not things you didn't bother to look up. 'high' confidence "
-            "requires named function + verified repro path."
+            _EVIDENCE_DOCTRINE + "\n\n"
+            "PHASE 1 — characterize the symptom and map the failing path. "
+            "This phase does NOT confirm a cause and does NOT fix anything; "
+            "it sets up the reproduction the next phase will run. Your "
+            "working directory is the project repo — USE YOUR TOOLS (ls, "
+            "find, grep, read) to ground everything; do NOT guess paths or "
+            "function names. Workflow: (1) restate the REPORTED SYMPTOM "
+            "exactly — the precise user action and the precise wrong result "
+            "(this is what must be reproduced; do not substitute a different "
+            "symptom). (2) Trace the execution path that action travels "
+            "(e.g. UI submit -> API route -> persistence -> reload query -> "
+            "render) and grep/read each hop so you know the real code. "
+            "(3) For EACH hop that could produce the reported result, record "
+            "a candidate_cause: a hypothesis, its null_hypothesis (this hop "
+            "works), and the falsification_test (the command/request whose "
+            "real output would disprove the null). (4) Propose repro_tests "
+            "that reproduce the REPORTED SYMPTOM (the user's action + the "
+            "user's wrong result), against a real test file. "
+            "Do NOT assert likely_location yet — leave it null unless a hop "
+            "is already contradicted by output you actually captured. "
+            "open_questions = only what you genuinely cannot determine. "
+            "confidence MUST be 'low' at this phase (nothing is reproduced "
+            "yet)."
         ),
         "output_contract": (
-            "After your investigation, emit ONE final JSON OBJECT with "
-            "keys: summary (str), affected_files (list of {path, "
-            "reason}), likely_location (str — file path + function/line), "
-            "repro_tests (list of {name, file, rationale, language}), "
-            "open_questions (list of str), confidence "
-            "('low'|'medium'|'high')."
+            "Emit ONE final JSON OBJECT with keys: summary (str), "
+            "reported_symptom (str — the exact user action and exact wrong "
+            "result, as the thing to reproduce), affected_files (list of "
+            "{path, reason} — paths you verified exist), candidate_causes "
+            "(list of {hypothesis, null_hypothesis, falsification_test} — "
+            "the hops, each falsifiable), likely_location (str|null — null "
+            "unless already contradicted by captured output), repro_tests "
+            "(list of {name, file, rationale, language} — each reproduces "
+            "the reported symptom), open_questions (list of str), confidence "
+            "('low' for this phase)."
         ),
         "error_report": user_report,
         "workspace_root": str(repo_root),
@@ -251,7 +291,10 @@ def _loop_observe_and_resolve(
 
     state: dict[str, Any] = {
         "summary": analysis.get("summary"),
+        "reported_symptom": analysis.get("reported_symptom"),
         "affected_files": analysis.get("affected_files") or [],
+        "candidate_causes": analysis.get("candidate_causes") or [],
+        "evidence": [],
         "likely_location": analysis.get("likely_location"),
         "repro_tests": analysis.get("repro_tests") or [],
         "confidence": analysis.get("confidence"),
@@ -279,45 +322,57 @@ def _loop_observe_and_resolve(
         payload = {
             "task": "user_report_observability_combined_gate_loop",
             "instruction": (
-                "Two co-equal gates must pass before this analysis is "
-                "complete: (A) every open question is either ANSWERED "
-                "(from code/tools) or marked DEFERRED (genuinely needs "
-                "runtime info you cannot get from static inspection). "
-                "(B) the bug is OBSERVED — you wrote a repro test in "
-                "the sandbox, ran it, and the captured output matches "
-                "the reported failure pattern. The two gates feed each "
-                "other: running the test often surfaces concrete data "
-                "that answers an open question; answering a question "
-                "often changes which test to write or how to run it. "
-                "Look at the current state (analysis + open questions + "
-                "last test result) and do the SINGLE most useful thing "
-                "next: answer a question (with tools), edit or write "
-                "the repro test (sandbox path provided), run the test "
-                "(bash), or mark a question deferred. After that one "
-                "action, evaluate and emit the updated state. You will "
-                "be re-invoked with your updated state until BOTH gates "
-                "pass — do NOT try to do everything in one pass."
+                _EVIDENCE_DOCTRINE + "\n\n"
+                "PHASE 2 — reproduce the reported symptom, then falsify "
+                "nulls with real output. Two co-equal gates must pass: "
+                "(A) every open question is either ANSWERED (with captured "
+                "output as evidence) or marked DEFERRED (genuinely needs "
+                "runtime info you cannot get statically). (B) the reported "
+                "symptom is OBSERVED — you wrote a repro in the sandbox that "
+                "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. "
+                "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 "
+                "different result (e.g. the user reported 'saved data is "
+                "empty on reload' but your test checks an HTTP status code), "
+                "it is NOT a reproduction — keep observed=false and fix the "
+                "repro. Once reproduced, disprove each candidate_cause's "
+                "null_hypothesis with a falsification test that produces real "
+                "output; only then may likely_location name that hop. "
+                "Do the SINGLE most useful next action (answer a question "
+                "with tools, write/edit the repro, run it, or defer a "
+                "question), then emit the updated state. You are re-invoked "
+                "until both gates pass — do NOT batch."
             ),
             "output_contract": (
                 "Emit ONE final JSON OBJECT with the FULL updated state. "
                 "Keys: summary (str — may revise as you learn), "
-                "affected_files (list of {path, reason} — may grow/"
-                "shrink), likely_location (str), repro_tests (list of "
-                "{name, file, rationale, language}), confidence "
-                "('low'|'medium'|'high'), open_questions (list of str "
-                "— questions still unresolved this iteration), "
-                "answered_questions (cumulative list of {question, "
-                "answer, evidence}), deferred_questions (cumulative "
-                "list of str — only questions genuinely needing runtime "
-                "info), observed (bool — true ONLY if you ran the repro "
-                "test and the output matched the reported failure), "
-                "repro_artifact_path (str|null — path relative to "
-                "workspace, e.g. '.devflow/observability/<id>/repro.py'), "
-                "repro_run_command (str|null — the bash command), "
-                "repro_output (str|null — captured stdout/stderr of "
-                "the last test run, truncated to ~3000 chars), "
-                "refinement_notes (str — what you did this iteration "
-                "and why)."
+                "reported_symptom (str — the user's action + wrong result, "
+                "unchanged target of the reproduction), affected_files "
+                "(list of {path, reason}), candidate_causes (list of "
+                "{hypothesis, null_hypothesis, falsification_test, status: "
+                "'open'|'falsified'|'held'}), evidence (cumulative list of "
+                "{claim, command, output, kind: 'observed'|'inferred'} — "
+                "every 'observed' item MUST carry the command and its real "
+                "output), likely_location (str|null — set ONLY once a hop's "
+                "null is falsified by captured output, else null), "
+                "repro_tests (list of {name, file, rationale, language}), "
+                "confidence ('low'|'medium'|'high' — 'high' requires the "
+                "symptom reproduced AND a candidate's null falsified by "
+                "output), open_questions (list of str), answered_questions "
+                "(cumulative list of {question, answer, evidence}), "
+                "deferred_questions (cumulative list of str), observed (bool "
+                "— true ONLY if your repro exercises the user's reported "
+                "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 "
+                "(str|null — the bash command), repro_output (str|null — "
+                "captured stdout/stderr of the last run, ~3000 chars), "
+                "refinement_notes (str — what you did this iteration and "
+                "why)."
             ),
             "current_state": state,
             "iteration": iteration,
@@ -363,10 +418,12 @@ def _loop_observe_and_resolve(
         # nature of answered_questions / deferred_questions defensively.
         prev_answered = state.get("answered_questions") or []
         prev_deferred = state.get("deferred_questions") or []
-        for k in ("summary", "affected_files", "likely_location", "repro_tests",
-                  "confidence", "open_questions", "answered_questions",
-                  "deferred_questions", "observed", "repro_artifact_path",
-                  "repro_run_command", "repro_output", "refinement_notes"):
+        for k in ("summary", "reported_symptom", "affected_files",
+                  "candidate_causes", "evidence", "likely_location",
+                  "repro_tests", "confidence", "open_questions",
+                  "answered_questions", "deferred_questions", "observed",
+                  "repro_artifact_path", "repro_run_command", "repro_output",
+                  "refinement_notes"):
             if k in parsed:
                 state[k] = parsed[k]
         # Defensive: never let the model shrink the cumulative lists.

{devflow_engine-1.1.24 → devflow_engine-1.1.25}/src/devflow_engine/llm/invoke.py

@@ -268,6 +268,7 @@ def resolve_api_tier_request_overrides(
     resolved_cfg = cfg if cfg is not None else _load_global_llm_cfg()
     overrides: dict[str, Any] = {
         "transport": "api",
+        "provider_mode": "provider_api",
     }
     if normalized_tier == "light":
         # Light is always sourced from Supabase as canonical.
@@ -297,19 +298,17 @@ def resolve_api_tier_request_overrides(
         overrides["strength"] = strength_override or "strong"
         return overrides
 
-    # ultra_light
-    tier_cfg = _tier_config("ultra_light", resolved_cfg)
-    if tier_cfg:
-        provider = _normalize_provider_name(
-            str(tier_cfg.get("apiProvider") or tier_cfg.get("provider") or "").strip()
-        )
-        model = str(tier_cfg.get("apiModel") or tier_cfg.get("model") or "").strip() or None
-        if provider:
-            overrides["provider"] = provider
-        if model:
-            overrides["model"] = model
-        return overrides
-    overrides["strength"] = strength_override or "ultra_light"
+    # ultra_light: cheapest/fastest tier; defaults to local ollama llama3.2
+    # unless explicitly overridden via flat cfg keys.
+    provider = _normalize_provider_name(
+        str(resolved_cfg.get("llm_api_ultra_light_provider") or "").strip()
+    ) or "ollama"
+    model = (
+        str(resolved_cfg.get("llm_api_ultra_light_model_default") or "").strip()
+        or "llama3.2"
+    )
+    overrides["provider"] = provider
+    overrides["model"] = model
     return overrides
 
 
@@ -713,6 +712,7 @@ class LlmInvocationRequest:
     delivery: str | None = None
     provider: str | None = None
     model: str | None = None
+    provider_mode: str | None = None
 
 
 @dataclass(frozen=True)
@@ -745,6 +745,7 @@ class LlmInvocationResult:
     prompt_artifact_count: int = 0
     cli_cwd: Path | None = None
     used_sanitized_cli_cwd: bool = False
+    provider_mode: str | None = None
 
 
 @dataclass(frozen=True)

{devflow_engine-1.1.24 → devflow_engine-1.1.25}/src/devflow_engine/stores/execution_store.py

@@ -492,6 +492,28 @@ CREATE TABLE IF NOT EXISTS source_doc_mutation_queue (
 CREATE INDEX IF NOT EXISTS idx_source_doc_mutation_queue_project_status_created_at
   ON source_doc_mutation_queue(project_id, status, created_at);
 
+CREATE TABLE IF NOT EXISTS quick_action_queue (
+  quick_action_queue_id TEXT PRIMARY KEY,
+  project_id TEXT,
+  enqueue_run_id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  quick_action_payload_path TEXT NOT NULL,
+  status TEXT NOT NULL,
+  claimed_by_worker_id TEXT,
+  claimed_at INTEGER,
+  started_run_id TEXT,
+  finished_run_id TEXT,
+  failure_message TEXT,
+  failure_context_json TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  FOREIGN KEY(project_id) REFERENCES projects(project_id),
+  FOREIGN KEY(enqueue_run_id) REFERENCES runs(run_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_quick_action_queue_project_status_created_at
+  ON quick_action_queue(project_id, status, created_at);
+
 CREATE TABLE IF NOT EXISTS recovery_queue (
   recovery_queue_id TEXT PRIMARY KEY,
   project_id TEXT,
@@ -766,6 +788,20 @@ class ExecutionStore:
             indexes=["CREATE INDEX IF NOT EXISTS idx_integration_queue_project_status_created_at ON integration_queue(project_id, status, created_at);"]
         )
 
+    def _ensure_quick_action_queue_schema(self, conn: sqlite3.Connection) -> None:
+        self._ensure_project_queue_schema(
+            conn,
+            table="quick_action_queue",
+            required=[
+                ("quick_action_queue_id", "TEXT"), ("project_id", "TEXT"), ("enqueue_run_id", "TEXT NOT NULL DEFAULT ''"),
+                ("title", "TEXT NOT NULL DEFAULT ''"), ("quick_action_payload_path", "TEXT NOT NULL DEFAULT ''"),
+                ("status", "TEXT NOT NULL DEFAULT 'queued'"), ("claimed_by_worker_id", "TEXT"), ("claimed_at", "INTEGER"),
+                ("started_run_id", "TEXT"), ("finished_run_id", "TEXT"), ("failure_message", "TEXT"), ("failure_context_json", "TEXT"),
+                ("created_at", "INTEGER NOT NULL DEFAULT 0"), ("updated_at", "INTEGER NOT NULL DEFAULT 0"),
+            ],
+            indexes=["CREATE INDEX IF NOT EXISTS idx_quick_action_queue_project_status_created_at ON quick_action_queue(project_id, status, created_at);"],
+        )
+
     def _ensure_story_queue_schema(self, conn: sqlite3.Connection) -> None:
         self._ensure_project_queue_schema(
             conn,
@@ -946,6 +982,7 @@ class ExecutionStore:
             self._ensure_error_tasks_schema(conn)
             self._ensure_story_queue_schema(conn)
             self._ensure_integration_queue_schema(conn)
+            self._ensure_quick_action_queue_schema(conn)
             self._ensure_project_workers_schema(conn)
             self._ensure_task_queue_schema(conn)
             # Seed meta row if empty.
@@ -2438,6 +2475,39 @@ class ExecutionStore:
             )
         return source_doc_mutation_queue_id
 
+    def enqueue_quick_action_task(
+        self,
+        *,
+        project_id: str | None,
+        enqueue_run_id: str,
+        title: str,
+        quick_action_payload_path: str,
+    ) -> str:
+        quick_action_queue_id = str(uuid.uuid4())
+        now = int(time.time())
+        with self._connect() as conn:
+            repo_row = conn.execute("SELECT repo_root FROM runs WHERE run_id=?", (enqueue_run_id,)).fetchone()
+            repo_root = None if repo_row is None or not repo_row["repo_root"] else Path(str(repo_row["repo_root"]))
+            resolved_project_id = self._resolve_project_id_for_queue_insert(conn, project_id=project_id, repo_root=repo_root)
+            conn.execute(
+                (
+                    "INSERT INTO quick_action_queue("
+                    "quick_action_queue_id, project_id, enqueue_run_id, title, quick_action_payload_path, status, created_at, updated_at"
+                    ") VALUES(?,?,?,?,?,?,?,?)"
+                ),
+                (
+                    quick_action_queue_id,
+                    resolved_project_id,
+                    enqueue_run_id,
+                    title,
+                    quick_action_payload_path,
+                    "queued",
+                    now,
+                    now,
+                ),
+            )
+        return quick_action_queue_id
+
     def enqueue_recovery_task(
         self,
         *,
@@ -2715,6 +2785,26 @@ class ExecutionStore:
             if worker is None:
                 raise RuntimeError(f"worker not active for project_id={project_id}")
 
+            quick_action_row = conn.execute(
+                "SELECT quick_action_queue_id, enqueue_run_id FROM quick_action_queue WHERE project_id=? AND status='queued' ORDER BY created_at ASC LIMIT 1",
+                (project_id,),
+            ).fetchone()
+            if quick_action_row is not None:
+                conn.execute(
+                    "UPDATE quick_action_queue SET status='claimed', claimed_by_worker_id=?, claimed_at=?, updated_at=? WHERE quick_action_queue_id=?",
+                    (worker_id, now, now, quick_action_row["quick_action_queue_id"]),
+                )
+                conn.execute(
+                    "UPDATE project_workers SET status='running', active_queue_type='quick_action', active_item_id=?, current_run_id=?, current_node_exec_id=NULL, updated_at=? WHERE worker_id=?",
+                    (quick_action_row["quick_action_queue_id"], quick_action_row["enqueue_run_id"], now, worker_id),
+                )
+                return {
+                    "queue_type": "quick_action",
+                    "item_id": quick_action_row["quick_action_queue_id"],
+                    "run_id": quick_action_row["enqueue_run_id"],
+                    "current_node_exec_id": None,
+                }
+
             # Role-aware claim:
             # - role='analyst' → only claim 'open' user_report rows
             #   (pure observability work; fix runs in a separate
@@ -3203,6 +3293,14 @@ class ExecutionStore:
                     "UPDATE idea_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 idea_queue_id=?",
                     (status, current_run_id, failure_message, json.dumps(failure_context, sort_keys=True) if failure_context is not None else None, now, item_id),
                 )
+            elif queue_type == "quick_action":
+                conn.execute(
+                    (
+                        "UPDATE quick_action_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 quick_action_queue_id=?"
+                    ),
+                    (status, current_run_id, failure_message, json.dumps(failure_context, sort_keys=True) if failure_context is not None else None, now, item_id),
+                )
             elif queue_type == "story":
                 conn.execute(
                     (
@@ -3501,6 +3599,25 @@ class ExecutionStore:
             payload["failure_context"] = None
         return payload
 
+    def get_quick_action_queue_item(self, *, quick_action_queue_id: str) -> dict[str, Any] | None:
+        with self._connect() as conn:
+            row = conn.execute(
+                (
+                    "SELECT quick_action_queue_id, project_id, enqueue_run_id, title, quick_action_payload_path, status, "
+                    "claimed_by_worker_id, claimed_at, started_run_id, finished_run_id, failure_message, failure_context_json, created_at, updated_at "
+                    "FROM quick_action_queue WHERE quick_action_queue_id=?"
+                ),
+                (quick_action_queue_id,),
+            ).fetchone()
+        if row is None:
+            return None
+        payload = dict(row)
+        try:
+            payload["failure_context"] = json.loads(str(payload.get("failure_context_json") or "")) if payload.get("failure_context_json") else None
+        except Exception:
+            payload["failure_context"] = None
+        return payload
+
     def list_failed_scope_queue_items(self, *, project_id: str, limit: int = 20) -> list[dict[str, Any]]:
         with self._connect() as conn:
             rows = conn.execute(

{devflow_engine-1.1.24 → devflow_engine-1.1.25}/src/devflow_engine/worker.py

@@ -45,6 +45,7 @@ def _queue_label(queue_type: str | None) -> str:
     return {
         'error': 'Errors',
         'recovery': 'Recovery',
+        'quick_action': 'Quick actions',
         'scope': 'Scopes',
         'idea_creation': 'Idea creation',
         'idea': 'Ideas',
@@ -129,6 +130,13 @@ def _load_source_doc_mutation_payload(*, store: ExecutionStore, source_doc_mutat
     return item
 
 
+def _load_quick_action_payload(*, store: ExecutionStore, quick_action_queue_id: str) -> dict[str, Any]:
+    item = store.get_quick_action_queue_item(quick_action_queue_id=quick_action_queue_id)
+    if item is None:
+        raise ValueError(f"quick_action_queue_id not found: {quick_action_queue_id}")
+    return item
+
+
 def _load_integration_payload(*, store: ExecutionStore, integration_queue_id: str) -> dict[str, Any]:
     item = store.get_integration_queue_item(integration_queue_id=integration_queue_id)
     if item is None:
@@ -254,6 +262,12 @@ def _build_story_churn_state(
 
 def _peek_next_queue_type(*, project_id: str, store: ExecutionStore) -> str | None:
     with store._connect() as conn:
+        quick_action_row = conn.execute(
+            "SELECT quick_action_queue_id FROM quick_action_queue WHERE project_id=? AND status='queued' ORDER BY created_at ASC LIMIT 1",
+            (project_id,),
+        ).fetchone()
+        if quick_action_row is not None:
+            return 'quick_action'
         error_row = conn.execute(
             "SELECT error_task_id FROM error_tasks WHERE project_id=? AND status IN ('open','triaged') ORDER BY created_at ASC LIMIT 1",
             (project_id,),
@@ -546,7 +560,43 @@ def process_once(
             return WorkerStartResult(project_id=project_id, worker_id=worker_id, processed=None, report=report)
 
         processed = {"queue_type": claimed["queue_type"], "item_id": claimed["item_id"]}
-        if claimed["queue_type"] == "recovery":
+        if claimed["queue_type"] == "quick_action":
+            item = _load_quick_action_payload(store=store, quick_action_queue_id=str(claimed["item_id"]))
+            run = store.start_run(
+                kind="worker.quick_action",
+                repo_root=repo_root,
+                args={
+                    "project_id": project_id,
+                    "quick_action_queue_id": item["quick_action_queue_id"],
+                    "title": item["title"],
+                    "payload_path": item["quick_action_payload_path"],
+                },
+            )
+            active_run_id = run.run_id
+            store.update_project_worker_context(worker_id=worker_id, current_run_id=run.run_id, current_node_exec_id=None)
+            with store._connect() as conn:
+                conn.execute(
+                    "UPDATE quick_action_queue SET status='in_progress', started_run_id=?, updated_at=? WHERE quick_action_queue_id=?",
+                    (run.run_id, int(time.time()), item["quick_action_queue_id"]),
+                )
+            failure_message = "quick_action worker executor is not implemented"
+            store.mark_run_finished(run_id=run.run_id, status="blocked")
+            store.complete_project_queue_item(
+                project_id=project_id,
+                worker_id=worker_id,
+                queue_type="quick_action",
+                item_id=str(claimed["item_id"]),
+                status="blocked",
+                current_run_id=run.run_id,
+                failure_message=failure_message,
+                failure_context={
+                    "quick_action_payload_path": str(item.get("quick_action_payload_path") or ""),
+                    "required_next_step": "Implement quick_action executor or route this payload to the iterate lane.",
+                },
+            )
+            processed["status"] = "blocked"
+            processed["failure_message"] = failure_message
+        elif claimed["queue_type"] == "recovery":
             item = _load_recovery_payload(store=store, recovery_queue_id=str(claimed["item_id"]))
             run = store.start_run(
                 kind="worker.recovery",