devflow-engine 1.1.14__tar.gz → 1.1.15__tar.gz

{devflow_engine-1.1.14 → devflow_engine-1.1.15}/PKG-INFO

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

{devflow_engine-1.1.14 → devflow_engine-1.1.15}/pyproject.toml

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

{devflow_engine-1.1.14 → devflow_engine-1.1.15}/src/devflow_engine/cli/app.py

@@ -1859,6 +1859,13 @@ def worker_start(
     project: str = typer.Option(..., "--project", help="Project id, GitHub URL, owner/repo, or workspace path"),
     once: bool = typer.Option(False, "--once", help="Process at most one queued item and exit"),
     json_out: bool = typer.Option(False, "--json", help="Emit JSON"),
+    role: str = typer.Option(
+        "both",
+        "--role",
+        help="Worker role: 'analyst' (claim 'open' user_report rows, run "
+        "observability only), 'fix' (claim 'observed' rows, run the rest "
+        "of the DAG), or 'both' (legacy default, run full DAG per item)",
+    ),
 ) -> None:
     """[CANONICAL] Start the queue-driven worker for a project.
 
@@ -1881,8 +1888,18 @@ def worker_start(
     project_id, repo_root = _resolve_worker_project(project)
     _exit_if_worker_guarded(repo_root=repo_root, json_out=json_out)
 
-    # Prevent starting a second worker if one is already running for this project
-    running_block = _check_no_running_worker_process(repo_root=repo_root, project_id=project_id)
+    role_normalized = (role or "both").strip().lower()
+    if role_normalized not in {"analyst", "fix", "both"}:
+        raise typer.BadParameter(f"--role must be analyst|fix|both, got {role!r}")
+    effective_role: str | None = None if role_normalized == "both" else role_normalized
+
+    # Per-role process lock so analyst+fix can run concurrently per
+    # project. Analyst pool (N parallel analysts) also passes through
+    # since the lock keys on (project, role) — multiple analyst
+    # processes coexist; the per-row claim is the actual serialization.
+    running_block = _check_no_running_worker_process(
+        repo_root=repo_root, project_id=project_id, role=effective_role,
+    )
     if running_block is not None:
         if json_out:
             sys.stdout.write(json.dumps({"error": "worker_start_blocked", "reason": running_block.reason, "source": running_block.source}, sort_keys=True) + "\n")
@@ -1893,7 +1910,7 @@ def worker_start(
     store = ExecutionStore(repo_root / ".devflow" / "execution.sqlite")
 
     if once:
-        result = process_worker_once(project_id=project_id, repo_root=repo_root, store=store)
+        result = process_worker_once(project_id=project_id, repo_root=repo_root, store=store, role=effective_role)
         payload = {
             "mode": "once",
             "project_id": result.project_id,

{devflow_engine-1.1.14 → devflow_engine-1.1.15}/src/devflow_engine/errors/error_solver_dag.py

@@ -334,8 +334,30 @@ class BuildObservabilityNode(Node):
             rc = context.get("runtimeContext") or {}
             source_kind = rc.get("source_kind") if isinstance(rc, dict) else None
 
-        fn: Callable[[dict[str, Any]], dict[str, Any]] = funcs["build_observability_fn"]
-        out = fn(context)
+        worker_role = funcs.get("worker_role") if isinstance(funcs, dict) else None
+
+        # Fix-worker fast path: when a row already has observability_json
+        # (analyst already ran), don't re-pay for pi observability —
+        # rebuild ``out`` from the cached observation and continue into
+        # FirstPassFix. Saves ~5-10 min per row vs re-running phase 1+2.
+        cached_observation: dict[str, Any] | None = None
+        if source_kind == "user_report" and worker_role == "fix":
+            with store._connect() as conn:
+                row = conn.execute(
+                    "SELECT observability_json FROM error_tasks WHERE error_task_id=?",
+                    (error_task_id,),
+                ).fetchone()
+            if row and row["observability_json"]:
+                try:
+                    cached_observation = json.loads(row["observability_json"])
+                except (TypeError, ValueError):
+                    cached_observation = None
+
+        if cached_observation is not None:
+            out: dict[str, Any] = {"observable": True, "observation": cached_observation, "cache_hit": True}
+        else:
+            fn: Callable[[dict[str, Any]], dict[str, Any]] = funcs["build_observability_fn"]
+            out = fn(context)
         persistor.persist(context=context, node_name="BuildObservability", output=out)
         self.save_output(BuildObservabilityNode.OutputType(**{"observable": bool(out.get("observable", True)), "details": out}))
 
@@ -390,7 +412,20 @@ class BuildObservabilityNode(Node):
             if isinstance(observation, dict):
                 task_context.metadata["user_report_observation"] = observation
 
-            if not gates_passed:
+            # Role-aware stop:
+            # - analyst → always stop here. The fix worker (separate
+            #   subprocess) will claim status='observed' rows and run
+            #   the rest of the DAG. Lets analysts run N-parallel
+            #   without stepping on workspace edits.
+            # - fix → never stop. We got here because we re-claimed an
+            #   already-analyzed row; gates passed by definition (the
+            #   claim filter requires observability_json IS NOT NULL).
+            # - None / legacy → gate-aware stop (pre-1.1.15 behavior).
+            if worker_role == "analyst":
+                task_context.stop_workflow()
+            elif worker_role == "fix":
+                pass  # always continue
+            elif not gates_passed:
                 task_context.stop_workflow()
 
         return task_context

{devflow_engine-1.1.14 → devflow_engine-1.1.15}/src/devflow_engine/stores/execution_store.py

@@ -1963,6 +1963,7 @@ class ExecutionStore:
         collect_evidence_fn: Callable[[dict[str, Any]], dict[str, Any]] | None = None,
         ship_fn: Callable[[dict[str, Any]], dict[str, Any]] | None = None,
         bypass_mode: str | None = None,
+        worker_role: str | None = None,
     ) -> dict[str, Any]:
         """Run the US-8.5 error solver DAG using an artifact-first process contract.
 
