feat(skills)!: kvb-dream processes everything, with kvb-optimize, cleanups and one reminder

kvb-skill-dream becomes the uncategorized collector kvb-dream. It reads the last 24 hours of every repository and session the agent touched, writes each finding into the memory of its own project, hands its findings to the new kvb-optimize (skill-cleanup, transcend, skill-auto, skill-tune, skill-compile, skill-essence, code-refactor, code-tune, think-gaps, one round of questions) and then runs kvb-cleanup and kvb-git-branch-gc. The separate kvb-skill-tune reminder is gone: one reminder reads the session id from the hook payload and hints each agent at most every twelve hours, and the global install enables kvb-dream-notify.timer, a systemd user timer that recommends /kvb-dream in a GNOME notification daily at 17:00 local time and catches up once after a missed run. enable-plugins.js retires the tune reminder hooks and repoints every earlier dream hook path. Operator order 2026-11-03; three descriptions trimmed for the listing budget.

BREAKING CHANGE: /kvb-skill-dream is now /kvb-dream; kvb-skill-tune no longer has its own reminder hook.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tests/test_autotune.py

@@ -1,33 +1,12 @@
-"""Validate the kvb-skill-tune reminder hook and its settings registration."""
+"""Validate the kvb-skill-tune skill text and its persistence targets."""
 
 from __future__ import annotations
 
-import json
-import shutil
-import subprocess
-import tempfile
 import unittest
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
 SKILL = REPO_ROOT / "skills" / "kvb-skill-tune" / "SKILL.md"
-HOOK = REPO_ROOT / "skills" / "kvb-skill-tune" / "hooks" / "reminder.sh"
-PATCHER = REPO_ROOT / "scripts" / "enable-plugins.js"
-
-
-def _run_hook(stamp: Path, interval: str = "3600") -> subprocess.CompletedProcess:
-    return subprocess.run(
-        ["bash", str(HOOK)],
-        capture_output=True,
-        text=True,
-        check=True,
-        env={
-            "PATH": "/usr/bin:/bin",
-            "HOME": str(stamp.parent),
-            "AUTOTUNE_STAMP": str(stamp),
-            "AUTOTUNE_INTERVAL_SECONDS": interval,
-        },
-    )
 
 
 class TestAutotuneSkill(unittest.TestCase):
@@ -36,6 +15,9 @@ class TestAutotuneSkill(unittest.TestCase):
         self.assertIn("name: kvb-skill-tune", text)
         self.assertIn("multiSelect: false", text)
 
+    def test_skill_has_no_own_reminder_hook(self):
+        self.assertFalse((SKILL.parent / "hooks").exists())
+
 
 class TestSkillPersistence(unittest.TestCase):
     """Both skill writers must persist to the skills repository AND the live dirs."""
@@ -58,66 +40,5 @@ class TestSkillPersistence(unittest.TestCase):
             self.assertIn(target, text)
 
 
-class TestAutotuneHook(unittest.TestCase):
-    def setUp(self):
-        self.tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self.tmp.cleanup)
-        self.stamp = Path(self.tmp.name) / ".claude" / ".autotune-stamp"
-
-    def test_first_run_hints_and_stamps(self):
-        result = _run_hook(self.stamp)
-        self.assertIn("/kvb-skill-tune", result.stdout)
-        self.assertTrue(self.stamp.is_file())
-
-    def test_second_run_is_silent_within_interval(self):
-        _run_hook(self.stamp)
-        self.assertEqual(_run_hook(self.stamp).stdout, "")
-
-    def test_hint_returns_after_the_interval(self):
-        _run_hook(self.stamp)
-        self.assertIn("/kvb-skill-tune", _run_hook(self.stamp, interval="0").stdout)
-
-    def test_corrupt_stamp_does_not_crash(self):
-        self.stamp.parent.mkdir(parents=True, exist_ok=True)
-        self.stamp.write_text("not-a-timestamp\n", encoding="utf-8")
-        self.assertIn("/kvb-skill-tune", _run_hook(self.stamp).stdout)
-
-
-@unittest.skipUnless(shutil.which("node"), "node not installed")
-class TestSettingsRegistration(unittest.TestCase):
-    def setUp(self):
-        self.tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self.tmp.cleanup)
-        self.settings = Path(self.tmp.name) / "settings.json"
-
-    def _patch(self) -> dict:
-        subprocess.run(
-            ["node", str(PATCHER), str(self.settings)], check=True, capture_output=True
-        )
-        return json.loads(self.settings.read_text(encoding="utf-8"))
-
-    def test_hook_registered_once(self):
-        self._patch()
-        data = self._patch()
-        entries = json.dumps(data["hooks"]["UserPromptSubmit"])
-        self.assertEqual(entries.count("kvb-skill-tune/hooks/reminder.sh"), 1)
-
-    def test_existing_hooks_preserved(self):
-        self.settings.write_text(
-            json.dumps(
-                {
-                    "hooks": {
-                        "UserPromptSubmit": [
-                            {"hooks": [{"type": "command", "command": "true"}]}
-                        ]
-                    }
-                }
-            ),
-            encoding="utf-8",
-        )
-        data = self._patch()
-        self.assertEqual(len(data["hooks"]["UserPromptSubmit"]), 4)
-
-
 if __name__ == "__main__":
     unittest.main()

