@stylusnexus/work-plan 2026.6.9

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

@@ -0,0 +1,152 @@
+"""Tests for handoff commit-attribution helpers: path-glob attribution
+(`github.paths`) and the repo-wide commit counter that drives the soft
+'silence is expected' signal.
+"""
+import sys
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from datetime import datetime
+
+from commands import handoff
+
+
+def _track(meta_github, local_path="/tmp/repo"):
+    return SimpleNamespace(
+        meta={"github": meta_github},
+        local_path=local_path,
+    )
+
+
+def _proc(stdout="", returncode=0):
+    return SimpleNamespace(stdout=stdout, returncode=returncode, stderr="")
+
+
+SINCE = datetime(2026, 4, 29, 0, 0, 0)
+
+
+class RecentCommitsPathGlobsTest(unittest.TestCase):
+    def test_path_glob_attributes_commit_with_no_issue_ref(self):
+        """A commit whose subject doesn't mention any tracked issue but
+        whose changed paths match `github.paths` should be attributed."""
+        log_output = (
+            "---COMMIT---\nabc1234|fix(useToast): debounce stacking|2026-04-30T10:00:00+00:00\n"
+            "---BODY---\n\n---ENDBODY---\n"
+            "apps/web/src/hooks/useToast.tsx\napps/web/src/hooks/useToast.test.tsx\n\n"
+            "---COMMIT---\ndef5678|chore: bump deps|2026-04-30T09:00:00+00:00\n"
+            "---BODY---\n\n---ENDBODY---\n"
+            "package.json\n"
+        )
+        track = _track({
+            "issues": [4148, 4149],
+            "paths": ["apps/web/src/hooks/useToast*"],
+        })
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout=log_output)):
+            commits = handoff._recent_commits(track, SINCE)
+        self.assertEqual(len(commits), 1)
+        self.assertEqual(commits[0]["sha"], "abc1234")
+
+    def test_issue_ref_still_attributes_when_paths_set(self):
+        """Issue-ref attribution and path attribution are an OR, not AND."""
+        log_output = (
+            "---COMMIT---\nabc1234|fix #4148: tighten guardrails|2026-04-30T10:00:00+00:00\n"
+            "---BODY---\n\n---ENDBODY---\n"
+            "infra/iam/policy.tf\n"
+        )
+        track = _track({
+            "issues": [4148],
+            "paths": ["apps/web/src/hooks/useToast*"],
+        })
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout=log_output)):
+            commits = handoff._recent_commits(track, SINCE)
+        self.assertEqual(len(commits), 1)
+        self.assertEqual(commits[0]["sha"], "abc1234")
+
+    def test_body_issue_ref_attributes_squash_merge_commit(self):
+        """Squash-merged PRs use Conventional Commit subjects with the issue
+        ref in the body (e.g. 'Closes #4148'). Subject scanning alone misses
+        these; body scanning must catch them."""
+        log_output = (
+            "---COMMIT---\nabc1234|feat(adventure): cache regen prompts|2026-04-30T10:00:00+00:00\n"
+            "---BODY---\n"
+            "Reduce duplicate LLM calls when artifacts regenerate.\n"
+            "\n"
+            "Closes #4148\n"
+            "---ENDBODY---\n"
+        )
+        track = _track({"issues": [4148]})
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout=log_output)):
+            commits = handoff._recent_commits(track, SINCE)
+        self.assertEqual(len(commits), 1)
+        self.assertEqual(commits[0]["sha"], "abc1234")
+
+    def test_body_ref_to_untracked_issue_does_not_attribute(self):
+        """A body that references an issue NOT in github.issues must not
+        attribute — otherwise any commit citing any issue would get picked up."""
+        log_output = (
+            "---COMMIT---\nabc1234|chore: unrelated|2026-04-30T10:00:00+00:00\n"
+            "---BODY---\nCloses #9999\n---ENDBODY---\n"
+        )
+        track = _track({"issues": [4148]})
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout=log_output)):
+            commits = handoff._recent_commits(track, SINCE)
+        self.assertEqual(commits, [])
+
+    def test_no_paths_no_issues_returns_empty(self):
+        """A track with neither tracked issues nor path globs gets nothing."""
+        track = _track({"issues": [], "paths": []})
+        with mock.patch("commands.handoff.subprocess.run") as run:
+            commits = handoff._recent_commits(track, SINCE)
+            run.assert_not_called()
+        self.assertEqual(commits, [])
+
+    def test_explicit_branches_skip_path_globs(self):
+        """When `github.branches` is set, paths do not apply (explicit
+        branches are the contract)."""
+        log_output = "abc1234|merge: feature work|2026-04-30T10:00:00+00:00"
+        track = _track({
+            "issues": [4148],
+            "branches": ["feature/x"],
+            "paths": ["should-not-apply/**"],
+        })
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout=log_output)) as run:
+            commits = handoff._recent_commits(track, SINCE)
+            args = run.call_args.args[0]
+            self.assertIn("feature/x", args)
+            self.assertNotIn("--name-only", args)
+        self.assertEqual(len(commits), 1)
+
+
+class RepoCommitsSinceTest(unittest.TestCase):
+    def test_counts_lines_in_log_output(self):
+        out = "sha1\nsha2\nsha3\n"
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout=out)):
+            n = handoff._repo_commits_since(Path("/tmp/repo"), SINCE)
+        self.assertEqual(n, 3)
+
+    def test_returns_zero_on_empty(self):
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout="")):
+            n = handoff._repo_commits_since(Path("/tmp/repo"), SINCE)
+        self.assertEqual(n, 0)
+
+    def test_returns_zero_on_failure(self):
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout="", returncode=128)):
+            n = handoff._repo_commits_since(Path("/tmp/repo"), SINCE)
+        self.assertEqual(n, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,183 @@
+"""Tests for --auto-next sibling-claim filtering (#50 corrected scope).
+
+`handoff --auto-next` is non-interactive on collisions: when the suggester
+returns issues already next_up on a sibling active track in the same repo,
+those issues are dropped silently (with a transparent "↷ skipped" line),
+NOT prompted. The edit branch falls back to --set-next-style warn/confirm
+because the user is explicit there.
+"""
+import io
+import sys
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest import mock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import handoff
+from lib.frontmatter import parse_file, write_file
+
+
+def _make_track(dir_path: Path, slug: str, *, repo: str, status: str = "active",
+                next_up=None, issues=None) -> Path:
+    meta = {
+        "track": slug,
+        "status": status,
+        "launch_priority": "P1",
+        "github": {
+            "repo": repo,
+            "issues": list(issues or [100, 200, 300, 400]),
+            "branches": [],
+        },
+        "next_up": list(next_up or []),
+    }
+    body = f"\n# {slug}\n\nBody.\n"
+    path = dir_path / f"{slug}.md"
+    write_file(path, meta, body)
+    return path
+
+
+def _open_issue(num: int, *, priority: str = "P1") -> dict:
+    return {
+        "number": num,
+        "title": f"issue-{num}",
+        "state": "OPEN",
+        "labels": [{"name": f"priority/{priority}"}],
+        "updatedAt": "2026-04-30T00:00:00Z",
+    }
+
+
+class AutoNextSkipTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.notes_root = Path(self.tmp.name) / "notes_root"
+        self.repo_dir = self.notes_root / "demo"
+        self.repo_dir.mkdir(parents=True)
+
+        self.cfg = {
+            "notes_root": str(self.notes_root),
+            "repos": {"demo": {"github": "stylusnexus/Demo"}},
+        }
+
+        self._patches = [
+            mock.patch("commands.handoff.load_config", return_value=self.cfg),
+            mock.patch("commands.handoff.has_uncommitted", return_value=False),
+        ]
+        for p in self._patches:
+            p.start()
+
+    def tearDown(self):
+        for p in self._patches:
+            p.stop()
+        self.tmp.cleanup()
+
+    def _run_auto_next(self, track_name: str, *, issues_response, prompt_answer="y"):
+        """Run handoff --auto-next with mocked fetch_issues + prompt_input."""
+        buf = io.StringIO()
+        with mock.patch("commands.handoff.fetch_issues", return_value=issues_response), \
+             mock.patch("commands.handoff.prompt_input", return_value=prompt_answer), \
+             redirect_stdout(buf):
+            rc = handoff.run([track_name, "--auto-next"])
+        return rc, buf.getvalue()
+
+    def test_no_collisions_passes_through_full_suggestion(self):
+        """Sibling has nothing in next_up → suggestion is unchanged."""
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo",
+                             issues=[100, 200])
+        _make_track(self.repo_dir, "track-b", repo="stylusnexus/Demo", next_up=[])
+
+        rc, out = self._run_auto_next("track-a",
+                                      issues_response=[_open_issue(100), _open_issue(200)])
+
+        self.assertEqual(rc, 0)
+        self.assertNotIn("↷ skipped", out)
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [100, 200])
+
+    def test_sibling_claimed_issue_is_skipped_with_transparent_line(self):
+        """Sibling has #100 → #100 is dropped from suggestion, message printed."""
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo",
+                             issues=[100, 200])
+        _make_track(self.repo_dir, "track-b", repo="stylusnexus/Demo", next_up=[100])
+
+        rc, out = self._run_auto_next("track-a",
+                                      issues_response=[_open_issue(100), _open_issue(200)])
+
+        self.assertEqual(rc, 0)
+        self.assertIn("↷ skipped #100 (already next_up on 'track-b')", out)
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [200])  # #100 dropped
+
+    def test_all_suggestions_claimed_returns_zero_unchanged(self):
+        """Every suggested issue is sibling-claimed → next_up unchanged, rc 0."""
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo",
+                             issues=[100, 200], next_up=[42])
+        _make_track(self.repo_dir, "track-b", repo="stylusnexus/Demo",
+                    next_up=[100, 200])
+
+        rc, out = self._run_auto_next("track-a",
+                                      issues_response=[_open_issue(100), _open_issue(200)])
+
+        self.assertEqual(rc, 0)
+        self.assertIn("All suggested issues are already next_up on sibling tracks", out)
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [42])  # original list intact
+
+    def test_parked_sibling_does_not_filter(self):
+        """Parked sibling holding #100 should NOT trigger a skip — parked
+        tracks don't compete for attention."""
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo",
+                             issues=[100, 200])
+        _make_track(self.repo_dir, "track-parked", repo="stylusnexus/Demo",
+                    status="parked", next_up=[100])
+
+        rc, out = self._run_auto_next("track-a",
+                                      issues_response=[_open_issue(100), _open_issue(200)])
+
+        self.assertEqual(rc, 0)
+        self.assertNotIn("↷ skipped", out)
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [100, 200])
+
+    def test_cross_repo_sibling_does_not_filter(self):
+        """Sibling in a different repo holding the same issue number should
+        NOT trigger a skip — issue numbers are repo-scoped."""
+        other_dir = self.notes_root / "other"
+        other_dir.mkdir(parents=True)
+        self.cfg["repos"]["other"] = {"github": "stylusnexus/Other"}
+
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo",
+                             issues=[100, 200])
+        _make_track(other_dir, "track-other", repo="stylusnexus/Other",
+                    next_up=[100])
+
+        rc, out = self._run_auto_next("track-a",
+                                      issues_response=[_open_issue(100), _open_issue(200)])
+
+        self.assertEqual(rc, 0)
+        self.assertNotIn("↷ skipped", out)
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [100, 200])
+
+    def test_user_decline_at_apply_prompt_keeps_skipped_record(self):
+        """User picks 'n' at the apply prompt → next_up unchanged, but skip
+        line was still printed (the filter ran before the prompt)."""
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo",
+                             issues=[100, 200], next_up=[7])
+        _make_track(self.repo_dir, "track-b", repo="stylusnexus/Demo", next_up=[100])
+
+        rc, out = self._run_auto_next("track-a",
+                                      issues_response=[_open_issue(100), _open_issue(200)],
+                                      prompt_answer="n")
+
+        self.assertEqual(rc, 0)
+        self.assertIn("↷ skipped #100", out)
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [7])  # decline preserved
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,149 @@
+"""Tests for cross-track next_up collision warning (#50).
+
+When the user applies a next_up list to one track, the CLI should warn if any
+of those issues are already next_up on a sibling active track in the same repo.
+The prompt is read-only on local frontmatter — no GitHub calls — and respects
+y/N: 'y' applies anyway, 'N' (default) skips the write.
+"""
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import handoff
+from lib.frontmatter import parse_file, write_file
+
+
+def _make_track(dir_path: Path, slug: str, *, repo: str, status: str = "active",
+                next_up=None) -> Path:
+    meta = {
+        "track": slug,
+        "status": status,
+        "launch_priority": "P1",
+        "github": {"repo": repo, "issues": [100, 200, 300, 400], "branches": []},
+        "next_up": list(next_up or []),
+    }
+    body = f"\n# {slug}\n\nBody.\n"
+    path = dir_path / f"{slug}.md"
+    write_file(path, meta, body)
+    return path
+
+
+class CollisionWarningTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.notes_root = Path(self.tmp.name) / "notes_root"
+        self.repo_dir = self.notes_root / "demo"
+        self.repo_dir.mkdir(parents=True)
+
+        self.cfg = {
+            "notes_root": str(self.notes_root),
+            "repos": {"demo": {"github": "stylusnexus/Demo"}},
+        }
+
+        self._patches = [
+            mock.patch("commands.handoff.load_config", return_value=self.cfg),
+            mock.patch("commands.handoff.fetch_issues", return_value=[]),
+            mock.patch("commands.handoff.has_uncommitted", return_value=False),
+        ]
+        for p in self._patches:
+            p.start()
+
+    def tearDown(self):
+        for p in self._patches:
+            p.stop()
+        self.tmp.cleanup()
+
+    def test_no_collision_no_prompt(self):
+        """No sibling holds the proposed issue → write proceeds without prompt."""
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo")
+        _make_track(self.repo_dir, "track-b", repo="stylusnexus/Demo", next_up=[999])
+
+        with mock.patch("commands.handoff.prompt_input") as mock_prompt:
+            rc = handoff.run(["track-a", "--set-next", "100,200"])
+
+        self.assertEqual(rc, 0)
+        mock_prompt.assert_not_called()
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [100, 200])
+
+    def test_collision_user_accepts_writes(self):
+        """Sibling holds #100 in next_up → prompt fires; 'y' writes anyway."""
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo")
+        _make_track(self.repo_dir, "track-b", repo="stylusnexus/Demo", next_up=[100])
+
+        with mock.patch("commands.handoff.prompt_input", return_value="y"):
+            rc = handoff.run(["track-a", "--set-next", "100,200"])
+
+        self.assertEqual(rc, 0)
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [100, 200])
+
+    def test_collision_user_declines_skips_write(self):
+        """Sibling holds #100; user declines → next_up unchanged."""
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo",
+                             next_up=[42])
+        _make_track(self.repo_dir, "track-b", repo="stylusnexus/Demo", next_up=[100])
+
+        with mock.patch("commands.handoff.prompt_input", return_value="n"):
+            rc = handoff.run(["track-a", "--set-next", "100,200"])
+
+        self.assertEqual(rc, 0)
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [42])  # original list intact
+
+    def test_parked_sibling_does_not_trigger_warning(self):
+        """A parked / abandoned track holding the issue should not flag —
+        parked tracks don't compete for attention."""
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo")
+        _make_track(self.repo_dir, "track-parked", repo="stylusnexus/Demo",
+                    status="parked", next_up=[100])
+
+        with mock.patch("commands.handoff.prompt_input") as mock_prompt:
+            rc = handoff.run(["track-a", "--set-next", "100"])
+
+        self.assertEqual(rc, 0)
+        mock_prompt.assert_not_called()
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [100])
+
+    def test_cross_repo_does_not_trigger_warning(self):
+        """A sibling in a different repo holding the same issue number should
+        not flag — issue numbers are repo-scoped."""
+        other_repo_dir = self.notes_root / "other"
+        other_repo_dir.mkdir(parents=True)
+        # Make config aware of the second repo so discover_tracks resolves it.
+        self.cfg["repos"]["other"] = {"github": "stylusnexus/Other"}
+
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo")
+        _make_track(other_repo_dir, "track-other", repo="stylusnexus/Other",
+                    next_up=[100])
+
+        with mock.patch("commands.handoff.prompt_input") as mock_prompt:
+            rc = handoff.run(["track-a", "--set-next", "100"])
+
+        self.assertEqual(rc, 0)
+        mock_prompt.assert_not_called()
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [100])
+
+    def test_self_track_excluded_from_check(self):
+        """Re-applying the same list to the SAME track must not self-collide."""
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo",
+                             next_up=[100, 200])
+
+        with mock.patch("commands.handoff.prompt_input") as mock_prompt:
+            rc = handoff.run(["track-a", "--set-next", "100,200"])
+
+        self.assertEqual(rc, 0)
+        mock_prompt.assert_not_called()
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [100, 200])
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,106 @@
+"""Tests for `handoff --set-next` flag (Claude-driven next_up persistence)."""
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import handoff
+from lib.frontmatter import parse_file, write_file
+
+
+def _make_track_file(dir_path: Path, slug: str = "demo-track") -> Path:
+    """Build a minimal track .md with empty next_up + frontmatter the
+    handoff command can resolve."""
+    meta = {
+        "track": slug,
+        "status": "active",
+        "launch_priority": "P1",
+        "github": {"repo": "stylusnexus/Demo", "issues": [100, 200, 300], "branches": []},
+        "next_up": [],
+    }
+    body = "\n# Demo\n\nBody content for the track.\n"
+    path = dir_path / f"{slug}.md"
+    write_file(path, meta, body)
+    return path
+
+
+class HandoffSetNextTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.notes_root = Path(self.tmp.name) / "notes_root"
+        # Tracks live under <notes_root>/<repo-folder>/<slug>.md so config
+        # discovery + repo resolution work the same as in production.
+        self.repo_dir = self.notes_root / "demo"
+        self.repo_dir.mkdir(parents=True)
+        self.track_path = _make_track_file(self.repo_dir, "demo-track")
+
+        # Stub config so discover_tracks walks our temp notes_root.
+        self.cfg = {
+            "notes_root": str(self.notes_root),
+            "repos": {"demo": {"github": "stylusnexus/Demo"}},
+        }
+
+        # Patch load_config to return our stub.
+        self._patches = [
+            mock.patch("commands.handoff.load_config", return_value=self.cfg),
+            # Skip GitHub fetch — fetch_issues hits `gh` over the network
+            # in production. Return [] so the rest of handoff runs purely
+            # off the body + frontmatter.
+            mock.patch("commands.handoff.fetch_issues", return_value=[]),
+            # Avoid scanning a real git repo — track has no local_path and
+            # current_branch isn't called when local_path is None, but be
+            # defensive in case derived_handoff drifts.
+            mock.patch("commands.handoff.has_uncommitted", return_value=False),
+        ]
+        for p in self._patches:
+            p.start()
+
+    def tearDown(self):
+        for p in self._patches:
+            p.stop()
+        self.tmp.cleanup()
+
+    def test_set_next_persists_to_frontmatter(self):
+        """--set-next 100,200,300 should write next_up: [100, 200, 300]."""
+        rc = handoff.run(["demo-track", "--set-next", "100,200,300"])
+        self.assertEqual(rc, 0)
+        meta, _ = parse_file(self.track_path)
+        self.assertEqual(meta["next_up"], [100, 200, 300])
+
+    def test_set_next_replaces_existing_list(self):
+        """--set-next overwrites any prior next_up entries."""
+        meta, body = parse_file(self.track_path)
+        meta["next_up"] = [9999]
+        write_file(self.track_path, meta, body)
+
+        rc = handoff.run(["demo-track", "--set-next", "100,200"])
+        self.assertEqual(rc, 0)
+        meta, _ = parse_file(self.track_path)
+        self.assertEqual(meta["next_up"], [100, 200])
+
+    def test_set_next_equals_form_also_works(self):
+        """--set-next=100,200 (key=value) should behave the same as space form."""
+        rc = handoff.run(["demo-track", "--set-next=100,200"])
+        self.assertEqual(rc, 0)
+        meta, _ = parse_file(self.track_path)
+        self.assertEqual(meta["next_up"], [100, 200])
+
+    def test_set_next_rejects_non_numeric(self):
+        """Garbage input → exit 2, frontmatter untouched."""
+        # Pre-condition: next_up is empty.
+        meta, _ = parse_file(self.track_path)
+        self.assertEqual(meta["next_up"], [])
+
+        rc = handoff.run(["demo-track", "--set-next", "not-numbers"])
+        self.assertEqual(rc, 2)
+        meta, _ = parse_file(self.track_path)
+        self.assertEqual(meta["next_up"], [])  # unchanged
+
+
+if __name__ == "__main__":
+    unittest.main()