@stylusnexus/work-plan 2026.6.14 → 2026.6.15

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

@@ -35,6 +35,9 @@ class BuildExportTest(unittest.TestCase):
         self.assertEqual(t["blockers"], [9]); self.assertEqual(t["next_up"], [1])
         self.assertEqual(t["rollup"], {"open": 1, "closed": 1})
         self.assertEqual(t["issues"][0], {"number": 1, "title": "a", "state": "open", "assignee": "@eve", "milestone": None, "in_progress": False, "in_progress_label": False, "blocked_by": [], "blocking": []})
+        # Phase 2: next_up_preset must be present in every track
+        self.assertIn("next_up_preset", t)
+        self.assertEqual(t["next_up_preset"], "flow")  # default when no next_up_order in meta
         json.dumps(out)  # must be serializable
 
     def test_path_is_null_when_track_has_no_path(self):
@@ -459,6 +462,56 @@ class InProgressExportTest(unittest.TestCase):
         self.assertFalse(issue["in_progress_label"])  # no label present
 
 
+class BuildExportNextUpPresetTest(unittest.TestCase):
+    """Tests that build_export emits next_up_preset on each track (#326 Phase 2)."""
+
+    def _build(self, track_meta_override=None, next_up_default=None):
+        from types import SimpleNamespace
+        meta = {
+            "status": "active",
+            "launch_priority": "P2",
+            "milestone_alignment": "v1",
+            "blockers": [],
+            "next_up": [],
+            "depends_on": [],
+            "github": {"repo": "o/r", "issues": []},
+        }
+        if track_meta_override:
+            meta.update(track_meta_override)
+        t = SimpleNamespace(name="alpha", repo="o/r", tier="private",
+                            path=Path("/tmp/notes/alpha.md"), folder="myrepo",
+                            meta=meta)
+        out = build_export([t], {("o/r", "alpha"): []}, {"o/r": "PRIVATE"},
+                           now="2026-06-14T00:00", next_up_default=next_up_default)
+        return out["tracks"][0]
+
+    def test_next_up_preset_field_present(self):
+        """Export emits next_up_preset for each track."""
+        track = self._build()
+        self.assertIn("next_up_preset", track)
+
+    def test_next_up_preset_defaults_to_flow(self):
+        """Track with no next_up_order → next_up_preset == 'flow'."""
+        track = self._build()
+        self.assertEqual(track["next_up_preset"], "flow")
+
+    def test_next_up_preset_reflects_track_setting(self):
+        """Track with next_up_order: {preset: priority-driven} → next_up_preset == 'priority-driven'."""
+        track = self._build({"next_up_order": {"preset": "priority-driven"}})
+        self.assertEqual(track["next_up_preset"], "priority-driven")
+
+    def test_next_up_preset_uses_global_default(self):
+        """Track with no next_up_order + global next_up_default='backlog' → next_up_preset == 'backlog'."""
+        track = self._build(next_up_default="backlog")
+        self.assertEqual(track["next_up_preset"], "backlog")
+
+    def test_track_setting_overrides_global_default(self):
+        """Track-level next_up_order overrides the global next_up_default."""
+        track = self._build({"next_up_order": {"preset": "backlog"}},
+                            next_up_default="priority-driven")
+        self.assertEqual(track["next_up_preset"], "backlog")
+
+
 class BlockedByExportTest(unittest.TestCase):
     def _track(self, name, repo):
         from types import SimpleNamespace

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

@@ -1,6 +1,7 @@
 """Tests for git_state pure functions."""
 import unittest
 import sys
+from datetime import datetime, timedelta
 from pathlib import Path
 from unittest import mock
 
@@ -49,40 +50,74 @@ class BranchInProgressTest(unittest.TestCase):
 
 
 class HotIssueNumbersTest(unittest.TestCase):
