@smilintux/skcapstone 0.10.0 → 0.12.5

package/tests/test_peers.py

@@ -6,7 +6,7 @@ Covers:
 - list_peers (empty, with peers)
 - get_peer / remove_peer
 - PeerRecord model
-- SKComm peer file creation
+- SKComms peer file creation
 - CLI commands (add, list, remove, show)
 """
 
@@ -30,9 +30,9 @@ from skcapstone.peers import (
 
 @pytest.fixture
 def homes(tmp_path):
-    """Create skcapstone and skcomm home directories."""
+    """Create skcapstone and skcomms home directories."""
     sk = tmp_path / ".skcapstone"
-    sc = tmp_path / ".skcomm"
+    sc = tmp_path / ".skcomms"
     sk.mkdir()
     sc.mkdir()
     return sk, sc
@@ -87,7 +87,7 @@ class TestAddPeerFromCard:
     def test_add_from_card(self, card_file, homes):
         """Card import creates peer records in both registries."""
         sk, sc = homes
-        peer = add_peer_from_card(card_file, skcapstone_home=sk, skcomm_home=sc)
+        peer = add_peer_from_card(card_file, skcapstone_home=sk, skcomms_home=sc)
 
         assert peer.name == "Lumina"
         assert peer.fingerprint == "AABB1122CCDD3344EEFF5566"
@@ -104,7 +104,7 @@ class TestAddPeerFromCard:
         """Nonexistent card raises FileNotFoundError."""
         sk, sc = homes
         with pytest.raises(FileNotFoundError):
-            add_peer_from_card(Path("/nope.json"), skcapstone_home=sk, skcomm_home=sc)
+            add_peer_from_card(Path("/nope.json"), skcapstone_home=sk, skcomms_home=sc)
 
     def test_invalid_json_raises(self, tmp_path, homes):
         """Invalid JSON raises ValueError."""
@@ -112,7 +112,7 @@ class TestAddPeerFromCard:
         bad = tmp_path / "bad.json"
         bad.write_text("{{{not json")
         with pytest.raises(ValueError):
-            add_peer_from_card(bad, skcapstone_home=sk, skcomm_home=sc)
+            add_peer_from_card(bad, skcapstone_home=sk, skcomms_home=sc)
 
     def test_missing_name_raises(self, tmp_path, homes):
         """Card without name raises ValueError."""
@@ -120,7 +120,7 @@ class TestAddPeerFromCard:
         no_name = tmp_path / "noname.json"
         no_name.write_text(json.dumps({"fingerprint": "123"}))
         with pytest.raises(ValueError, match="name"):
-            add_peer_from_card(no_name, skcapstone_home=sk, skcomm_home=sc)
+            add_peer_from_card(no_name, skcapstone_home=sk, skcomms_home=sc)
 
 
 class TestAddPeerManual:
@@ -131,7 +131,7 @@ class TestAddPeerManual:
         sk, sc = homes
         peer = add_peer_manual(
             name="Opus", email="opus@smilintux.org",
-            skcapstone_home=sk, skcomm_home=sc,
+            skcapstone_home=sk, skcomms_home=sc,
         )
         assert peer.name == "Opus"
         assert peer.email == "opus@smilintux.org"
@@ -145,7 +145,7 @@ class TestAddPeerManual:
 
         peer = add_peer_manual(
             name="Opus", public_key_path=key_file,
-            skcapstone_home=sk, skcomm_home=sc,
+            skcapstone_home=sk, skcomms_home=sc,
         )
         assert peer.public_key != ""
         assert peer.trust_level == "verified"
@@ -163,7 +163,7 @@ class TestListPeers:
     def test_list_with_peers(self, card_file, homes):
         """Added peers appear in listing."""
         sk, sc = homes
-        add_peer_from_card(card_file, skcapstone_home=sk, skcomm_home=sc)
+        add_peer_from_card(card_file, skcapstone_home=sk, skcomms_home=sc)
 
         peers = list_peers(skcapstone_home=sk)
         assert len(peers) == 1
@@ -176,7 +176,7 @@ class TestGetPeer:
     def test_get_existing(self, card_file, homes):
         """Known peer is returned."""
         sk, sc = homes
-        add_peer_from_card(card_file, skcapstone_home=sk, skcomm_home=sc)
+        add_peer_from_card(card_file, skcapstone_home=sk, skcomms_home=sc)
 
         peer = get_peer("Lumina", skcapstone_home=sk)
         assert peer is not None
@@ -194,16 +194,16 @@ class TestRemovePeer:
     def test_remove_existing(self, card_file, homes):
         """Removing an existing peer cleans up all files."""
         sk, sc = homes
-        add_peer_from_card(card_file, skcapstone_home=sk, skcomm_home=sc)
+        add_peer_from_card(card_file, skcapstone_home=sk, skcomms_home=sc)
 
-        assert remove_peer("Lumina", skcapstone_home=sk, skcomm_home=sc)
+        assert remove_peer("Lumina", skcapstone_home=sk, skcomms_home=sc)
         assert not (sk / "peers" / "lumina.json").exists()
         assert not (sc / "peers" / "lumina.yml").exists()
 
     def test_remove_unknown(self, homes):
         """Removing unknown peer returns False."""
         sk, sc = homes
-        assert not remove_peer("Nobody", skcapstone_home=sk, skcomm_home=sc)
+        assert not remove_peer("Nobody", skcapstone_home=sk, skcomms_home=sc)
 
 
 class TestCLI:

package/tests/test_pillars.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 from pathlib import Path
 
+from skcapstone.pillars.consciousness import initialize_consciousness
 from skcapstone.pillars.identity import generate_identity
 from skcapstone.pillars.security import (
     AuditEntry,
@@ -163,3 +164,100 @@ class TestSecurityPillar:
         """read_audit_log returns empty list when no log exists."""
         entries = read_audit_log(tmp_path / "nonexistent")
         assert entries == []
+
+
+class TestConsciousnessPillar:
+    """Tests for consciousness pillar initialization (SKWhisper + SKTrip)."""
+
+    def test_returns_missing_when_no_skwhisper(self, tmp_agent_home: Path):
+        """initialize_consciousness returns MISSING when no SKWhisper data exists."""
+        state = initialize_consciousness(tmp_agent_home)
+        assert state.status == PillarStatus.MISSING
+
+    def test_degraded_with_digested_sessions_no_daemon(self, tmp_agent_home: Path, monkeypatch):
+        """DEGRADED when sessions have been digested but daemon is not running."""
+        import os
+        agent_name = os.environ.get("SKCAPSTONE_AGENT", "lumina")
+        whisper_dir = tmp_agent_home / "agents" / agent_name / "skwhisper"
+        whisper_dir.mkdir(parents=True, exist_ok=True)
+
+        # Write state.json with one digested session
+        state_json = whisper_dir / "state.json"
+        state_json.write_text(json.dumps({
+            "last_digest": "2026-03-25T12:00:00+00:00",
+            "sessions": {
+                "abc123": {"digested_at": "2026-03-25T12:00:00+00:00"}
+            }
+        }))
+
+        # Daemon not running (systemctl will fail in test env)
+        state = initialize_consciousness(tmp_agent_home)
+        assert state.sessions_digested == 1
+        assert state.sessions_pending == 0
+        assert state.status in (PillarStatus.DEGRADED, PillarStatus.ACTIVE)
+
+    def test_whisper_md_age_tracked(self, tmp_agent_home: Path):
+        """whisper.md existence and age are captured correctly."""
+        import os
+        agent_name = os.environ.get("SKCAPSTONE_AGENT", "lumina")
+        whisper_dir = tmp_agent_home / "agents" / agent_name / "skwhisper"
+        whisper_dir.mkdir(parents=True, exist_ok=True)
+
+        whisper_md = whisper_dir / "whisper.md"
+        whisper_md.write_text("# Whisper context\n")
+
+        state = initialize_consciousness(tmp_agent_home)
+        assert state.whisper_md == whisper_md
+        assert state.whisper_md_age_hours >= 0.0
+
+    def test_patterns_json_topic_count(self, tmp_agent_home: Path):
+        """topics_tracked reflects the number of topics in patterns.json."""
+        import os
+        agent_name = os.environ.get("SKCAPSTONE_AGENT", "lumina")
+        whisper_dir = tmp_agent_home / "agents" / agent_name / "skwhisper"
+        whisper_dir.mkdir(parents=True, exist_ok=True)
+
+        patterns = whisper_dir / "patterns.json"
+        patterns.write_text(json.dumps({
+            "topics": {"sovereignty": {}, "memory": {}, "consciousness": {}}
+        }))
+
+        state = initialize_consciousness(tmp_agent_home)
+        assert state.topics_tracked == 3
+
+    def test_active_with_daemon_fresh_whisper_and_patterns(
+        self, tmp_agent_home: Path, monkeypatch
+    ):
+        """Fresh SKWhisper context plus tracked patterns is active when daemon is active."""
+        agent_name = "jarvis"
+        monkeypatch.setenv("SKCAPSTONE_AGENT", agent_name)
+        whisper_dir = tmp_agent_home / "agents" / agent_name / "skwhisper"
+        whisper_dir.mkdir(parents=True, exist_ok=True)
+        (whisper_dir / "whisper.md").write_text("# Whisper context\n")
+        (whisper_dir / "patterns.json").write_text(json.dumps({
+            "topics": {"sovereignty": {}, "memory": {}}
+        }))
+
+        class Result:
+            stdout = "active\n"
+
+        monkeypatch.setattr(
+            "subprocess.run",
+            lambda *args, **kwargs: Result(),
+        )
+
+        state = initialize_consciousness(tmp_agent_home)
+
+        assert state.status == PillarStatus.ACTIVE
+
+    def test_trip_sessions_counted(self, tmp_agent_home: Path):
+        """trip_sessions counts .json files in the sktrip directory."""
+        import os
+        agent_name = os.environ.get("SKCAPSTONE_AGENT", "lumina")
+        trip_dir = tmp_agent_home / "agents" / agent_name / "sktrip"
+        trip_dir.mkdir(parents=True, exist_ok=True)
+        (trip_dir / "trip-001.json").write_text("{}")
+        (trip_dir / "trip-002.json").write_text("{}")
+
+        state = initialize_consciousness(tmp_agent_home)
+        assert state.trip_sessions == 2

package/tests/test_preflight.py

@@ -301,15 +301,15 @@ class TestPreflightCheckerPackages:
         real_import = builtins.__import__
 
         def _mock_import(name, *args, **kwargs):
-            if name == "skcomm":
-                raise ImportError("no module named skcomm")
+            if name == "skcomms":
+                raise ImportError("no module named skcomms")
             return real_import(name, *args, **kwargs)
 
         checker = PreflightChecker(home=tmp_path)
         with patch("builtins.__import__", side_effect=_mock_import):
             result = checker.check_packages()
         assert result.status == "fail"
-        assert "skcomm" in result.message
+        assert "skcomms" in result.message
 
     def test_all_present_ok(self, tmp_path: Path) -> None:
         checker = PreflightChecker(home=tmp_path)

package/tests/test_runtime.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 from pathlib import Path
 
 from skcapstone.runtime import AgentRuntime
@@ -28,6 +29,26 @@ class TestAgentRuntime:
         assert manifest.name == "test-agent"
         assert manifest.last_awakened is not None
 
+    def test_awaken_prefers_identity_name_over_shared_config(self, tmp_path: Path):
+        """Agent-local identity should beat a shared-root fallback config name."""
+        shared_root = tmp_path / ".skcapstone"
+        agent_home = shared_root / "agents" / "aster"
+        (agent_home / "identity").mkdir(parents=True)
+        (agent_home / "config").mkdir(parents=True)
+
+        (shared_root / "config").mkdir(parents=True)
+        (shared_root / "config" / "config.yaml").write_text("agent_name: Jarvis\n")
+        (agent_home / "manifest.json").write_text(json.dumps({"name": "aster"}))
+        (agent_home / "identity" / "identity.json").write_text(json.dumps({
+            "name": "Aster",
+            "fingerprint": "A" * 40,
+            "capauth_managed": True,
+        }))
+
+        runtime = AgentRuntime(home=agent_home)
+        manifest = runtime.awaken()
+        assert manifest.name == "Aster"
+
     def test_register_connector(self, initialized_agent_home: Path):
         """Registering a connector should persist it."""
         runtime = AgentRuntime(home=initialized_agent_home)

package/tests/test_scheduled_tasks.py

@@ -225,12 +225,14 @@ class TestBuildScheduler:
         stop = threading.Event()
         scheduler = build_scheduler(tmp_path, stop)
         names = {s["name"] for s in scheduler.status()}
-        assert names == {
+        # The core standard tasks must be registered (more — sync, service
+        # health, itil, dreaming — have since been added to build_scheduler).
+        assert {
             "heartbeat_pulse",
             "backend_reprobe",
             "memory_promotion_sweep",
             "profile_freshness_check",
-        }
+        }.issubset(names)
 
     def test_heartbeat_interval_is_30s(self, tmp_path):
         stop = threading.Event()
@@ -292,12 +294,15 @@ class TestMemoryPromotionTask:
         with patch("skcapstone.memory_promoter.PromotionEngine", return_value=mock_engine):
             callback()  # should not raise
 
-    def test_import_error_propagates_as_exception(self, tmp_path):
-        """If PromotionEngine raises on import the task should propagate (caught by runner)."""
+    def test_import_error_is_swallowed_not_propagated(self, tmp_path):
+        """A failing promotion sweep must NOT crash the scheduler: the sweep runs
+        in a background thread and catches/logs its own errors."""
+        import time as _time
+
         callback = make_memory_promotion_task(tmp_path)
         with patch("skcapstone.memory_promoter.PromotionEngine", side_effect=RuntimeError("unavailable")):
-            with pytest.raises(RuntimeError, match="unavailable"):
-                callback()
+            callback()  # spawns a daemon thread; must return without raising
+        _time.sleep(0.1)  # let the background sweep run and swallow the error
 
 
 class TestBackendReprobeTask:

package/tests/test_scheduler_cli.py

@@ -0,0 +1,47 @@
+"""Tests for `skcapstone scheduler` CLI command group."""
+
+import click
+from click.testing import CliRunner
+from skcapstone.cli.scheduler_cmd import register_scheduler_commands
+
+
+def _app(tmp_path, monkeypatch):
+    monkeypatch.setenv("SKCAPSTONE_HOME", str(tmp_path))
+    (tmp_path / "config").mkdir(parents=True, exist_ok=True)
+    (tmp_path / "config" / "jobs.yaml").write_text(
+        "jobs:\n  demo:\n    every: 60s\n    type: shell\n    command: 'echo hi'\n    nodes: all\n",
+        encoding="utf-8")
+
+    @click.group()
+    def main():
+        pass
+
+    register_scheduler_commands(main)
+    return main
+
+
+def test_scheduler_list(tmp_path, monkeypatch):
+    main = _app(tmp_path, monkeypatch)
+    res = CliRunner().invoke(main, ["scheduler", "list"])
+    assert res.exit_code == 0 and "demo" in res.output
+
+
+def test_scheduler_run_now(tmp_path, monkeypatch):
+    main = _app(tmp_path, monkeypatch)
+    res = CliRunner().invoke(main, ["scheduler", "run", "demo"])
+    assert res.exit_code == 0 and "hi" in res.output
+
+
+def test_scheduler_run_unknown_job_errors(tmp_path, monkeypatch):
+    main = _app(tmp_path, monkeypatch)
+    res = CliRunner().invoke(main, ["scheduler", "run", "nope"])
+    assert res.exit_code != 0
+
+
+def test_scheduler_disable_then_list(tmp_path, monkeypatch):
+    main = _app(tmp_path, monkeypatch)
+    assert CliRunner().invoke(main, ["scheduler", "disable", "demo"]).exit_code == 0
+    # after disable, jobs.yaml should mark it disabled
+    import yaml
+    data = yaml.safe_load((tmp_path / "config" / "jobs.yaml").read_text())
+    assert data["jobs"]["demo"]["enabled"] is False

package/tests/test_scheduler_features.py

@@ -0,0 +1,133 @@
+"""Tests for skscheduler reliability features (2026-06-09):
+retries + backoff, jitter parsing, and the notify (sk-alert) hook."""
+
+import threading
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from pathlib import Path
+
+from skcapstone import scheduled_tasks as st
+from skcapstone.scheduled_tasks import TaskScheduler
+from skcapstone.scheduler_jobs import JobSpec, load_jobs
+
+
+# --- JobSpec / loader -------------------------------------------------------
+
+def test_load_jobs_parses_reliability_fields(tmp_path: Path):
+    cfg = tmp_path / "jobs.yaml"
+    cfg.write_text(
+        "jobs:\n"
+        "  flaky:\n"
+        "    every: 60s\n"
+        "    type: shell\n"
+        "    command: 'true'\n"
+        "    retries: 3\n"
+        "    retry_backoff: 2.5\n"
+        "    jitter: 30\n"
+        "    notify: on_failure\n"
+        "    notify_level: crit\n"
+    )
+    (job,) = load_jobs(cfg)
+    assert job.retries == 3
+    assert job.retry_backoff == 2.5
+    assert job.jitter == 30.0
+    assert job.notify == "on_failure"
+    assert job.notify_level == "crit"
+
+
+def test_jobspec_reliability_defaults():
+    j = JobSpec(name="x")
+    assert j.retries == 0 and j.retry_backoff == 0.0 and j.jitter == 0.0
+    assert j.notify == "off" and j.notify_level == "warn"
+
+
+# --- notify hook ------------------------------------------------------------
+
+class _Res:
+    def __init__(self, ok, output="", error=""):
+        self.ok, self.output, self.error = ok, output, error
+
+
+def _patch_alert(monkeypatch):
+    calls = []
+    monkeypatch.setattr(st.shutil, "which", lambda _n: "/usr/bin/sk-alert")
+    monkeypatch.setattr(st.subprocess, "run", lambda args, **k: calls.append(args) or None)
+    return calls
+
+
+def test_notify_off_sends_nothing(monkeypatch):
+    calls = _patch_alert(monkeypatch)
+    TaskScheduler._maybe_notify(JobSpec(name="j", notify="off"), _Res(False, error="boom"), 1)
+    assert calls == []
+
+
+def test_notify_on_failure_fires_with_tail(monkeypatch):
+    calls = _patch_alert(monkeypatch)
+    TaskScheduler._maybe_notify(
+        JobSpec(name="j", notify="on_failure", notify_level="crit"),
+        _Res(False, output="line1\nline2", error="boom"), attempts=2)
+    assert len(calls) == 1
+    args = calls[0]
+    assert "-l" in args and "crit" in args
+    assert "❌ FAILED" in args[-1] and "after 2 attempts" in args[-1]
+    assert "line2" in args[-1]
+
+
+def test_notify_on_success_skips_failure(monkeypatch):
+    calls = _patch_alert(monkeypatch)
+    TaskScheduler._maybe_notify(JobSpec(name="j", notify="on_success"), _Res(False, error="x"), 1)
+    assert calls == []
+
+
+def test_notify_always_fires_on_success_info_level(monkeypatch):
+    calls = _patch_alert(monkeypatch)
+    TaskScheduler._maybe_notify(JobSpec(name="j", notify="always"), _Res(True, output="done"), 1)
+    assert len(calls) == 1 and "info" in calls[0] and "✅ ok" in calls[0][-1]
+
+
+# --- retries ----------------------------------------------------------------
+
+def test_run_config_job_retries_until_success(monkeypatch):
+    seq = [_Res(False, error="e1"), _Res(False, error="e2"), _Res(True)]
+    n = {"runs": 0}
+    recorded = {}
+
+    class FakeRunner:
+        @contextmanager
+        def lock(self, job):
+            yield True
+        def run(self, job):
+            r = seq[n["runs"]]; n["runs"] += 1; return r
+
+    class FakeState:
+        def record_run(self, name, now, ok, error):
+            recorded.update(ok=ok, error=error, name=name)
+
+    mgr = TaskScheduler(home=Path("/tmp"), stop_event=threading.Event())
+    mgr._job_runner = FakeRunner()
+    mgr._state = FakeState()
+    job = JobSpec(name="flaky", retries=2, retry_backoff=0.0, jitter=0.0)
+    mgr._run_config_job(job, datetime.now(timezone.utc))
+    assert n["runs"] == 3          # failed twice, succeeded on 3rd
+    assert recorded["ok"] is True
+
+
+def test_run_config_job_stops_after_exhausting_retries(monkeypatch):
+    n = {"runs": 0}; recorded = {}
+
+    class FakeRunner:
+        @contextmanager
+        def lock(self, job):
+            yield True
+        def run(self, job):
+            n["runs"] += 1; return _Res(False, error="always fails")
+
+    class FakeState:
+        def record_run(self, name, now, ok, error):
+            recorded.update(ok=ok)
+
+    mgr = TaskScheduler(home=Path("/tmp"), stop_event=threading.Event())
+    mgr._job_runner = FakeRunner(); mgr._state = FakeState()
+    mgr._run_config_job(JobSpec(name="bad", retries=1), datetime.now(timezone.utc))
+    assert n["runs"] == 2          # 1 + 1 retry
+    assert recorded["ok"] is False

package/tests/test_scheduler_integration.py

@@ -0,0 +1,87 @@
+"""Integration tests for config-driven jobs in TaskScheduler.
+
+Tests that load_config_jobs and tick_config_jobs work correctly, and that
+build_scheduler picks up a jobs.yaml file from the config directory.
+"""
+from __future__ import annotations
+
+import threading
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+from skcapstone.scheduler_jobs import JobSpec
+from skcapstone.scheduled_tasks import TaskScheduler
+
+
+def test_due_config_job_for_this_host_fires(tmp_path: Path):
+    """Due jobs are dispatched to a worker thread; assert fired after the thread completes."""
+    sched = TaskScheduler(home=tmp_path, stop_event=threading.Event())
+    fired = []
+    done = threading.Event()
+    job = JobSpec(name="j", type="shell", command="true", every_seconds=1, nodes=["hostA"])
+    sched.load_config_jobs(jobs=[job], hostname="hostA", host_aliases={"hostA"}, state_root=tmp_path)
+    from skcapstone.scheduler_runner import JobResult
+
+    def _run(j):
+        fired.append(j.name)
+        done.set()
+        return JobResult(ok=True)
+
+    sched._job_runner.run = _run  # type: ignore
+    sched.tick_config_jobs(now=datetime(2026, 6, 8, 12, 0, tzinfo=timezone.utc))
+    assert done.wait(2), "job should have run within 2s"
+    assert fired == ["j"]
+
+
+def test_job_not_for_this_host_skipped(tmp_path: Path):
+    sched = TaskScheduler(home=tmp_path, stop_event=threading.Event())
+    fired = []
+    job = JobSpec(name="j", type="shell", command="true", every_seconds=1, nodes=[".41"])
+    sched.load_config_jobs(jobs=[job], hostname="hostB", host_aliases={"hostB"}, state_root=tmp_path)
+    sched._job_runner.run = lambda j: fired.append(j.name)  # type: ignore
+    sched.tick_config_jobs()
+    assert fired == []
+
+
+def test_build_scheduler_loads_jobs_yaml(tmp_path, monkeypatch):
+    cfg_dir = tmp_path / "config"; cfg_dir.mkdir()
+    (cfg_dir / "jobs.yaml").write_text(
+        "jobs:\n  noop:\n    every: 60s\n    type: shell\n    command: 'true'\n    nodes: all\n",
+        encoding="utf-8")
+    from skcapstone.scheduled_tasks import build_scheduler
+    sched = build_scheduler(home=tmp_path, stop_event=threading.Event())
+    assert any(j.name == "noop" for j in sched._config_jobs)
+
+
+def test_tick_does_not_block_on_slow_job(tmp_path):
+    """Verify that tick_config_jobs returns immediately even when a job is slow.
+
+    The job worker runs in a daemon thread; a slow job must not hold up the
+    scheduler tick thread (which also drives heartbeats and built-in tasks).
+    """
+    import time
+    from datetime import datetime, timezone
+
+    sched = TaskScheduler(home=tmp_path, stop_event=threading.Event())
+    job = JobSpec(name="slow", type="shell", command="true", every_seconds=1, nodes=["h"])
+    sched.load_config_jobs(jobs=[job], hostname="h", host_aliases={"h"}, state_root=tmp_path)
+    started = threading.Event()
+    release = threading.Event()
+
+    def slow_run(j):
+        started.set()
+        release.wait(5)
+        from skcapstone.scheduler_runner import JobResult
+        return JobResult(ok=True)
+
+    sched._job_runner.run = slow_run  # type: ignore
+
+    t0 = time.monotonic()
+    sched.tick_config_jobs(now=datetime(2026, 6, 8, 12, 0, tzinfo=timezone.utc))
+    elapsed = time.monotonic() - t0
+
+    assert elapsed < 1.0, f"tick must not block on the job, but took {elapsed:.3f}s"
+    assert started.wait(2), "job worker should have started in background"
+    release.set()