devops-bot-sdk 1.4.94__tar.gz → 1.4.99__tar.gz

{devops_bot_sdk-1.4.94 → devops_bot_sdk-1.4.99}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.94
+Version: 1.4.99
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.4.94 → devops_bot_sdk-1.4.99}/devops_bot_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.94
+Version: 1.4.99
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.4.94 → devops_bot_sdk-1.4.99}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -24,6 +24,10 @@ sdk/collectors/__init__.py
 sdk/collectors/files.py
 sdk/collectors/process.py
 sdk/collectors/screenshot.py
+sdk/design_verify/__init__.py
+sdk/design_verify/browser.py
+sdk/design_verify/compare.py
+sdk/design_verify/loop.py
 sdk/hooks/__init__.py
 sdk/hooks/crucial_guard.py
 sdk/ipc/__init__.py

{devops_bot_sdk-1.4.94 → devops_bot_sdk-1.4.99}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devops-bot-sdk"
-version = "1.4.94"
+version = "1.4.99"
 description = "DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app"
 readme = "README.md"
 license = "LicenseRef-Proprietary"

{devops_bot_sdk-1.4.94 → devops_bot_sdk-1.4.99}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.4.94
+Version: 1.4.99
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -30,7 +30,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.4.94"
+__version__ = "1.4.99"
 __author__  = "AgentOS"
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.4.94 → devops_bot_sdk-1.4.99}/sdk/client.py

@@ -58,7 +58,7 @@ def _notify_status(task_id: str, status: str) -> None:
             pass
 
 
-SDK_VERSION    = "1.4.94"
+SDK_VERSION    = "1.4.99"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time
@@ -849,9 +849,17 @@ class BackendClient:
         headers = {k: v for k, v in self._headers.items() if k.lower() != "content-type"}
         headers.update({"accept": "*/*", "developer-name": "null", "product": ""})
         # POST /tasks-ml must never carry an SLA target — the backend validator
-        # rejects any value not shaped like "8h", and SLA is not ours to set.
+        # rejects any value not shaped like "8h" (an empty "" 400s with
+        # "Slatarget must be a positive integer of hours…"), and SLA is not ours
+        # to set. Drop it by NORMALISED name so every casing/separator variant
+        # (slaTarget, slaTargets, sla_target, SLATarget, sla-target, …) is
+        # excluded — never sent as "" or anything else, always an empty field.
+        def _is_sla(key: str) -> bool:
+            norm = "".join(ch for ch in key.lower() if ch.isalnum())
+            return norm in ("slatarget", "slatargets")
+
         files = [(k, (None, str(v))) for k, v in fields.items()
-                 if v is not None and k not in ("slaTarget", "slaTargets")]
+                 if v is not None and not _is_sla(k)]
         for m in (model_used or []):
             files.append(("modelUsed[]", (None, str(m))))  # [] → backend parses as array
         try:

devops_bot_sdk-1.4.99/sdk/design_verify/__init__.py

@@ -0,0 +1,51 @@
+"""Visual design verification & refinement loop (prototype).
+
+Why this exists
+---------------
+Design-to-code fidelity is capped when the system generates a frontend ONCE
+from a JIRA screenshot and never *looks* at what it built. This package closes
+that loop:
+
+    generate -> render in a real browser -> screenshot -> compare against the
+    original design -> feed the differences back -> correct -> repeat.
+
+It is deliberately decoupled from the main pipeline (nothing here is imported by
+the live `handlers`/`local_exec` flow yet) so it can be developed and tested in
+isolation, then slotted into `_code_one_repo` once proven.
+
+Two external pieces it leans on — both already available, no new Python deps:
+
+* ``agent-browser`` — Vercel Labs' Rust browser-automation CLI. Renders the
+  generated UI in headless Chrome and screenshots it. Install separately; see
+  ``README.md``. This is the ONLY new tool requirement.
+* the local ``claude`` CLI — reused via :func:`sdk.local_exec.run_claude_local`.
+  Its built-in ``Read`` tool reads image files natively, so it doubles as the
+  vision model that diffs the two screenshots. No `anthropic`/`openai` package
+  is added.
+
+What the caller must supply
+---------------------------
+The one input this repo does not currently receive is the **original design
+image** (the JIRA attachment). The backend hydrates task *text* only — attachment
+URLs never reach the SDK today (see ``sdk/models/requests.py``). To use this
+loop, the backend/operator must provide a local path to that screenshot. That
+integration is out of scope for this prototype; the loop takes the path as an
+argument.
+"""
+from __future__ import annotations
+
+from .browser import BrowserError, DiffResult, diff_baseline, render_screenshot, snapshot
+from .compare import ComparisonReport, compare_design
+from .loop import RefinementResult, verify_and_refine
+
+__all__ = [
+    "render_screenshot",
+    "snapshot",
+    "diff_baseline",
+    "DiffResult",
+    "BrowserError",
+    "compare_design",
+    "ComparisonReport",
+    "verify_and_refine",
+    "RefinementResult",
+]

