@suiflex/suitest-mcp 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suiflex/suitest-mcp",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "publishConfig": {
     "access": "public"
   },

package/python/suitest_lifecycle/blackbox/mcp.py

@@ -388,15 +388,22 @@ def blackbox_publish_results(**kwargs: Any) -> dict[str, Any]:
     import os as _os
     import re as _re
 
+    from suitest_lifecycle.retest import rewrite_project_id
+
     project_id = str(kwargs.pop("project_id", "") or "")
     suite_name = str(kwargs.pop("suite_name", "") or "")
+    # EXPLICIT recreate opt-in — mirrors the lifecycle run tools. Without it a
+    # stale binding fails this publish instead of minting a fresh project.
+    recreate = bool(kwargs.pop("recreate_project", False))
     config_path = str(kwargs.get("config_path", "") or "")
     ui, paths = _resolve(**kwargs)
-    if config_path and not project_id:
+    if config_path:
         from suitest_lifecycle.config import load_config
 
         cfg = load_config(config_path)
-        project_id = cfg.publish.project_id
+        if not project_id:
+            project_id = cfg.publish.project_id
+        recreate = recreate or cfg.publish.recreate
     # No project configured → the server finds-or-creates one by a slug derived
     # from the target host. Publishing is MANDATORY in the blackbox pipeline;
     # "no project yet" is not an excuse to keep results local.
@@ -424,6 +431,66 @@ def blackbox_publish_results(**kwargs: Any) -> dict[str, Any]:
 
     try:
         with SuitestClient(api_url, token=token, timeout=180.0) as client:
+            # --- project binding gate (before any upload/insert) ----------- #
+            binding: dict[str, Any] = {"status": "first_setup", "action": "will_create_by_slug"}
+            if project_id:
+                binding = {
+                    "status": "unverified",
+                    "action": "server_unreachable",
+                    "projectId": project_id,
+                }
+                try:
+                    resolved = client.resolve_project(
+                        project_id=project_id,
+                        project_slug=project_slug,
+                        project_name=project_name,
+                    )
+                except Exception:
+                    # Resolve endpoint unreachable/older server: proceed — the
+                    # publish itself still 404s a stale id without inserting.
+                    resolved = None
+                if resolved is not None:
+                    status = str(resolved.get("status", "missing"))
+                    if status == "valid":
+                        binding = {
+                            "status": "valid",
+                            "action": "reused_existing_project",
+                            "projectId": project_id,
+                        }
+                    elif status == "repaired":
+                        project_id = str(resolved.get("projectId", ""))
+                        binding = {
+                            "status": "repaired",
+                            "action": "rebound_by_" + str(resolved.get("matchedBy", "match")),
+                            "projectId": project_id,
+                        }
+                        if config_path:
+                            rewrite_project_id(Path(config_path), project_id)
+                    elif recreate:
+                        binding = {
+                            "status": "recreate_requested",
+                            "action": "will_recreate_by_slug",
+                        }
+                        project_id = ""  # server find-or-creates by slug below
+                    else:
+                        return _envelope(
+                            False,
+                            f"stale project binding: projectId '{project_id}' not found in "
+                            "the workspace and no unambiguous project matched — nothing "
+                            "was published",
+                            data={
+                                "projectBinding": {
+                                    "status": "missing",
+                                    "action": "fail",
+                                    "projectId": project_id,
+                                    "candidates": resolved.get("candidates", []),
+                                }
+                            },
+                            errors=[
+                                "fix publish.projectId (or the project_id argument), or "
+                                "re-run with recreate_project=true to create a new project"
+                            ],
+                        )
 
             def _up(path: str, mime: str) -> str:
                 try:
@@ -505,26 +572,41 @@ def blackbox_publish_results(**kwargs: Any) -> dict[str, Any]:
                 )
             imported = client.bulk_import_cases(
                 project_id=project_id,
-                project_slug=project_slug,
-                project_name=project_name,
+                # Slug fallback ONLY when no validated id — an explicit id must
+                # never silently degrade into a find-or-create.
+                project_slug="" if project_id else project_slug,
+                project_name="" if project_id else project_name,
                 suite_name=suite,
                 mode="frontend",
                 cases=cases_payload,
+                # Current generation = the suite's alive set; an empty payload
+                # (nothing generated) must not stale the whole suite.
+                mark_stale=bool(cases_payload),
             )
