devflow-engine 1.1.18__tar.gz → 1.1.20__tar.gz

{devflow_engine-1.1.18 → devflow_engine-1.1.20}/PKG-INFO

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

{devflow_engine-1.1.18 → devflow_engine-1.1.20}/pyproject.toml

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

{devflow_engine-1.1.18 → devflow_engine-1.1.20}/src/devflow_engine/cli/app.py

@@ -59,7 +59,7 @@ from ..integration.dag import backfill_integration_current, prepare_integration_
 from ..playground.hooks import preflight as playground_preflight
 from ..project_registry import find_project_for_repo_root, resolve_project_entry
 from ..review.dag import run_review_dag
-from ..stores.execution_store import ExecutionStore
+from ..stores.execution_store import ExecutionStore, ProjectWorkerAlreadyActiveError
 from ..source_scope.dag import run_source_docs_to_scopes_dag, run_source_to_scope_dag, run_source_to_scope_resume
 from ..source_docs_updater import apply_source_doc_updates, detect_source_doc_changes, enqueue_source_doc_update_if_needed, ensure_source_doc_scaffold, process_source_doc_update_once
 from ..ui_grounding.dag import run_ui_grounding_dag
@@ -1910,7 +1910,31 @@ 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, role=effective_role)
+        # Bug 2 (2026-05-25): when the host controller burst-fires N
+        # parallel `worker start --once` subprocesses, the OS-level
+        # process-lock check above races; sqlite's row-level uniqueness
+        # is the real serializer. Losers raise
+        # ProjectWorkerAlreadyActiveError — they never claimed a queue
+        # row, so we MUST NOT bubble exit code 1 (which the controller
+        # treats as worker failure) and MUST NOT touch any rows. Emit a
+        # structured back-off payload and exit EX_TEMPFAIL=75 so the
+        # controller can distinguish "retry later" from genuine failure.
+        try:
+            result = process_worker_once(project_id=project_id, repo_root=repo_root, store=store, role=effective_role)
+        except ProjectWorkerAlreadyActiveError as exc:
+            backoff_payload = {
+                "error": "worker_already_active",
+                "project_id": project_id,
+                "existing_worker_id": exc.existing_worker_id,
+                "message": str(exc),
+                "retry_after_seconds": 5,
+            }
+            if json_out:
+                sys.stdout.write(json.dumps(backoff_payload, sort_keys=True) + "\n")
+            else:
+                sys.stderr.write(str(exc) + "\n")
+            # EX_TEMPFAIL (sysexits.h) = 75 — temporary failure, retry.
+            raise typer.Exit(code=75)
         payload = {
             "mode": "once",
             "project_id": result.project_id,

{devflow_engine-1.1.18 → devflow_engine-1.1.20}/src/devflow_engine/errors/error_solver_dag.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import secrets
 import subprocess
 import time
 import uuid
@@ -136,14 +137,73 @@ class WorkspaceDirtyError(RuntimeError):
 
 _ENGINE_INTERNAL_PREFIXES = (".devflow/",)
 
+# Build/test output and dependency directories that may appear at any depth
+# in the tree (root, per-frontend, per-backend). Matched as path segments
+# so files anywhere under `<...>/test-results/...` are filtered.
+_NOISE_DIR_SEGMENTS = (
+    "test-results",
+    "playwright-report",
+    "coverage",
+    "dist",
+    "build",
+    ".next",
+    "node_modules",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".turbo",
+    ".cache",
+)
+
+# File-suffix exclusions: runtime files / editor backups / OS noise that
+# nothing about the error-solver DAG should ever commit.
+_NOISE_SUFFIXES = (
+    ".pyc",
+    ".log",
+    ".bak",
+    ".swp",
+    ".swo",
+    "~",
+    ".db",
+    ".sqlite",
+    ".sqlite-shm",
+    ".sqlite-wal",
+    ".sqlite-journal",
+    ".db-shm",
+    ".db-wal",
+    ".db-journal",
+)
+
+# Exact basenames that are pure noise regardless of directory.
+_NOISE_BASENAMES = (
+    ".DS_Store",
+    "Thumbs.db",
+)
+
 
 def _is_source_path(path: str) -> bool:
     if path.startswith(_ENGINE_INTERNAL_PREFIXES):
         return False
-    # .pyc and __pycache__/ are regenerated by the running backend
-    # and never belong in a fix commit.
-    if path.endswith(".pyc") or "__pycache__/" in path:
+    basename = path.rsplit("/", 1)[-1]
+    if basename in _NOISE_BASENAMES:
+        return False
+    # `.env` and `.env.<anything>` runtime env files at any depth.
+    if basename == ".env" or basename.startswith(".env."):
+        return False
+    if basename.endswith(_NOISE_SUFFIXES):
         return False
+    # devflow.db at the workspace root is the engine-host api_tokens
+    # store. Its contents thrash on every API call and nothing about a
+    # fix-commit cares about it. Filtered explicitly so a tracked
+    # devflow.db at root never blocks a run.
+    if basename == "devflow.db":
+        return False
+    # Any segment of the path being a build/test/dep dir → noise.
+    segments = path.split("/")
+    for seg in segments[:-1]:  # don't match the file's own basename
+        if seg in _NOISE_DIR_SEGMENTS:
+            return False
     return True
 
 
@@ -697,10 +757,22 @@ class ResolveNode(Node):
                 verification=verification,
             )
             task_context.metadata["commit_result"] = commit_result