@@ -2011,6 +2012,12 @@ class ExecutionStore:
                 "iterative_fix_fn": iterative_fix_fn,
                 "needs_user_input_fn": needs_user_input_fn,
                 "ship_fn": ship_fn,
+                # Role propagation for BuildObservabilityNode:
+                # - analyst → always stop after observability
+                # - fix → skip pi observability (use cached observation_json),
+                #   never stop, let DAG flow to FirstPassFix
+                # - None (legacy) → gate-aware stop (current behavior)
+                "worker_role": worker_role,
             },
         )
 
@@ -2428,7 +2435,12 @@ class ExecutionStore:
             )
         return self.get_project_worker_report(project_id=project_id)
 
-    def claim_next_project_queue_item(self, *, project_id: str, worker_id: str) -> dict[str, Any] | None:
+    def claim_next_project_queue_item(
+        self, *,
+        project_id: str,
+        worker_id: str,
+        role: str | None = None,
+    ) -> dict[str, Any] | None:
         now = int(time.time())
         with self._connect() as conn:
             worker = conn.execute(
@@ -2441,14 +2453,39 @@ class ExecutionStore:
             if worker is None:
                 raise RuntimeError(f"worker not active for project_id={project_id}")
 
-            error_row = conn.execute(
-                (
+            # Role-aware claim:
+            # - role='analyst' → only claim 'open' user_report rows
+            #   (pure observability work; fix runs in a separate
+            #   worker subprocess so analysts and fixers can run
+            #   concurrently).
+            # - role='fix' → only claim 'observed' user_report rows
+            #   where gates passed (observability_json populated,
+            #   ready for FirstPassFix).
+            # - role=None (default / 'both') → legacy behavior:
+            #   claim either, run the full DAG end-to-end in one
+            #   subprocess.
+            if role == "analyst":
+                error_query = (
                     "SELECT error_task_id, run_id FROM error_tasks "
                     "WHERE project_id=? AND status IN ('open','triaged') "
+                    "AND source_kind='user_report' "
                     "ORDER BY created_at ASC LIMIT 1"
-                ),
-                (project_id,),
-            ).fetchone()
+                )
+            elif role == "fix":
+                error_query = (
+                    "SELECT error_task_id, run_id FROM error_tasks "
+                    "WHERE project_id=? AND status='observed' "
+                    "AND source_kind='user_report' "
+                    "AND observability_json IS NOT NULL "
+                    "ORDER BY created_at ASC LIMIT 1"
+                )
+            else:
+                error_query = (
+                    "SELECT error_task_id, run_id FROM error_tasks "
+                    "WHERE project_id=? AND status IN ('open','triaged') "
+                    "ORDER BY created_at ASC LIMIT 1"
+                )
+            error_row = conn.execute(error_query, (project_id,)).fetchone()
             if error_row is not None:
                 conn.execute(
                     "UPDATE error_tasks SET status='in_progress', updated_at=? WHERE error_task_id=?",

{devflow_engine-1.1.14 → devflow_engine-1.1.15}/src/devflow_engine/worker.py

@@ -499,16 +499,38 @@ def reconcile_stale_worker(*, project_id: str, repo_root: Path, store: Execution
     )
     return {"reconciled": True, "queue_type": queue_type, "item_id": item_id, "run_id": run_id, "worker_id": worker_id, "report": final_report}
 
-def process_once(*, project_id: str, repo_root: Path, store: ExecutionStore) -> WorkerStartResult:
+def process_once(
+    *,
+    project_id: str,
+    repo_root: Path,
+    store: ExecutionStore,
+    role: str | None = None,
+) -> WorkerStartResult:
+    """Run one queued item.
+
+    ``role`` filters which rows the worker will claim:
+    - ``None`` (default): legacy behavior, claim either 'open' or
+      'observed' user_report rows + run the full DAG.
+    - ``'analyst'``: only claim 'open' user_report rows; analyst exits
+      after observability so the fix worker can pick up the result.
+    - ``'fix'``: only claim 'observed' user_report rows (gates passed);
+      BuildObservabilityNode short-circuits on the cached observation.
+
+    The role split lets analyst-shaped work run in N parallel
+    subprocesses while fix work stays singleton (per-project workspace
+    can't take concurrent edits)."""
     ensure_worker_start_allowed(repo_root=repo_root)
-    source_doc_tick = process_source_doc_update_once(store=store, repo_root=repo_root)
-    if source_doc_tick.task is not None:
-        return WorkerStartResult(
-            project_id=project_id,
-            worker_id=source_doc_tick.worker_id,
-            processed={"queue_type": "source_docs", "item_id": source_doc_tick.task["task_id"]},
-            report=store.get_project_worker_report(project_id=project_id),
-        )
+    # Analyst/fix workers don't run source-doc maintenance — that's a
+    # 'both' default-mode concern.
+    if role is None:
+        source_doc_tick = process_source_doc_update_once(store=store, repo_root=repo_root)
+        if source_doc_tick.task is not None:
+            return WorkerStartResult(
+                project_id=project_id,
+                worker_id=source_doc_tick.worker_id,
+                processed={"queue_type": "source_docs", "item_id": source_doc_tick.task["task_id"]},
+                report=store.get_project_worker_report(project_id=project_id),
+            )
 
     worker_id = store.start_project_worker(project_id=project_id, repo_root=repo_root)
     processed: dict[str, Any] | None = None
@@ -516,7 +538,9 @@ def process_once(*, project_id: str, repo_root: Path, store: ExecutionStore) ->
     active_run_id: str | None = None
 
     try:
-        claimed = store.claim_next_project_queue_item(project_id=project_id, worker_id=worker_id)
+        claimed = store.claim_next_project_queue_item(
+            project_id=project_id, worker_id=worker_id, role=role,
+        )
         if claimed is None:
             report = store.stop_project_worker(project_id=project_id)
             return WorkerStartResult(project_id=project_id, worker_id=worker_id, processed=None, report=report)
@@ -661,6 +685,7 @@ def process_once(*, project_id: str, repo_root: Path, store: ExecutionStore) ->
                 iterative_fix_fn=_worker_iterative_fix,
                 needs_user_input_fn=lambda _ctx: True,
                 runtime_context=None,
+                worker_role=role,
             )
             outcome = str(result.get("outcome") or "blocked")
             store.complete_project_queue_item(project_id=project_id, worker_id=worker_id, queue_type="error", item_id=str(claimed["item_id"]), status=outcome, current_run_id=str(claimed.get("run_id") or "") or None)

{devflow_engine-1.1.14 → devflow_engine-1.1.15}/src/devflow_engine/worker_guard.py

@@ -135,12 +135,21 @@ def ensure_worker_start_allowed(*, repo_root: Path | None) -> None:
 
 
 def _check_no_running_worker_process(
-    *, repo_root: Path, project_id: str
+    *, repo_root: Path, project_id: str, role: str | None = None,
 ) -> WorkerGuardBlock | None:
     """Check if a live worker process is already running for this project.
 
-    Returns a WorkerGuardBlock if a running worker is found and confirmed alive.
-    If a stale running row exists (dead process), marks it stopped and returns None.
+    Role-aware blocking semantics:
+    - role=None ('both'): block if ANY worker is running (legacy).
+    - role='fix': block if another 'fix' or 'both' worker is running
+      (workspace edits can't safely interleave).
+    - role='analyst': block ONLY if a 'both' worker is running.
+      Multiple analyst processes are allowed (pool semantics) — they
+      serialize at the per-row claim level, not at the process level.
+
+    Returns a WorkerGuardBlock if a conflicting worker is found and
+    confirmed alive. Stale DB rows (dead PIDs) are cleaned up
+    in-place and return None.
     """
     import re
     import sqlite3
@@ -209,13 +218,44 @@ def _check_no_running_worker_process(
                 conn.commit()
                 continue
             # Check if it matches our project path
-            if resolved_repo in line:
+            if resolved_repo not in line:
+                continue
+
+            # Detect the running process's role from its cmdline.
+            # Format: `... devflow worker start --project ... [--role analyst|fix]`
+            if "--role analyst" in line:
+                running_role: str | None = "analyst"
+            elif "--role fix" in line:
+                running_role = "fix"
+            else:
+                running_role = None  # 'both' (legacy)
+
+            # Apply role-aware blocking rules.
+            # incoming role | running role | block?
+            # ---------------------------------------
+            # None (both)   | anything     | YES (legacy)
+            # fix           | fix or None  | YES (workspace edit conflict)
+            # fix           | analyst      | NO  (analyst can't write code)
+            # analyst       | None (both)  | YES ('both' might be fixing)
+            # analyst       | analyst      | NO  (pool — multiple OK)
+            # analyst       | fix          | NO  (independent rows)
+            should_block = False
+            if role is None:
+                should_block = True
+            elif role == "fix" and running_role in (None, "fix"):
+                should_block = True
+            elif role == "analyst" and running_role is None:
+                should_block = True
+
+            if should_block:
                 row = rows[0]
                 return WorkerGuardBlock(
                     reason=(
-                        f"A worker process (PID {pid}) is already running for this project "
-                        f"and is currently handling queue_type={row['active_queue_type']!r}, "
-                        f"item_id={row['active_item_id']!r}."
+                        f"A worker process (PID {pid}, role={running_role or 'both'}) "
+                        f"is already running for this project and is currently handling "
+                        f"queue_type={row['active_queue_type']!r}, "
+                        f"item_id={row['active_item_id']!r}. "
+                        f"Requested role={role or 'both'}."
                     ),
                     source=f"process:PID={pid}",
                 )

{devflow_engine-1.1.14 → devflow_engine-1.1.15}/uv.lock

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