@agentikos/omega-os 0.1.0 → 0.19.5

package/omega/Agentik_Engine/tests/test_skill_power.py

@@ -0,0 +1,259 @@
+"""Tests for the skill-power layer.
+
+Covers:
+  * Bridge from $OMEGA_HOME/Agentik_AI/.../skills/ → ~/.claude/skills/
+    (the symlink layer in ClaudeCodeAdapter.link_to_user_claude)
+  * WORKFLOWS catalog presence + shape
+  * Richness invariants on the role→skill map (no regressions in coverage)
+"""
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine import skill_routing as SR  # noqa: E402
+from omega_engine.sync import ClaudeCodeAdapter  # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Bridge: provider tree → ~/.claude/skills/
+# ---------------------------------------------------------------------------
+
+
+def _make_ssot(home: Path, skill_ids: list[str]) -> None:
+    """Create a minimal SSOT tree with `skill_ids` skills."""
+    skills = home / "Agentik_SSOT" / "skills"
+    skills.mkdir(parents=True)
+    for sid in skill_ids:
+        d = skills / sid
+        d.mkdir()
+        (d / "SKILL.md").write_text(
+            f"---\nname: {sid}\ndescription: test skill {sid}\n"
+            f"allowed-tools: Bash Read\n---\n# {sid}\n"
+        )
+
+
+class TestLinkToUserClaude(unittest.TestCase):
+    def test_link_creates_symlinks_in_user_claude(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp) / "Omega"
+            user_claude = Path(tmp) / ".claude"
+            _make_ssot(home, ["pursue", "codeaudit", "debugaudit"])
+            adapter = ClaudeCodeAdapter()
+            adapter.project(home)  # populates the provider tree
+            info = adapter.link_to_user_claude(home, user_claude=user_claude)
+            self.assertEqual(info["linked_skills"], 3)
+            for sid in ("pursue", "codeaudit", "debugaudit"):
+                link = user_claude / "skills" / sid
+                self.assertTrue(link.is_symlink(),
+                                f"{sid} should be a symlink")
+                # Resolves to a path inside the provider tree
+                self.assertTrue(
+                    str(link.resolve()).startswith(str(home)),
+                    f"{sid} should resolve inside $OMEGA_HOME"
+                )
+                self.assertTrue(
+                    (link / "SKILL.md").exists(),
+                    f"{sid}/SKILL.md should be reachable via the symlink"
+                )
+
+    def test_link_is_idempotent(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp) / "Omega"
+            user_claude = Path(tmp) / ".claude"
+            _make_ssot(home, ["pursue"])
+            adapter = ClaudeCodeAdapter()
+            adapter.project(home)
+            a = adapter.link_to_user_claude(home, user_claude=user_claude)
+            b = adapter.link_to_user_claude(home, user_claude=user_claude)
+            # Same count both times — no duplicates, no errors.
+            self.assertEqual(a["linked_skills"], 1)
+            self.assertEqual(b["linked_skills"], 1)
+            self.assertEqual(
+                len(list((user_claude / "skills").iterdir())), 1
+            )
+
+    def test_link_removes_stale_symlinks_for_deleted_ssot_skills(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp) / "Omega"
+            user_claude = Path(tmp) / ".claude"
+            _make_ssot(home, ["a", "b", "c"])
+            adapter = ClaudeCodeAdapter()
+            adapter.project(home)
+            adapter.link_to_user_claude(home, user_claude=user_claude)
+            # Remove skill 'b' from SSOT + the provider tree, re-sync.
+            import shutil
+            shutil.rmtree(home / "Agentik_SSOT" / "skills" / "b")
+            shutil.rmtree(
+                home / "Agentik_AI" / "providers" / "claude-code"
+                / ".claude" / "skills" / "b"
+            )
+            info = adapter.link_to_user_claude(home, user_claude=user_claude)
+            self.assertEqual(info["linked_skills"], 2)
+            self.assertIn(
+                str(user_claude / "skills" / "b"), info["removed"]
+            )
+            self.assertFalse((user_claude / "skills" / "b").exists())
+
+    def test_link_preserves_user_owned_dirs(self):
+        """A real dir the user created (not a symlink) must NEVER be touched."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp) / "Omega"
+            user_claude = Path(tmp) / ".claude"
+            _make_ssot(home, ["pursue"])
+            (user_claude / "skills" / "myhandwritten").mkdir(parents=True)
+            (user_claude / "skills" / "myhandwritten" / "SKILL.md").write_text(
+                "---\nname: myhandwritten\n---\n# mine\n"
+            )
+            adapter = ClaudeCodeAdapter()
+            adapter.project(home)
+            adapter.link_to_user_claude(home, user_claude=user_claude)
+            # User's skill is still a real dir with the original content.
+            self.assertTrue(
+                (user_claude / "skills" / "myhandwritten").is_dir()
+            )
+            self.assertFalse(
+                (user_claude / "skills" / "myhandwritten").is_symlink()
+            )
+            content = (
+                user_claude / "skills" / "myhandwritten" / "SKILL.md"
+            ).read_text()
+            self.assertIn("name: myhandwritten", content)
+
+    def test_project_auto_links_by_default(self):
+        """project() should also bridge by default unless OMEGA_SYNC_NO_LINK=1."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp) / "Omega"
+            user_claude = Path(tmp) / ".claude"
+            _make_ssot(home, ["pursue"])
+            # Force HOME so the auto-link inside project() targets our tmp.
+            old_home = os.environ.get("HOME")
+            try:
+                os.environ["HOME"] = str(user_claude.parent)
+                adapter = ClaudeCodeAdapter()
+                result = adapter.project(home)
+            finally:
+                if old_home is not None:
+                    os.environ["HOME"] = old_home
+            self.assertIn("linked_to_user_claude", result)
+            self.assertEqual(
+                result["linked_to_user_claude"].get("linked_skills"), 1
+            )
+
+    def test_project_skips_link_when_env_var_set(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp) / "Omega"
+            _make_ssot(home, ["pursue"])
+            os.environ["OMEGA_SYNC_NO_LINK"] = "1"
+            try:
+                adapter = ClaudeCodeAdapter()
+                result = adapter.project(home)
+            finally:
+                del os.environ["OMEGA_SYNC_NO_LINK"]
+            self.assertEqual(result["linked_to_user_claude"], {})
+
+
+# ---------------------------------------------------------------------------
+# WORKFLOWS catalog
+# ---------------------------------------------------------------------------
+
+
+class TestWorkflows(unittest.TestCase):
+    def test_workflows_exist(self):
+        self.assertIn("ship-feature", SR.WORKFLOWS)
+        self.assertIn("self-audit-loop", SR.WORKFLOWS)
+        self.assertIn("ux-redesign", SR.WORKFLOWS)
+        self.assertIn("linear-fix-batch", SR.WORKFLOWS)
+        self.assertIn("scheduled-quality", SR.WORKFLOWS)
+
+    def test_every_workflow_mentions_at_least_two_skills(self):
+        # Each canonical workflow must compose multiple skills — otherwise
+        # it's not a "workflow", it's a single-skill invocation.
+        for name, body in SR.WORKFLOWS.items():
+            slash_count = body.count("/dispatch") + body.count("/pursue") \
+                          + body.count("/codeaudit") + body.count("/debugaudit") \
+                          + body.count("/uiuxaudit") + body.count("/secaudit") \
+                          + body.count("/perfaudit") + body.count("/cadence") \
+                          + body.count("/refontaudit") + body.count("/a11yaudit")
+            self.assertGreaterEqual(
+                slash_count, 2,
+                f"workflow '{name}' must compose at least 2 skills"
+            )
+
+    def test_workflows_reference_real_ssot_skills(self):
+        # The canonical workflows shouldn't reference skills that don't exist
+        # in the SSOT catalog. We don't enforce this strictly (the SSOT may
+        # ship without some optional skills) — but if dispatch/pursue/codeaudit
+        # exist they should be reachable.
+        from pathlib import Path as _P
+        repo = _P(__file__).resolve().parents[3]
+        ssot = repo / "omega" / "Agentik_SSOT" / "skills"
+        if not ssot.is_dir():
+            self.skipTest("SSOT not in repo")
+        present = {d.name for d in ssot.iterdir() if d.is_dir()}
+        for must in ("dispatch", "pursue", "codeaudit"):
+            self.assertIn(must, present,
+                          f"workflow assumes /{must} exists in SSOT")
+
+
+# ---------------------------------------------------------------------------
+# Role-skill map richness invariants
+# ---------------------------------------------------------------------------
+
+
+class TestRoleMapRichness(unittest.TestCase):
+    def test_oracle_has_dispatch_and_pursue(self):
+        recs = SR.recommend("oracle")
+        self.assertIn("dispatch", recs)
+        self.assertIn("pursue", recs)
+
+    def test_worker_has_at_least_8_audits(self):
+        """The worker is the busiest role — give it real self-audit power."""
+        recs = SR.recommend("worker")
+        self.assertGreaterEqual(len(recs), 8,
+            "worker should have ≥ 8 skills so self-audit covers most domains")
+
+    def test_seraph_has_widest_palette(self):
+        """Seraph is the senior verifier — it should see EVERY audit domain."""
+        recs = SR.recommend("seraph")
+        self.assertGreaterEqual(len(recs), 10,
+            "seraph should have the widest audit palette of any role")
+
+    def test_specialised_workers_exist(self):
+        """Domain-specialist workers must exist + each has its primary audit."""
+        for role, primary in [
+            ("worker_ui", "uiuxaudit"),
+            ("worker_perf", "perfaudit"),
+            ("worker_sec", "secaudit"),
+            ("worker_api", "apiaudit"),
+            ("worker_data", "dataaudit"),
+            ("worker_seo", "seoaudit"),
+            ("worker_ops", "automationaudit"),
+            ("worker_growth", "retentionaudit"),
+        ]:
+            recs = SR.recommend(role)
+            self.assertIn("pursue", recs,
+                f"specialised role {role} must include /pursue")
+            self.assertIn(primary, recs,
+                f"specialised role {role} must include its primary audit /{primary}")
+
+    def test_classifier_is_minimal(self):
+        # Triage roles deliberately have zero skills — fast haiku pass.
+        self.assertEqual(SR.recommend("classifier"), [])
+        self.assertEqual(SR.recommend("triage"), [])
+
+    def test_total_role_count(self):
+        """Sanity floor: at least 20 roles. If someone deletes the
+        specialised workers this test catches it."""
+        self.assertGreaterEqual(len(SR._ROLE_SKILLS), 20)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/omega/Agentik_Engine/tests/test_skill_routing.py