+            # v1.1.19: persist resolution_commit_sha + portal_token so the
+            # bug-portal route can render the fix diff and the host's
+            # post-observability dispatch can mint a /bugs/{token} URL.
+            resolution_sha = ""
+            if isinstance(commit_result, dict) and commit_result.get("committed"):
+                resolution_sha = str(commit_result.get("sha") or "")
+            portal_token = secrets.token_urlsafe(32)
+            task_context.metadata["portal_token"] = portal_token
+            task_context.metadata["resolution_commit_sha"] = resolution_sha
             with store._connect() as conn:
                 conn.execute(
-                    "UPDATE error_tasks SET status='resolved', updated_at=? WHERE error_task_id=?",
-                    (int(time.time()), error_task_id),
+                    "UPDATE error_tasks SET status='resolved', "
+                    "resolution_commit_sha=?, portal_token=?, "
+                    "staging_push_status=COALESCE(staging_push_status,'unpushed'), "
+                    "updated_at=? WHERE error_task_id=?",
+                    (resolution_sha or None, portal_token, int(time.time()), error_task_id),
                 )
             task_context.metadata["outcome"] = "resolved"
             task_context.metadata["reason"] = None

{devflow_engine-1.1.18 → devflow_engine-1.1.20}/src/devflow_engine/stores/execution_store.py

@@ -568,6 +568,31 @@ class RunRecord:
     created_at: int
 
 
+class ProjectWorkerAlreadyActiveError(RuntimeError):
+    """Raised when start_project_worker is called while another worker
+    row for the same project is in an active state.
+
+    Why a dedicated class:
+    The host controller burst-fires N parallel `devflow worker start
+    --once --json` subprocesses to drain the rerun queue. The OS-level
+    process lock check is best-effort (races on simultaneous spawns);
+    sqlite's row-level uniqueness is the real serializer. The losers of
+    that race must back off WITHOUT flipping any queue rows to
+    'failed' — they never claimed a row. The CLI catches this exact
+    class and exits with EX_TEMPFAIL=75 + a structured payload so the
+    controller can distinguish "back off, retry later" from a genuine
+    worker failure (exit 1) or kill-switch block (exit 2).
+    """
+
+    def __init__(self, project_id: str, existing_worker_id: str | None = None) -> None:
+        self.project_id = project_id
+        self.existing_worker_id = existing_worker_id
+        msg = f"worker already active for project_id={project_id}"
+        if existing_worker_id:
+            msg += f" (existing worker_id={existing_worker_id})"
+        super().__init__(msg)
+
+
 class ExecutionStore:
     def __init__(self, db_path: Path):
         self.db_path = db_path
@@ -669,6 +694,24 @@ class ExecutionStore:
             # only or symptom-mismatched repros so the dashboard can
             # surface them for human review without parsing context.json.
             ("quality_status", "TEXT"),
+            # v1.1.19: portal + modification + staging-push pipeline.
+            # ResolveNode persists resolution_commit_sha after _commit_resolution
+            # succeeds; the bug-portal route renders `git show <sha>` from it.
+            ("resolution_commit_sha", "TEXT"),
+            # Null = root user report. Non-null = "request changes" modification
+            # row, linked to its parent so the analyst sees the parent's commit
+            # as prior context.
+            ("parent_error_task_id", "TEXT"),
+            # Single-use opaque token for /bugs/{token} portal access. Minted
+            # in ResolveNode at resolve time. Lookup is by exact match.
+            ("portal_token", "TEXT"),
+            # Lifecycle of the staging push:
+            #   unpushed  → resolved but not yet pushed
+            #   pushed    → user clicked Approve and push succeeded to both remotes
+            #   rejected  → user clicked "Request changes" (rare; usually creates
+            #               a child row instead, but kept for explicit reject)
+            #   push_failed → push attempted, returned non-zero on either remote
+            ("staging_push_status", "TEXT NOT NULL DEFAULT 'unpushed'"),
             ("created_at", "INTEGER NOT NULL DEFAULT 0"),
             ("updated_at", "INTEGER NOT NULL DEFAULT 0"),
         ]