tests/test_dream.py

@@ -1,4 +1,4 @@
-"""Validate the dream reminder hook and its settings registration."""
+"""Validate the kvb-dream reminder, its GNOME notification, timer and settings registration."""
 
 from __future__ import annotations
 
@@ -10,101 +10,124 @@ import unittest
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
-SKILL = REPO_ROOT / "skills" / "kvb-skill-dream" / "SKILL.md"
-HOOK = REPO_ROOT / "skills" / "kvb-skill-dream" / "hooks" / "reminder.sh"
+DREAM = REPO_ROOT / "skills" / "kvb-dream"
+SKILL = DREAM / "SKILL.md"
+HOOK = DREAM / "hooks" / "reminder.sh"
+NOTIFY = DREAM / "hooks" / "notify.sh"
+TIMER = DREAM / "systemd" / "kvb-dream-notify.timer"
+SERVICE = DREAM / "systemd" / "kvb-dream-notify.service"
 PATCHER = REPO_ROOT / "scripts" / "enable-plugins.js"
 
 
-def _run_hook(
-    cwd: Path, stamp: Path | None = None, interval: str = "43200"
-) -> subprocess.CompletedProcess:
-    env = {
-        "PATH": "/usr/bin:/bin",
-        "HOME": str(cwd),
-        "DREAM_INTERVAL_SECONDS": interval,
-    }
-    if stamp is not None:
-        env["DREAM_STAMP"] = str(stamp)
-    return subprocess.run(
-        ["bash", str(HOOK)],
-        capture_output=True,
-        text=True,
-        check=True,
-        cwd=str(cwd),
-        env=env,
-    )
-
-
 class TestDreamSkill(unittest.TestCase):
-    def test_skill_is_trigger_only(self):
+    def test_skill_runs_optimize_and_the_cleanups(self):
         text = SKILL.read_text(encoding="utf-8")
-        self.assertIn("name: kvb-skill-dream", text)
+        self.assertIn("name: kvb-dream", text)
         self.assertIn("multiSelect: false", text)
+        for skill in ("`kvb-optimize`", "`kvb-cleanup`", "`kvb-git-branch-gc`"):
+            self.assertIn(skill, text)
+
+    def test_optimize_covers_every_optimization_skill(self):
+        text = (REPO_ROOT / "skills" / "kvb-optimize" / "SKILL.md").read_text(encoding="utf-8")
+        for skill in (
+            "kvb-skill-cleanup",
+            "kvb-transcend",
+            "kvb-skill-auto",
+            "kvb-skill-tune",
+            "kvb-skill-compile",
+            "kvb-skill-essence",
+            "kvb-code-refactor",
+            "kvb-code-tune",
+            "kvb-think-gaps",
+        ):
+            self.assertIn(f"`{skill}`", text)
 
 
 class TestDreamHook(unittest.TestCase):
     def setUp(self):
         self.tmp = tempfile.TemporaryDirectory()
         self.addCleanup(self.tmp.cleanup)
-        self.cwd = Path(self.tmp.name)
-        self.stamp = self.cwd / ".claude" / ".dream-stamp"
+        self.stamps = Path(self.tmp.name) / "stamps"
 
-    def test_first_run_hints_and_stamps(self):
-        result = _run_hook(self.cwd, self.stamp)
-        self.assertIn("/kvb-skill-dream", result.stdout)
-        self.assertTrue(self.stamp.is_file())
+    def _run(self, payload: str, interval: str = "43200") -> str:
+        return subprocess.run(
+            ["bash", str(HOOK)],
+            input=payload,
+            capture_output=True,
+            text=True,
+            check=True,
+            env={
+                "PATH": "/usr/bin:/bin",
+                "HOME": self.tmp.name,
+                "DREAM_STAMP_DIR": str(self.stamps),
+                "DREAM_INTERVAL_SECONDS": interval,
+            },
+        ).stdout
 
