codee-agent 0.1.0__py3-none-any.whl

codee/lib/test_runs_db.py

@@ -0,0 +1,199 @@
+import sqlite3
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from codee_main_context.context import CodeeMainContext
+
+from codee.lib import runs_db
+
+
+def _ctx(data_dir: Path) -> CodeeMainContext:
+    return CodeeMainContext(data_dir=data_dir)
+
+
+def _bad_ctx(tmp_path: Path) -> CodeeMainContext:
+    # A data_dir that doesn't exist -> sqlite can't open the file -> must be swallowed.
+    return _ctx(tmp_path / "missing" / "deeper")
+
+
+def _db_file(data_dir: Path) -> Path:
+    return data_dir / "codee.db"
+
+
+def test_round_trip_newest_first(tmp_path):
+    ctx = _ctx(tmp_path)
+    runs_db.record_run("skill-a", "cron", "sid-1", "succeeded",
+                       started_at="2026-06-27T10:00:00+00:00", main_context=ctx)
+    runs_db.record_run("skill-b", "email", "sid-2", "failed", error="boom",
+                       started_at="2026-06-27T11:00:00+00:00", main_context=ctx)
+
+    rows = runs_db.recent_runs(main_context=ctx)
+    assert [r["skill_name"] for r in rows] == ["skill-b", "skill-a"]  # newest first
+    assert rows[0]["trigger_type"] == "email"
+    assert rows[0]["status"] == "failed"
+    assert rows[0]["error"] == "boom"
+    assert rows[0]["session_id"] == "sid-2"
+
+
+def test_empty_db_returns_empty_list(tmp_path):
+    assert runs_db.recent_runs(main_context=_ctx(tmp_path)) == []
+
+
+def test_limit_and_offset_page_through_runs(tmp_path):
+    ctx = _ctx(tmp_path)
+    for i in range(5):
+        runs_db.record_run(f"skill-{i}", "cron", f"sid-{i}", "succeeded",
+                           started_at=f"2026-06-27T1{i}:00:00+00:00", main_context=ctx)
+
+    page1 = runs_db.recent_runs(2, main_context=ctx)
+    page2 = runs_db.recent_runs(2, 2, main_context=ctx)
+    page3 = runs_db.recent_runs(2, 4, main_context=ctx)
+
+    assert [r["skill_name"] for r in page1] == ["skill-4", "skill-3"]
+    assert [r["skill_name"] for r in page2] == ["skill-2", "skill-1"]
+    assert [r["skill_name"] for r in page3] == ["skill-0"]
+    assert runs_db.recent_runs(2, 5, main_context=ctx) == []
+
+
+def test_record_run_never_raises_on_bad_path(tmp_path):
+    # An unopenable db path must be swallowed (FR-009).
+    runs_db.record_run("skill", "cron", "sid", "succeeded",
+                       main_context=_bad_ctx(tmp_path))
+
+
+def test_main_context_is_required():
+    # The whole module keys off main_context.data_dir; a missing context must fail
+    # loudly at the call site instead of being swallowed as a logging miss.
+    for call in (lambda: runs_db.record_run("s", "cron", "sid", "succeeded"),
+                 lambda: runs_db.recent_runs(),
+                 lambda: runs_db.start_job("sid", "m")):
+        try:
+            call()
+        except TypeError:
+            continue
+        raise AssertionError("main_context must be a required keyword argument")
+
+
+# ---------------------------------------------------------------- counts() (US1)
+def _ago(hours):
+    return (datetime.now(timezone.utc) - timedelta(hours=hours)).isoformat()
+
+
+def test_counts_total_and_last_24h(tmp_path):
+    ctx = _ctx(tmp_path)
+    # Two inside the 24h window, one well outside, one exactly at the boundary (excluded, strict >).
+    runs_db.record_run("a", "cron", "s1", "succeeded", started_at=_ago(1), main_context=ctx)
+    runs_db.record_run("b", "cron", "s2", "succeeded", started_at=_ago(23), main_context=ctx)
+    runs_db.record_run("c", "cron", "s3", "succeeded", started_at=_ago(48), main_context=ctx)
+    assert runs_db.counts(ctx) == {"total": 3, "last_24h": 2}
+
+
+def test_counts_empty_db_zeros(tmp_path):
+    assert runs_db.counts(_ctx(tmp_path)) == {"total": 0, "last_24h": 0}
+
+
+def test_counts_never_raises_on_bad_path(tmp_path):
+    assert runs_db.counts(_bad_ctx(tmp_path)) == {"total": 0, "last_24h": 0}
+
+
+def test_runs_by_hour_buckets(tmp_path):
+    ctx = _ctx(tmp_path)
+    runs_db.record_run("a", "cron", "s1", "succeeded", started_at=_ago(2), main_context=ctx)
+    runs_db.record_run("b", "cron", "s2", "succeeded", started_at=_ago(2.1), main_context=ctx)
+    runs_db.record_run("c", "cron", "s3", "succeeded", started_at=_ago(48), main_context=ctx)  # out of window
+
+    hourly = runs_db.runs_by_hour(ctx)
+    assert len(hourly) == 24  # always 24 buckets
+    # oldest-first: buckets are the last 24 hour labels in ascending time order
+    now = datetime.now(timezone.utc).replace(minute=0, second=0, microsecond=0)
+    expected = [(now - timedelta(hours=h)).strftime("%H:00") for h in range(23, -1, -1)]
+    assert [h["hour"] for h in hourly] == expected
+    assert sum(h["runs"] for h in hourly) == 2  # 48h-old run excluded; the two ~2h-old runs counted
+
+
+def test_runs_by_hour_empty_and_bad_path(tmp_path):
+    bad = _bad_ctx(tmp_path)
+    assert all(h["runs"] == 0 for h in runs_db.runs_by_hour(bad))
+    assert len(runs_db.runs_by_hour(bad)) == 24
+
+
+# ---------------------------------------------------------------- message column (US2)
+def test_message_round_trip(tmp_path):
+    ctx = _ctx(tmp_path)
+    runs_db.record_run("a", "cron", "s1", "succeeded", message="hello", main_context=ctx)
+    runs_db.record_run("b", "email", "s2", "succeeded", message="", main_context=ctx)
+    runs_db.record_run("c", "aws-sqs", "s3", "succeeded", main_context=ctx)  # message defaults None
+    by_skill = {r["skill_name"]: r["message"] for r in runs_db.recent_runs(main_context=ctx)}
+    assert by_skill == {"a": "hello", "b": "", "c": None}
+
+
+# ---------------------------------------------------------------- active_jobs
+def test_active_job_lifecycle(tmp_path):
+    ctx = _ctx(tmp_path)
+    jid = runs_db.start_job("sid-1", "/task-developer NIM-1", main_context=ctx)
+    jobs = runs_db.active_jobs(ctx)
+    assert len(jobs) == 1
+    assert jobs[0]["session_id"] == "sid-1"
+    assert jobs[0]["message"] == "/task-developer NIM-1"
+    assert jobs[0]["elapsed"] >= 0
+
+    runs_db.finish_job(jid, main_context=ctx)
+    assert runs_db.active_jobs(ctx) == []
+
+
+def test_active_jobs_elapsed_and_order(tmp_path):
+    ctx = _ctx(tmp_path)
+    runs_db.start_job("young", "b", started_at=_ago(0.01), main_context=ctx)
+    runs_db.start_job("old", "a", started_at=_ago(1), main_context=ctx)
+    jobs = runs_db.active_jobs(ctx)
+    assert [j["session_id"] for j in jobs] == ["young", "old"]  # youngest first
+    assert jobs[1]["elapsed"] >= 3500  # ~1h old
+
+
+def test_clear_active_jobs_purges_stale(tmp_path):
+    ctx = _ctx(tmp_path)
+    runs_db.start_job("s1", "m1", main_context=ctx)
+    runs_db.start_job("s2", "m2", main_context=ctx)
+    runs_db.clear_active_jobs(ctx)
+    assert runs_db.active_jobs(ctx) == []
+
+
+def test_active_jobs_never_raise_on_bad_path(tmp_path):
+    bad = _bad_ctx(tmp_path)
+    assert runs_db.active_jobs(bad) == []
+    assert runs_db.start_job("s", "m", main_context=bad) is None
+    runs_db.finish_job(None, main_context=bad)  # no-op, no raise
+    runs_db.clear_active_jobs(bad)
+
+
+def test_fmt_elapsed():
+    assert runs_db.fmt_elapsed(45) == "45s"
+    assert runs_db.fmt_elapsed(125) == "2m 5s"
+    assert runs_db.fmt_elapsed(3700) == "1h 1m"
+
+
+def test_migration_adds_message_column_without_data_loss(tmp_path):
+    ctx = _ctx(tmp_path)
+    # Build an old-schema DB (spec 001, no message column) with one row.
+    with sqlite3.connect(_db_file(tmp_path)) as conn:
+        conn.execute(
+            """CREATE TABLE runs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                skill_name TEXT NOT NULL, trigger_type TEXT NOT NULL,
+                session_id TEXT NOT NULL, status TEXT NOT NULL,
+                error TEXT, started_at TEXT NOT NULL)"""
+        )
+        conn.execute(
+            "INSERT INTO runs (skill_name, trigger_type, session_id, status, started_at)"
+            " VALUES ('old', 'cron', 'sid-old', 'succeeded', '2026-06-27T10:00:00+00:00')"
+        )
+
+    runs_db.init(ctx)  # must not raise; must add the column
+    rows = runs_db.recent_runs(main_context=ctx)
+    assert len(rows) == 1
+    assert rows[0]["skill_name"] == "old"
+    assert rows[0]["message"] is None  # pre-feature row reads as NULL
+
+    # New writes carry message; the upgraded DB round-trips it.
+    runs_db.record_run("new", "cron", "sid-new", "succeeded", message="m", main_context=ctx)
+    assert runs_db.recent_runs(main_context=ctx)[0]["message"] == "m"