@@ -690,6 +733,10 @@ class ExecutionStore:
         )
         conn.execute("CREATE INDEX IF NOT EXISTS idx_error_tasks_run_id ON error_tasks(run_id);")
         conn.execute("CREATE INDEX IF NOT EXISTS idx_error_tasks_status ON error_tasks(status);")
+        # v1.1.19: fast lookup by portal_token for the bugs portal route.
+        conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_error_tasks_portal_token ON error_tasks(portal_token);"
+        )
 
     def _ensure_project_queue_schema(self, conn: sqlite3.Connection, *, table: str, required: list[tuple[str, str]], indexes: list[str]) -> None:
         row = conn.execute(
@@ -1953,6 +2000,200 @@ class ExecutionStore:
             )
         return error_task_id
 
+    # ---------------------------------------------------------------------
+    # v1.1.19 — bug-portal + modification-request + staging-push helpers
+    # ---------------------------------------------------------------------
+    def get_resolved_with_portal(self, error_task_id: str) -> dict[str, Any] | None:
+        """Return a portal-shaped view of a resolved error_task row.
+
+        Used by the host controller's /bugs/{token} route to render the
+        review portal. Returns None when the row doesn't exist OR isn't
+        resolved (the portal is only meaningful for resolved rows).
+        """
+        with self._connect() as conn:
+            self._ensure_error_tasks_schema(conn)
+            row = conn.execute(
+                "SELECT error_task_id, project_id, title, message, status, "
+                "reporter_email, reporter_username, "
+                "observability_json, resolution_commit_sha, portal_token, "
+                "parent_error_task_id, staging_push_status, "
+                "expected_behavior, steps_to_reproduce_json, report_context_json, "
+                "created_at, updated_at "
+                "FROM error_tasks WHERE error_task_id=?",
+                (error_task_id,),
+            ).fetchone()
+        if row is None:
+            return None
+        try:
+            obs = json.loads(row["observability_json"]) if row["observability_json"] else None
+        except (TypeError, ValueError):
+            obs = None
+        try:
+            steps = json.loads(row["steps_to_reproduce_json"] or "[]")
+        except (TypeError, ValueError):
+            steps = []
+        try:
+            ctx = json.loads(row["report_context_json"] or "{}")
+        except (TypeError, ValueError):
+            ctx = {}
+        repro_run_command = None
+        if isinstance(obs, dict):
+            repro_run_command = obs.get("repro_run_command")
+        return {
+            "error_task_id": row["error_task_id"],
+            "project_id": row["project_id"],
+            "title": row["title"],
+            "message": row["message"],
+            "status": row["status"],
+            "reporter_email": row["reporter_email"],
+            "reporter_username": row["reporter_username"],
+            "observability": obs,
+            "resolution_commit_sha": row["resolution_commit_sha"],
+            "portal_token": row["portal_token"],
+            "parent_error_task_id": row["parent_error_task_id"],
+            "staging_push_status": row["staging_push_status"] or "unpushed",
+            "expected_behavior": row["expected_behavior"],
+            "steps_to_reproduce": steps,
+            "report_context": ctx,
+            "repro_run_command": repro_run_command,
+            "created_at": row["created_at"],
+            "updated_at": row["updated_at"],
+        }
+
+    def find_by_portal_token(self, token: str) -> dict[str, Any] | None:
+        """Look up the error_task_id for a portal token, then return the
+        same shape as :meth:`get_resolved_with_portal`. Returns None when
+        the token doesn't match any row."""
+        if not token:
+            return None
+        with self._connect() as conn:
+            self._ensure_error_tasks_schema(conn)
+            row = conn.execute(
+                "SELECT error_task_id FROM error_tasks WHERE portal_token=? LIMIT 1",
+                (token,),
+            ).fetchone()
+        if row is None:
+            return None
+        return self.get_resolved_with_portal(row["error_task_id"])
+
+    def create_modification_request(self, parent_etid: str, message: str) -> str:
+        """Create a "request changes" child error_task linked to a resolved parent.
+
+        Copies project_id / reporter_* / source_app from the parent so the
+        analyst pool can re-claim and re-run with the parent's commit as
+        prior context. Returns the new error_task_id.
+
+        Fingerprint is ``mod:<parent_etid>:<nonce>`` so each modification is
+        unique even if the user spams the button — the active-fingerprint
+        unique index would otherwise reject the second one.
+        """
+        if not parent_etid or not (message or "").strip():
+            raise ValueError("parent_etid and non-empty message required")
+        now = int(time.time())
+        with self._connect() as conn:
+            self._ensure_error_tasks_schema(conn)
+            parent = conn.execute(
+                "SELECT project_id, source_app, reporter_id, reporter_email, "
+                "reporter_username, title, severity "
+                "FROM error_tasks WHERE error_task_id=?",
+                (parent_etid,),
+            ).fetchone()
+            if parent is None:
+                raise ValueError(f"parent error_task {parent_etid} not found")
+
+            new_etid = str(uuid.uuid4())
+            nonce = uuid.uuid4().hex[:12]
+            fingerprint = f"mod:{parent_etid}:{nonce}"
+            sentinel_run_id = f"user-report-{parent['project_id'] or 'global'}"
+            # Sentinel run row should already exist from the parent, but
+            # be defensive in case schema was hand-seeded.
+            conn.execute(
+                "INSERT OR IGNORE INTO runs("
+                "run_id, kind, status, config_json, created_at, updated_at"
+                ") VALUES(?,?,?,?,?,?)",
+                (sentinel_run_id, "user_report", "succeeded", "{}", now, now),
+            )
+            child_title = (parent["title"] or "modification request")
+            if not child_title.lower().startswith("modification:"):
+                child_title = f"Modification: {child_title}"
+            child_title = child_title[:512]
+            conn.execute(
+                "INSERT INTO error_tasks("
+                "error_task_id, project_id, run_id, plane, title, status, severity, "
+                "source_kind, source_app, source_ref, fingerprint, occurrence_count, "
+                "error_type, message, stacktrace, next_steps_json, "
+                "expected_behavior, steps_to_reproduce_json, report_context_json, "
+                "notify_on_update, reporter_id, reporter_email, reporter_username, "
+                "parent_error_task_id, staging_push_status, "
+                "created_at, updated_at"
+                ") VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                (
+                    new_etid,
+                    parent["project_id"],
+                    sentinel_run_id,
+                    "user_report",
+                    child_title,
+                    "open",
+                    parent["severity"] or "medium",
+                    "user_report",
+                    parent["source_app"] or "",
+                    f"mod:{parent_etid}",
+                    fingerprint,
+                    1,
+                    None,
+                    message.strip(),
+                    None,
+                    "[]",
+                    None,
+                    "[]",
+                    json.dumps({"parent_error_task_id": parent_etid}, sort_keys=True),
+                    0,
+                    parent["reporter_id"],
+                    parent["reporter_email"],
+                    parent["reporter_username"],
+                    parent_etid,
+                    "unpushed",
+                    now,
+                    now,
+                ),
+            )
+        return new_etid
+
+    def mark_staging_pushed(self, error_task_id: str) -> None:
+        """Flip staging_push_status='pushed' (called after a successful
+        double-remote push from the host controller)."""
+        now = int(time.time())
+        with self._connect() as conn:
+            self._ensure_error_tasks_schema(conn)
+            conn.execute(
+                "UPDATE error_tasks SET staging_push_status='pushed', updated_at=? "
+                "WHERE error_task_id=?",
+                (now, error_task_id),
+            )
+
+    def mark_staging_rejected(self, error_task_id: str) -> None:
+        """Flip staging_push_status='rejected'. Distinct from push_failed:
+        rejected = the user explicitly declined; push_failed = git refused."""
+        now = int(time.time())
+        with self._connect() as conn:
+            self._ensure_error_tasks_schema(conn)
+            conn.execute(
+                "UPDATE error_tasks SET staging_push_status='rejected', updated_at=? "
+                "WHERE error_task_id=?",
+                (now, error_task_id),
+            )
+
+    def mark_staging_push_failed(self, error_task_id: str) -> None:
+        """Flip staging_push_status='push_failed' (git push returned non-zero)."""
+        now = int(time.time())
+        with self._connect() as conn:
+            self._ensure_error_tasks_schema(conn)
+            conn.execute(
+                "UPDATE error_tasks SET staging_push_status='push_failed', updated_at=? "
+                "WHERE error_task_id=?",
+                (now, error_task_id),
+            )
+
     # ---------------------------------------------------------------------
     # Area 8.5 error solver DAG (Electron parity, minimal deterministic runner)
     # ---------------------------------------------------------------------
