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

devflow_engine-1.1.19/DESIGN_NOTES.md

@@ -0,0 +1,145 @@
+# DevFlow Error-Solver Hardening — Design Notes
+
+Track A landed in `v1.1.18`:
+- `errors/repo_quality_judge.py` — pure-LLM judge (medium tier → MiniMax) scoring
+  repro artifacts on `behavioral_vs_presence` and `fails_for_described_reason`.
+- `BuildObservabilityNode` runs the judge after the observation pass and before
+  `FirstPassFix`. Unhealthy judgments flip `error_tasks.quality_status` to
+  `awaiting_quality_review` and stop the workflow with `status='observed'`.
+- `ResolveNode` enforces the red-before-fix invariant: `verified =
+  green_gate AND observation_was_red`. Closes the "already-green-at-intake" leak
+  (`src/devflow_engine/errors/error_solver_dag.py` ResolveNode).
+- Schema: added `error_tasks.quality_status TEXT` via
+  `ExecutionStore._ensure_error_tasks_schema` (in-code migration, no Alembic).
+
+The rest of this document is the queue for the NEXT vertical slices. Each
+slice is intentionally small enough to land in one PR.
+
+---
+
+## Slice 1 — Playwright observe-time spec generation + visual-artifact capture
+
+**Why:** The repo-quality judge catches presence-only repros at intake, but it
+doesn't yet generate the behavioral repro itself. For UI bugs the observability
+worker should emit a Playwright spec (not just a pytest grep script) plus a
+screenshot/video so the portal can render visual evidence to the submitter and
+the fix worker.
+
+**Where to start:**
+- Sources of truth on Playwright discipline live at:
+  - `/Volumes/devflow/.openclaw/workspace/docs/how_to_playwright_right.md`
+  - `/Volumes/devflow/.openclaw/workspace/docs/PLAYWRITE-E2E-PROCESS.md`
+- Add a sibling to `src/devflow_engine/errors/user_report_observability.py`:
+  `user_report_observability_playwright.py`. Reuse the same agentic pi+tools
+  scaffold but emit `repro.spec.ts` + `artifacts/{screenshot.png,trace.zip}`.
+- BuildObservabilityNode already scopes the sandbox to
+  `.devflow/observability/{etid}/`; mirror that path layout for the new artifact set.
+- Wire selection (pytest vs. Playwright) through `report_context.surface` — when
+  the user-report intake came from a frontend route, prefer Playwright.
+- The repo-quality judge keys off the same payload shape (`repro_artifact.path` +
+  `repro_artifact.source`) — pass the `.spec.ts` source through unchanged.
+
+**Acceptance:**
+- A user-report against a route renders a `.spec.ts` + screenshot + trace.
+- RepoQualityJudge sees `behavioral` for a spec that exercises the page and
+  asserts on visible DOM/text, `presence` for a spec that only asserts a
+  selector exists in the rendered HTML.
+
+---
+
+## Slice 2 — Bug-portal routes `/bugs/{token}` on devflow-host
+
+**Why:** Submitters need to see (and respond to) the analyst's observation +
+repro + quality-judgment without an account. Mirrors the clarify magic-link
+pattern that's already in production for clarification questions.
+
+**Where to start:**
+- Mirror the controller pattern at
+  `controller/api/clarify.py` (in the devflow-host repo, not engine).
+- Token mechanism: reuse `clarification_links.create_link()` —
+  same TTL/rotation semantics already approved.
+- Engine side: add a `create_bug_portal_link(error_task_id)` helper next to
+  the existing clarification-link helper. New rows in the existing
+  `clarification_links` table with a discriminator column, OR a new
+  `bug_portal_links` table — prefer the former to keep the token rotation
+  audit in one place.
+- Portal routes (devflow-host):
+  - `GET /bugs/{token}` — render observation summary, repro source, judgment.
+  - `POST /bugs/{token}/request-changes` — see Slice 3.
+  - `POST /bugs/{token}/approve` — see Slice 4.
+
+**Acceptance:**
+- A user-report row with `quality_status='awaiting_quality_review'` exposes a
+  portal URL in `error_tasks` (new column `portal_url` or derived).
+- Submitter sees the repro and the judge's rationale; can act on it.
+
+---
+
+## Slice 3 — Modification-request → linked-new error_task
+
+**Why:** When a submitter clicks "request changes" on the portal, that's new
+information the analyst doesn't have yet. Spawn a new `error_tasks` row linked
+back to the original so the analyst pool re-claims it cleanly without losing
+the original audit trail.
+
+**Where to start:**
+- New schema column: `error_tasks.parent_error_task_id TEXT` (NULL for roots).
+  Add to `ExecutionStore._ensure_error_tasks_schema` required list. Index on it
+  for `WHERE parent_error_task_id = ?` lookups.
+- Engine helper: `ExecutionStore.create_modification_request(parent_etid,
+  message)` — inserts a child row with `source_kind='user_report'`,
+  `status='open'`, copies `project_id` + `reporter_*` + `source_app` from
+  parent, message = submitter's modification request, fingerprint derived
+  from `parent_etid + nonce` to bypass dedupe.
+- Portal handler `POST /bugs/{token}/request-changes` calls that helper.
+- Worker claim filter (`stores/execution_store.py` ~ line 2461 / 2478) does
+  NOT need changes — child rows are plain `open` user_report rows.
+
+**Acceptance:**
+- Submitter modification creates a sibling row visible to the analyst with a
+  link back to the original via `parent_error_task_id`.
+- Original row's `quality_status` remains; child gets its own DAG run.
+
+---
+
+## Slice 4 — Submitter-approval → staging push integration
+
+**Why:** After RepoQualityJudge + green-gate + observation_was_red all pass,
+the resolution commit lives in the worker's local repo but doesn't reach
+staging until a human approves. The portal `approve` button should be the
+trigger.
+
+**Where to start:**
+- The commit is already created by `_commit_resolution` in
+  `errors/error_solver_dag.py` (lines 179–224). The SHA is persisted to
+  `task_context.metadata["commit_result"]`. Extend ResolveNode to also write
+  the SHA into `error_tasks.resolution_commit_sha TEXT` (new column).
+- Portal handler `POST /bugs/{token}/approve`:
+  1. Look up `resolution_commit_sha` on the row.
+  2. `git push origin HEAD:refs/heads/staging-<etid>` from the worker's repo
+     clone (engine-side helper: `push_resolution_to_staging(etid)`).
+  3. Optionally open a PR via `gh pr create` against the project's main.
+- New `error_tasks.staging_status TEXT` column to track
+  `unpushed | pushed | pr_open | merged | rejected`.
+
+**Acceptance:**
+- Approval pushes exactly the resolution commit (single-commit branch) to
+  staging.
+- Rejection leaves the commit local and flips
+  `quality_status='awaiting_quality_review'` so a fresh analyst pass can
+  iterate.
+
+---
+
+## Anchors quick-reference
+
+- Engine DAG entrypoint: `src/devflow_engine/errors/error_solver_dag.py`
+  - `BuildObservabilityNode.process` — observation + RepoQualityJudge
+  - `ResolveNode.process` — red-before-fix invariant + commit
+  - `_commit_resolution` — atomic per-error commit (existing)
+- Schema migrations: `src/devflow_engine/stores/execution_store.py`
+  `_ensure_error_tasks_schema` (~ line 611)
+- Runner: `ExecutionStore.run_error_solver_dag` (~ line 1953); add new
+  `repo_quality_judge_fn` kwarg already present.
+- Judge: `src/devflow_engine/errors/repo_quality_judge.py`
+- Tests: `tests/area8_errors/test_us85_error_solver_repo_quality.py`

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

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

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

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

