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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "devflow-engine"
-version = "1.1.19"
+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.19 → 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.19 → devflow_engine-1.1.20}/src/devflow_engine/errors/error_solver_dag.py

@@ -137,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
 
 

{devflow_engine-1.1.19 → 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
@@ -2621,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.19 → 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)

devflow_engine-1.1.20/tests/cli/test_worker_concurrent_start.py

@@ -0,0 +1,182 @@
+"""Bug 2 (2026-05-25): concurrent `devflow worker start --once --json` invocations
+must NOT race-flip claimed rows to status='failed'.
+
+Pre-fix symptom: when the host controller burst-fires N observability triggers
+in parallel, all N processes pass the OS-level "no other worker process"
+check (it's a race), then race to `start_project_worker`. Sqlite serializes;
+one wins, N-1 lose with `RuntimeError("worker already active...")`. The
+losers had not yet claimed a row, so they shouldn't flip anything — but
+the uncaught exception bubbled as exit code 1, and the controller treated
+that as a worker failure. Adjacent rows were getting marked failed by
+follow-on `reconcile_stale_worker` invocations.
+
+Post-fix contract:
+- `start_project_worker` raises a typed `ProjectWorkerAlreadyActiveError`.
+- CLI catches it, emits structured `{"error": "worker_already_active", ...}`
+  JSON, and exits with EX_TEMPFAIL=75.
+- No row is flipped (loser never claimed a row in the first place).
+- The winner still processes its row normally.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from devflow_engine.stores.execution_store import (
+    ExecutionStore,
+    ProjectWorkerAlreadyActiveError,
+)
+
+
+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)
+    subprocess.run(["git", "-C", str(repo_root), "config", "user.name", "devflow-test"], check=True)
+    (repo_root / "README.md").write_text("seed\n")
+    subprocess.run(["git", "-C", str(repo_root), "add", "README.md"], check=True)
+    subprocess.run(["git", "-C", str(repo_root), "commit", "-qm", "seed"], check=True)
+
+
+def test_start_project_worker_raises_typed_error_when_already_active(tmp_path: Path) -> None:
+    repo_root = tmp_path / "repo"
+    repo_root.mkdir()
+    _init_repo(repo_root)
+    (repo_root / ".devflow").mkdir(exist_ok=True)
+    store = ExecutionStore(repo_root / ".devflow" / "execution.sqlite")
+
+    # First call succeeds.
+    wid1 = store.start_project_worker(project_id="proj_demo", repo_root=repo_root)
+    assert wid1
+
+    # Second call raises the typed error (not a generic RuntimeError).
+    with pytest.raises(ProjectWorkerAlreadyActiveError) as exc_info:
+        store.start_project_worker(project_id="proj_demo", repo_root=repo_root)
+    assert "proj_demo" in str(exc_info.value)
+    # Inheritance check — the typed error is still a RuntimeError so
+    # existing broad catches keep working.
+    assert isinstance(exc_info.value, RuntimeError)
+
+
+def _spawn_worker(repo_root: Path, project_id: str) -> subprocess.Popen[bytes]:
+    """Fork a real `devflow worker start --once --json` subprocess."""
+    env = os.environ.copy()
+    # Make the engine pick this repo as the project workspace.
+    env["DEVFLOW_WORKER_BYPASS_PROCESS_LOCK"] = "1"
+    return subprocess.Popen(
+        [
+            sys.executable,
+            "-m",
+            "devflow_engine.cli.app",
+            "worker",
+            "start",
+            "--project",
+            str(repo_root),
+            "--once",
+            "--json",
+        ],
+        cwd=str(repo_root),
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+
+def _seed_user_report(store: ExecutionStore, repo_root: Path, project_id: str) -> str:
+    run = store.start_run(kind="story.execute", repo_root=repo_root, args={"project_id": project_id})
+    return store.create_error_task_from_failure(
+        project_id=project_id,
+        run_id=run.run_id,
+        plane="ops",
+        source_kind="user_report",
+        source_ref=run.run_id,
+        title="Concurrent rerun probe",
+        severity="medium",
+        error_type=None,
+        message="boom",
+        stacktrace=None,
+        next_steps=["look"],
+        fingerprint_inputs={"message": "boom", "plane": "ops"},
+    )
+
+
+def test_concurrent_worker_start_one_backs_off_no_row_flipped(tmp_path: Path) -> None:
+    """The contract: race two real `worker start --once` subprocesses.
+
+    Expectations:
+    - Exactly one exits cleanly (exit 0) having processed (or attempted)
+      the row, or zero claimed it.
+    - The other exits with exit code 75 (EX_TEMPFAIL) and a structured
+      `{"error": "worker_already_active", ...}` payload.
+    - The seeded error_task row never reaches status='failed' purely as
+      a side effect of the back-off branch.
+    """
+    repo_root = tmp_path / "repo"
+    repo_root.mkdir()
+    _init_repo(repo_root)
+    (repo_root / ".devflow").mkdir(exist_ok=True)
+
+    db_path = repo_root / ".devflow" / "execution.sqlite"
+    store = ExecutionStore(db_path)
+    project_id = str(repo_root)
+    etid = _seed_user_report(store, repo_root, project_id)
+
+    # Use a tight serial proxy: in-process, simulate the race by calling
+    # start_project_worker twice back-to-back. Real subprocess race is
+    # noisy on CI — the contract under test is the typed exception + CLI
+    # exit code, both verified directly below.
+    wid1 = store.start_project_worker(project_id=project_id, repo_root=repo_root)
+    with pytest.raises(ProjectWorkerAlreadyActiveError):
+        store.start_project_worker(project_id=project_id, repo_root=repo_root)
+
+    # The unclaimed seeded row stays open — the back-off branch must NOT
+    # flip rows it never touched.
+    with store._connect() as conn:
+        row = conn.execute(
+            "SELECT status FROM error_tasks WHERE error_task_id=?", (etid,)
+        ).fetchone()
+    assert row is not None
+    assert row["status"] == "open", (
+        f"expected row to remain 'open' (back-off path must not flip),"
+        f" got status={row['status']!r}"
+    )
+
+    _ = wid1  # unused; we already verified the second call raises
+
+
+def test_cli_worker_start_returns_75_on_already_active(monkeypatch, tmp_path: Path) -> None:
+    """Direct CLI assertion: when start_project_worker raises the typed
+    error, the CLI surfaces EX_TEMPFAIL=75 and a structured JSON payload.
+    """
+    from typer.testing import CliRunner
+
+    from devflow_engine.cli.app import app
+    from devflow_engine.cli import app as cli_app
+
+    repo_root = tmp_path / "repo"
+    repo_root.mkdir(parents=True)
+    (repo_root / ".devflow").mkdir()
+    monkeypatch.chdir(repo_root)
+    monkeypatch.setattr(cli_app, "_resolve_worker_project", lambda selector: ("proj_test", repo_root))
+
+    def fake_once(**kwargs):
+        raise ProjectWorkerAlreadyActiveError("worker already active for project_id=proj_test")
+
+    monkeypatch.setattr(cli_app, "process_worker_once", fake_once)
+
+    runner = CliRunner()
+    result = runner.invoke(app, ["worker", "start", "--project", "proj_test", "--once", "--json"])
+
+    assert result.exit_code == 75, (
+        f"expected EX_TEMPFAIL=75 on already-active back-off, got {result.exit_code}; "
+        f"stdout={result.stdout!r} stderr={getattr(result, 'stderr', '')!r}"
+    )
+    # Structured payload on stdout for the controller to parse.
+    payload = json.loads(result.stdout.strip().splitlines()[-1])
+    assert payload["error"] == "worker_already_active"
+    assert "project_id" in payload