@@ -2405,7 +2646,10 @@ class ExecutionStore:
                 (project_id,),
             ).fetchone()
             if existing is not None:
-                raise RuntimeError(f"worker already active for project_id={project_id}")
+                raise ProjectWorkerAlreadyActiveError(
+                    project_id=project_id,
+                    existing_worker_id=str(existing["worker_id"]) if existing["worker_id"] else None,
+                )
             conn.execute(
                 (
                     "INSERT INTO project_workers("

{devflow_engine-1.1.18 → devflow_engine-1.1.20}/tests/area8_errors/test_us85_error_solver_commit_per_run.py

@@ -4,10 +4,80 @@ from pathlib import Path
 
 import pytest
 
-from devflow_engine.errors.error_solver_dag import WorkspaceDirtyError
+from devflow_engine.errors.error_solver_dag import WorkspaceDirtyError, _is_source_path
 from devflow_engine.stores.execution_store import ExecutionStore
 
 
+# Bug 1 (2026-05-25): _is_source_path filter is too narrow. The chi-webapp
+# workspace accumulates runtime/editor/build noise that has nothing to do
+# with an error_solver run; pre-fix it blocked legitimate runs as "dirty".
+@pytest.mark.parametrize(
+    "path",
+    [
+        # env files at any depth
+        ".env",
+        ".env.local",
+        ".env.production",
+        "fastapi_backend/.env",
+        "admin-frontend/.env.local",
+        # local sqlite databases (and their WAL/SHM siblings)
+        "fastapi_backend/dev.db",
+        "fastapi_backend/test_repro.db",
+        "fastapi_backend/dev.sqlite",
+        "fastapi_backend/dev.sqlite-shm",
+        "fastapi_backend/dev.sqlite-wal",
+        # devflow.db at workspace root is an engine-host api_tokens store
+        "devflow.db",
+        # runtime logs
+        "admin-frontend/openapi-ts-error-1779479564325.log",
+        "fastapi_backend/uvicorn.log",
+        # editor / OS noise
+        "src/component.tsx.bak",
+        "CreateEngagementForm.tsx.bak",
+        "foo.py.swp",
+        "bar.txt~",
+        ".DS_Store",
+        "admin-frontend/.DS_Store",
+        # build/test output dirs — at any depth, not just root
+        "nextjs-frontend/test-results/.playwright-artifacts-0/foo.png",
+        "admin-frontend/playwright-report/index.html",
+        "fastapi_backend/coverage/index.html",
+        "admin-frontend/dist/main.js",
+        "admin-frontend/build/main.js",
+        "nextjs-frontend/.next/server/pages.js",
+        # node_modules anywhere
+        "node_modules/foo/index.js",
+        "admin-frontend/node_modules/foo/package.json",
+        # existing exclusions still work
+        ".devflow/state.json",
+        "fastapi_backend/__pycache__/main.cpython-313.pyc",
+        "fastapi_backend/main.pyc",
+    ],
+)
+def test_is_source_path_excludes_runtime_noise(path: str) -> None:
+    assert _is_source_path(path) is False, f"{path!r} should be filtered out"
+
+
+@pytest.mark.parametrize(
+    "path",
+    [
+        "admin-frontend/components/issue-report-widget.tsx",
+        "fastapi_backend/api/v1/users.py",
+        "src/devflow_engine/worker.py",
+        "README.md",
+        "package.json",
+        "fastapi_backend/migrations/0001_init.sql",
+        "scripts/deploy.sh",
+        # files whose name CONTAINS noise tokens but aren't noise paths
+        "docs/env.md",
+        "src/log_config.py",
+        "src/database.py",
+    ],
+)
+def test_is_source_path_keeps_real_source(path: str) -> None:
+    assert _is_source_path(path) is True, f"{path!r} should be kept as source"
+
+
 def _init_repo(repo_root: Path) -> None:
     subprocess.run(["git", "init", "-q", str(repo_root)], check=True)
     subprocess.run(["git", "-C", str(repo_root), "config", "user.email", "test@devflow.local"], check=True)