{devflow_engine-1.1.17 → devflow_engine-1.1.19}/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
@@ -697,10 +698,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.17 → devflow_engine-1.1.19}/src/devflow_engine/stores/execution_store.py

@@ -669,6 +669,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 +708,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 +1975,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)
     # ---------------------------------------------------------------------

devflow_engine-1.1.19/tests/area8_errors/test_us85_portal_and_modification.py

@@ -0,0 +1,192 @@
+"""v1.1.19 — bug-portal + modification-request + staging-push columns.
+
+Validates:
+- ResolveNode writes resolution_commit_sha + portal_token after a successful
+  resolve, and the row defaults to staging_push_status='unpushed'.
+- create_modification_request() inserts a child row with parent_error_task_id
+  set and a unique fingerprint that doesn't collide with the parent's active
+  fingerprint constraint.
+- find_by_portal_token() returns the row only for the correct token, None for
+  garbage tokens.
+- mark_staging_pushed / mark_staging_rejected flip the lifecycle field.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from devflow_engine.stores.execution_store import ExecutionStore
+
+
+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 _seed_user_report(
+    store: ExecutionStore, repo_root: Path, *, external_id: str = "ext-001"
+) -> str:
+    # Use create_error_task_from_failure (engine/runtime intake) instead of
+    # create_error_task_from_user_report so BuildObservability doesn't take
+    # the user-report branch that stops the workflow early. The portal +
+    # modification helpers are source_kind-agnostic — they read columns
+    # populated by ResolveNode, which is what we're exercising here.
+    run = store.start_run(
+        kind="story.execute", repo_root=repo_root, args={"story_id": "STORY:demo"}
+    )
+    etid = store.create_error_task_from_failure(
+        project_id="proj_demo",
+        run_id=run.run_id,
+        plane="ops",
+        source_kind="execution",
+        source_ref=run.run_id,
+        title="Demo bug",
+        severity="medium",
+        error_type=None,
+        message="something broke",
+        stacktrace=None,
+        next_steps=["Do X"],
+        fingerprint_inputs={"message": external_id, "plane": "ops"},
+    )
+    # Backfill the user-report-adjacent columns the portal needs to render
+    # and that create_modification_request copies onto the child row.
+    with store._connect() as conn:
+        conn.execute(
+            "UPDATE error_tasks SET reporter_email=?, reporter_username=?, "
+            "source_app=? WHERE error_task_id=?",
+            ("reporter@example.com", "reporter", "demo_app", etid),
+        )
+    return etid
+
+
+def _run_resolve(store: ExecutionStore, repo_root: Path, etid: str) -> dict:
+    def fix_fn(_ctx):
+        (repo_root / "fix.py").write_text("# fix\n")
+        return {"fixed": True, "verification": {"green_gate": True, "repro_run_command": "python fix.py"}}
+
+    return store.run_error_solver_dag(
+        error_task_id=etid,
+        repo_root=repo_root,
+        build_observability_fn=lambda _ctx: {"observable": True},
+        first_pass_fix_fn=fix_fn,
+        iterative_fix_fn=lambda _ctx: {"fixed": False},
+        needs_user_input_fn=lambda _ctx: False,
+    )
+
+
+def test_resolve_persists_resolution_commit_sha_portal_token_and_default_push_status(
+    tmp_path: Path,
+) -> None:
+    repo_root = tmp_path / "repo"
+    repo_root.mkdir()
+    _init_repo(repo_root)
+
+    db_path = repo_root / ".devflow" / "execution.sqlite"
+    store = ExecutionStore(db_path)
+    etid = _seed_user_report(store, repo_root)
+
+    result = _run_resolve(store, repo_root, etid)
+    assert result.get("outcome") == "resolved", result
+
+    row = store.get_resolved_with_portal(etid)
+    assert row is not None
+    assert row["status"] == "resolved"
+    assert row["resolution_commit_sha"], "resolution_commit_sha must be populated"
+    assert len(row["resolution_commit_sha"]) == 40, "expected full git SHA"
+    assert row["portal_token"], "portal_token must be minted"
+    assert len(row["portal_token"]) >= 32
+    assert row["staging_push_status"] == "unpushed"
+
+
+def test_create_modification_request_links_to_parent_with_unique_fingerprint(
+    tmp_path: Path,
+) -> None:
+    repo_root = tmp_path / "repo"
+    repo_root.mkdir()
+    _init_repo(repo_root)
+    db_path = repo_root / ".devflow" / "execution.sqlite"
+    store = ExecutionStore(db_path)
+
+    parent_etid = _seed_user_report(store, repo_root)
+    _run_resolve(store, repo_root, parent_etid)
+
+    child_a = store.create_modification_request(parent_etid, "the dropdown is still wrong")
+    child_b = store.create_modification_request(parent_etid, "still broken, different way")
+    assert child_a != child_b
+    assert child_a != parent_etid
+
+    # Both children link to the parent and have distinct fingerprints.
+    with store._connect() as conn:
+        rows = {
+            r["error_task_id"]: dict(r)
+            for r in conn.execute(
+                "SELECT error_task_id, parent_error_task_id, fingerprint, status, "
+                "project_id, reporter_email, source_kind "
+                "FROM error_tasks WHERE error_task_id IN (?,?,?)",
+                (parent_etid, child_a, child_b),
+            ).fetchall()
+        }
+
+    assert rows[child_a]["parent_error_task_id"] == parent_etid
+    assert rows[child_b]["parent_error_task_id"] == parent_etid
+    assert rows[child_a]["fingerprint"] != rows[child_b]["fingerprint"]
+    assert rows[child_a]["fingerprint"].startswith(f"mod:{parent_etid}:")
+    assert rows[child_a]["project_id"] == rows[parent_etid]["project_id"]
+    assert rows[child_a]["reporter_email"] == rows[parent_etid]["reporter_email"]
+    assert rows[child_a]["status"] == "open"
+    assert rows[child_a]["source_kind"] == "user_report"
+
+
+def test_find_by_portal_token_returns_row_only_for_correct_token(
+    tmp_path: Path,
+) -> None:
+    repo_root = tmp_path / "repo"
+    repo_root.mkdir()
+    _init_repo(repo_root)
+    db_path = repo_root / ".devflow" / "execution.sqlite"
+    store = ExecutionStore(db_path)
+    etid = _seed_user_report(store, repo_root)
+    _run_resolve(store, repo_root, etid)
+
+    row = store.get_resolved_with_portal(etid)
+    assert row is not None
+    token = row["portal_token"]
+
+    via_token = store.find_by_portal_token(token)
+    assert via_token is not None
+    assert via_token["error_task_id"] == etid
+
+    assert store.find_by_portal_token("not-a-real-token") is None
+    assert store.find_by_portal_token("") is None
+
+
+def test_mark_staging_pushed_and_rejected_flip_status(tmp_path: Path) -> None:
+    repo_root = tmp_path / "repo"
+    repo_root.mkdir()
+    _init_repo(repo_root)
+    db_path = repo_root / ".devflow" / "execution.sqlite"
+    store = ExecutionStore(db_path)
+    etid = _seed_user_report(store, repo_root)
+    _run_resolve(store, repo_root, etid)
+
+    store.mark_staging_pushed(etid)
+    assert store.get_resolved_with_portal(etid)["staging_push_status"] == "pushed"
+
+    # Independent etid to avoid sequencing surprises (push→reject is unusual
+    # but the helper should be idempotent on the row that's the target).
+    etid2 = _seed_user_report(store, repo_root, external_id="ext-002")
+    # Need to commit before second resolve (workspace must be clean).
+    subprocess.run(
+        ["git", "-C", str(repo_root), "commit", "-q", "--allow-empty", "-m", "spacer"],
+        check=True,
+    )
+    _run_resolve(store, repo_root, etid2)
+    store.mark_staging_rejected(etid2)
+    assert store.get_resolved_with_portal(etid2)["staging_push_status"] == "rejected"

{devflow_engine-1.1.17 → devflow_engine-1.1.19}/uv.lock

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