@@ -0,0 +1,189 @@
+"""Tests for omega_engine.skill_routing — role → skills resolution + the
+system-prompt skill block.
+
+The routing module is pure (no I/O for the role map, single Read for the
+description extraction) so these tests stay fast: ~30 ms total.
+"""
+from __future__ import annotations
+
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine import skill_routing as SR  # noqa: E402
+from omega_engine import worker as W          # noqa: E402
+
+
+class TestRoleDefaults(unittest.TestCase):
+    def test_worker_includes_pursue_and_audits(self):
+        recs = SR.recommend("worker")
+        self.assertIn("pursue", recs)
+        self.assertIn("codeaudit", recs)
+        self.assertIn("debugaudit", recs)
+
+    def test_oracle_includes_dispatch(self):
+        self.assertIn("dispatch", SR.recommend("oracle"))
+
+    def test_classifier_is_empty(self):
+        self.assertEqual(SR.recommend("classifier"), [])
+
+    def test_unknown_role_returns_empty_list(self):
+        self.assertEqual(SR.recommend("does-not-exist"), [])
+
+    def test_recommend_returns_copy(self):
+        # Mutating the return value must not pollute the global map.
+        a = SR.recommend("worker")
+        a.append("garbage")
+        self.assertNotIn("garbage", SR.recommend("worker"))
+
+    def test_power_skills_listed(self):
+        # The constant exists, includes the obvious ones, has stable ordering.
+        self.assertIn("dispatch", SR.POWER_SKILLS)
+        self.assertIn("pursue", SR.POWER_SKILLS)
+        self.assertIn("codeaudit", SR.POWER_SKILLS)
+
+
+class TestResolution(unittest.TestCase):
+    def test_explicit_wins(self):
+        out = SR.skills_for("worker", explicit=["only-this"])
+        self.assertEqual(out, ["only-this"])
+
+    def test_topology_wins_over_role_default(self):
+        out = SR.skills_for("worker", topology_skills=["mission-skill"])
+        self.assertEqual(out, ["mission-skill"])
+
+    def test_explicit_wins_over_topology(self):
+        out = SR.skills_for("worker", explicit=["a"], topology_skills=["b"])
+        self.assertEqual(out, ["a"])
+
+    def test_falls_back_to_role_default(self):
+        out = SR.skills_for("oracle")
+        self.assertIn("dispatch", out)
+
+
+class TestCatalog(unittest.TestCase):
+    def test_empty_home_returns_empty(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            self.assertEqual(SR.catalog_for_home(tmp), [])
+
+    def test_lists_skill_dirs_and_files(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "Agentik_SSOT" / "skills"
+            (root / "pursue").mkdir(parents=True)
+            (root / "pursue" / "SKILL.md").write_text("---\nname: pursue\n---")
+            (root / "codeaudit").mkdir()
+            (root / "codeaudit" / "SKILL.md").write_text("---\nname: codeaudit\n---")
+            (root / "no-skillmd").mkdir()  # not a real skill, must be skipped
+            (root / "rag-route.md").write_text("---\nname: rag-route\n---")
+            out = SR.catalog_for_home(tmp)
+            self.assertIn("pursue", out)
+            self.assertIn("codeaudit", out)
+            self.assertIn("rag-route", out)
+            self.assertNotIn("no-skillmd", out)
+
+
+class TestSkillBlock(unittest.TestCase):
+    def test_empty_returns_empty(self):
+        self.assertEqual(SR.format_skill_block([]), "")
+
+    def test_block_lists_skill_ids_and_header(self):
+        block = SR.format_skill_block(["pursue", "codeaudit"])
+        self.assertIn("## Skills available", block)
+        self.assertIn("/pursue", block)
+        self.assertIn("/codeaudit", block)
+        self.assertIn("invoke them as slash", block)
+
+    def test_block_includes_descriptions_when_skillmd_present(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "Agentik_SSOT" / "skills"
+            (root / "pursue").mkdir(parents=True)
+            (root / "pursue" / "SKILL.md").write_text(
+                "---\nname: pursue\n"
+                "description: Goal-driven loop until verify exits 0.\n"
+                "---\n# pursue\n"
+            )
+            block = SR.format_skill_block(["pursue"], home=tmp)
+            self.assertIn("Goal-driven loop", block)
+
+    def test_description_too_long_is_truncated(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp) / "Agentik_SSOT" / "skills"
+            (root / "huge").mkdir(parents=True)
+            long_desc = "x" * 200
+            (root / "huge" / "SKILL.md").write_text(
+                f"---\nname: huge\ndescription: {long_desc}\n---"
+            )
+            block = SR.format_skill_block(["huge"], home=tmp)
+            self.assertIn("...", block)
+
+
+class TestWorkerBriefSkills(unittest.TestCase):
+    def test_default_role_resolves_to_role_skills(self):
+        b = W.WorkerBrief(task_id="t1", role="worker", intent="x")
+        skills = b.resolved_skills()
+        self.assertIn("pursue", skills)
+
+    def test_explicit_skills_override(self):
+        b = W.WorkerBrief(task_id="t1", role="worker", intent="x",
+                          skills=["only-this"])
+        self.assertEqual(b.resolved_skills(), ["only-this"])
+
+    def test_classifier_role_empty_by_default(self):
+        b = W.WorkerBrief(task_id="t1", role="classifier", intent="x")
+        self.assertEqual(b.resolved_skills(), [])
+
+    def test_json_round_trip_preserves_skills(self):
+        import json
+        b = W.WorkerBrief(task_id="t1", role="worker", intent="x",
+                          skills=["pursue", "codeaudit"])
+        loaded = W.WorkerBrief.from_dict(json.loads(b.to_json()))
+        self.assertEqual(loaded.skills, ["pursue", "codeaudit"])
+
+
+class TestRunBriefEmbedsSkillBlock(unittest.TestCase):
+    """When the brief carries skills, the system_prompt sent to claude
+    contains the skill block."""
+
+    def test_system_prompt_includes_skill_section(self):
+        import json as _json
+        from unittest import mock
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            brief = W.WorkerBrief(
+                task_id="t-sk", role="worker", intent="x",
+                skills=["pursue", "codeaudit"],
+            )
+            W.write_brief(home, brief)
+            captured = {}
+
+            def fake_run(cmd, **kw):
+                captured["cmd"] = cmd
+                import subprocess
+                return subprocess.CompletedProcess(
+                    args=cmd, returncode=0,
+                    stdout=_json.dumps({
+                        "result": "ok", "session_id": "s",
+                        "usage": {}, "total_cost_usd": 0.0,
+                    }),
+                    stderr="",
+                )
+
+            with mock.patch.object(W.subprocess, "run", side_effect=fake_run):
+                W.run_brief(home, "t-sk")
+            cmd = captured["cmd"]
+            # --append-system-prompt is present
+            self.assertIn("--append-system-prompt", cmd)
+            idx = cmd.index("--append-system-prompt")
+            block = cmd[idx + 1]
+            self.assertIn("## Skills available", block)
+            self.assertIn("/pursue", block)
+            self.assertIn("/codeaudit", block)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/omega/Agentik_Engine/tests/test_snapshot_partial.py

@@ -0,0 +1,172 @@
+"""Snapshotting (bounded reduction) + PARTIAL policy (per-topology join handling).
+
+Standalone: python3 tests/test_snapshot_partial.py
+"""
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from omega_engine.audit import AuditGate                        # noqa: E402
+from omega_engine.bus import EventBus                           # noqa: E402
+from omega_engine.events import Event, EventType                # noqa: E402
+from omega_engine.executor import Executor                      # noqa: E402
+from omega_engine.provider import AgentRequest, AgentResult     # noqa: E402
+from omega_engine.reducer import reduce_task, reduce_task_fast  # noqa: E402
+from omega_engine.router import ModelRouter                     # noqa: E402
+from omega_engine.store import SQLiteStore                      # noqa: E402
+from omega_engine.task import Kind, TaskState                   # noqa: E402
+
+
+# ----- snapshotting ---------------------------------------------------------
+
+def test_snapshot_round_trip():
+    """A snapshot captures the reduced state; latest_snapshot returns it."""
+    db = tempfile.mktemp(suffix=".db")
+    store = SQLiteStore(db)
+    for et in (EventType.CREATED, EventType.DISPATCHED, EventType.STARTED):
+        store.append(Event(task_id="t1", type=et))
+    snap = store.snapshot("t1")
+    assert snap is not None
+    assert snap["state"] is TaskState.RUNNING
+
+    again = store.latest_snapshot("t1")
+    assert again is not None and again["state"] is TaskState.RUNNING
+    store.close()
+    os.remove(db)
+
+
+def test_snapshot_makes_reduce_correct_and_short():
+    """reduce_task_fast skips events covered by the snapshot."""
+    db = tempfile.mktemp(suffix=".db")
+    store = SQLiteStore(db)
+    seq = [EventType.CREATED, EventType.DISPATCHED, EventType.STARTED]
+    for et in seq:
+        store.append(Event(task_id="t1", type=et))
+    store.snapshot("t1")  # state == RUNNING, captured at the 3rd event
+
+    # 0 events after the snapshot -> fast path returns the snapshot state
+    assert reduce_task_fast(store, "t1") is TaskState.RUNNING
+
+    # add more events; fast == full
+    for et in (EventType.CLAIMED_DONE, EventType.VERIFYING, EventType.VERIFIED,
+               EventType.COMPLETED):
+        store.append(Event(task_id="t1", type=et))
+
+    full = reduce_task(store.events_for("t1"))
+    fast = reduce_task_fast(store, "t1")
+    assert full is TaskState.COMPLETED
+    assert fast is TaskState.COMPLETED
+    # only events AFTER the snapshot should be folded by the fast path
+    assert len(store.events_since_snapshot("t1")) == 4
+    store.close()
+    os.remove(db)
+
+
+def test_snapshot_on_unknown_task_returns_none():
+    db = tempfile.mktemp(suffix=".db")
+    store = SQLiteStore(db)
+    assert store.snapshot("ghost") is None
+    assert store.latest_snapshot("ghost") is None
+    store.close()
+    os.remove(db)
+
+
+# ----- PARTIAL policy -------------------------------------------------------
+
+class _PartialProvider:
+    """3-worker plan; selected indices fail their runtime audit (verify_cmd=false)."""
+    id = "test-partial"
+
+    def __init__(self, fail_indices) -> None:
+        self._fail = set(fail_indices)
+
+    def run(self, req: AgentRequest) -> AgentResult:
+        if req.role in ("oracle", "manager", "aisb"):
+            plan = []
+            for i in range(3):
+                cmd = "false" if i in self._fail else "true"
+                plan.append({"role": "worker",
+                             "spec": {"task": f"t{i}", "verify_cmd": cmd}})
+            return AgentResult(text="planned", claimed_done=True, plan=plan)
+        if req.role == "worker":
+            return AgentResult(
+                text="done", claimed_done=True,
+                artifacts={"files": ["x.py"], "summary": "done"},
+            )
+        if req.role in ("verifier", "audit"):
+            return AgentResult(
+                text="ok", claimed_done=True,
+                artifacts={"verdict": {"score": 95, "verified": True,
+                                       "confidence": "high",
+                                       "summary": "ok",
+                                       "findings": [], "fix_plan": []}})
+        return AgentResult(text="ok", claimed_done=True)
+
+
+def _engine(provider, partial_policy="fail_up"):
+    db = tempfile.mktemp(suffix=".db")
+    store = SQLiteStore(db)
+    bus = EventBus(store)
+    router = ModelRouter.single(provider)
+    executor = Executor(store, bus, router, AuditGate(),
+                        partial_policy=partial_policy)
+    return store, executor, db
+
+
+def test_partial_fail_up_default():
+    """Default policy: a PARTIAL scope fails the dispatcher."""
+    store, ex, db = _engine(_PartialProvider(fail_indices=[1]))
+    result = ex.run_mission("partial mission")
+    assert result.final_state is TaskState.FAILED, result.final_state
+    store.close(); os.remove(db)
+
+
+def test_partial_accept_partial():
+    """accept_partial: the dispatcher completes despite a failed child."""
+    store, ex, db = _engine(_PartialProvider(fail_indices=[1]),
+                            partial_policy="accept_partial")
+    result = ex.run_mission("partial mission")
+    assert result.final_state is TaskState.COMPLETED, result.final_state
+    store.close(); os.remove(db)
+
+
+def test_partial_retry_failed_spawns_extra_children():
+    """retry_failed: a replacement task is spawned for each failed child."""
+    store, ex, db = _engine(_PartialProvider(fail_indices=[1]),
+                            partial_policy="retry_failed")
+    result = ex.run_mission("partial mission")
+    workers = [t for t in result.tasks.values() if t.kind is Kind.EXECUTOR]
+    # original 3 + 1 retry replacement = 4 worker tasks (the failing index
+    # was retried once; under this provider it fails again, so the final
+    # state is FAILED — but the retry attempt is observable)
+    assert len(workers) == 4, f"retry did not spawn a replacement: {len(workers)}"
+    assert result.final_state is TaskState.FAILED  # retry exhausted -> fail_up
+    store.close(); os.remove(db)
+
+
+def test_unknown_partial_policy_raises():
+    raised = False
+    try:
+        _engine(_PartialProvider([]), partial_policy="ignore")
+    except ValueError:
+        raised = True
+    assert raised
+
+
+def _run_all() -> bool:
+    tests = [v for k, v in sorted(globals().items())
+             if k.startswith("test_") and callable(v)]
+    passed = 0
+    for t in tests:
+        t()
+        print(f"  PASS  {t.__name__}")
+        passed += 1
+    print(f"\n{passed}/{len(tests)} snapshot+partial tests passed")
+    return passed == len(tests)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _run_all() else 1)