+            resolved_id = str(imported.get("projectId", "") or "") or project_id
             run = client.ingest_run(
-                project_id=project_id,
-                project_slug=project_slug,
-                project_name=project_name,
+                project_id=resolved_id,
+                project_slug="" if resolved_id else project_slug,
+                project_name="" if resolved_id else project_name,
                 suite_name=suite,
                 name=f"{suite} run",
                 results=results_payload,
             )
     except SuitestAPIError as exc:
         return _envelope(False, f"publish failed: {exc}", errors=[str(exc)])
+    # Slug-based publish minted (or found) the project — pin its id so the next
+    # blackbox publish is an explicit-id retest, never a re-create.
+    if config_path and resolved_id and binding["status"] in ("first_setup", "recreate_requested"):
+        rewrite_project_id(Path(config_path), resolved_id)
     return _envelope(
         True,
         f"published: {len(imported.get('imported', []))} case(s), run {run.get('runId')}",
-        data={"imported": imported, "run": run},
+        data={
+            "imported": imported,
+            "run": run,
+            "projectBinding": {**binding, "projectId": resolved_id},
+            "staleCases": imported.get("stale", []),
+        },
     )
 
 

package/python/suitest_lifecycle/cli.py

@@ -92,6 +92,12 @@ def main(argv: list[str] | None = None) -> int:
 
     test = sub.add_parser("test", help="Run the full config-driven lifecycle")
     test.add_argument("--config", default="suitest.config.json")
+    test.add_argument(
+        "--recreate-project",
+        action="store_true",
+        help="EXPLICITLY recreate the Suitest project when publish.projectId is "
+        "stale and repair finds no match (otherwise a stale binding fails the run)",
+    )
 
     sub.add_parser("mcp", help="Serve the stdio MCP server")
 
@@ -109,7 +115,10 @@ def main(argv: list[str] | None = None) -> int:
         from suitest_lifecycle.config import load_config
         from suitest_lifecycle.orchestrator import run_lifecycle
 
-        res = run_lifecycle(load_config(args.config))
+        cfg = load_config(args.config)
+        if args.recreate_project:
+            cfg.publish.recreate = True
+        res = run_lifecycle(cfg)
         print(res.summary)
         for step in res.steps:
             print(f"  - {step}")

package/python/suitest_lifecycle/config.py

@@ -76,6 +76,11 @@ class PublishConfig:
     workspace_id: str = ""
     project_id: str = ""
     suite_name: str = ""
+    # EXPLICIT recreate opt-in: when the configured projectId no longer exists
+    # and repair finds no match, a fresh project is created ONLY if this is set
+    # (config keys ``recreateProject``/``resetProjectBinding``, env
+    # SUITEST_RECREATE_PROJECT=1, or the MCP tool arg ``recreate_project``).
+    recreate: bool = False
 
 
 @dataclass
@@ -264,6 +269,8 @@ def load_config(path: str | Path) -> Config:
     publish = PublishConfig()
     pub_raw = raw.get("publish", {})
     if isinstance(pub_raw, dict):
+        import os
+
         publish = PublishConfig(
             enabled=bool(pub_raw.get("enabled", False)),
             api_url=str(pub_raw.get("apiUrl", "http://localhost:4000")).rstrip("/"),
@@ -271,6 +278,11 @@ def load_config(path: str | Path) -> Config:
             workspace_id=str(pub_raw.get("workspaceId", "")),
             project_id=str(pub_raw.get("projectId", "")),
             suite_name=str(pub_raw.get("suiteName", "")),
+            recreate=bool(
+                pub_raw.get("recreateProject", False)
+                or pub_raw.get("resetProjectBinding", False)
+                or os.environ.get("SUITEST_RECREATE_PROJECT", "") in ("1", "true")
+            ),
         )
 
     ids_raw = raw.get("testIds", [])

package/python/suitest_lifecycle/mcp_server.py

@@ -22,6 +22,10 @@ if TYPE_CHECKING:
 
 PROTOCOL_VERSION = "2024-11-05"
 
