@stylusnexus/work-plan 2026.6.9-1

package/skills/work-plan/tests/test_close_tier.py

@@ -0,0 +1,166 @@
+"""Tests for tier-aware archive display in close command (Phase C)."""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import close
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _shared_track(*, name="auth-flow", repo="org/myrepo"):
+    """Return a SimpleNamespace that looks like a shared Track."""
+    return SimpleNamespace(
+        name=name,
+        # Path is under a .work-plan/ dir, NOT under notes_root
+        path=Path(f"/home/user/projects/myrepo/.work-plan/{name}.md"),
+        body="# shared track body",
+        meta={
+            "track": name,
+            "status": "active",
+            "github": {"repo": repo},
+        },
+        has_frontmatter=True,
+        repo=repo,
+        tier="shared",
+    )
+
+
+def _private_track(*, name="alpha", repo="ok/repo"):
+    """Return a SimpleNamespace for a private (notes_root) Track."""
+    return SimpleNamespace(
+        name=name,
+        path=Path(f"/tmp/fake-notes/ok/{name}.md"),
+        body="# private track body",
+        meta={
+            "track": name,
+            "status": "active",
+            "github": {"repo": repo},
+        },
+        has_frontmatter=True,
+        repo=repo,
+        tier="private",
+    )
+
+
+def _drive(args, track, notes_root="/tmp/fake-notes", vis="PRIVATE"):
+    cfg = {
+        "notes_root": notes_root,
+        "repos": {"ok": {"github": "ok/repo"}, "myrepo": {"github": "org/myrepo"}},
+    }
+    with patch("commands.close.load_config", return_value=cfg), \
+         patch("commands.close.discover_tracks", return_value=[track]), \
+         patch("commands.close.find_track_by_name", return_value=track), \
+         patch("lib.write_guard.repo_visibility", return_value=vis), \
+         patch("commands.close.write_file") as mw, \
+         patch("commands.close.shutil") as ms, \
+         patch("pathlib.Path.mkdir"):
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = close.run(args)
+    return rc, mw, ms, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+class CloseTierTest(unittest.TestCase):
+
+    def test_shared_track_shipped_does_not_crash_on_relative_to(self):
+        """close on a shared track: archive is outside notes_root —
+        should NOT raise ValueError, falls back to absolute path display."""
+        track = _shared_track()
+        rc, mw, ms, out = _drive(
+            ["auth-flow", "--state=shipped"],
+            track=track,
+            notes_root="/tmp/fake-notes",
+            vis="PRIVATE",
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        ms.move.assert_called_once()
+        # Output should contain the track name and end state
+        self.assertIn("auth-flow", out)
+        self.assertIn("shipped", out)
+
+    def test_shared_track_shipped_prints_commit_hint(self):
+        """close on a shared track → output includes commit+push hint."""
+        track = _shared_track()
+        rc, mw, ms, out = _drive(
+            ["auth-flow", "--state=shipped"],
+            track=track,
+            notes_root="/tmp/fake-notes",
+            vis="PRIVATE",
+        )
+        self.assertEqual(rc, 0)
+        self.assertIn("shared track", out)
+        self.assertIn("commit + push", out)
+
+    def test_private_track_shipped_no_commit_hint(self):
+        """close on a private track → no commit+push hint in output."""
+        track = _private_track()
+        rc, mw, ms, out = _drive(
+            ["alpha", "--state=shipped"],
+            track=track,
+            notes_root="/tmp/fake-notes",
+            vis="PRIVATE",
+        )
+        self.assertEqual(rc, 0)
+        self.assertNotIn("commit + push", out)
+
+    def test_shared_track_abandoned_prints_commit_hint(self):
+        """close --state=abandoned on a shared track → commit+push hint."""
+        track = _shared_track(name="old-feature")
+        rc, mw, ms, out = _drive(
+            ["old-feature", "--state=abandoned"],
+            track=track,
+            notes_root="/tmp/fake-notes",
+            vis="PRIVATE",
+        )
+        self.assertEqual(rc, 0)
+        self.assertIn("shared track", out)
+        self.assertIn("commit + push", out)
+
+    def test_shared_track_parked_no_move_no_hint(self):
+        """close --state=parked on a shared track → parked (no move),
+        no commit+push hint (parked stays in place, returns early)."""
+        track = _shared_track()
+        rc, mw, ms, out = _drive(
+            ["auth-flow", "--state=parked"],
+            track=track,
+            notes_root="/tmp/fake-notes",
+            vis="PRIVATE",
+        )
+        self.assertEqual(rc, 0)
+        ms.move.assert_not_called()
+        # The commit hint is only printed after a move (archive operation)
+        self.assertNotIn("commit + push", out)
+
+    def test_private_track_shipped_display_uses_relative_path(self):
+        """Private track close shows path relative to notes_root (existing behaviour)."""
+        track = _private_track()
+        rc, mw, ms, out = _drive(
+            ["alpha", "--state=shipped"],
+            track=track,
+            notes_root="/tmp/fake-notes",
+            vis="PRIVATE",
+        )
+        self.assertEqual(rc, 0)
+        # Should not contain the absolute prefix for private tracks
+        # (it will contain 'ok/archive/shipped/alpha.md' or similar)
+        self.assertIn("shipped", out)
+        self.assertIn("alpha", out)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_closure.py

@@ -0,0 +1,51 @@
+"""Tests for closure detection."""
+import unittest
+import sys
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.closure import is_closure_ready, ClosureSignals
+
+
+class ClosureReadyTest(unittest.TestCase):
+    def test_all_signals_green(self):
+        signals = ClosureSignals(
+            all_issues_closed=True,
+            all_branches_done=True,
+            next_up_empty=True,
+            cold_14d=True,
+            no_recent_related_issues=True,
+        )
+        ready, reasons = is_closure_ready(signals)
+        self.assertTrue(ready)
+        self.assertEqual(reasons, [])
+
+    def test_open_issue_blocks_closure(self):
+        signals = ClosureSignals(
+            all_issues_closed=False,
+            all_branches_done=True,
+            next_up_empty=True,
+            cold_14d=True,
+            no_recent_related_issues=True,
+        )
+        ready, reasons = is_closure_ready(signals)
+        self.assertFalse(ready)
+        self.assertIn("open issues remain", " ".join(reasons))
+
+    def test_partial_signals_returns_count(self):
+        signals = ClosureSignals(
+            all_issues_closed=True,
+            all_branches_done=True,
+            next_up_empty=False,
+            cold_14d=False,
+            no_recent_related_issues=True,
+        )
+        ready, reasons = is_closure_ready(signals)
+        self.assertFalse(ready)
+        self.assertEqual(len(reasons), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_config.py

@@ -0,0 +1,85 @@
+"""Tests for config loader."""
+import unittest
+import tempfile
+import sys
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.config import (
+    load_config, ConfigError,
+    resolve_github_for_folder, resolve_local_path_for_folder,
+)
+
+
+class LoadConfigTest(unittest.TestCase):
+    def _write(self, d, content):
+        path = Path(d) / "config.yml"
+        path.write_text(content, encoding="utf-8")
+        return path
+
+    def test_load_dict_shape(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = self._write(d, (
+                "notes_root: /tmp/notes\n"
+                "repos:\n"
+                "  critforge:\n"
+                "    github: stylusnexus/CritForge\n"
+                "    local: /Applications/Development/Projects/CritForge\n"
+            ))
+            cfg = load_config(path)
+            self.assertEqual(cfg["notes_root"], "/tmp/notes")
+            self.assertEqual(cfg["repos"]["critforge"]["github"], "stylusnexus/CritForge")
+            self.assertEqual(cfg["repos"]["critforge"]["local"],
+                             "/Applications/Development/Projects/CritForge")
+
+    def test_load_string_shape_normalizes_to_dict(self):
+        # Backward-friendly: bare string is treated as github-only, no local
+        with tempfile.TemporaryDirectory() as d:
+            path = self._write(d, (
+                "notes_root: /tmp/notes\n"
+                "repos:\n"
+                "  critforge: stylusnexus/CritForge\n"
+            ))
+            cfg = load_config(path)
+            self.assertEqual(cfg["repos"]["critforge"]["github"], "stylusnexus/CritForge")
+            self.assertIsNone(cfg["repos"]["critforge"]["local"])
+
+    def test_missing_file_self_seeds(self):
+        # No install hook exists for plugin installs, so a missing config is
+        # seeded on first load rather than raising.
+        with tempfile.TemporaryDirectory() as d:
+            path = Path(d) / "work-plan" / "config.yml"
+            cfg = load_config(path, notes_root=Path(d) / "notes")
+            self.assertTrue(path.is_file())
+            self.assertEqual(cfg["repos"], {})
+            self.assertIn("notes_root", cfg)
+
+    def test_missing_notes_root_raises(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = self._write(d, "repos:\n  foo: bar/baz\n")
+            with self.assertRaises(ConfigError) as ctx:
+                load_config(path)
+            self.assertIn("notes_root", str(ctx.exception))
+
+
+class ResolveTest(unittest.TestCase):
+    def setUp(self):
+        self.cfg = {
+            "repos": {
+                "critforge": {"github": "stylusnexus/CritForge", "local": "/path/to/critforge"},
+            },
+        }
+
+    def test_resolve_github(self):
+        self.assertEqual(resolve_github_for_folder("critforge", self.cfg), "stylusnexus/CritForge")
+        self.assertIsNone(resolve_github_for_folder("unknown", self.cfg))
+
+    def test_resolve_local_path(self):
+        self.assertEqual(resolve_local_path_for_folder("critforge", self.cfg), Path("/path/to/critforge"))
+        self.assertIsNone(resolve_local_path_for_folder("unknown", self.cfg))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_config_seed.py

@@ -0,0 +1,41 @@
+"""Lazy config seeding — plugin installs run no install hook (issue: org-sharing).
+
+The CLI must create a usable config.yml on first run when one is absent, at a
+stable absolute path, idempotently. Offline; uses temp dirs (never the real HOME).
+"""
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.config import load_config, ensure_config
+
+
+class EnsureConfigTest(unittest.TestCase):
+    def test_load_config_seeds_when_missing(self):
+        with tempfile.TemporaryDirectory() as d:
+            cfg_path = Path(d) / "work-plan" / "config.yml"
+            notes = Path(d) / "notes"
+            cfg = load_config(cfg_path, notes_root=notes)
+            self.assertTrue(cfg_path.is_file(), "config.yml should be seeded")
+            self.assertEqual(cfg["repos"], {})
+            # notes_root is an ABSOLUTE path (no literal ~), and the dir exists.
+            self.assertEqual(cfg["notes_root"], str(notes))
+            self.assertFalse(cfg["notes_root"].startswith("~"))
+            self.assertTrue(notes.is_dir())
+
+    def test_ensure_config_idempotent(self):
+        with tempfile.TemporaryDirectory() as d:
+            cfg_path = Path(d) / "work-plan" / "config.yml"
+            notes = Path(d) / "notes"
+            self.assertTrue(ensure_config(cfg_path, notes_root=notes))
+            before = cfg_path.read_bytes()
+            self.assertFalse(ensure_config(cfg_path, notes_root=notes))
+            self.assertEqual(cfg_path.read_bytes(), before)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_config_shared.py

@@ -0,0 +1,57 @@
+"""Tests for is_valid_git_repo() in lib/config."""
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.config import is_valid_git_repo
+
+
+class IsValidGitRepoTest(unittest.TestCase):
+    def test_returns_true_for_dir_with_dot_git(self):
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            (base / ".git").mkdir()
+            self.assertTrue(is_valid_git_repo(base))
+
+    def test_dot_git_can_be_a_file_worktree(self):
+        """Worktrees have .git as a file, not a dir — still truthy via .exists()."""
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            (base / ".git").write_text("gitdir: ../.git/worktrees/foo\n", encoding="utf-8")
+            self.assertTrue(is_valid_git_repo(base))
+
+    def test_returns_false_for_nonexistent_path(self):
+        self.assertFalse(is_valid_git_repo(Path("/tmp/nonexistent_12345")))
+
+    def test_returns_false_for_file(self):
+        with tempfile.TemporaryDirectory() as d:
+            f = Path(d) / "not_a_dir.txt"
+            f.write_text("hello", encoding="utf-8")
+            self.assertFalse(is_valid_git_repo(f))
+
+    def test_returns_false_for_dir_without_dot_git(self):
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d) / "plain_dir"
+            base.mkdir()
+            self.assertFalse(is_valid_git_repo(base))
+
+    def test_accepts_path_object(self):
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            (base / ".git").mkdir()
+            self.assertTrue(is_valid_git_repo(Path(d)))
+
+    def test_accepts_string_path(self):
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            (base / ".git").mkdir()
+            # is_valid_git_repo coerces to Path internally
+            self.assertTrue(is_valid_git_repo(d))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_coverage.py

@@ -0,0 +1,192 @@
+"""Tests for the coverage subcommand."""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import coverage
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_cfg(repos=None):
+    if repos is None:
+        repos = {"myrepo": {"github": "org/myrepo", "local": "/tmp/myrepo"}}
+    return {"notes_root": "/tmp/notes", "repos": repos}
+
+
+def _make_track(name, repo, issue_nums, status="active"):
+    return SimpleNamespace(
+        name=name,
+        repo=repo,
+        has_frontmatter=True,
+        meta={"status": status, "github": {"repo": repo, "issues": issue_nums}},
+    )
+
+
+def _run(args, *, cfg, tracks, open_issues_by_repo):
+    """Run coverage.run with mocked config, tracks, and gh calls."""
+    def _mock_open_issues(repo, limit=1000):
+        return open_issues_by_repo.get(repo, [])
+
+    buf = io.StringIO()
+    with patch("commands.coverage.load_config", return_value=cfg), \
+         patch("commands.coverage.discover_tracks", return_value=tracks), \
+         patch("commands.coverage.fetch_open_issues", side_effect=_mock_open_issues), \
+         redirect_stdout(buf):
+        rc = coverage.run(args)
+    return rc, buf.getvalue()
+
+
+def _issues(*numbers):
+    return [{"number": n, "title": f"Issue {n}", "state": "OPEN"} for n in numbers]
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+class CoverageBasicTest(unittest.TestCase):
+
+    def test_all_tracked_reports_full_coverage(self):
+        cfg = _make_cfg()
+        tracks = [_make_track("t1", "org/myrepo", [1, 2, 3])]
+        rc, out = _run([], cfg=cfg, tracks=tracks,
+                       open_issues_by_repo={"org/myrepo": _issues(1, 2, 3)})
+        self.assertEqual(rc, 0)
+        self.assertIn("full coverage", out)
+        self.assertIn("Untracked:    0", out)
+
+    def test_partial_coverage_shows_count_and_percent(self):
+        cfg = _make_cfg()
+        tracks = [_make_track("t1", "org/myrepo", [1, 2])]
+        rc, out = _run([], cfg=cfg, tracks=tracks,
+                       open_issues_by_repo={"org/myrepo": _issues(1, 2, 3, 4)})
+        self.assertEqual(rc, 0)
+        self.assertIn("Untracked:    2", out)
+        self.assertIn("50%", out)
+
+    def test_no_open_issues_reports_zero(self):
+        cfg = _make_cfg()
+        tracks = [_make_track("t1", "org/myrepo", [1])]
+        rc, out = _run([], cfg=cfg, tracks=tracks,
+                       open_issues_by_repo={"org/myrepo": []})
+        self.assertEqual(rc, 0)
+        self.assertIn("No open issues", out)
+
+    def test_no_tracks_everything_untracked(self):
+        cfg = _make_cfg()
+        rc, out = _run([], cfg=cfg, tracks=[],
+                       open_issues_by_repo={"org/myrepo": _issues(1, 2, 3)})
+        self.assertEqual(rc, 0)
+        self.assertIn("Untracked:    3", out)
+        self.assertIn("100%", out)
+
+
+class CoverageRepoFlagTest(unittest.TestCase):
+
+    def test_repo_flag_scopes_to_one_repo(self):
+        cfg = _make_cfg(repos={
+            "repoA": {"github": "org/repoA"},
+            "repoB": {"github": "org/repoB"},
+        })
+        tracks = [
+            _make_track("tA", "org/repoA", [1]),
+            _make_track("tB", "org/repoB", [2]),
+        ]
+        rc, out = _run(["--repo=repoA"], cfg=cfg, tracks=tracks,
+                       open_issues_by_repo={"org/repoA": _issues(1, 99),
+                                            "org/repoB": _issues(2, 98)})
+        self.assertEqual(rc, 0)
+        self.assertIn("repoA", out)
+        self.assertNotIn("repoB", out)
+
+    def test_unknown_repo_flag_returns_error(self):
+        cfg = _make_cfg()
+        rc, out = _run(["--repo=nope"], cfg=cfg, tracks=[],
+                       open_issues_by_repo={})
+        self.assertEqual(rc, 1)
+        self.assertIn("ERROR", out)
+
+
+class CoverageListFlagTest(unittest.TestCase):
+
+    def test_list_flag_shows_issue_titles(self):
+        cfg = _make_cfg()
+        tracks = [_make_track("t1", "org/myrepo", [1])]
+        rc, out = _run(["--list"], cfg=cfg, tracks=tracks,
+                       open_issues_by_repo={"org/myrepo": _issues(1, 2, 3)})
+        self.assertEqual(rc, 0)
+        self.assertIn("Issue 2", out)
+        self.assertIn("Issue 3", out)
+
+    def test_list_flag_truncates_at_default_20(self):
+        cfg = _make_cfg()
+        open_nums = list(range(1, 26))  # 25 issues, none tracked
+        rc, out = _run(["--list"], cfg=cfg, tracks=[],
+                       open_issues_by_repo={"org/myrepo": _issues(*open_nums)})
+        self.assertEqual(rc, 0)
+        self.assertIn("and 5 more", out)
+
+    def test_limit_flag_overrides_default(self):
+        cfg = _make_cfg()
+        open_nums = list(range(1, 11))  # 10 issues
+        rc, out = _run(["--list", "--limit=3"], cfg=cfg, tracks=[],
+                       open_issues_by_repo={"org/myrepo": _issues(*open_nums)})
+        self.assertEqual(rc, 0)
+        self.assertIn("and 7 more", out)
+
+    def test_without_list_flag_no_titles_shown(self):
+        cfg = _make_cfg()
+        tracks = [_make_track("t1", "org/myrepo", [1])]
+        rc, out = _run([], cfg=cfg, tracks=tracks,
+                       open_issues_by_repo={"org/myrepo": _issues(1, 2, 3)})
+        self.assertEqual(rc, 0)
+        self.assertNotIn("Issue 2", out)
+        self.assertNotIn("Issue 3", out)
+        self.assertIn("--list", out)  # hint printed
+
+    def test_exact_limit_no_remainder_line(self):
+        cfg = _make_cfg()
+        rc, out = _run(["--list", "--limit=3"], cfg=cfg, tracks=[],
+                       open_issues_by_repo={"org/myrepo": _issues(1, 2, 3)})
+        self.assertEqual(rc, 0)
+        self.assertNotIn("more", out)
+
+
+class CoverageMultiRepoTest(unittest.TestCase):
+
+    def test_all_repos_reported_when_no_repo_flag(self):
+        cfg = _make_cfg(repos={
+            "repoA": {"github": "org/repoA"},
+            "repoB": {"github": "org/repoB"},
+        })
+        tracks = [_make_track("tA", "org/repoA", [1])]
+        rc, out = _run([], cfg=cfg, tracks=tracks,
+                       open_issues_by_repo={"org/repoA": _issues(1, 2),
+                                            "org/repoB": _issues(3, 4)})
+        self.assertEqual(rc, 0)
+        self.assertIn("repoA", out)
+        self.assertIn("repoB", out)
+
+    def test_tracks_without_frontmatter_ignored(self):
+        cfg = _make_cfg()
+        no_fm = SimpleNamespace(name="orphan", repo="org/myrepo",
+                                has_frontmatter=False, meta={})
+        rc, out = _run([], cfg=cfg, tracks=[no_fm],
+                       open_issues_by_repo={"org/myrepo": _issues(1, 2)})
+        self.assertEqual(rc, 0)
+        # Both issues should be untracked since the track has no frontmatter
+        self.assertIn("Untracked:    2", out)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_doc_discovery.py

@@ -0,0 +1,51 @@
+"""Tests for doc discovery + kind classification."""
+import unittest
+import sys
+import tempfile
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.doc_discovery import classify_kind, discover_docs, Doc
+
+
+class ClassifyKindTest(unittest.TestCase):
+    def test_superpowers_plan(self):
+        self.assertEqual(classify_kind("docs/superpowers/plans/2026-03-16-x.md"), "plan")
+
+    def test_superpowers_spec(self):
+        self.assertEqual(classify_kind("docs/superpowers/specs/2026-03-16-x-design.md"), "spec")
+
+    def test_design_suffix_is_spec(self):
+        self.assertEqual(classify_kind("docs/plans/2026-02-17-foo-design.md"), "spec")
+
+    def test_plain_docs_plan(self):
+        self.assertEqual(classify_kind("docs/plans/2026-02-17-foo.md"), "plan")
+
+    def test_other_is_adhoc(self):
+        self.assertEqual(classify_kind("notes/random.md"), "adhoc")
+
+
+class DiscoverDocsTest(unittest.TestCase):
+    def test_finds_default_globs_and_dedupes(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = Path(d)
+            (root / "docs/superpowers/plans").mkdir(parents=True)
+            (root / "docs/plans").mkdir(parents=True)
+            (root / "docs/superpowers/plans/2026-03-16-a.md").write_text("x")
+            (root / "docs/plans/2026-02-17-b-design.md").write_text("x")
+            (root / "docs/plans/README.txt").write_text("ignore")  # not .md
+            docs = discover_docs(root)
+            rels = sorted(x.rel for x in docs)
+            self.assertEqual(rels, [
+                "docs/plans/2026-02-17-b-design.md",
+                "docs/superpowers/plans/2026-03-16-a.md",
+            ])
+            kinds = {x.rel: x.kind for x in docs}
+            self.assertEqual(kinds["docs/superpowers/plans/2026-03-16-a.md"], "plan")
+            self.assertEqual(kinds["docs/plans/2026-02-17-b-design.md"], "spec")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_drift.py

@@ -0,0 +1,38 @@
+"""Tests for drift detection."""
+import unittest
+import sys
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.drift import detect_drift
+
+
+class DetectDriftTest(unittest.TestCase):
+    def test_no_drift_when_table_matches(self):
+        body = (
+            "| # | Title | Status |\n"
+            "|---|---|---|\n"
+            "| #1 | foo | ✅ Shipped |\n"
+        )
+        github_issues = [{"number": 1, "state": "CLOSED"}]
+        self.assertEqual(detect_drift(body, github_issues), [])
+
+    def test_drift_when_open_in_md_closed_in_github(self):
+        body = (
+            "| # | Title | Status |\n"
+            "|---|---|---|\n"
+            "| #1 | foo | 🔲 Open |\n"
+        )
+        github_issues = [{"number": 1, "state": "CLOSED"}]
+        drift = detect_drift(body, github_issues)
+        self.assertEqual(len(drift), 1)
+        self.assertEqual(drift[0]["issue"], 1)
+
+    def test_no_table_returns_empty(self):
+        self.assertEqual(detect_drift("# No table\n", [{"number": 1, "state": "CLOSED"}]), [])
+
+
+if __name__ == "__main__":
+    unittest.main()