-    def test_second_run_is_silent_within_interval(self):
-        _run_hook(self.cwd, self.stamp)
-        self.assertEqual(_run_hook(self.cwd, self.stamp).stdout, "")
+    @staticmethod
+    def _session(sid: str) -> str:
+        return json.dumps({"session_id": sid, "prompt": "hi"})
+
+    def test_first_run_hints_and_stamps_the_session(self):
+        self.assertIn("/kvb-dream", self._run(self._session("a1")))
+        self.assertTrue((self.stamps / "a1").is_file())
+
+    def test_second_run_of_the_same_agent_is_silent(self):
+        self._run(self._session("a1"))
+        self.assertEqual(self._run(self._session("a1")), "")
+
+    def test_every_agent_gets_its_own_hint(self):
+        self._run(self._session("a1"))
+        self.assertIn("/kvb-dream", self._run(self._session("b2")))
 
     def test_hint_returns_after_the_interval(self):
-        _run_hook(self.cwd, self.stamp)
-        self.assertIn("/kvb-skill-dream", _run_hook(self.cwd, self.stamp, interval="0").stdout)
+        self._run(self._session("a1"))
+        self.assertIn("/kvb-dream", self._run(self._session("a1"), interval="0"))
 
     def test_corrupt_stamp_does_not_crash(self):
-        self.stamp.parent.mkdir(parents=True, exist_ok=True)
-        self.stamp.write_text("not-a-timestamp\n", encoding="utf-8")
-        self.assertIn("/kvb-skill-dream", _run_hook(self.cwd, self.stamp).stdout)
+        self.stamps.mkdir()
+        (self.stamps / "a1").write_text("not-a-timestamp\n", encoding="utf-8")
+        self.assertIn("/kvb-dream", self._run(self._session("a1")))
 
-    def test_outside_a_repository_it_stays_silent(self):
-        self.assertEqual(_run_hook(self.cwd).stdout, "")
+    def test_without_a_valid_session_it_stays_silent(self):
+        for payload in ("", "not json", self._session(""), self._session("../escape")):
+            with self.subTest(payload=payload):
+                self.assertEqual(self._run(payload), "")
+        self.assertFalse(self.stamps.exists())
 
-    @unittest.skipUnless(shutil.which("git"), "git not installed")
-    def test_stamp_is_per_repository(self):
-        for name in ("one", "two"):
-            repo = self.cwd / name
-            repo.mkdir()
-            subprocess.run(
-                ["git", "init", "-q", str(repo)], check=True, capture_output=True
-            )
-            self.assertIn("/kvb-skill-dream", _run_hook(repo).stdout)
-            self.assertTrue((repo / ".git" / ".dream-stamp").is_file())
-            self.assertEqual(_run_hook(repo).stdout, "")
 