+# Run tools accept the explicit recreate opt-in (goal: recreate NEVER happens
+# implicitly — only via this flag or the publish.recreateProject config key).
+RECREATE_TOOLS = frozenset({"run_tests", "run_backend_tests", "run_frontend_tests"})
+
 _TOOL_DESCRIPTIONS = {
     "analyze_project": "Static-analyze the target project; list endpoints (backend) or pages (frontend).",
     "generate_test_cases": "Analyze, build a PRD + test plan, and export runnable test files.",
@@ -74,6 +78,14 @@ _BLACKBOX_INPUT_SCHEMA: dict[str, object] = {
             "type": "string",
             "description": "Suitest project id to publish into (blackbox_publish_results)",
         },
+        "recreate_project": {
+            "type": "boolean",
+            "description": (
+                "EXPLICIT opt-in: recreate the project when the configured/passed "
+                "project id no longer exists and repair finds no match "
+                "(blackbox_publish_results). Without it a stale binding fails the publish."
+            ),
+        },
         "prd_file": {
             "type": "string",
             "description": "Markdown PRD path — PRD-driven semantic plan via the workspace LLM (blackbox_generate_playwright_tests)",
@@ -90,18 +102,29 @@ def _tool_schema(name: str) -> dict[str, object]:
             "description": _TOOL_DESCRIPTIONS.get(name, name),
             "inputSchema": _BLACKBOX_INPUT_SCHEMA,
         }
+    properties: dict[str, object] = {
+        "config_path": {
+            "type": "string",
+            "description": "Path to suitest.config.json",
+            "default": "suitest.config.json",
+        }
+    }
+    if name in RECREATE_TOOLS:
+        properties["recreate_project"] = {
+            "type": "boolean",
+            "description": (
+                "EXPLICIT opt-in: recreate the project when the configured "
+                "publish.projectId no longer exists and repair finds no match. "
+                "Without this flag a stale binding FAILS the run (nothing is inserted)."
+            ),
+            "default": False,
+        }
     return {
         "name": name,
         "description": _TOOL_DESCRIPTIONS.get(name, name),
         "inputSchema": {
             "type": "object",
-            "properties": {
-                "config_path": {
-                    "type": "string",
-                    "description": "Path to suitest.config.json",
-                    "default": "suitest.config.json",
-                }
-            },
+            "properties": properties,
             "required": ["config_path"],
         },
     }
@@ -124,7 +147,7 @@ def handle(message: dict[str, object]) -> dict[str, object] | None:
             {
                 "protocolVersion": PROTOCOL_VERSION,
                 "capabilities": {"tools": {}},
-                "serverInfo": {"name": "suitest-lifecycle", "version": "0.1.0"},
+                "serverInfo": {"name": "suitest-lifecycle", "version": "0.1.1"},
             },
         )
     if method in ("notifications/initialized", "initialized"):
@@ -144,6 +167,11 @@ def handle(message: dict[str, object]) -> dict[str, object] | None:
         try:
             if str(name) in KWARG_TOOLS:
                 envelope = tool(**arguments)
+            elif str(name) in RECREATE_TOOLS:
+                envelope = tool(
+                    str(arguments.get("config_path", "suitest.config.json")),
+                    bool(arguments.get("recreate_project", False)),
+                )
             else:
                 envelope = tool(str(arguments.get("config_path", "suitest.config.json")))
         except Exception as exc:  # defensive: never crash the server on a tool bug

package/python/suitest_lifecycle/orchestrator.py

@@ -27,6 +27,18 @@ from suitest_lifecycle.process import ProcessManager
 from suitest_lifecycle.publish import publish_results
 from suitest_lifecycle.readiness import wait_until_ready
 from suitest_lifecycle.report import write_all_reports
