skillflow-py 1.4.0__tar.gz → 1.4.2__tar.gz

{skillflow_py-1.4.0 → skillflow_py-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skillflow-py
-Version: 1.4.0
+Version: 1.4.2
 Summary: Config-agnostic LLM pipeline graph executor — turn skills into flows
 Author: Skillflow contributors
 License-Expression: MIT

{skillflow_py-1.4.0 → skillflow_py-1.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skillflow-py"
-version = "1.4.0"
+version = "1.4.2"
 description = "Config-agnostic LLM pipeline graph executor — turn skills into flows"
 readme = "README.md"
 license = "MIT"

{skillflow_py-1.4.0 → skillflow_py-1.4.2}/src/skillflow/core.py

@@ -1057,7 +1057,11 @@ class SkillFlow:
 
                 if not hook_result.get("passed", False):
                     error = hook_result.get("error", f"Lifecycle hook '{hook_name}' failed")
-                    on_failure = hook_spec.get("on_failure", "fail") if isinstance(hook_spec, dict) else "fail"
+                    # A tool-hook sequence bubbles the failing item's on_failure
+                    # in the result; fall back to the spec-level value otherwise.
+                    on_failure = hook_result.get("on_failure") or (
+                        hook_spec.get("on_failure", "fail")
+                        if isinstance(hook_spec, dict) else "fail")
                     if on_failure == "retry":
                         self._emit_lifecycle_event(token, hook_name, "retry", error)
                         self._handle_lifecycle_retry(token, error)
@@ -1255,19 +1259,64 @@ class SkillFlow:
 
         hook_spec can be:
         - A dict with 'tool' (single tool call): used for after_validate, on_deliver
-        - A list of dicts (multi-check): used for after_deliver
+        - A list of validation specs (multi-check): used for after_deliver
+        - A list of {'tool', 'params'} dicts (sequential tool hooks): used for
+          on_deliver when several repo-mutating tools must run in order (e.g.
+          repo_apply then repo_delete). Each runs via _execute_tool_hook, so
+          $STEP_DIR is resolved and project_root injected — unlike check specs,
+          which run through StepValidator and receive neither.
 
         Returns {passed: bool, error?: str}.
         """
         self._emit_lifecycle_event(token, hook_name, "started")
 
         if isinstance(hook_spec, list):
-            return self._execute_check_hook(token, node, hook_name, hook_spec)
+            # after_deliver runs validation checks against the project repo;
+            # other slots (on_deliver) run a sequence of tool hooks with full
+            # variable resolution.
+            if hook_name == "after_deliver":
+                return self._execute_check_hook(token, node, hook_name, hook_spec)
+            return self._execute_tool_hook_sequence(token, node, hook_name, hook_spec)
         elif isinstance(hook_spec, dict) and "tool" in hook_spec:
             return self._execute_tool_hook(token, node, hook_name, hook_spec)
         else:
             return {"passed": False, "error": f"Invalid hook spec for '{hook_name}'"}
 
+    def _execute_tool_hook_sequence(self, token: ClaimToken, node: StepNode,
+                                     hook_name: str, items: list) -> dict:
+        """Run a list of tool hooks in order (e.g. repo_apply then repo_delete).
+
+        Each item is a ``{'tool', 'params', 'on_failure'?}`` dict executed via
+        :meth:`_execute_tool_hook` (full variable resolution + project_root
+        injection). Per-item ``on_failure`` is honored: ``warn``/``skip`` log and
+        continue to the next item; ``retry``/``fail`` stop the sequence and
+        bubble up (carrying the item's ``on_failure``) so the caller applies the
+        right step-level outcome.
+        """
+        detail_files = None
+        for item in items:
+            if not (isinstance(item, dict) and "tool" in item):
+                return {"passed": False,
+                        "error": f"Invalid tool hook in '{hook_name}': {item!r}"}
+            res = self._execute_tool_hook(token, node, hook_name, item)
+            if not res.get("passed", True):
+                on_failure = item.get("on_failure", "fail")
+                if on_failure in ("warn", "skip"):
+                    self._emit_lifecycle_event(
+                        token, hook_name,
+                        "warned" if on_failure == "warn" else "skipped",
+                        res.get("error", ""))
+                    continue
+                # retry / fail: stop and let the caller apply the step outcome.
+                return {**res, "on_failure": on_failure}
+            files = res.get("files")
+            if isinstance(files, list):
+                detail_files = files
+        out = {"passed": True}
+        if detail_files is not None:
+            out["files"] = detail_files
+        return out
+
     def _execute_tool_hook(self, token: ClaimToken, node: StepNode,
                             hook_name: str, hook_spec: dict) -> dict:
         """Execute a tool-type lifecycle hook (single tool call)."""
@@ -2273,15 +2322,56 @@ class SkillFlow:
             return inst["id"] if inst else None
 
     def _reopen_tool_step_in_tx(self, run_id: str, step_id: str) -> None:
-        """Release a claimed tool step back to pending after a crashed execution,
-        so it is retried promptly instead of stalling until its claim times out.
+        """Release a claimed tool step back to pending after a CRASHED execution,
+        so it retries promptly instead of stalling until its claim times out.
+
+        Capped at 3 crashes: a tool that crashes deterministically is broken,
+        not transient, so relaunching it every tick just rampages until the
+        host's step-count valve trips. The SF-20 stale-recovery cap does NOT
+        cover this path (a crash reopens directly, never via
+        recover_stale_claims), so track the count here and fail after 3.
         """
         with self._tx() as conn:
+            row = conn.execute(
+                "SELECT id, inputs_json FROM skillflow_steps "
+                "WHERE run_id = ? AND step_id = ? AND status = 'claimed' "
+                "ORDER BY id DESC LIMIT 1",
+                (run_id, step_id),
+            ).fetchone()
+            if not row:
+                return
+            inputs = self._deserialize(row["inputs_json"])
+            reopen_count = inputs.get("_tool_reopen_count", 0) + 1
+            if reopen_count >= 3:
+                error_msg = (
+                    f"Tool step '{step_id}' crashed {reopen_count} times — "
+                    f"failing (likely a bug in the tool, not a transient error)."
+                )
+                conn.execute(
+                    "UPDATE skillflow_steps SET status = 'failed', "
+                    "version = version + 1, last_error = ?, claimed_at = NULL, "
+                    "claimed_by = NULL, updated_at = datetime('now') WHERE id = ?",
+                    (error_msg, row["id"]),
+                )
+                conn.execute(
+                    "UPDATE skillflow_runs SET current_node = NULL, "
+                    "updated_at = datetime('now') WHERE id = ?",
+                    (run_id,),
+                )
+                self.notifications.publish_sync(
+                    "step_failed",
+                    {"run_id": run_id, "step_id": step_id,
+                     "error": error_msg, "retryable": False},
+                    step_id=step_id, run_id=run_id,
+                )
+                return
+            inputs["_tool_reopen_count"] = reopen_count
             conn.execute(
                 "UPDATE skillflow_steps SET status = 'pending', claimed_at = NULL, "
-                "claimed_by = NULL, version = version + 1, updated_at = datetime('now') "
-                "WHERE run_id = ? AND step_id = ? AND status = 'claimed'",
-                (run_id, step_id),
+                "claimed_by = NULL, version = version + 1, inputs_json = ?, "
+                "updated_at = datetime('now') "
+                "WHERE id = ? AND status = 'claimed'",
+                (self._serialize(inputs), row["id"]),
             )
 
     def advance_run(self, run_id: str) -> str | None:
@@ -2869,18 +2959,41 @@ class SkillFlow:
     # ── Recovery ──────────────────────────────────────────────────
 
     def recover_stale_claims(self, stale_threshold_seconds: float = 300) -> list[str]:
-        threshold = time.strftime(
-            "%Y-%m-%dT%H:%M:%SZ",
-            time.gmtime(time.time() - stale_threshold_seconds),
-        )
+        now_epoch = time.time()
         with self._tx() as conn:
-            stale = conn.execute(
+            claimed = conn.execute(
                 """
-                SELECT id, run_id, step_id, inputs_json FROM skillflow_steps
-                WHERE status = 'claimed' AND claimed_at < ?
+                SELECT id, run_id, step_id, inputs_json, claimed_at
+                FROM skillflow_steps WHERE status = 'claimed'
                 """,
-                (threshold,),
             ).fetchall()
+            # For a TOOL step, a claim is stale only once it is older than the
+            # LONGER of the caller's flat threshold and the node's own
+            # timeout_seconds. A slow-but-alive tool (e.g. run_tests, whose node
+            # declares timeout_seconds=1200) must NOT be reclaimed at the flat
+            # threshold — reclaiming it relaunches the tool concurrently with
+            # itself, piling up mutually-starving copies (the step-5 rampage).
+            # Only a claim older than the tool's max legitimate runtime is
+            # presumed dead. Scoped to tool steps on purpose: agent-step
+            # reclaim timing is unchanged (it feeds a separate live
+            # investigation), and this is the only path prone to the rampage
+            # because inline tools re-launch on every advance_run.
+            stale = []
+            for row in claimed:
+                window = stale_threshold_seconds
+                try:
+                    node = self._get_resolver_for_run(
+                        row["run_id"]).get_node(row["step_id"])
+                    if (node and node.step_type == "tool"
+                            and node.timeout_seconds
+                            and node.timeout_seconds > window):
+                        window = float(node.timeout_seconds)
+                except Exception:
+                    pass
+                threshold = time.strftime(
+                    "%Y-%m-%dT%H:%M:%SZ", time.gmtime(now_epoch - window))
+                if row["claimed_at"] and row["claimed_at"] < threshold:
+                    stale.append(row)
             run_ids: set[str] = set()
             for row in stale:
                 # SF-20: track stale recovery count to detect crash loops.

{skillflow_py-1.4.0 → skillflow_py-1.4.2}/src/skillflow_py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skillflow-py
-Version: 1.4.0
+Version: 1.4.2
 Summary: Config-agnostic LLM pipeline graph executor — turn skills into flows
 Author: Skillflow contributors
 License-Expression: MIT

{skillflow_py-1.4.0 → skillflow_py-1.4.2}/tests/test_core.py

@@ -1142,6 +1142,111 @@ def test_lifecycle_events_in_outbox(sf: SkillFlow, tmp_path: Path):
     assert step["status"] == "completed"
 
 
+def test_on_deliver_list_runs_tools_end_to_end(sf: SkillFlow, tmp_path: Path):
+    """on_deliver as a LIST runs its tool hooks (not validation checks): a
+    repo_apply in list form resolves $STEP_DIR and commits into the repo.
+
+    Regression: a list previously routed to StepValidator (check hook), which
+    neither unwraps ``params`` nor resolves ``$STEP_DIR`` — so a repo-mutating
+    tool placed there silently no-op'd.
+    """
+    import subprocess
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    subprocess.run(["git", "init", "-q"], cwd=repo, check=True)
+    subprocess.run(["git", "config", "user.email", "t@t"], cwd=repo, check=True)
+    subprocess.run(["git", "config", "user.name", "t"], cwd=repo, check=True)
+
+    sf._tool_loader = ToolLoader(
+        Path(__file__).parent.parent / "src" / "skillflow" / "tools")
+    sf._workspace = WorkspaceManager(
+        str(tmp_path / "ws"), projects_base=str(tmp_path / "projects"),
+        code_path_resolver=lambda pid: str(repo),
+    )
+
+    node = StepNode(
+        id="s1", step_type="agent", output_mode="content",
+        output_fixed={"out": "main.py"},
+        lifecycle={"on_deliver": [
+            {"tool": "repo_apply", "params": {"source_dir": "$STEP_DIR"}},
+        ]},
+        transitions=[Transition(to=None)],
+    )
+    g = PipelineGraph(name="ondeliver_list", begin="s1", steps=[node])
+    sf.register_graph(g)
+
+    rid = sf.create_run("ondeliver_list", {"project_id": "p1"})
+    sf.start_run(rid)
+    sf.advance_run(rid)
+    token = sf.claim_next_step(rid)
+    tmp = sf._workspace.get_step_tmp_dir("p1", "ondeliver_list", "s1")
+    (tmp / "main.py").write_text("print('hi')\n")
+    sf.confirm_step(token.token, StepResult(outputs={}, flags={}))
+
+    # Landed AND committed → the list ran the tool hook with $STEP_DIR resolved
+    # (old code would have no-op'd via the check-hook path).
+    assert (repo / "main.py").read_text() == "print('hi')\n"
+    log = subprocess.run(["git", "log", "--oneline"], cwd=repo,
+                         capture_output=True, text=True).stdout
+    assert "step: s1" in log, f"no apply commit:\n{log}"
+
+
+def test_on_deliver_list_order_and_on_failure(sf: SkillFlow, tmp_path: Path,
+                                               monkeypatch):
+    """on_deliver list = ordered tool-hook sequence honoring per-item
+    on_failure; after_deliver list still routes to validation checks."""
+    sf._tool_loader = ToolLoader(
+        Path(__file__).parent.parent / "src" / "skillflow" / "tools")
+    sf._workspace = WorkspaceManager(str(tmp_path / "ws"),
+                                     projects_base=str(tmp_path / "projects"))
+    node = StepNode(
+        id="s1", step_type="agent", output_mode="content",
+        output_fixed={"out": "r.md"}, transitions=[Transition(to=None)],
+    )
+    g = PipelineGraph(name="seq", begin="s1", steps=[node])
+    sf.register_graph(g)
+    rid = sf.create_run("seq", {"project_id": "pid"})
+    sf.start_run(rid)
+    sf.advance_run(rid)
+    token = sf.claim_next_step(rid).token   # the ClaimToken inside the ClaimedStep
+
+    calls: list = []
+
+    def fake_tool_hook(tok, nd, hook_name, spec):
+        calls.append(spec["tool"])
+        if spec["tool"] == "boom":
+            return {"passed": False, "error": "kaboom"}
+        return {"passed": True, "files": ["x"]}
+    monkeypatch.setattr(sf, "_execute_tool_hook", fake_tool_hook)
+
+    # 1) ordering + all-pass → sequence passes, surfaces files detail
+    r = sf._execute_lifecycle_hook(token, node, "on_deliver",
+        [{"tool": "repo_apply"}, {"tool": "repo_delete"}])
+    assert calls == ["repo_apply", "repo_delete"]
+    assert r["passed"] is True and r.get("files") == ["x"]
+
+    # 2) failing item with on_failure=warn → continue; sequence still passes
+    calls.clear()
+    r = sf._execute_lifecycle_hook(token, node, "on_deliver",
+        [{"tool": "boom", "on_failure": "warn"}, {"tool": "repo_delete"}])
+    assert calls == ["boom", "repo_delete"]
+    assert r["passed"] is True
+
+    # 3) failing item with default on_failure=fail → stop + bubble on_failure
+    calls.clear()
+    r = sf._execute_lifecycle_hook(token, node, "on_deliver",
+        [{"tool": "boom"}, {"tool": "repo_delete"}])
+    assert calls == ["boom"]
+    assert r["passed"] is False and r["on_failure"] == "fail"
+
+    # 4) after_deliver list is unchanged: routes to checks, not the tool
+    #    sequence, so the faked tool-hook path is never touched.
+    calls.clear()
+    sf._execute_lifecycle_hook(token, node, "after_deliver",
+        [{"tool": "syntax_lint", "files": ["*.nomatch"]}])
+    assert calls == []
+
+
 # ── Durable run trace ─────────────────────────────────────────────────
 
 def test_trace_append_and_get(sf: SkillFlow):

skillflow_py-1.4.2/tests/test_recovery.py

@@ -0,0 +1,184 @@
+"""Unit tests for recovery.py."""
+
+import time
+
+import pytest
+
+from skillflow.core import SkillFlow
+from skillflow.graph import PipelineGraph, StepNode, Transition
+
+
+def _agent(id: str, transitions=None):
+    return StepNode(id=id, step_type="agent", transitions=transitions or [])
+
+
+def test_recover_respects_tool_timeout_seconds(sf: SkillFlow):
+    """A TOOL step claimed longer than the flat threshold but WITHIN its
+    timeout_seconds is NOT reclaimed — a slow-but-alive tool (run_tests,
+    timeout 1200s) must not be relaunched concurrently with itself (the step-5
+    rampage). Only once the claim exceeds the tool timeout is it presumed dead.
+    Agent steps are intentionally NOT scoped by this (their reclaim timing
+    feeds a separate investigation)."""
+    graph = PipelineGraph(
+        name="test", begin="a",
+        steps=[StepNode(id="a", step_type="tool", tool_name="write",
+                        timeout_seconds=1200, transitions=[])],
+    )
+    sf.register_graph(graph)
+    run_id = sf.create_run("test")
+    sf.start_run(run_id)
+    # Seed a claimed tool-step instance claimed 100s ago (already > flat 60s).
+    claimed_100s_ago = time.strftime(
+        "%Y-%m-%dT%H:%M:%SZ", time.gmtime(time.time() - 100))
+    with sf._lock:
+        sf._conn.execute(
+            "INSERT INTO skillflow_steps (run_id, step_id, step_config_json, "
+            "inputs_json, max_retries, status, claimed_at, created_at, updated_at) "
+            "VALUES (?, 'a', '{}', '{}', 3, 'claimed', ?, "
+            "datetime('now'), datetime('now'))",
+            (run_id, claimed_100s_ago))
+        sf._conn.commit()
+
+    # 100s > flat 60s, but < 1200s tool timeout → presumed ALIVE, NOT reclaimed.
+    assert sf.recover_stale_claims(stale_threshold_seconds=60) == []
+    st = sf._conn.execute(
+        "SELECT status FROM skillflow_steps WHERE run_id=? AND step_id='a' "
+        "ORDER BY id DESC LIMIT 1", (run_id,)).fetchone()
+    assert st["status"] == "claimed"  # still held, not stolen
+
+    # Backdate beyond the 1200s tool timeout → now presumed dead → reclaimed.
+    claimed_1300s_ago = time.strftime(
+        "%Y-%m-%dT%H:%M:%SZ", time.gmtime(time.time() - 1300))
+    with sf._lock:
+        sf._conn.execute(
+            "UPDATE skillflow_steps SET claimed_at=? WHERE run_id=? AND step_id='a'",
+            (claimed_1300s_ago, run_id))
+        sf._conn.commit()
+    assert run_id in sf.recover_stale_claims(stale_threshold_seconds=60)
+
+
+def test_tool_reopen_caps_at_three_crashes(sf: SkillFlow):
+    """A tool step that crashes deterministically FAILS after 3 reopens instead
+    of being relaunched every tick (which rampaged until the host step-count
+    valve). The SF-20 stale-recovery cap doesn't cover the crash-reopen path."""
+    graph = PipelineGraph(
+        name="test", begin="a",
+        steps=[StepNode(id="a", step_type="agent", transitions=[])],
+    )
+    sf.register_graph(graph)
+    run_id = sf.create_run("test")
+    sf.start_run(run_id)
+    with sf._lock:
+        sf._conn.execute(
+            "INSERT INTO skillflow_steps (run_id, step_id, step_config_json, "
+            "inputs_json, max_retries, status, claimed_at, created_at, updated_at) "
+            "VALUES (?, 'a', '{}', '{}', 3, 'claimed', "
+            "'2026-01-01T00:00:00Z', datetime('now'), datetime('now'))",
+            (run_id,))
+        sf._conn.commit()
+
+    def _status():
+        return sf._conn.execute(
+            "SELECT status FROM skillflow_steps WHERE run_id=? AND step_id='a' "
+            "ORDER BY id DESC LIMIT 1", (run_id,)).fetchone()["status"]
+
+    # Crashes 1 and 2 reopen to pending; re-claim to simulate the next attempt.
+    for _ in range(2):
+        sf._reopen_tool_step_in_tx(run_id, "a")
+        assert _status() == "pending"
+        with sf._lock:
+            sf._conn.execute(
+                "UPDATE skillflow_steps SET status='claimed' "
+                "WHERE run_id=? AND step_id='a'", (run_id,))
+            sf._conn.commit()
+
+    # Third crash → failed, not reopened → no more relaunches.
+    sf._reopen_tool_step_in_tx(run_id, "a")
+    assert _status() == "failed"
+
+
+def _trans(to: str):
+    return Transition(to=to)
+
+
+def test_recover_stale_claims_resets_claimed(sf: SkillFlow):
+    graph = PipelineGraph(
+        name="test", begin="a",
+        steps=[_agent("a", [_trans("b")]), _agent("b", [])],
+    )
+    sf.register_graph(graph)
+    run_id = sf.create_run("test")
+    sf.start_run(run_id)
+    sf.advance_run(run_id)
+    sf.claim_next_step(run_id)
+
+    # Recover with negative threshold (everything is stale)
+    recovered = sf.recover_stale_claims(stale_threshold_seconds=-1)
+    assert run_id in recovered
+
+    # Step should be re-claimable
+    sf.advance_run(run_id)
+    claimed = sf.claim_next_step(run_id)
+    assert claimed is not None
+    assert claimed.step_id == "a"
+
+
+def test_recover_stale_claims_fresh_not_affected(sf: SkillFlow):
+    graph = PipelineGraph(
+        name="test", begin="a",
+        steps=[_agent("a", [])],
+    )
+    sf.register_graph(graph)
+    run_id = sf.create_run("test")
+    sf.start_run(run_id)
+    sf.advance_run(run_id)
+    sf.claim_next_step(run_id)
+
+    # Default threshold — just-claimed step is fresh
+    recovered = sf.recover_stale_claims(stale_threshold_seconds=300)
+    assert len(recovered) == 0
+
+
+def test_recover_stale_claims_no_stale_steps(sf: SkillFlow):
+    graph = PipelineGraph(
+        name="test", begin="a",
+        steps=[_agent("a", [])],
+    )
+    sf.register_graph(graph)
+    sf.create_run("test")
+    recovered = sf.recover_stale_claims()
+    assert recovered == []
+
+
+def test_recover_stale_keeps_current_node(sf: SkillFlow):
+    graph = PipelineGraph(
+        name="test", begin="a",
+        steps=[_agent("a", [_trans("b")]), _agent("b", [])],
+    )
+    sf.register_graph(graph)
+    run_id = sf.create_run("test")
+    sf.start_run(run_id)
+    sf.advance_run(run_id)
+    sf.claim_next_step(run_id)
+
+    sf.recover_stale_claims(stale_threshold_seconds=-1)
+    run = sf.get_run(run_id)
+    # current_node is kept so advance_run re-claims the crashed step
+    assert run["current_node"] == "a"
+
+
+def test_recover_stale_claims_method_on_instance(sf_tmp: SkillFlow):
+    """Test the SkillFlow.recover_stale_claims() method (replaces standalone function)."""
+
+    graph = PipelineGraph(
+        name="test", begin="a",
+        steps=[_agent("a", [])],
+    )
+    sf_tmp.register_graph(graph)
+    run_id = sf_tmp.create_run("test")
+    sf_tmp.start_run(run_id)
+    sf_tmp.advance_run(run_id)
+    sf_tmp.claim_next_step(run_id)
+
+    recovered = sf_tmp.recover_stale_claims(stale_threshold_seconds=-1)
+    assert len(recovered) >= 0

skillflow_py-1.4.0/tests/test_recovery.py

@@ -1,99 +0,0 @@
-"""Unit tests for recovery.py."""
-
-import time
-
-import pytest
-
-from skillflow.core import SkillFlow
-from skillflow.graph import PipelineGraph, StepNode, Transition
-
-
-def _agent(id: str, transitions=None):
-    return StepNode(id=id, step_type="agent", transitions=transitions or [])
-
-
-def _trans(to: str):
-    return Transition(to=to)
-
-
-def test_recover_stale_claims_resets_claimed(sf: SkillFlow):
-    graph = PipelineGraph(
-        name="test", begin="a",
-        steps=[_agent("a", [_trans("b")]), _agent("b", [])],
-    )
-    sf.register_graph(graph)
-    run_id = sf.create_run("test")
-    sf.start_run(run_id)
-    sf.advance_run(run_id)
-    sf.claim_next_step(run_id)
-
-    # Recover with negative threshold (everything is stale)
-    recovered = sf.recover_stale_claims(stale_threshold_seconds=-1)
-    assert run_id in recovered
-
-    # Step should be re-claimable
-    sf.advance_run(run_id)
-    claimed = sf.claim_next_step(run_id)
-    assert claimed is not None
-    assert claimed.step_id == "a"
-
-
-def test_recover_stale_claims_fresh_not_affected(sf: SkillFlow):
-    graph = PipelineGraph(
-        name="test", begin="a",
-        steps=[_agent("a", [])],
-    )
-    sf.register_graph(graph)
-    run_id = sf.create_run("test")
-    sf.start_run(run_id)
-    sf.advance_run(run_id)
-    sf.claim_next_step(run_id)
-
-    # Default threshold — just-claimed step is fresh
-    recovered = sf.recover_stale_claims(stale_threshold_seconds=300)
-    assert len(recovered) == 0
-
-
-def test_recover_stale_claims_no_stale_steps(sf: SkillFlow):
-    graph = PipelineGraph(
-        name="test", begin="a",
-        steps=[_agent("a", [])],
-    )
-    sf.register_graph(graph)
-    sf.create_run("test")
-    recovered = sf.recover_stale_claims()
-    assert recovered == []
-
-
-def test_recover_stale_keeps_current_node(sf: SkillFlow):
-    graph = PipelineGraph(
-        name="test", begin="a",
-        steps=[_agent("a", [_trans("b")]), _agent("b", [])],
-    )
-    sf.register_graph(graph)
-    run_id = sf.create_run("test")
-    sf.start_run(run_id)
-    sf.advance_run(run_id)
-    sf.claim_next_step(run_id)
-
-    sf.recover_stale_claims(stale_threshold_seconds=-1)
-    run = sf.get_run(run_id)
-    # current_node is kept so advance_run re-claims the crashed step
-    assert run["current_node"] == "a"
-
-
-def test_recover_stale_claims_method_on_instance(sf_tmp: SkillFlow):
-    """Test the SkillFlow.recover_stale_claims() method (replaces standalone function)."""
-
-    graph = PipelineGraph(
-        name="test", begin="a",
-        steps=[_agent("a", [])],
-    )
-    sf_tmp.register_graph(graph)
-    run_id = sf_tmp.create_run("test")
-    sf_tmp.start_run(run_id)
-    sf_tmp.advance_run(run_id)
-    sf_tmp.claim_next_step(run_id)
-
-    recovered = sf_tmp.recover_stale_claims(stale_threshold_seconds=-1)
-    assert len(recovered) >= 0