devops_bot_sdk-1.4.99/sdk/design_verify/browser.py

@@ -0,0 +1,195 @@
+"""Thin async wrapper around the ``agent-browser`` CLI.
+
+Only the two operations the verification loop needs are exposed: render a URL and
+screenshot it to a file, and grab a structured accessibility snapshot. The
+daemon that ``agent-browser`` runs behind the scenes starts on first command and
+persists between calls, so successive screenshots in a refinement loop are cheap.
+
+Command syntax mirrors the upstream CLI (vercel-labs/agent-browser):
+
+    agent-browser open <url>          # navigate (aliases: navigate, goto)
+    agent-browser screenshot <path>   # --full, --screenshot-format png|jpeg
+    agent-browser snapshot --json     # accessibility tree with @e refs
+"""
+from __future__ import annotations
+
+import asyncio
+import re
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+_BINARY = "agent-browser"
+# A single browser op should never hang the loop; the daemon is local.
+_CMD_TIMEOUT_S = 60.0
+
+# agent-browser's `diff screenshot` prints human-readable lines; parse defensively
+# rather than assume a stable JSON shape. Captures "12.34%" and "1234 pixels".
+_PCT_RE = re.compile(r"([\d.]+)\s*%")
+_PIXELS_RE = re.compile(r"([\d,]+)\s*(?:different\s+)?pixels", re.IGNORECASE)
+
+
+class BrowserError(RuntimeError):
+    """Raised when the agent-browser CLI is missing or a command fails."""
+
+
+@dataclass
+class DiffResult:
+    """Outcome of a native `agent-browser diff screenshot` pixel comparison."""
+    mismatch_pct: float | None       # None when a pixel % could not be determined
+    diff_pixels: int | None
+    diff_image: str | None           # path to the red-highlighted diff image
+    dimension_mismatch: bool         # baseline/current sizes differ -> no pixel diff
+    raw: str = ""
+
+
+def is_available() -> bool:
+    """True if the ``agent-browser`` binary is on PATH."""
+    return shutil.which(_BINARY) is not None
+
+
+async def _run(*args: str) -> str:
+    """Run one agent-browser subcommand, returning stdout (text)."""
+    if not is_available():
+        raise BrowserError(
+            f"`{_BINARY}` not found on PATH. Install it (see "
+            "sdk/design_verify/README.md) — it is the only external dependency "
+            "of the design verification loop."
+        )
+    proc = await asyncio.create_subprocess_exec(
+        _BINARY, *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        out, err = await asyncio.wait_for(proc.communicate(), timeout=_CMD_TIMEOUT_S)
+    except asyncio.TimeoutError as exc:  # pragma: no cover - defensive
+        proc.kill()
+        raise BrowserError(f"`{_BINARY} {args[0]}` timed out after {_CMD_TIMEOUT_S}s") from exc
+    if proc.returncode != 0:
+        raise BrowserError(
+            f"`{_BINARY} {' '.join(args)}` failed (exit {proc.returncode}): "
+            f"{err.decode(errors='replace').strip()}"
+        )
+    return out.decode(errors="replace")
+
+
+async def render_screenshot(
+    url: str,
+    out_path: str | Path,
+    *,
+    full_page: bool = False,
+    fmt: str = "png",
+) -> Path:
+    """Navigate to ``url`` and screenshot it to ``out_path``.
+
+    ``full_page`` captures the entire scrollable page (``--full``); the default
+    captures just the viewport, which usually matches a design mock's framing
+    better. Returns the resolved output path.
+    """
+    out = Path(out_path).expanduser().resolve()
+    out.parent.mkdir(parents=True, exist_ok=True)
+    await _run("open", url)
+    args = ["screenshot", str(out), "--screenshot-format", fmt]
+    if full_page:
+        args.append("--full")
+    await _run(*args)
+    if not out.exists():
+        raise BrowserError(f"screenshot reported success but {out} was not written")
+    return out
+
+
+async def snapshot(url: str | None = None, *, interactive_only: bool = False) -> str:
+    """Return the page's accessibility tree as JSON text.
+
+    Lets the comparison assert *structure* (roles, labels, hierarchy) — not just
+    pixels. If ``url`` is given, navigates first; otherwise snapshots the current
+    page. Useful as a secondary signal when a pixel diff is ambiguous.
+    """
+    if url:
+        await _run("open", url)
+    args = ["snapshot", "--json"]
+    if interactive_only:
+        args.append("--interactive")
+    return await _run(*args)
+
+
+async def diff_baseline(
+    baseline: str | Path,
+    *,
+    out_path: str | Path,
+    url: str | None = None,
+    threshold: float = 0.1,
+) -> DiffResult:
+    """Pixel-diff the current page against a ``baseline`` image.
+
+    Runs ``agent-browser diff screenshot --baseline <baseline> -o <out> -t <thr>``,
+    which screenshots the live page and compares it to ``baseline`` at the pixel
+    level, writing a red-highlighted diff image to ``out_path``. If ``url`` is
+    given, navigates there first.
+
+    This is a *quantitative, localizing* signal — mismatch % and a highlight
+    image — NOT a semantic judgement. Baselines whose dimensions differ from the
+    render yield ``dimension_mismatch=True`` (the CLI refuses a pixel compare);
+    that is expected for design mocks and is handled gracefully by the caller,
+    which falls back to the vision comparison.
+
+    A nonzero exit here means "differences found," not failure, so — unlike the
+    other commands — we do not raise on it; we parse the reported metrics.
+    """
+    if not is_available():
+        raise BrowserError(
+            f"`{_BINARY}` not found on PATH. Install it (see "
+            "sdk/design_verify/README.md)."
+        )
+    base = Path(baseline).expanduser().resolve()
+    if not base.exists():
+        raise BrowserError(f"baseline image not found: {base}")
+    out = Path(out_path).expanduser().resolve()
+    out.parent.mkdir(parents=True, exist_ok=True)
+
+    if url:
+        await _run("open", url)
+
+    proc = await asyncio.create_subprocess_exec(
+        _BINARY, "diff", "screenshot",
+        "--baseline", str(base),
+        "-o", str(out),
+        "-t", str(threshold),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        raw_out, raw_err = await asyncio.wait_for(
+            proc.communicate(), timeout=_CMD_TIMEOUT_S
+        )
+    except asyncio.TimeoutError as exc:  # pragma: no cover - defensive
+        proc.kill()
+        raise BrowserError(f"`{_BINARY} diff screenshot` timed out") from exc
+
+    text = (raw_out.decode(errors="replace") + "\n" + raw_err.decode(errors="replace")).strip()
+    dim_mismatch = "dimension mismatch" in text.lower()
+    pct = None
+    px = None
+    if not dim_mismatch:
+        m = _PCT_RE.search(text)
+        if m:
+            pct = float(m.group(1))
+        m = _PIXELS_RE.search(text)
+        if m:
+            px = int(m.group(1).replace(",", ""))
+    return DiffResult(
+        mismatch_pct=pct,
+        diff_pixels=px,
+        diff_image=str(out) if out.exists() else None,
+        dimension_mismatch=dim_mismatch,
+        raw=text,
+    )
+
+
+async def close() -> None:
+    """Close the active browser session (best-effort)."""
+    try:
+        await _run("close")
+    except BrowserError:
+        pass

devops_bot_sdk-1.4.99/sdk/design_verify/compare.py

@@ -0,0 +1,150 @@
+"""Vision comparison of a rendered UI against the original design.
+
+Instead of adding an `anthropic`/`openai` dependency, this reuses the local
+``claude`` CLI (via :func:`sdk.local_exec.run_claude_local`). The CLI's built-in
+``Read`` tool reads image files natively, so we point it at BOTH the original
+design screenshot and the freshly rendered one and ask it to produce a strict
+JSON diff. This keeps the loop dependency-free and consistent with how the rest
+of the SDK already shells out to the local agent.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from sdk.local_exec import run_claude_local
+
+# Only Read is needed — the comparison must never edit files.
+_COMPARE_TOOLS = ["Read"]
+
+
+@dataclass
+class Discrepancy:
+    area: str            # e.g. "header", "primary CTA", "card grid spacing"
+    severity: str        # "high" | "medium" | "low"
+    expected: str        # what the design shows
+    actual: str          # what the rendered UI shows
+
+
+@dataclass
+class ComparisonReport:
+    fidelity_score: int                       # 0-100, higher = closer to design
+    discrepancies: list[Discrepancy] = field(default_factory=list)
+    correction_prompt: str = ""               # concrete fix instructions for the coder
+    raw: str = ""                             # raw model output (for debugging)
+
+    @property
+    def passed(self) -> bool:
+        return self.fidelity_score >= 0  # threshold applied by the loop, not here
+
+
+def _build_compare_prompt(
+    design_path: Path,
+    rendered_path: Path,
+    diff_path: Path | None = None,
+    diff_note: str = "",
+) -> str:
+    """Prompt the local agent to diff two images and emit strict JSON only."""
+    diff_block = ""
+    if diff_path is not None:
+        diff_block = (
+            f"  3. PIXEL DIFF (changed regions highlighted in red): {diff_path}\n"
+        )
+    hint = ""
+    if diff_note:
+        hint = (
+            "\nA pixel-level comparison was already run: "
+            f"{diff_note} Read the PIXEL DIFF image to see WHERE the pixels "
+            "differ (red = changed), and use it to localize your review — but "
+            "judge semantically, not by raw pixel count (fonts/anti-aliasing/"
+            "placeholder content inflate raw pixel diffs).\n"
+        )
+    return (
+        "You are a meticulous UI design reviewer. Images are on disk:\n"
+        f"  1. TARGET DESIGN (the intended look): {design_path}\n"
+        f"  2. CURRENT RENDER (what our generated frontend actually looks like): "
+        f"{rendered_path}\n"
+        f"{diff_block}"
+        f"{hint}\n"
+        "Use the Read tool to open and view the images. Then compare the CURRENT "
+        "RENDER against the TARGET DESIGN across: overall layout & structure, "
+        "spacing/alignment, colors, typography (family/size/weight), component "
+        "presence and ordering, iconography, and content/labels.\n\n"
+        "Output ONLY a single JSON object (no prose, no markdown fences) with this "
+        "exact shape:\n"
+        "{\n"
+        '  "fidelity_score": <int 0-100, how closely the render matches the design>,\n'
+        '  "discrepancies": [\n'
+        '    {"area": "<region/component>", "severity": "high|medium|low", '
+        '"expected": "<what the design shows>", "actual": "<what the render shows>"}\n'
+        "  ],\n"
+        '  "correction_prompt": "<a concise, imperative set of concrete code changes '
+        "that would close the gaps — reference components, colors (hex if visible), "
+        'spacing, and layout explicitly so a coding agent can act on it directly>"\n'
+        "}\n\n"
+        "Rank discrepancies most-severe first. If the render already matches "
+        "closely, return a high score, an empty discrepancies list, and an empty "
+        "correction_prompt."
+    )
+
+
+def _extract_json(text: str) -> dict:
+    """Pull the first balanced JSON object out of the model's output."""
+    start = text.find("{")
+    end = text.rfind("}")
+    if start == -1 or end == -1 or end <= start:
+        raise ValueError(f"no JSON object found in comparison output: {text[:200]!r}")
+    return json.loads(text[start : end + 1])
+
+
+async def compare_design(
+    design_path: str | Path,
+    rendered_path: str | Path,
+    *,
+    work_dir: str | Path,
+    diff_path: str | Path | None = None,
+    diff_note: str = "",
+) -> ComparisonReport:
+    """Diff a rendered screenshot against the target design; return a report.
+
+    ``work_dir`` is the cwd handed to the local ``claude`` CLI — any readable dir
+    works; the image paths are passed absolute so location does not matter.
+
+    ``diff_path``/``diff_note`` optionally pass a pre-computed pixel-diff image
+    (from :func:`sdk.design_verify.browser.diff_baseline`) and its metrics, so
+    the vision model can localize its review to the highlighted regions.
+    """
+    design = Path(design_path).expanduser().resolve()
+    rendered = Path(rendered_path).expanduser().resolve()
+    for p in (design, rendered):
+        if not p.exists():
+            raise FileNotFoundError(f"image not found: {p}")
+    diff = Path(diff_path).expanduser().resolve() if diff_path else None
+    if diff is not None and not diff.exists():
+        diff = None  # diff is a best-effort aid; never fail the review on it
+
+    result = await run_claude_local(
+        _build_compare_prompt(design, rendered, diff, diff_note),
+        str(work_dir),
+        allowed_tools=_COMPARE_TOOLS,
+    )
+    if not result.get("ok"):
+        raise RuntimeError(f"comparison run failed: {result.get('error')}")
+
+    raw = result.get("result", "") or ""
+    data = _extract_json(raw)
+    return ComparisonReport(
+        fidelity_score=int(data.get("fidelity_score", 0)),
+        discrepancies=[
+            Discrepancy(
+                area=str(d.get("area", "")),
+                severity=str(d.get("severity", "")),
+                expected=str(d.get("expected", "")),
+                actual=str(d.get("actual", "")),
+            )
+            for d in data.get("discrepancies", [])
+        ],
+        correction_prompt=str(data.get("correction_prompt", "")),
+        raw=raw,
+    )

devops_bot_sdk-1.4.99/sdk/design_verify/loop.py

@@ -0,0 +1,169 @@
+"""The closed refinement loop: render -> compare -> correct -> repeat.
+
+This is the piece that turns a one-shot design-to-code generation into a
+self-correcting one. It assumes the frontend has already been generated once and
+is being served at ``preview_url`` (a local dev server). Each iteration:
+
+    1. screenshot the live preview with agent-browser
+    2. compare it against the target design (local claude vision diff)
+    3. stop if fidelity >= threshold or we've run out of iterations
+    4. otherwise feed the correction prompt back to the coding agent, which edits
+       the real files; then loop (the caller's dev server hot-reloads)
+
+The coding step is injectable (``coder``) so the real pipeline can plug in its
+session-resuming ``run_claude_local`` call (keeping context across iterations)
+instead of the default fresh-run coder used here.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Awaitable, Callable
+
+from sdk.local_exec import DEFAULT_ALLOWED_TOOLS, run_claude_local
+
+from .browser import BrowserError, diff_baseline, render_screenshot
+from .compare import ComparisonReport, compare_design
+
+# A coder takes (project_path, correction_prompt) and applies fixes in place.
+Coder = Callable[[str, str], Awaitable[None]]
+
+
+@dataclass
+class Iteration:
+    index: int
+    screenshot: str
+    fidelity_score: int
+    discrepancy_count: int
+
+
+@dataclass
+class RefinementResult:
+    passed: bool
+    iterations: list[Iteration] = field(default_factory=list)
+    final_report: ComparisonReport | None = None
+
+    @property
+    def best_score(self) -> int:
+        return max((it.fidelity_score for it in self.iterations), default=0)
+
+
+async def _default_coder(project_path: str, correction_prompt: str) -> None:
+    """Fallback coder: a fresh local `claude` run that applies the corrections.
+
+    The real pipeline should pass a ``coder`` that RESUMES the ticket's session
+    (``resume_session_id=...``) so the agent keeps the design context across
+    iterations instead of starting cold each time.
+    """
+    prompt = (
+        "A visual review compared the current frontend against the target design "
+        "and found the differences below. Edit the code in this repository to "
+        "close them. Make the minimal, correct changes; do not restructure "
+        "unrelated code.\n\n"
+        f"{correction_prompt}"
+    )
+    result = await run_claude_local(
+        prompt, project_path, allowed_tools=DEFAULT_ALLOWED_TOOLS
+    )
+    if not result.get("ok"):
+        raise RuntimeError(f"correction run failed: {result.get('error')}")
+
+
+async def verify_and_refine(
+    *,
+    project_path: str | Path,
+    design_path: str | Path,
+    preview_url: str,
+    artifact_dir: str | Path,
+    threshold: int = 90,
+    max_iterations: int = 3,
+    full_page: bool = False,
+    coder: Coder | None = None,
+    on_event: Callable[[str], None] | None = None,
+) -> RefinementResult:
+    """Iteratively refine the generated UI until it matches ``design_path``.
+
+    Args:
+        project_path: repo whose frontend files get edited on each correction.
+        design_path:  the original design image (e.g. the JIRA screenshot).
+        preview_url:  URL where the generated UI is being served (dev server).
+        artifact_dir: where per-iteration screenshots are written.
+        threshold:    stop once fidelity_score >= this (0-100).
+        max_iterations: hard cap on correction rounds.
+        coder:        applies corrections; defaults to a fresh local claude run.
+        on_event:     optional progress sink (receives human-readable lines).
+
+    Returns a :class:`RefinementResult` with per-iteration scores and the final
+    comparison report.
+    """
+    project_path = str(project_path)
+    art = Path(artifact_dir).expanduser().resolve()
+    art.mkdir(parents=True, exist_ok=True)
+    coder = coder or _default_coder
+
+    def emit(msg: str) -> None:
+        if on_event:
+            on_event(msg)
+
+    result = RefinementResult(passed=False)
+    report: ComparisonReport | None = None
+
+    for i in range(1, max_iterations + 1):
+        shot = art / f"render_iter_{i}.png"
+        emit(f"[iter {i}/{max_iterations}] rendering {preview_url}")
+        await render_screenshot(preview_url, shot, full_page=full_page)
+
+        # Native pixel diff first — a fast, localizing signal + a highlight image
+        # the vision step can reason over. Best-effort: design mocks often differ
+        # in dimensions (CLI refuses the pixel compare), so never fail the loop
+        # on it — fall back to a pure vision comparison.
+        diff_path: str | None = None
+        diff_note = ""
+        try:
+            dr = await diff_baseline(
+                design_path, out_path=art / f"diff_iter_{i}.png"
+            )
+            if dr.dimension_mismatch:
+                diff_note = (
+                    "the render and design differ in dimensions, so no pixel "
+                    "diff was produced."
+                )
+            elif dr.mismatch_pct is not None:
+                diff_path = dr.diff_image
+                diff_note = f"the raw pixel mismatch is {dr.mismatch_pct:.1f}%."
+        except BrowserError as exc:
+            emit(f"[iter {i}/{max_iterations}] pixel diff skipped: {exc}")
+
+        emit(f"[iter {i}/{max_iterations}] comparing against design")
+        report = await compare_design(
+            design_path, shot, work_dir=art,
+            diff_path=diff_path, diff_note=diff_note,
+        )
+        result.iterations.append(
+            Iteration(
+                index=i,
+                screenshot=str(shot),
+                fidelity_score=report.fidelity_score,
+                discrepancy_count=len(report.discrepancies),
+            )
+        )
+        emit(
+            f"[iter {i}/{max_iterations}] fidelity={report.fidelity_score} "
+            f"discrepancies={len(report.discrepancies)}"
+        )
+
+        if report.fidelity_score >= threshold or not report.correction_prompt:
+            result.passed = report.fidelity_score >= threshold
+            break
+
+        if i == max_iterations:
+            break  # scored but out of correction budget
+
+        emit(f"[iter {i}/{max_iterations}] applying corrections")
+        await coder(project_path, report.correction_prompt)
+        # Give a hot-reloading dev server a moment to rebuild before re-shooting.
+        time.sleep(2)
+
+    result.final_report = report
+    return result

{devops_bot_sdk-1.4.94 → devops_bot_sdk-1.4.99}/sdk/ipc/handlers.py

@@ -1355,13 +1355,22 @@ async def _handle_story(
         # The Story is complete — nothing to convert or code in this run.
         return None
 
-    # STEP 1 — validate whether this is a CODEBASE (development) task: repo links /
-    # file paths in the instructions, or dev signals (PRs, branches, endpoints,
-    # deploy, …). A codebase task ALWAYS gets a technical PRD built from the current
-    # codebase; other domains (Finance, HR, …) get one only when explicitly asked.
+    # STEP 1 — do we have CODEBASE UNDERSTANDING to ground a PRD in? That means an
+    # actual repo target (a github/gitlab/bitbucket link in the instructions OR the
+    # story), or dev work called for in the OPERATOR INSTRUCTIONS (PRs, branches,
+    # endpoints, deploy, …).
+    #
+    # Deliberately NOT keyed off the story DESCRIPTION's vocabulary or a "PRD"
+    # mention: a business/BA user story that merely contains technical words
+    # (endpoint, API, database, "PRD", …) is NOT a codebase task. Keying off the
+    # description used to false-positive such stories into PRD generation, which
+    # folded an unwanted PRD into — and mangled — the operator's own document.
     has_repo = bool(_extract_repo_targets(human)) or bool(_extract_repo_targets(user_story))
-    is_codebase_task = has_repo or _is_dev_task(human) or _is_dev_task(user_story)
-    wants_prd = is_codebase_task or _wants_prd(human) or _wants_prd(user_story)
+    is_codebase_task = has_repo or _is_dev_task(human)
+    # PRD ONLY when we have codebase understanding. Without a repo/codebase, the
+    # Story is converted to a Task with its description left intact (the whole,
+    # proper document the operator provided) — never rewritten with a PRD.
+    wants_prd = is_codebase_task
 
     if is_codebase_task:
         step = ("validated as a codebase task — building a technical PRD from the "