-    @unittest.skipUnless(shutil.which("git"), "git not installed")
-    def test_linked_worktrees_share_the_stamp(self):
-        repo = self.cwd / "main"
-        tree = self.cwd / "tree"
-        env = {
-            "PATH": "/usr/bin:/bin",
-            "HOME": str(self.cwd),
-            "GIT_AUTHOR_NAME": "t",
-            "GIT_AUTHOR_EMAIL": "t@t",
-            "GIT_COMMITTER_NAME": "t",
-            "GIT_COMMITTER_EMAIL": "t@t",
-        }
-        repo.mkdir()
-        for args in (
-            ["init", "-q"],
-            ["commit", "-q", "--allow-empty", "-m", "init"],
-            ["worktree", "add", "-q", str(tree)],
-        ):
-            subprocess.run(
-                ["git", *args], check=True, capture_output=True, env=env, cwd=str(repo)
-            )
-        self.assertIn("/kvb-skill-dream", _run_hook(repo).stdout)
-        self.assertEqual(_run_hook(tree).stdout, "")
+class TestDreamNotification(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.bin = Path(self.tmp.name) / "bin"
+        self.bin.mkdir()
+        self.calls = Path(self.tmp.name) / "calls"
+        fake = self.bin / "notify-send"
+        fake.write_text(f'#!/bin/sh\nprintf "%s\\n" "$@" >> "{self.calls}"\n', encoding="utf-8")
+        fake.chmod(0o755)
+
+    def _run(self, desktop: str) -> None:
+        subprocess.run(
+            ["bash", str(NOTIFY)],
+            capture_output=True,
+            check=True,
+            env={"PATH": f"{self.bin}:/usr/bin:/bin", "XDG_CURRENT_DESKTOP": desktop},
+        )
+
+    def test_gnome_session_gets_the_popup(self):
+        self._run("ubuntu:GNOME")
+        self.assertIn("/kvb-dream", self.calls.read_text(encoding="utf-8"))
+
+    def test_other_desktops_stay_silent(self):
+        self._run("KDE")
+        self.assertFalse(self.calls.exists())
+
+    def test_timer_fires_daily_at_five_pm_and_catches_up(self):
+        timer = TIMER.read_text(encoding="utf-8")
+        self.assertIn("OnCalendar=*-*-* 17:00:00", timer)
+        self.assertIn("Persistent=true", timer)
+        self.assertIn("kvb-dream/hooks/notify.sh", SERVICE.read_text(encoding="utf-8"))
 
 
 @unittest.skipUnless(shutil.which("node"), "node not installed")
@@ -124,8 +147,8 @@ class TestSettingsRegistration(unittest.TestCase):
         self._patch()
         data = self._patch()
         entries = json.dumps(data["hooks"]["UserPromptSubmit"])
-        self.assertEqual(entries.count("kvb-skill-dream/hooks/reminder.sh"), 1)
-        self.assertEqual(entries.count("kvb-skill-tune/hooks/reminder.sh"), 1)
+        self.assertEqual(entries.count("kvb-dream/hooks/reminder.sh"), 1)
+        self.assertNotIn("tune/hooks/reminder.sh", entries)
         gate = json.dumps(data["hooks"]["PreToolUse"])
         self.assertEqual(gate.count("kvb-org-organize/scripts/council.py"), 1)
         self.assertEqual(gate.count("kvb-org-organize/scripts/watch.py"), 1)
@@ -135,7 +158,15 @@ class TestSettingsRegistration(unittest.TestCase):
         self.assertEqual(gate.count("kvb-org-perform/scripts/log.py"), 1)
         self.assertEqual(post.count("kvb-org-perform/scripts/log.py"), 1)
 
-    def test_hooks_of_renamed_skills_are_repointed(self):
+    def test_existing_hooks_preserved(self):
+        self.settings.write_text(
+            json.dumps({"hooks": {"UserPromptSubmit": [{"hooks": [{"type": "command", "command": "true"}]}]}}),
+            encoding="utf-8",
+        )
+        data = self._patch()
+        self.assertIn('"true"', json.dumps(data["hooks"]["UserPromptSubmit"]))
+
+    def test_tune_reminders_retire_and_dream_reminders_are_repointed(self):
         base = Path(self.tmp.name) / "skills"
 
         def hook(command):
@@ -147,7 +178,8 @@ class TestSettingsRegistration(unittest.TestCase):
                     "hooks": {
                         "UserPromptSubmit": [
                             hook(f'bash "{base}/autotune/hooks/reminder.sh"'),
-                            hook(f'bash "{base}/kvb-skills-dream/hooks/reminder.sh"'),
+                            hook(f'bash "{base}/kvb-skill-tune/hooks/reminder.sh"'),
+                            hook(f'bash "{base}/kvb-skill-dream/hooks/reminder.sh"'),
                             hook(f'python3 "{base}/democracy/scripts/watch.py" watch'),
                             hook("echo keep"),
                         ],
@@ -167,12 +199,11 @@ class TestSettingsRegistration(unittest.TestCase):
         )
         data = self._patch()
         text = json.dumps(data["hooks"])
-        for old in ("/autotune/", "/kvb-skills-dream/", "/democracy/", "/subagent-model/"):
+        for old in ("/autotune/", "/kvb-skill-tune/", "/kvb-skill-dream/", "/democracy/", "/subagent-model/"):
             self.assertNotIn(f"skills{old}", text)
         self.assertIn("echo keep", text)
         entries = json.dumps(data["hooks"]["UserPromptSubmit"])
-        self.assertEqual(entries.count("kvb-skill-dream/hooks/reminder.sh"), 1)
-        self.assertEqual(entries.count("kvb-skill-tune/hooks/reminder.sh"), 1)
+        self.assertEqual(entries.count("kvb-dream/hooks/reminder.sh"), 1)
         self.assertEqual(entries.count("kvb-org-organize/scripts/watch.py"), 1)
         gate = json.dumps(data["hooks"]["PreToolUse"])
         self.assertEqual(gate.count("kvb-org-organize/scripts/council.py"), 1)

tests/test_naming.py

@@ -10,7 +10,9 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 SKILLS = REPO_ROOT / "skills"
 README = REPO_ROOT / "README.md"
 CATEGORIES = ("think", "create", "code", "ci", "git", "check", "org", "skill")
-UNCATEGORIZED = frozenset({"kvb-cleanup", "kvb-help", "kvb-transcend"})
+UNCATEGORIZED = frozenset(
+    {"kvb-cleanup", "kvb-dream", "kvb-help", "kvb-optimize", "kvb-transcend"}
+)
 SPEC = re.compile(r"^[a-z0-9]+(-[a-z0-9]+)*$")
 SCHEMA = re.compile(rf"^kvb-(?:{'|'.join(CATEGORIES)})-[a-z0-9]+(?:-[a-z0-9]+)*$")
 NAME_LINE = re.compile(r"^name:\s*(\S+)\s*$", re.MULTILINE)