@agentikos/omega-os 0.2.0 → 0.19.5

package/omega/Agentik_Engine/tests/test_pursue_cadence.py

@@ -0,0 +1,217 @@
+"""Tests for the Agentik OS native primitives `pursue` and `cadence`.
+
+These are the Agentik OS equivalents of Claude Code's bundled /goal and
+/loop, re-implemented as engine primitives that run on the Claude Code Max
+subscription with no per-API-call surcharge. The tests exercise:
+
+  * `pursue()` — goal-driven loop. Uses the MockProvider so we can drive
+    the loop deterministically + a verify_cmd whose exit code we control
+    by touching a sentinel file.
+  * `cadence` — charter persistence (schedule / list / disable / remove)
+    and the round-trip with the autonomous supervisor on disk.
+  * `sync` — the directory-based SKILL.md layout is picked up and
+    projected to a Claude Code-shaped skills tree.
+"""
+from __future__ import annotations
+
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+import yaml
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine.cadence import (  # noqa: E402
+    disable_cadence,
+    list_cadences,
+    remove_cadence,
+    schedule_cadence,
+)
+from omega_engine.done_signal import read_done  # noqa: E402
+from omega_engine.provider import MockProvider  # noqa: E402
+from omega_engine.pursue import pursue  # noqa: E402
+from omega_engine.router import ModelRouter  # noqa: E402
+
+
+class TestPursueSuccessOnFirstIteration(unittest.TestCase):
+    def test_verify_passes_first_try(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            router = ModelRouter.single(MockProvider())
+            result = pursue(
+                intent="hello world",
+                verify_cmd="true",                # always exits 0
+                omega_home=home,
+                max_iterations=3,
+                router=router,
+                cwd=str(home),
+            )
+            self.assertEqual(result.status, "done_clean")
+            self.assertEqual(result.iterations, 1)
+            self.assertEqual(result.final_verify_exit, 0)
+            self.assertTrue(result.log_path.exists())
+            self.assertTrue(result.done_path.exists())
+            sig = read_done(home, result.task_id)
+            self.assertEqual(sig.status, "done_clean")
+            self.assertIn("hello world", sig.summary)
+
+
+class TestPursueExhaustsBudget(unittest.TestCase):
+    def test_verify_never_passes_returns_failed(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            router = ModelRouter.single(MockProvider())
+            result = pursue(
+                intent="impossible",
+                verify_cmd="false",               # always exits 1
+                omega_home=home,
+                max_iterations=3,
+                router=router,
+                cwd=str(home),
+            )
+            self.assertEqual(result.status, "failed")
+            self.assertEqual(result.iterations, 3)
+            self.assertEqual(result.final_verify_exit, 1)
+            # Per-iteration log has 3 lines
+            lines = result.log_path.read_text().strip().splitlines()
+            self.assertEqual(len(lines), 3)
+            sig = read_done(home, result.task_id)
+            self.assertEqual(sig.status, "failed")
+            self.assertEqual(len(sig.artifacts["attempts"]), 3)
+
+
+class TestPursueEventualSuccess(unittest.TestCase):
+    def test_sentinel_appears_mid_run(self):
+        """A verify_cmd that passes only after a sentinel file exists.
+
+        We simulate "the agent's edit landed at iter N" by pre-creating the
+        sentinel file after the loop starts is impossible (synchronous test),
+        so we use a verify_cmd whose first call fails and second call passes
+        via a touch in the cmd itself (every odd attempt creates, every even
+        attempt reads — but exit-code 0 only when the file already existed).
+        """
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            sentinel = home / "GOAL"
+            # First call: touch the file, exit 1. Second call: file exists, exit 0.
+            verify_cmd = (
+                f"test -f {sentinel} || (touch {sentinel} && exit 1)"
+            )
+            router = ModelRouter.single(MockProvider())
+            result = pursue(
+                intent="reach the sentinel",
+                verify_cmd=verify_cmd,
+                omega_home=home,
+                max_iterations=5,
+                router=router,
+                cwd=str(home),
+            )
+            self.assertEqual(result.status, "done_clean")
+            self.assertEqual(result.iterations, 2)
+
+
+class TestCadenceSchedule(unittest.TestCase):
+    def test_schedule_cron_writes_yaml(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            path = schedule_cadence(
+                intent="ping the API",
+                trigger_type="cron",
+                schedule="*/5 * * * *",
+                omega_home=home,
+            )
+            self.assertTrue(path.exists())
+            data = yaml.safe_load(path.read_text())
+            self.assertTrue(data["id"].startswith("cadence-"))
+            self.assertEqual(data["trigger"]["type"], "cron")
+            self.assertEqual(data["trigger"]["schedule"], "*/5 * * * *")
+            self.assertEqual(data["spec"]["intent"], "ping the API")
+            self.assertTrue(data["enabled"])
+
+    def test_schedule_delay_validates_integer(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            with self.assertRaises(ValueError):
+                schedule_cadence(
+                    intent="x", trigger_type="delay", schedule="not-int",
+                    omega_home=home,
+                )
+
+    def test_schedule_rejects_unknown_trigger(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            with self.assertRaises(ValueError):
+                schedule_cadence(
+                    intent="x", trigger_type="hourly", schedule="1",
+                    omega_home=home,
+                )
+
+    def test_list_returns_each_charter(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            schedule_cadence("first", "cron", "* * * * *", omega_home=home,
+                             charter_id="cadence-aaa")
+            schedule_cadence("second", "delay", "60", omega_home=home,
+                             charter_id="cadence-bbb")
+            entries = list_cadences(home)
+            ids = {e["id"] for e in entries}
+            self.assertEqual(ids, {"cadence-aaa", "cadence-bbb"})
+
+    def test_disable_flips_enabled_field(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            schedule_cadence("x", "cron", "* * * * *", omega_home=home,
+                             charter_id="cadence-x")
+            self.assertTrue(disable_cadence("cadence-x", omega_home=home))
+            entries = list_cadences(home)
+            self.assertFalse(entries[0]["enabled"])
+            # Second disable is a no-op.
+            self.assertFalse(disable_cadence("cadence-x", omega_home=home))
+
+    def test_remove_deletes_charter(self):
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            schedule_cadence("x", "cron", "* * * * *", omega_home=home,
+                             charter_id="cadence-x")
+            self.assertTrue(remove_cadence("cadence-x", omega_home=home))
+            self.assertEqual(list_cadences(home), [])
+            self.assertFalse(remove_cadence("cadence-x", omega_home=home))
+
+
+class TestSyncSkillProjection(unittest.TestCase):
+    def test_directory_layout_projected_to_claude_code(self):
+        """A SKILL.md in a sub-directory must be projected to the native shape."""
+        from omega_engine.sync import SyncEngine
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            # Source layout: Agentik_SSOT/skills/pursue/SKILL.md (+ supporting)
+            src_skill = home / "Agentik_SSOT" / "skills" / "pursue"
+            src_skill.mkdir(parents=True)
+            (src_skill / "SKILL.md").write_text("---\nname: pursue\n---\n# pursue")
+            (src_skill / "examples.md").write_text("an example")
+            (src_skill / "scripts").mkdir()
+            (src_skill / "scripts" / "helper.sh").write_text("#!/bin/sh\n")
+            # Run sync directly against this home.
+            outcomes = SyncEngine().sync_all(home)
+            # We just need to know the projection didn't crash + skills were written.
+            self.assertTrue(any(o.get("skills_written", 0) >= 1 for o in outcomes),
+                            msg=f"no skill projected; outcomes={outcomes}")
+
+    def test_flat_layout_still_works(self):
+        from omega_engine.sync import SyncEngine
+        with tempfile.TemporaryDirectory() as td:
+            home = Path(td)
+            src_dir = home / "Agentik_SSOT" / "skills"
+            src_dir.mkdir(parents=True)
+            (src_dir / "legacy.md").write_text("# legacy flat skill")
+            outcomes = SyncEngine().sync_all(home)
+            self.assertTrue(any(o.get("skills_written", 0) >= 1 for o in outcomes),
+                            msg=f"flat layout not projected; outcomes={outcomes}")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/omega/Agentik_Engine/tests/test_role_aliases_and_ssot.py

@@ -0,0 +1,207 @@
+"""Tests for v0.19.2 fixes (full-system review pass):
+
+  1. Topology role aliases (aisb→niobe, manager→keymaker, worker→construct,
+     audit→seraph) — load_agent_prompt now resolves them to the AISB suite.
+  2. Every SSOT skill has valid YAML frontmatter (rag-route.md was the
+     last offender — now fixed).
+"""
+from __future__ import annotations
+
+import os
+import re
+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 prompts as P  # noqa: E402
+
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+SSOT_SKILLS = REPO_ROOT / "omega" / "Agentik_SSOT" / "skills"
+
+
+# ---------------------------------------------------------------------------
+# Alias map
+# ---------------------------------------------------------------------------
+
+
+class TestRoleAliases(unittest.TestCase):
+    """Topology uses generic role names; AISB suite uses canonical names.
+    The alias map bridges the gap so `load_agent_prompt("worker")` resolves
+    to `construct.md`, etc."""
+
+    def _make_aisb(self, root: Path, *, names: list[str]) -> None:
+        """Seed a fake $OMEGA_HOME/Agentik_SSOT/agents/aisb/ tree."""
+        aisb = root / "Agentik_SSOT" / "agents" / "aisb"
+        aisb.mkdir(parents=True)
+        for n in names:
+            (aisb / f"{n}.md").write_text(
+                f"---\nname: {n}\n---\n# {n} agent prompt\nrole identity body."
+            )
+
+    def test_worker_resolves_to_construct(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            self._make_aisb(home, names=["construct", "oracle", "seraph"])
+            P.clear_cache()
+            path = P.find_agent_file(home, "worker")
+            self.assertIsNotNone(path,
+                "worker should alias to construct.md")
+            self.assertEqual(path.name, "construct.md")
+
+    def test_manager_resolves_to_keymaker(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            self._make_aisb(home, names=["keymaker", "oracle"])
+            P.clear_cache()
+            path = P.find_agent_file(home, "manager")
+            self.assertEqual(path.name, "keymaker.md")
+
+    def test_audit_resolves_to_seraph(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            self._make_aisb(home, names=["seraph"])
+            P.clear_cache()
+            self.assertEqual(P.find_agent_file(home, "audit").name,
+                             "seraph.md")
+
+    def test_aisb_resolves_to_niobe(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            self._make_aisb(home, names=["niobe"])
+            P.clear_cache()
+            self.assertEqual(P.find_agent_file(home, "aisb").name,
+                             "niobe.md")
+
+    def test_direct_match_wins_over_alias(self):
+        """If a topology defines its own ``worker.md``, that wins over the
+        alias-to-construct."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            self._make_aisb(home, names=["worker", "construct"])
+            P.clear_cache()
+            path = P.find_agent_file(home, "worker")
+            self.assertEqual(path.name, "worker.md")
+
+    def test_unknown_role_returns_none(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            self._make_aisb(home, names=["oracle"])
+            P.clear_cache()
+            self.assertIsNone(P.find_agent_file(home, "nope-not-real"))
+
+    def test_load_agent_prompt_alias_pulls_body(self):
+        """load_agent_prompt should return the construct body when asked
+        for 'worker', not None."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            self._make_aisb(home, names=["construct"])
+            P.clear_cache()
+            body = P.load_agent_prompt(home, "worker")
+            self.assertIsNotNone(body)
+            self.assertIn("construct agent prompt", body)
+            self.assertIn("role identity body", body)
+
+    def test_alias_falls_back_to_other_suite(self):
+        """If aisb/ doesn't have it, the alias should also try other suites."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            other = home / "Agentik_SSOT" / "agents" / "custom"
+            other.mkdir(parents=True)
+            (other / "construct.md").write_text(
+                "---\nname: construct\n---\n# custom suite construct"
+            )
+            P.clear_cache()
+            path = P.find_agent_file(home, "worker")
+            self.assertIsNotNone(path)
+            self.assertTrue(str(path).endswith("custom/construct.md"))
+
+
+class TestTopologyMappingMatchesTemplates(unittest.TestCase):
+    """The topology YAML's role names must all resolve to a real prompt
+    after applying the alias map. This guards against a topology drift
+    where a new role is added but no alias / no template ships."""
+
+    def test_every_topology_role_resolves(self):
+        import yaml as _yaml
+        topo = REPO_ROOT / "omega" / "Agentik_Orchestration" / "topologies" / "aisb-oracle-worker.yaml"
+        if not topo.exists():
+            self.skipTest("topology not present")
+        data = _yaml.safe_load(topo.read_text())
+        templates = REPO_ROOT / "bootstrap" / "templates" / "aisb"
+        if not templates.is_dir():
+            self.skipTest("AISB templates not present")
+        available = {p.stem for p in templates.glob("*.md")}
+        for node in data["nodes"]:
+            role = node["role"]
+            # The role itself OR its alias must be in the templates set
+            candidates = [role]
+            aliased = P._ROLE_ALIASES.get(role)
+            if aliased:
+                candidates.append(aliased)
+            self.assertTrue(
+                any(c in available for c in candidates),
+                f"topology role {role!r} has no template "
+                f"(tried {candidates}; available {sorted(available)})",
+            )
+
+
+# ---------------------------------------------------------------------------
+# SSOT skills frontmatter
+# ---------------------------------------------------------------------------
+
+
+class TestSSOTSkillsFrontmatter(unittest.TestCase):
+    """Every skill under Agentik_SSOT/skills/ must have a valid YAML
+    frontmatter (name + description). Without it, the skill is silently
+    skipped by the Claude Code skill loader."""
+
+    def test_every_skill_has_name_and_description(self):
+        if not SSOT_SKILLS.is_dir():
+            self.skipTest("SSOT skills dir not in repo")
+        bad: list[tuple[str, str]] = []
+        for entry in sorted(SSOT_SKILLS.iterdir()):
+            if entry.is_dir():
+                sm = entry / "SKILL.md"
+            elif entry.suffix == ".md":
+                sm = entry
+            else:
+                continue
+            if not sm.exists():
+                continue
+            src = sm.read_text()
+            if not src.startswith("---"):
+                bad.append((entry.name, "no frontmatter"))
+                continue
+            end = src.find("---", 3)
+            if end < 0:
+                bad.append((entry.name, "unclosed frontmatter"))
+                continue
+            fm = src[3:end]
+            if "name:" not in fm:
+                bad.append((entry.name, "no name field"))
+            if "description:" not in fm:
+                bad.append((entry.name, "no description field"))
+        self.assertEqual(bad, [],
+            f"SSOT skills with bad frontmatter: {bad}")
+
+    def test_rag_route_now_has_frontmatter(self):
+        if not SSOT_SKILLS.is_dir():
+            self.skipTest("SSOT skills dir not in repo")
+        p = SSOT_SKILLS / "rag-route.md"
+        if not p.exists():
+            self.skipTest("rag-route.md not present")
+        src = p.read_text()
+        self.assertTrue(src.startswith("---"),
+            "rag-route.md must have YAML frontmatter")
+        self.assertIn("name: rag-route", src)
+        self.assertIn("description:", src)
+
+
+if __name__ == "__main__":
+    unittest.main()