+from suitest_lifecycle.retest import (
+    BindingResult,
+    build_fingerprint,
+    can_reuse_generated,
+    classify_results,
+    diff_fingerprint,
+    load_codegen_meta,
+    load_snapshot,
+    reconcile_codegen,
+    resolve_binding,
+    save_snapshot,
+)
 from suitest_lifecycle.runner import run_tests
 from suitest_lifecycle.serialize import (
     code_summary_to_json,
@@ -48,6 +60,10 @@ class LifecycleResult:
     artifacts: list[str] = field(default_factory=list)
     errors: list[str] = field(default_factory=list)
     steps: list[str] = field(default_factory=list)
+    # Retest telemetry: mode, project binding, change detection, generated-code
+    # status, failure classification, next actions. Surfaced verbatim in the
+    # MCP envelope so agents can reason about WHY a retest behaved as it did.
+    retest: dict[str, object] = field(default_factory=dict)
 
 
 def _publish_step(pub: dict[str, object]) -> str:
@@ -58,6 +74,15 @@ def _publish_step(pub: dict[str, object]) -> str:
     return f"publish skipped — {pub.get('reason')}"
 
 
+def _record_publish(pub: dict[str, object], steps: list[str], errors: list[str]) -> None:
+    """A failed publish never fails the run, but it must be LOUD: agents only
+    read the envelope's ``errors``, so a steps-only note is effectively silent."""
+    msg = _publish_step(pub)
+    steps.append(msg)
+    if not pub.get("published"):
+        errors.append(msg)
+
+
 def _today() -> str:
     return datetime.date.today().isoformat()
 
@@ -114,6 +139,67 @@ def _is_blackbox(config: Config) -> bool:
     return config.mode is Mode.FRONTEND and config.analysis_source == "blackbox"
 
 
+# Stable identity fields for a discovered element — deliberately EXCLUDES
+# volatile data (screenshot paths, dynamic visible text) so a retest against an
+# unchanged app never false-positives as a UI change.
+_ELEMENT_ID_FIELDS = (
+    "kind",
+    "testid",
+    "role",
+    "name",
+    "label",
+    "placeholder",
+    "dom_id",
+    "css",
+    "input_type",
+)
+
+
+def _crawl_elements(crawl: object | None) -> dict[str, object] | None:
+    """Per-route interactive-element identity from a live DOM crawl.
+
+    Feeds selector-level change detection (``selector_changed``). Returns None
+    when no crawl ran (repo-analysis runs have no element capture)."""
+    if crawl is None:
+        return None
+    page_elements = getattr(crawl, "page_elements", None)
+    page_testids = getattr(crawl, "page_testids", None)
+    pe = page_elements if isinstance(page_elements, dict) else {}
+    pt = page_testids if isinstance(page_testids, dict) else {}
+    if not pe and not pt:
+        return None
+    return {
+        str(route): {"elements": pe.get(route), "testids": pt.get(route)}
+        for route in sorted({*pe, *pt})
+    }
+
+
+def _discovery_elements(pages: list[object]) -> dict[str, object]:
+    """Per-route element identity from a blackbox discovery (same purpose as
+    :func:`_crawl_elements`, different source shape)."""
+
+    def _ident(e: object, *, with_text: bool = False) -> dict[str, object]:
+        d: dict[str, object] = {f: getattr(e, f, "") for f in _ELEMENT_ID_FIELDS}
+        if with_text:
+            # Button labels are part of the UI contract (button_label_changed);
+            # link/input text is too dynamic to fingerprint.
+            d["text"] = getattr(e, "text", "")
+        return d
+
+    out: dict[str, object] = {}
+    for p in pages:
+        out[str(getattr(p, "route", ""))] = {
+            "inputs": [_ident(e) for e in getattr(p, "inputs", [])],
+            "buttons": [_ident(e, with_text=True) for e in getattr(p, "buttons", [])],
+            "links": [_ident(e) for e in getattr(p, "links", [])],
+            "hasTable": getattr(p, "has_table", False),
+            "hasForm": getattr(p, "has_form", False),
+            "hasModal": getattr(p, "has_modal", False),
+            "rowLocator": getattr(p, "row_locator", ""),
+        }
+    return out
+
+
 def generate_only(
     config: Config,
     summary: CodeSummary | None = None,
@@ -145,7 +231,54 @@ def generate_only(
     from suitest_lifecycle.llm_bridge import build_dom_context
 
     dom_context = build_dom_context(crawl, summary)  # type: ignore[arg-type]
-    cases = _export(config, cases, summary, paths, llm=codegen_llm, dom_context=dom_context)
+
+    # --- retest: change detection + generated-code reuse -------------------- #
+    import hashlib
+
+    fingerprint = build_fingerprint(summary, cases, _crawl_elements(crawl))
+    change_report = diff_fingerprint(load_snapshot(paths), fingerprint)
+    dom_digest = hashlib.sha256(dom_context.encode("utf-8")).hexdigest()[:16]
+    meta_prev = load_codegen_meta(paths)
+    reuse = (
+        not change_report["first"]
+        and not change_report["changed"]
+        and can_reuse_generated(cases, paths, meta_prev, dom_digest, config.codegen)
+    )
+    export_error = ""
+    stash: dict[str, str] = {}
+    if not reuse:
+        # Stash current files so a regen never silently destroys reviewed code:
+        # changed files are archived to history/, a failed regen is rolled back.
+        for entry in meta_prev.values():
+            fname = str(entry.get("file", ""))
+            fp = paths.test_file(fname) if fname else None
+            if fp is not None and fp.is_file():
+                stash[fname] = fp.read_text(encoding="utf-8")
+        try:
+            cases = _export(config, cases, summary, paths, llm=codegen_llm, dom_context=dom_context)
+        except Exception as exc:  # regen failure → keep prior code, flag needs_review
+            export_error = f"{type(exc).__name__}: {exc}"
+            for fname, content in stash.items():
+                paths.test_file(fname).write_text(content, encoding="utf-8")
+            for c in cases:
+                prev_entry = meta_prev.get(c.title)
+                if prev_entry:
+                    c.automation_file = str(prev_entry.get("file", ""))
+    _meta, gen_counts = reconcile_codegen(
+        cases,
+        paths,
+        meta_prev,
+        stash,
+        dom_digest,
+        config.codegen,
+        reused=reuse,
+        export_error=export_error,
+    )
+    save_snapshot(paths, fingerprint)
+    (paths.tmp_dir / "change_report.json").write_text(
+        json.dumps({"changeDetection": change_report, "generatedCode": gen_counts}, indent=2),
+        encoding="utf-8",
+    )
 
     paths.code_summary_json.write_text(json.dumps(code_summary_to_json(summary), indent=2), "utf-8")
     paths.prd_json.write_text(json.dumps(prd_to_json(prd), indent=2), encoding="utf-8")
@@ -249,6 +382,19 @@ def _blackbox_generate(config: Config) -> tuple[CodeSummary, list[PlanCase], Pat
             else "No login form found."
         ),
     )
+    # Retest change detection for the blackbox path (deterministic codegen, so
+    # code reuse is just hash bookkeeping — no LLM cost to skip).
+    fingerprint = build_fingerprint(summary, cases, _discovery_elements(list(discovery.pages)))
+    change_report = diff_fingerprint(load_snapshot(paths), fingerprint)
+    _meta, gen_counts = reconcile_codegen(
+        cases, paths, load_codegen_meta(paths), {}, "", "blackbox"
+    )
+    save_snapshot(paths, fingerprint)
+    (paths.tmp_dir / "change_report.json").write_text(
+        _json.dumps({"changeDetection": change_report, "generatedCode": gen_counts}, indent=2),
+        encoding="utf-8",
+    )
+
     paths.code_summary_json.write_text(
         _json.dumps(code_summary_to_json(summary), indent=2), encoding="utf-8"
     )
@@ -257,10 +403,109 @@ def _blackbox_generate(config: Config) -> tuple[CodeSummary, list[PlanCase], Pat
     return summary, cases, paths, steps
 
 
+def _load_change_report(paths: Paths) -> dict[str, object]:
+    p = paths.tmp_dir / "change_report.json"
+    if not p.is_file():
+        return {}
+    try:
+        raw = json.loads(p.read_text(encoding="utf-8"))
+        return raw if isinstance(raw, dict) else {}
+    except ValueError:
+        return {}
+
+
+_RUN_MODE = {
+    "local_only": "local_only",
+    "first_setup": "first_test",
+    "recreate_requested": "recreate",
+    "valid": "retest",
+    "repaired": "retest",
+    "unverified": "retest",
+    "missing": "blocked",
+}
+
+
+def _build_retest(
+    binding: BindingResult,
+    report: dict[str, object],
+    classifications: dict[str, str],
+    pub: dict[str, object],
+) -> dict[str, object]:
+    cd = report.get("changeDetection")
+    gc = report.get("generatedCode")
+    cd = cd if isinstance(cd, dict) else {}
+    gc = gc if isinstance(gc, dict) else {}
+    mode = _RUN_MODE.get(binding.status, "retest")
+    if mode == "retest" and cd.get("first"):
+        mode = "first_test"  # binding valid but this host never generated before
+    kinds = sorted(set(classifications.values()))
+    stale_raw = pub.get("stale")
+    stale = stale_raw if isinstance(stale_raw, list) else []
+
+    next_actions: list[str] = []
+    if binding.status == "missing":
+        next_actions.append(
+            "Fix publish.projectId in suitest.config.json (see candidates), or set "
+            "publish.recreateProject=true / re-run with recreate_project to create a new project."
+        )
+    if stale:
+        next_actions.append(f"Review {len(stale)} STALE test case(s) in the TCM: {stale}")
+    if kinds:
+        next_actions.append("Inspect classified failures: " + ", ".join(kinds))
+    if gc.get("needs_review"):
+        next_actions.append(
+            "Code regeneration failed — prior automation kept; see codegen_meta.json (needs_review)."
+        )
+    if not next_actions:
+        next_actions.append("No action needed — binding resolved and results recorded.")
+
+    return {
+        "mode": mode,
+        "projectBinding": binding.to_json(),
+        "changeDetection": cd,
+        "generatedCode": gc,
+        "failureClassification": kinds,
+        "testCases": {
+            "created": pub.get("created", 0),
+            "reused": pub.get("reused", 0),
+            "stale": len(stale),
+        },
+        "testRun": {
+            "created": bool(pub.get("published")),
+            "runId": pub.get("runId"),
+            "status": pub.get("runStatus"),
+        },
+        "published": bool(pub.get("published")),
+        "publishReason": str(pub.get("reason", "")),
+        "nextActions": next_actions,
+    }
+
+
 def run_lifecycle(config: Config) -> LifecycleResult:
     steps: list[str] = []
     errors: list[str] = []
 
+    # Project binding FIRST: a stale, unrepairable binding must fail loudly
+    # before anything is generated, executed, or inserted server-side.
+    binding = resolve_binding(config, recreate=config.publish.recreate)
+    steps.append(f"project binding: {binding.status} ({binding.action})")
+    if binding.detail:
+        steps.append(f"binding detail: {binding.detail}")
+    if binding.blocks_publish:
+        errors.append(binding.detail)
+        pub: dict[str, object] = {"published": False, "reason": binding.detail, "blocked": True}
+        return LifecycleResult(
+            success=False,
+            summary=(
+                "FAILED — project binding is stale (projectId not found) and could not be "
+                "repaired. Nothing was generated, executed, or published."
+            ),
+            run=None,
+            errors=errors,
+            steps=steps,
+            retest=_build_retest(binding, {}, {}, pub),
+        )
+
     crawl_mode = _is_crawl(config) or _is_blackbox(config)
     summary_code: CodeSummary | None
     if crawl_mode:
@@ -287,10 +532,13 @@ def run_lifecycle(config: Config) -> LifecycleResult:
 
     def _finish_fail(detail: str) -> LifecycleResult:
         errors.append(f"not ready: {detail}")
+        kind = "dependency_not_ready" if detail.startswith("dependency") else "target_not_ready"
         run_failed = _empty_run(config, summary_code, server_started, False, detail, startup_tail)
         _finalize(config, cases, run_failed, paths)
+        fail_pub: dict[str, object] = {"published": False, "reason": "run aborted before tests"}
         if config.publish.enabled:
-            steps.append(_publish_step(publish_results(config, run_failed, cases, paths)))
+            fail_pub = publish_results(config, run_failed, cases, paths, binding=binding)
+            _record_publish(fail_pub, steps, errors)
         return LifecycleResult(
             success=False,
             summary=f"FAILED — {detail}",
@@ -298,6 +546,9 @@ def run_lifecycle(config: Config) -> LifecycleResult:
             artifacts=_artifact_list(paths),
             errors=errors,
             steps=steps,
+            retest=_build_retest(
+                binding, _load_change_report(paths), {"readiness": kind}, fail_pub
+            ),
         )
 
     try:
@@ -392,8 +643,23 @@ def run_lifecycle(config: Config) -> LifecycleResult:
 
     run = _build_run(config, summary_code, results, server_started, ready_detail, startup_tail)
     _finalize(config, cases, run, paths)
+
+    report = _load_change_report(paths)
+    cd = report.get("changeDetection")
+    api_changed = bool(cd.get("apiChanged")) if isinstance(cd, dict) else False
+    classifications = classify_results(run.results, config.mode, api_changed=api_changed)
+    if classifications:
+        steps.append(
+            "failure classification: "
+            + ", ".join(f"{tid}={kind}" for tid, kind in sorted(classifications.items()))
+        )
+
+    pub2: dict[str, object] = {"published": False, "reason": "publish disabled"}
     if config.publish.enabled:
-        steps.append(_publish_step(publish_results(config, run, cases, paths)))
+        pub2 = publish_results(
+            config, run, cases, paths, binding=binding, classifications=classifications
+        )
+        _record_publish(pub2, steps, errors)
 
     ok = run.failed == 0 and run.errored == 0
     verb = "PASSED" if ok else "FAILED"
@@ -407,6 +673,7 @@ def run_lifecycle(config: Config) -> LifecycleResult:
         artifacts=_artifact_list(paths),
         errors=errors,
         steps=steps,
+        retest=_build_retest(binding, report, classifications, pub2),
     )