+    def setUp(self):
+        # hot_issue_numbers memoizes per resolved path; reset between cases so a
+        # prior test's "/repo" result doesn't leak into the next.
+        from lib import git_state
+        git_state._reset_hot_cache()
+
+    def _ref_line(self, branch, age_hours):
+        ts = int((datetime.now() - timedelta(hours=age_hours)).timestamp())
+        return f"{branch}\t{ts}"
+
+    def _enum(self, *lines):
+        return mock.Mock(return_value=mock.Mock(returncode=0,
+                                                stdout="\n".join(lines) + "\n"))
+
     def test_returns_empty_when_repo_missing(self):
         self.assertEqual(hot_issue_numbers(None), set())
         self.assertEqual(hot_issue_numbers(Path("/nonexistent")), set())
 
-    def test_maps_hot_feat_and_fix_branches_to_numbers(self):
-        listing = "dev\nmain\nfeat/271-foo\nfix/88-bar\nchore/x\nwork-plan/plan\n"
-        enum = mock.Mock(return_value=mock.Mock(returncode=0, stdout=listing))
+    def test_recent_feat_and_fix_branches_are_hot(self):
+        # Two recently-committed feat/fix branches + cold/non-matching ones.
+        lines = ["dev\t0", "main\t0",
+                 self._ref_line("feat/271-foo", 1),    # 1h ago -> hot
+                 self._ref_line("fix/88-bar", 5),       # 5h ago -> hot
+                 self._ref_line("feat/9-old", 100),     # 100h ago -> cold
+                 "chore/x\t0", "work-plan/plan\t0"]
         with mock.patch("lib.git_state.Path.exists", return_value=True), \
-             mock.patch("lib.git_state._git", enum), \
-             mock.patch("lib.git_state.branch_in_progress",
-                        side_effect=lambda b, p: b in ("feat/271-foo", "fix/88-bar")):
+             mock.patch("lib.git_state._git", self._enum(*lines)), \
+             mock.patch("lib.git_state.current_branch", return_value=None):
             self.assertEqual(hot_issue_numbers(Path("/repo")), {271, 88})
 
     def test_no_substring_collision_2710_is_not_271(self):
-        listing = "feat/2710-y\n"
         with mock.patch("lib.git_state.Path.exists", return_value=True), \
              mock.patch("lib.git_state._git",
-                        return_value=mock.Mock(returncode=0, stdout=listing)), \
-             mock.patch("lib.git_state.branch_in_progress", return_value=True):
+                        self._enum(self._ref_line("feat/2710-y", 1))), \
+             mock.patch("lib.git_state.current_branch", return_value=None):
             self.assertEqual(hot_issue_numbers(Path("/repo")), {2710})
 
     def test_cold_matched_branch_excluded(self):
-        listing = "feat/271-foo\n"
         with mock.patch("lib.git_state.Path.exists", return_value=True), \
              mock.patch("lib.git_state._git",
-                        return_value=mock.Mock(returncode=0, stdout=listing)), \
-             mock.patch("lib.git_state.branch_in_progress", return_value=False):
+                        self._enum(self._ref_line("feat/271-foo", 48))), \
+             mock.patch("lib.git_state.current_branch", return_value=None):
             self.assertEqual(hot_issue_numbers(Path("/repo")), set())
 
+    def test_uncommitted_on_current_branch_is_hot_even_if_cold(self):
+        # A cold (old-tip) feat branch that's checked out with uncommitted work.
+        with mock.patch("lib.git_state.Path.exists", return_value=True), \
+             mock.patch("lib.git_state._git",
+                        self._enum(self._ref_line("feat/271-foo", 200))), \
+             mock.patch("lib.git_state.current_branch", return_value="feat/271-foo"), \
+             mock.patch("lib.git_state.has_uncommitted", return_value=True):
+            self.assertEqual(hot_issue_numbers(Path("/repo")), {271})
+
     def test_enumeration_failure_returns_empty(self):
         with mock.patch("lib.git_state.Path.exists", return_value=True), \
              mock.patch("lib.git_state._git", return_value=None):
             self.assertEqual(hot_issue_numbers(Path("/repo")), set())
 