codee/lib/test_trigger_cron_skills.py

@@ -0,0 +1,485 @@
+import contextlib
+import io
+import json
+import tempfile
+import unittest
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from codee_main_context.context import CodeeMainContext
+
+from codee.lib.trigger_aws_sqs_skills import (
+    AwsSqsMessage,
+    find_aws_sqs_triggered_skills,
+    render_aws_sqs_prompt,
+    trigger_aws_sqs_skills,
+)
+from codee.lib.trigger_cron_skills import (
+    _cron_matches,
+    _find_scheduled_skills,
+    _latest_due,
+    _parse_skill_file,
+    request_force_run,
+    trigger_cron_skills,
+)
+
+
+def _ctx(data_dir: Path) -> CodeeMainContext:
+    return CodeeMainContext(data_dir=data_dir)
+
+
+class FakeSqsMessageSource:
+    def __init__(self, messages):
+        self.messages = list(messages)
+        self.deleted = []
+        self.received_skills = []
+
+    def receive(self, skill):
+        self.received_skills.append(skill)
+        if not self.messages:
+            return None
+        return self.messages.pop(0)
+
+    def delete(self, message):
+        self.deleted.append(message)
+
+
+class CronSkillTests(unittest.TestCase):
+    def test_parse_skill_file_strips_frontmatter(self):
+        metadata, body = _parse_skill_file(
+            "---\n"
+            "name: Check stale feature flags\n"
+            "description: Runs every day.\n"
+            "cron: 0 0 * * *\n"
+            "---\n"
+            "\n"
+            "# Skill Body\n"
+            "Do the scheduled work.\n"
+        )
+
+        self.assertEqual(metadata["cron"], "0 0 * * *")
+        self.assertEqual(metadata["name"], "Check stale feature flags")
+        self.assertEqual(body, "# Skill Body\nDo the scheduled work.")
+
+    def test_cron_matches_steps_and_lists(self):
+        tick = datetime(2026, 6, 7, 10, 15)
+
+        self.assertTrue(_cron_matches("*/5 10 * * *", tick))
+        self.assertTrue(_cron_matches("10,15 9-11 * * *", tick))
+        self.assertFalse(_cron_matches("*/10 10 * * *", tick))
+
+    def test_find_scheduled_skills_reads_skill_directories(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            skills_dir = Path(temp_dir)
+            skill_dir = skills_dir / "daily-check"
+            skill_dir.mkdir()
+            (skill_dir / "SKILL.md").write_text(
+                "---\n"
+                "name: Daily Check\n"
+                "disable-model-invocation: true\n"
+                "cron: 0 0 * * *\n"
+                "---\n\n"
+                "Run the daily check.\n"
+            )
+
+            skills = _find_scheduled_skills(skills_dir)
+
+        self.assertEqual(len(skills), 1)
+        self.assertEqual(skills[0].name, "Daily Check")
+        self.assertEqual(skills[0].body, "Run the daily check.")
+
+    def test_find_scheduled_skills_requires_disable_model_invocation(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            skills_dir = Path(temp_dir)
+            skill_dir = skills_dir / "daily-check"
+            skill_dir.mkdir()
+            (skill_dir / "SKILL.md").write_text(
+                "---\nname: Daily Check\ncron: 0 0 * * *\n---\n\nRun the daily check.\n"
+            )
+
+            output = io.StringIO()
+            with contextlib.redirect_stdout(output):
+                skills = _find_scheduled_skills(skills_dir)
+
+        self.assertEqual(skills, [])
+        self.assertIn("ERROR", output.getvalue())
+        self.assertIn("disable-model-invocation: true", output.getvalue())
+
+    def test_find_aws_sqs_triggered_skills_reads_frontmatter(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            skills_dir = Path(temp_dir)
+            skill_dir = skills_dir / "sqs-check"
+            skill_dir.mkdir()
+            (skill_dir / "SKILL.md").write_text(
+                "---\n"
+                "name: SQS Check\n"
+                "disable-model-invocation: true\n"
+                "x-codee-trigger: aws-sqs\n"
+                "x-codee-aws-sqs-queue: codee-queue\n"
+                "---\n\n"
+                "Process this content: {CONTENT}\n"
+            )
+
+            skills = find_aws_sqs_triggered_skills(skills_dir)
+
+        self.assertEqual(len(skills), 1)
+        self.assertEqual(skills[0].name, "SQS Check")
+        self.assertEqual(skills[0].queue, "codee-queue")
+        self.assertEqual(skills[0].body, "Process this content: {CONTENT}")
+
+    def test_find_aws_sqs_triggered_skills_requires_queue(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            skills_dir = Path(temp_dir)
+            skill_dir = skills_dir / "sqs-check"
+            skill_dir.mkdir()
+            (skill_dir / "SKILL.md").write_text(
+                "---\n"
+                "name: SQS Check\n"
+                "disable-model-invocation: true\n"
+                "x-codee-trigger: aws-sqs\n"
+                "---\n\n"
+                "Process one SQS message.\n"
+            )
+
+            output = io.StringIO()
+            with contextlib.redirect_stdout(output):
+                skills = find_aws_sqs_triggered_skills(skills_dir)
+
+        self.assertEqual(skills, [])
+        self.assertIn("x-codee-aws-sqs-queue", output.getvalue())
+
+    def test_render_aws_sqs_prompt_replaces_content_placeholder(self):
+        self.assertEqual(
+            render_aws_sqs_prompt("Handle this:\n{CONTENT}", "message body"),
+            "Handle this:\nmessage body",
+        )
+
+    def test_render_aws_sqs_prompt_appends_content_without_placeholder(self):
+        self.assertEqual(
+            render_aws_sqs_prompt("Handle this message.", "message body"),
+            "Handle this message.\n\nmessage body",
+        )
+
+    def test_reconcile_runs_due_skill_once_per_minute(self):
+        calls = []
+
+        def run_claude(message: str, session_id: str, model: str = "") -> str:
+            calls.append((message, session_id))
+            return "done"
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            skills_dir = root / "skills"
+            state_file = root / "state.json"
+            skill_dir = skills_dir / "daily-check"
+            skill_dir.mkdir(parents=True)
+            (skill_dir / "SKILL.md").write_text(
+                "---\n"
+                "name: Daily Check\n"
+                "disable-model-invocation: true\n"
+                "cron: 15 10 * * *\n"
+                "---\n\n"
+                "Run the daily check.\n"
+            )
+            tick = datetime(2026, 6, 7, 10, 15, 30)
+
+            trigger_cron_skills(run_claude, now=tick, skills_dir=skills_dir,
+                                state_file=state_file, main_context=_ctx(root))
+            trigger_cron_skills(run_claude, now=tick, skills_dir=skills_dir,
+                                state_file=state_file, main_context=_ctx(root))
+
+        self.assertEqual(len(calls), 1)
+        self.assertEqual(calls[0][0], "Run the daily check.")
+        self.assertTrue(calls[0][1])
+
+    def test_reconcile_retries_when_run_fails(self):
+        # A failing run (e.g. over usage limit) must NOT mark the slot done, so
+        # the next tick within the catch-up window runs it again.
+        calls = []
+
+        def run_claude(message: str, session_id: str, model: str = "") -> str:
+            calls.append(session_id)
+            if len(calls) == 1:
+                raise RuntimeError("over limit")
+            return "done"
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            skills_dir = root / "skills"
+            state_file = root / "state.json"
+            skill_dir = skills_dir / "daily-check"
+            skill_dir.mkdir(parents=True)
+            (skill_dir / "SKILL.md").write_text(
+                "---\n"
+                "name: Daily Check\n"
+                "disable-model-invocation: true\n"
+                "cron: 15 10 * * *\n"
+                "---\n\n"
+                "Run the daily check.\n"
+            )
+            tick = datetime(2026, 6, 7, 10, 15, 30)
+
+            trigger_cron_skills(run_claude, now=tick, skills_dir=skills_dir,
+                                state_file=state_file, main_context=_ctx(root))
+            # nothing recorded yet -> retried on the next tick same minute
+            self.assertFalse(state_file.exists())
+            trigger_cron_skills(run_claude, now=tick, skills_dir=skills_dir,
+                                state_file=state_file, main_context=_ctx(root))
+
+            self.assertEqual(len(calls), 2)
+            self.assertTrue(state_file.exists())
+
+    def test_latest_due_finds_missed_fire_within_window(self):
+        # cron fires at 12:05; a tick lands at 12:10 (exact minute was skipped)
+        cron = "5 12 * * *"
+        tick = datetime(2026, 6, 7, 12, 10)
+        due = _latest_due(cron, tick, timedelta(hours=24))
+        self.assertEqual(due, datetime(2026, 6, 7, 12, 5))
+
+    def test_latest_due_returns_none_outside_window(self):
+        # weekly Monday-midnight cron, tick is days later, window only 24h
+        cron = "0 0 * * 1"
+        tick = datetime(2026, 6, 7, 12, 10)  # a Sunday
+        self.assertIsNone(_latest_due(cron, tick, timedelta(hours=24)))
+
+    def test_reconcile_catches_up_missed_minute(self):
+        calls = []
+
+        def run_claude(message: str, session_id: str, model: str = "") -> str:
+            calls.append((message, session_id))
+            return "done"
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            skills_dir = root / "skills"
+            state_file = root / "state.json"
+            skill_dir = skills_dir / "daily-check"
+            skill_dir.mkdir(parents=True)
+            (skill_dir / "SKILL.md").write_text(
+                "---\n"
+                "name: Daily Check\n"
+                "disable-model-invocation: true\n"
+                "cron: 5 12 * * *\n"
+                "---\n\n"
+                "Run the daily check.\n"
+            )
+
+            # 12:00 tick: not yet due, nothing runs.
+            trigger_cron_skills(
+                run_claude,
+                now=datetime(2026, 6, 7, 12, 0),
+                skills_dir=skills_dir,
+                state_file=state_file,
+                main_context=_ctx(root),
+            )
+            self.assertEqual(calls, [])
+
+            # 12:10 tick: the 12:05 fire was missed while busy -> catch up now.
+            trigger_cron_skills(
+                run_claude,
+                now=datetime(2026, 6, 7, 12, 10),
+                skills_dir=skills_dir,
+                state_file=state_file,
+                main_context=_ctx(root),
+            )
+            self.assertEqual(len(calls), 1)
+
+            # A later tick the same day must not re-run the same occurrence.
+            trigger_cron_skills(
+                run_claude,
+                now=datetime(2026, 6, 7, 12, 20),
+                skills_dir=skills_dir,
+                state_file=state_file,
+                main_context=_ctx(root),
+            )
+            self.assertEqual(len(calls), 1)
+
+            state = json.loads(state_file.read_text())
+            self.assertEqual(list(state.values()), ["2026-06-07T12:05"])
+
+    def test_reconcile_does_not_backrun_on_first_sight(self):
+        # Starting the listener after a past fire must not retroactively run it;
+        # it should only seed a baseline so future misses are caught.
+        calls = []
+
+        def run_claude(message: str, session_id: str, model: str = "") -> str:
+            calls.append((message, session_id))
+            return "done"
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            skills_dir = root / "skills"
+            state_file = root / "state.json"
+            skill_dir = skills_dir / "daily-check"
+            skill_dir.mkdir(parents=True)
+            (skill_dir / "SKILL.md").write_text(
+                "---\n"
+                "name: Daily Check\n"
+                "disable-model-invocation: true\n"
+                "cron: 0 0 * * *\n"
+                "---\n\n"
+                "Run the daily check.\n"
+            )
+
+            # First ever tick lands at 23:00, hours after the 00:00 fire.
+            trigger_cron_skills(
+                run_claude,
+                now=datetime(2026, 6, 7, 23, 0),
+                skills_dir=skills_dir,
+                state_file=state_file,
+                main_context=_ctx(root),
+            )
+            self.assertEqual(calls, [])
+
+            state = json.loads(state_file.read_text())
+            self.assertEqual(list(state.values()), ["2026-06-07T00:00"])
+
+    def test_force_run_fires_off_schedule_then_clears(self):
+        calls = []
+
+        def run_claude(message: str, session_id: str, model: str = "") -> str:
+            calls.append(session_id)
+            return "done"
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            skills_dir = root / "skills"
+            state_file = root / "state.json"
+            # request_force_run derives this path from main_context.data_dir.
+            force_file = root / "cron_skill_force.json"
+            skill_dir = skills_dir / "daily-check"
+            skill_dir.mkdir(parents=True)
+            skill_path = skill_dir / "SKILL.md"
+            skill_path.write_text(
+                "---\n"
+                "name: Daily Check\n"
+                "disable-model-invocation: true\n"
+                "cron: 0 0 * * *\n"
+                "---\n\n"
+                "Run the daily check.\n"
+            )
+
+            # 15:30 is nowhere near the 00:00 cron, but a force request must run it.
+            request_force_run(skill_path, _ctx(root))
+            off_schedule = datetime(2026, 6, 7, 15, 30)
+            trigger_cron_skills(run_claude, now=off_schedule, skills_dir=skills_dir,
+                                state_file=state_file, force_file=force_file,
+                                main_context=_ctx(root))
+            self.assertEqual(len(calls), 1)
+
+            # Force is one-shot: a later off-schedule tick must not re-run it.
+            trigger_cron_skills(run_claude, now=datetime(2026, 6, 7, 15, 31),
+                                skills_dir=skills_dir, state_file=state_file,
+                                force_file=force_file, main_context=_ctx(root))
+            self.assertEqual(len(calls), 1)
+            self.assertEqual(json.loads(force_file.read_text()), [])
+
+    def test_force_run_stays_queued_when_run_fails(self):
+        calls = []
+
+        def run_claude(message: str, session_id: str, model: str = "") -> str:
+            calls.append(session_id)
+            raise RuntimeError("over limit")
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            skills_dir = root / "skills"
+            state_file = root / "state.json"
+            # request_force_run derives this path from main_context.data_dir.
+            force_file = root / "cron_skill_force.json"
+            skill_dir = skills_dir / "daily-check"
+            skill_dir.mkdir(parents=True)
+            skill_path = skill_dir / "SKILL.md"
+            skill_path.write_text(
+                "---\nname: Daily Check\ndisable-model-invocation: true\n"
+                "cron: 0 0 * * *\n---\n\nRun the daily check.\n"
+            )
+
+            request_force_run(skill_path, _ctx(root))
+            trigger_cron_skills(run_claude, now=datetime(2026, 6, 7, 15, 30),
+                                skills_dir=skills_dir, state_file=state_file,
+                                force_file=force_file, main_context=_ctx(root))
+
+            # Still queued so the next tick retries it.
+            key = json.loads(force_file.read_text())
+            self.assertEqual(len(key), 1)
+            self.assertEqual(len(calls), 1)
+
+    def test_reconcile_passes_the_skill_model_to_the_agent(self):
+        calls = []
+
+        def run_claude(message: str, session_id: str, model: str = "") -> str:
+            calls.append(model)
+            return "done"
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            skills_dir = root / "skills"
+            for slug, model_line in (("with-model", "model: claude-opus-5\n"),
+                                     ("without-model", "")):
+                skill_dir = skills_dir / slug
+                skill_dir.mkdir(parents=True)
+                (skill_dir / "SKILL.md").write_text(
+                    "---\n"
+                    f"name: {slug}\n"
+                    "disable-model-invocation: true\n"
+                    "cron: 15 10 * * *\n"
+                    f"{model_line}"
+                    "---\n\n"
+                    "Run it.\n"
+                )
+            tick = datetime(2026, 6, 7, 10, 15)
+
+            trigger_cron_skills(run_claude, now=tick, skills_dir=skills_dir,
+                                state_file=root / "state.json",
+                                main_context=_ctx(root))
+
+        # Sorted by directory name, so the skill declaring a model comes first.
+        self.assertEqual(calls, ["claude-opus-5", ""])
+
+    def test_reconcile_runs_one_aws_sqs_message_per_tick(self):
+        calls = []
+        message = AwsSqsMessage(
+            content="payload",
+            queue_url="https://sqs.example/queue",
+            receipt_handle="receipt",
+        )
+        sqs_source = FakeSqsMessageSource([message])
+
+        def run_claude(user_message: str, session_id: str, model: str = "") -> str:
+            calls.append((user_message, session_id))
+            return "done"
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            skills_dir = root / "skills"
+            skill_dir = skills_dir / "sqs-check"
+            skill_dir.mkdir(parents=True)
+            (skill_dir / "SKILL.md").write_text(
+                "---\n"
+                "name: SQS Check\n"
+                "disable-model-invocation: true\n"
+                "x-codee-trigger: aws-sqs\n"
+                "x-codee-aws-sqs-queue: codee-queue\n"
+                "---\n\n"
+                "Process this content: {CONTENT}\n"
+            )
+
+            trigger_aws_sqs_skills(
+                run_claude,
+                skills_dir=skills_dir,
+                sqs_message_source=sqs_source,
+                main_context=_ctx(root),
+            )
+
+        self.assertEqual(len(calls), 1)
+        self.assertEqual(calls[0][0], "Process this content: payload")
+        self.assertTrue(calls[0][1])
+        self.assertEqual(sqs_source.deleted, [message])
+
+
+if __name__ == "__main__":
+    unittest.main()