@stylusnexus/work-plan 2026.6.9 → 2026.6.10

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_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_export.py

@@ -6,10 +6,11 @@ SKILL_ROOT = Path(__file__).resolve().parents[1]; sys.path.insert(0, str(SKILL_R
 from lib.export_model import build_export
 import commands.export as export_cmd
 
-def _track(name, repo, issues, blockers=None, next_up=None, status="active"):
+def _track(name, repo, issues, blockers=None, next_up=None, status="active", depends_on=None):
     return SimpleNamespace(name=name, repo=repo, tier="private",
         meta={"status": status, "launch_priority": "P2", "milestone_alignment": "v1",
               "blockers": blockers or [], "next_up": next_up or [],
+              "depends_on": depends_on or [],
               "github": {"repo": repo, "issues": issues}})
 
 class BuildExportTest(unittest.TestCase):
@@ -29,6 +30,49 @@ class BuildExportTest(unittest.TestCase):
         self.assertEqual(t["issues"][0], {"number": 1, "title": "a", "state": "open", "assignee": "@eve", "milestone": None})
         json.dumps(out)  # must be serializable
 
+class BuildExportNextUpFilterTest(unittest.TestCase):
+    """next_up entries whose issue is closed in the fetched payload are filtered out."""
+
+    def _build(self, next_up_nums, issue_states):
+        """Build export where issues have given states; return the track's next_up."""
+        raw_issues = [
+            {"number": n, "title": f"i{n}", "state": state, "assignees": []}
+            for n, state in issue_states.items()
+        ]
+        tracks = [_track("t1", "o/r", list(issue_states.keys()), next_up=next_up_nums)]
+        out = build_export(tracks, {"t1": raw_issues}, {"o/r": "PRIVATE"}, now="t")
+        return out["tracks"][0]["next_up"]
+
+    def test_closed_next_up_filtered(self):
+        """Closed issue in next_up is removed from the export payload."""
+        result = self._build([95], {95: "CLOSED"})
+        self.assertEqual(result, [])
+
+    def test_open_next_up_kept(self):
+        """Open issue in next_up is kept."""
+        result = self._build([95], {95: "OPEN"})
+        self.assertEqual(result, [95])
+
+    def test_mixed_next_up_only_open_kept(self):
+        """Mixed next_up: closed issue removed, open issue kept."""
+        result = self._build([95, 96], {95: "CLOSED", 96: "OPEN"})
+        self.assertEqual(result, [96])
+
+    def test_next_up_issue_not_in_fetched_payload_kept(self):
+        """If a next_up issue wasn't fetched (e.g. not in the track's issue list),
+        it's preserved rather than silently dropped — we only remove confirmed-closed."""
+        tracks = [_track("t1", "o/r", [95], next_up=[95, 200])]
+        raw_issues = [{"number": 95, "title": "t", "state": "CLOSED", "assignees": []}]
+        out = build_export(tracks, {"t1": raw_issues}, {"o/r": "PRIVATE"}, now="t")
+        result = out["tracks"][0]["next_up"]
+        # 95 is confirmed closed → filtered; 200 not in payload → kept
+        self.assertEqual(result, [200])
+
+    def test_empty_next_up_unchanged(self):
+        result = self._build([], {95: "OPEN"})
+        self.assertEqual(result, [])
+
+
 class BuildExportUntrackedTest(unittest.TestCase):
     """Tests for the untracked kwarg on build_export."""
 
@@ -86,6 +130,165 @@ class BuildExportUntrackedTest(unittest.TestCase):
         json.dumps(out)  # must not raise
 
 
+class BuildExportTierFieldTest(unittest.TestCase):
+    """Tests that build_export uses the track's actual tier field."""
+
+    def _build(self, tier_value):
+        """Build a minimal export with a track that has the given tier."""
+        from types import SimpleNamespace
+        t = SimpleNamespace(
+            name="t1",
+            repo="o/r",
+            tier=tier_value,
+            meta={
+                "status": "active",
+                "launch_priority": "P2",
+                "milestone_alignment": "v1",
+                "blockers": [],
+                "next_up": [],
+                "github": {"repo": "o/r", "issues": []},
+            },
+        )
+        out = build_export([t], {}, {"o/r": "PRIVATE"}, now="2026-06-09T00:00")
+        return out["tracks"][0]["tier"]
+
+    def test_tier_shared_exported_as_shared(self):
+        """Track with tier='shared' → export JSON has tier='shared'."""
+        self.assertEqual(self._build("shared"), "shared")
+
+    def test_tier_private_exported_as_private(self):
+        """Track with tier='private' → export JSON has tier='private'."""
+        self.assertEqual(self._build("private"), "private")
+
+    def test_tier_none_exported_as_private(self):
+        """Track with tier=None → export JSON has tier='private' (safe default)."""
+        self.assertEqual(self._build(None), "private")
+
+
 class ExportCommandGateTest(unittest.TestCase):
     def test_requires_json_flag(self):
         self.assertEqual(export_cmd.run([]), 2)
+
+
+class MilestoneSortKeyTest(unittest.TestCase):
+    """Tests for milestone_sort_key — the sort-order function."""
+
+    def test_active_milestone_first(self):
+        from lib.export_model import milestone_sort_key
+        active = {"number": 10, "milestone": "v1"}
+        future = {"number": 20, "milestone": "v2"}
+        # active milestone (matches alignment) should sort before future
+        self.assertLess(
+            milestone_sort_key(active, milestone_alignment="v1"),
+            milestone_sort_key(future, milestone_alignment="v1"),
+        )
+
+    def test_future_before_null(self):
+        from lib.export_model import milestone_sort_key
+        future = {"number": 10, "milestone": "v2"}
+        null_ms = {"number": 99, "milestone": None}
+        self.assertLess(
+            milestone_sort_key(future, milestone_alignment="v1"),
+            milestone_sort_key(null_ms, milestone_alignment="v1"),
+        )
+
+    def test_null_last(self):
+        from lib.export_model import milestone_sort_key
+        null_ms = {"number": 10, "milestone": None}
+        active = {"number": 20, "milestone": "v1"}
+        self.assertLess(
+            milestone_sort_key(active, milestone_alignment="v1"),
+            milestone_sort_key(null_ms, milestone_alignment="v1"),
+        )
+
+    def test_number_tiebreak_within_group(self):
+        from lib.export_model import milestone_sort_key
+        a = {"number": 10, "milestone": "v1"}
+        b = {"number": 5, "milestone": "v1"}
+        # Both match alignment → tier 0; lower number sorts first
+        self.assertLess(
+            milestone_sort_key(b, milestone_alignment="v1"),
+            milestone_sort_key(a, milestone_alignment="v1"),
+        )
+
+    def test_empty_string_milestone_treated_as_null(self):
+        from lib.export_model import milestone_sort_key
+        empty = {"number": 1, "milestone": ""}
+        null_ms = {"number": 2, "milestone": None}
+        # Both should be in tier 2
+        k1 = milestone_sort_key(empty, milestone_alignment="v1")
+        k2 = milestone_sort_key(null_ms, milestone_alignment="v1")
+        self.assertEqual(k1[0], 2)  # tier
+        self.assertEqual(k2[0], 2)
+
+
+class GroupIssuesByMilestoneTest(unittest.TestCase):
+    """Tests for group_issues_by_milestone."""
+
+    def test_single_group_returns_one_entry(self):
+        from lib.export_model import group_issues_by_milestone
+        issues = [
+            {"number": 1, "milestone": "v1"},
+            {"number": 2, "milestone": "v1"},
+        ]
+        groups = group_issues_by_milestone(issues, milestone_alignment="v1")
+        self.assertEqual(len(groups), 1)
+        label, items = groups[0]
+        self.assertEqual(label, "v1")
+        self.assertEqual([i["number"] for i in items], [1, 2])
+
+    def test_all_null_returns_single_group(self):
+        from lib.export_model import group_issues_by_milestone
+        issues = [
+            {"number": 2, "milestone": None},
+            {"number": 1, "milestone": None},
+        ]
+        groups = group_issues_by_milestone(issues, milestone_alignment="v1")
+        self.assertEqual(len(groups), 1)
+        label, items = groups[0]
+        self.assertIsNone(label)
+        # Sorted by number within the null group
+        self.assertEqual([i["number"] for i in items], [1, 2])
+
+    def test_multi_group_active_first(self):
+        from lib.export_model import group_issues_by_milestone
+        issues = [
+            {"number": 30, "milestone": None},
+            {"number": 20, "milestone": "v2"},
+            {"number": 10, "milestone": "v1"},
+        ]
+        groups = group_issues_by_milestone(issues, milestone_alignment="v1")
+        self.assertEqual(len(groups), 3)
+        # Active milestone (v1) first
+        self.assertEqual(groups[0][0], "v1")
+        self.assertEqual([i["number"] for i in groups[0][1]], [10])
+        # Future (v2) second
+        self.assertEqual(groups[1][0], "v2")
+        self.assertEqual([i["number"] for i in groups[1][1]], [20])
+        # Null last
+        self.assertIsNone(groups[2][0])
+        self.assertEqual([i["number"] for i in groups[2][1]], [30])
+
+    def test_empty_issues_returns_empty(self):
+        from lib.export_model import group_issues_by_milestone
+        self.assertEqual(group_issues_by_milestone([]), [])
+
+
+class BuildExportDependsOnTest(unittest.TestCase):
+    """Tests that depends_on is surfaced in the export JSON (#102)."""
+
+    def test_depends_on_exported(self):
+        tracks = [_track("alpha", "o/r", [1], depends_on=["beta", "gamma"])]
+        issues_by_track = {"alpha": [
+            {"number": 1, "title": "a", "state": "OPEN", "assignees": []},
+        ]}
+        out = build_export(tracks, issues_by_track, {"o/r": "PRIVATE"}, now="t")
+        self.assertEqual(out["tracks"][0]["depends_on"], ["beta", "gamma"])
+
+    def test_depends_on_empty_by_default(self):
+        tracks = [_track("alpha", "o/r", [1])]
+        issues_by_track = {"alpha": [
+            {"number": 1, "title": "a", "state": "OPEN", "assignees": []},
+        ]}
+        out = build_export(tracks, issues_by_track, {"o/r": "PRIVATE"}, now="t")
+        self.assertEqual(out["tracks"][0]["depends_on"], [])

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

@@ -72,12 +72,12 @@ class ExportRunJsonTest(unittest.TestCase):
         self.assertEqual(out["schema"], 1)
 
     def test_track_issues_assembled_in_declared_order(self):
-        # Track declares [2, 1] — output order must match declaration, not map-insertion order
+        # Issues are milestone-sorted (#101): null-milestone group sorts by number.
         tracks = [_track("alpha", _SHARED_REPO, [2, 1])]
         rc, out, _ = self._run_with_mocks(tracks, _EXPORT_MAP)
         self.assertEqual(rc, 0)
         issue_nums = [i["number"] for i in out["tracks"][0]["issues"]]
-        self.assertEqual(issue_nums, [2, 1])
+        self.assertEqual(issue_nums, [1, 2])
 
     def test_shared_issue_appears_in_both_tracks(self):
         tracks = [