+    def test_memoizes_per_resolved_path(self):
+        # Second call with the same path must NOT re-invoke git.
+        enum = self._enum(self._ref_line("feat/271-foo", 1))
+        with mock.patch("lib.git_state.Path.exists", return_value=True), \
+             mock.patch("lib.git_state._git", enum), \
+             mock.patch("lib.git_state.current_branch", return_value=None):
+            self.assertEqual(hot_issue_numbers(Path("/repo")), {271})
+            self.assertEqual(hot_issue_numbers(Path("/repo")), {271})
+            self.assertEqual(enum.call_count, 1)
+
 
 if __name__ == "__main__":
     unittest.main()

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

@@ -1,10 +1,11 @@
 """Tests for the next_up suggestion algorithm.
 
 Covers the priority + recency sort, blocker exclusion, closed-issue filter,
-top-N capping, and the `updatedAt`-missing fallback. The algorithm has one
-home (lib/next_up.py) shared by handoff's --auto-next flag and brief's
-next_up_auto: true frontmatter knob — so a regression here would surface
-in both commands.
+top-N capping, `updatedAt`-missing fallback, dependency gate (blocked_by),
+in-progress float, fan-out ranking, and the deterministic number tiebreak.
+The algorithm has one home (lib/next_up.py) shared by handoff's --auto-next
+flag and brief's next_up_auto: true frontmatter knob — so a regression here
+would surface in both commands.
 """
 import sys
 import unittest
@@ -13,19 +14,33 @@ from pathlib import Path
 SKILL_ROOT = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(SKILL_ROOT))
 
-from lib.next_up import suggest_next_up
+from lib.next_up import suggest_next_up, resolve_next_up_order, PRESETS, DEFAULT_PRESET
 
 
 def _issue(num, *, state="OPEN", priority=None, updated="2026-01-01T00:00:00Z",
-           title="", milestone=None):
-    """Build a minimal issue dict matching gh's --json output."""
+           title="", milestone=None, blocked_by=None, blocking=None):
+    """Build a minimal issue dict matching gh's --json output.
+
+    blocked_by / blocking each accept a list of {number, repo, title} dicts
+    (OPEN-filtered, as delivered by github_state after #257).
+    """
     labels = [{"name": f"priority/{priority}"}] if priority else []
     ms_obj = {"title": milestone} if milestone else None
-    return {
+    issue = {
         "number": num, "state": state, "labels": labels,
         "updatedAt": updated, "title": title or f"issue #{num}",
         "milestone": ms_obj,
     }
+    if blocked_by is not None:
+        issue["blocked_by"] = blocked_by
+    if blocking is not None:
+        issue["blocking"] = blocking
+    return issue
+
+
+def _dep(num, repo="stylusnexus/demo"):
+    """Build a minimal dependency edge dict {number, repo, title}."""
+    return {"number": num, "repo": repo, "title": f"dep #{num}"}
 
 
 class SuggestNextUpTest(unittest.TestCase):
@@ -145,5 +160,263 @@ class SuggestNextUpTest(unittest.TestCase):
         self.assertEqual(result, [2, 1])  # parsable+newer wins; garbage trails
 
 
+class InProgressAndDependencyTest(unittest.TestCase):
+    """Phase 1 additions: dependency gate, in-progress float, fan-out, tiebreak."""
+
+    # ------------------------------------------------------------------
+    # in-progress float
+    # ------------------------------------------------------------------
+
+    def test_in_progress_floats_above_higher_priority(self):
+        """An in-progress P2 should sort above a non-in-progress P0."""
+        issues = [
+            _issue(1, priority="P0"),   # high priority, NOT in-progress
+            _issue(2, priority="P2"),   # lower priority, IS in-progress
+        ]
+        result = suggest_next_up(issues, [], in_progress_nums={2})
+        self.assertEqual(result[0], 2, "in-progress issue must float to top")
+        self.assertEqual(result[1], 1)
+
+    def test_in_progress_floats_above_milestone_aligned(self):
+        """In-progress with no milestone still beats milestone-aligned non-in-progress."""
+        issues = [
+            _issue(1, priority="P3", milestone="v1.0 — MVP"),  # aligned, not in-prog
+            _issue(2, priority="P3", milestone=None),           # no milestone, in-prog
+        ]
+        result = suggest_next_up(issues, [], track_milestone="v1.0",
+                                 in_progress_nums={2})
+        self.assertEqual(result[0], 2)
+
+    # ------------------------------------------------------------------
+    # dependency gate
+    # ------------------------------------------------------------------
+
+    def test_blocked_issue_excluded_from_candidates(self):
+        """An issue with a non-empty blocked_by list is gated out of the result."""
+        issues = [
+            _issue(1, priority="P0", blocked_by=[_dep(99)]),  # blocked — gated
+            _issue(2, priority="P1"),                          # open, unblocked
+        ]
+        result = suggest_next_up(issues, [])
+        self.assertNotIn(1, result, "blocked issue must not appear")
+        self.assertIn(2, result)
+
+    def test_blocked_but_in_progress_stays_in_result(self):
+        """An in-progress issue is never gated out by blocked_by."""
+        issues = [
+            _issue(1, priority="P0", blocked_by=[_dep(99)]),  # blocked but in-progress
+            _issue(2, priority="P1"),
+        ]
+        result = suggest_next_up(issues, [], in_progress_nums={1})
+        self.assertIn(1, result, "in-progress issue must survive the blocked_by gate")
+
+    def test_empty_blocked_by_list_is_not_gated(self):
+        """An explicit empty blocked_by list is treated as unblocked."""
+        issues = [
+            _issue(1, priority="P0", blocked_by=[]),
+            _issue(2, priority="P1"),
+        ]
+        result = suggest_next_up(issues, [])
+        self.assertIn(1, result, "empty blocked_by should not gate the issue")
+
+    def test_missing_blocked_by_key_is_not_gated(self):
+        """Issues without a blocked_by key at all pass through (backward-compat)."""
+        issues = [
+            _issue(1, priority="P0"),  # no blocked_by key
+            _issue(2, priority="P1"),
+        ]
+        result = suggest_next_up(issues, [])
+        self.assertIn(1, result)
+
+    # ------------------------------------------------------------------
+    # fan-out ranking
+    # ------------------------------------------------------------------
+
+    def test_higher_fanout_ranks_above_higher_priority(self):
+        """Fan-out (unblocking count) outranks priority within same milestone bucket."""
+        issues = [
+            _issue(1, priority="P0",   # high priority, zero fan-out
+                   blocking=[]),
+            _issue(2, priority="P2",   # lower priority, high fan-out
+                   blocking=[_dep(10), _dep(11), _dep(12)]),
+        ]
+        result = suggest_next_up(issues, [])
+        self.assertEqual(result[0], 2, "fan-out beats priority")
+        self.assertEqual(result[1], 1)
+
+    def test_milestone_beats_fanout(self):
+        """Milestone alignment beats fan-out: aligned-zero-fanout > off-milestone-high-fanout."""
+        issues = [
+            _issue(1, priority="P2", milestone="v1.0 — MVP",   # aligned, no fan-out
+                   blocking=[]),
+            _issue(2, priority="P2", milestone="v2.0 — Beta",  # off-milestone, high fan-out
+                   blocking=[_dep(10), _dep(11), _dep(12)]),
+        ]
+        result = suggest_next_up(issues, [], track_milestone="v1.0")
+        self.assertEqual(result[0], 1, "milestone-aligned must beat high-fanout off-milestone")
+
+    def test_blocking_field_absent_treated_as_zero_fanout(self):
+        """Missing blocking key → fan-out = 0; does not crash."""
+        issues = [
+            _issue(1, priority="P1"),   # no blocking key
+            _issue(2, priority="P1", blocking=[_dep(10)]),  # fan-out=1
+        ]
+        result = suggest_next_up(issues, [])
+        self.assertEqual(result[0], 2, "fan-out=1 beats fan-out=0")
+
+    # ------------------------------------------------------------------
+    # deterministic tiebreak
+    # ------------------------------------------------------------------
+
+    def test_number_tiebreak_when_all_else_equal(self):
+        """When every sort dimension ties, lower issue number wins."""
+        issues = [
+            _issue(30, priority="P1", updated="2026-01-01T00:00:00Z"),
+            _issue(10, priority="P1", updated="2026-01-01T00:00:00Z"),
+            _issue(20, priority="P1", updated="2026-01-01T00:00:00Z"),
+        ]
+        result = suggest_next_up(issues, [])
+        self.assertEqual(result, [10, 20, 30])
+
+    # ------------------------------------------------------------------
+    # backward-compat
+    # ------------------------------------------------------------------
+
+    def test_no_in_progress_nums_does_not_crash(self):
+        """Calling without in_progress_nums must not raise; no in-progress boost applied."""
+        issues = [_issue(1, priority="P0"), _issue(2, priority="P1")]
+        result = suggest_next_up(issues, [])  # old call signature
+        self.assertEqual(result, [1, 2])
+
+    def test_blocked_by_excluded_without_in_progress_nums(self):
+        """Without in_progress_nums, blocked issues are gated out (no in-prog bypass)."""
+        issues = [
+            _issue(1, priority="P0", blocked_by=[_dep(99)]),
+            _issue(2, priority="P1"),
+        ]
+        result = suggest_next_up(issues, [])
+        self.assertNotIn(1, result)
+        self.assertIn(2, result)
+
+    def test_manual_blocker_still_excluded(self):
+        """Manual blocker_nums exclusion is unaffected by the new in-progress param."""
+        issues = [
+            _issue(1, priority="P0"),
+            _issue(2, priority="P1"),
+        ]
+        result = suggest_next_up(issues, [1], in_progress_nums={1})
+        # in-progress does NOT override manual blocker_nums exclusion
+        self.assertNotIn(1, result)
+        self.assertIn(2, result)
+
+
+class PresetAndResolverTest(unittest.TestCase):
+    """Phase 2: preset ordering + resolver tests."""
+
+    # ------------------------------------------------------------------
+    # preset ordering
+    # ------------------------------------------------------------------
+
+    def test_flow_preset_equivalent_to_phase1_default(self):
+        """order=None and order=PRESETS['flow'] must produce identical results."""
+        issues = [
+            _issue(1, priority="P0", milestone="v1.0"),
+            _issue(2, priority="P2", updated="2026-04-30T00:00:00Z"),
+            _issue(3, priority="P1", milestone="v1.0", blocking=[_dep(5), _dep(6)]),
+        ]
+        result_none = suggest_next_up(issues, [], track_milestone="v1.0")
+        result_flow = suggest_next_up(issues, [], track_milestone="v1.0",
+                                      order=PRESETS["flow"])
+        self.assertEqual(result_none, result_flow,
+                         "order=None must be equivalent to order=PRESETS['flow']")
+
+    def test_priority_driven_ranks_p0_above_off_milestone(self):
+        """priority-driven: a P0 with no milestone beats a P3 on the track milestone."""
+        issues = [
+            _issue(1, priority="P0", milestone=None),
+            _issue(2, priority="P3", milestone="v0.4.0 — MVP"),
+        ]
+        result = suggest_next_up(issues, [], track_milestone="v0.4.0",
+                                 order=PRESETS["priority-driven"])
+        # With priority-driven, priority > milestone so P0 beats P3-on-milestone
+        self.assertEqual(result[0], 1,
+                         "P0 with no milestone must beat P3 on track milestone under priority-driven")
+
+    def test_backlog_puts_oldest_first(self):
+        """backlog preset: oldest issue (smallest timestamp) ranks above newer."""
+        issues = [
+            _issue(10, priority="P2", updated="2026-06-01T00:00:00Z"),  # newer
+            _issue(20, priority="P2", updated="2024-01-01T00:00:00Z"),  # older
+        ]
+        result = suggest_next_up(issues, [], order=PRESETS["backlog"])
+        self.assertEqual(result[0], 20,
+                         "backlog preset must surface oldest (most stalled) issue first")
+
+    def test_unknown_criterion_in_order_skipped(self):
+        """An order list with an unknown criterion must not crash; known ones still apply."""
+        issues = [
+            _issue(1, priority="P0"),
+            _issue(2, priority="P1"),
+        ]
+        # Should not raise; the unknown 'bogus' criterion is skipped
+        result = suggest_next_up(issues, [], order=["bogus", "priority", "recency"])
+        self.assertEqual(result[0], 1, "priority criterion must still sort correctly")
+        self.assertNotIn("bogus", result)  # just making sure it didn't error on str
+
+    # ------------------------------------------------------------------
+    # resolver
+    # ------------------------------------------------------------------
+
+    def test_resolve_next_up_order_uses_track_frontmatter(self):
+        """Track with next_up_order: {preset: priority-driven} → resolver returns that preset."""
+        meta = {"next_up_order": {"preset": "priority-driven"}}
+        name, order = resolve_next_up_order(meta)
+        self.assertEqual(name, "priority-driven")
+        self.assertEqual(order, PRESETS["priority-driven"])
+
+    def test_resolve_next_up_order_falls_back_to_global_default(self):
+        """No track frontmatter → uses global default param."""
+        meta = {}
+        name, order = resolve_next_up_order(meta, default_preset="backlog")
+        self.assertEqual(name, "backlog")
+        self.assertEqual(order, PRESETS["backlog"])
+
+    def test_resolve_next_up_order_falls_back_to_default_preset(self):
+        """Neither track frontmatter nor global default → returns ('flow', PRESETS['flow'])."""
+        meta = {}
+        name, order = resolve_next_up_order(meta)
+        self.assertEqual(name, DEFAULT_PRESET)
+        self.assertEqual(order, PRESETS[DEFAULT_PRESET])
+
+    def test_resolve_next_up_order_custom_uses_order_list(self):
+        """next_up_order: {preset: custom, order: [priority, recency]} → custom order used."""
+        meta = {"next_up_order": {"preset": "custom", "order": ["priority", "recency"]}}
+        name, order = resolve_next_up_order(meta)
+        self.assertEqual(name, "custom")
+        self.assertEqual(order, ["priority", "recency"])
+
+    def test_resolve_next_up_order_unknown_preset_falls_back_to_flow(self):
+        """Track has next_up_order: {preset: nonexistent} → returns ('flow', PRESETS['flow'])."""
+        meta = {"next_up_order": {"preset": "nonexistent"}}
+        name, order = resolve_next_up_order(meta)
+        self.assertEqual(name, DEFAULT_PRESET)
+        self.assertEqual(order, PRESETS[DEFAULT_PRESET])
+
+    def test_resolve_next_up_order_invalid_custom_order_falls_back(self):
+        """next_up_order: {preset: custom, order: [bogus]} → falls back to flow."""
+        meta = {"next_up_order": {"preset": "custom", "order": ["bogus"]}}
+        name, order = resolve_next_up_order(meta)
+        self.assertEqual(name, DEFAULT_PRESET)
+        self.assertEqual(order, PRESETS[DEFAULT_PRESET])
+
+    def test_resolve_reads_next_up_order_not_next_up(self):
+        """Resolver reads 'next_up_order' key (a mapping), NOT 'next_up' (the issue-list)."""
+        # next_up is the issue list — should not affect the resolver
+        meta = {"next_up": [101, 102], "next_up_order": {"preset": "backlog"}}
+        name, order = resolve_next_up_order(meta)
+        self.assertEqual(name, "backlog")
+        self.assertEqual(order, PRESETS["backlog"])
+
+
 if __name__ == "__main__":
     unittest.main()