@stylusnexus/work-plan 2026.6.15 → 2026.6.18

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

@@ -0,0 +1,147 @@
+"""Tests for the dedupe-tiers command and its tracks.py helpers (#359)."""
+import io
+import sys
+import tempfile
+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 dedupe_tiers
+from lib import tracks
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _track(*, name, repo="org/repo", folder="repo", issues=None, body="", path=None,
+           tier="private"):
+    meta = {"track": name, "github": {"repo": repo}}
+    if issues is not None:
+        meta["github"]["issues"] = issues
+    return SimpleNamespace(
+        name=name,
+        path=Path(path) if path else Path(f"/tmp/notes/{folder}/{name}.md"),
+        repo=repo,
+        folder=folder,
+        meta=meta,
+        body=body,
+        tier=tier,
+    )
+
+
+def _drive(args, pairs, *, notes_root="/tmp/notes"):
+    cfg = {"notes_root": notes_root, "repos": {"repo": {"github": "org/repo"}}}
+    buf = io.StringIO()
+    with patch("commands.dedupe_tiers.load_config", return_value=cfg), \
+         patch("commands.dedupe_tiers.find_tier_duplicates", return_value=pairs), \
+         redirect_stdout(buf):
+        rc = dedupe_tiers.run(args)
+    return rc, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# issue_refs
+# ---------------------------------------------------------------------------
+
+class TestIssueRefs(unittest.TestCase):
+    def test_unions_frontmatter_and_body(self):
+        t = _track(name="a", issues=[10, 20], body="see #20 and #30 here")
+        self.assertEqual(tracks.issue_refs(t), {10, 20, 30})
+
+    def test_empty_when_no_refs(self):
+        t = _track(name="a", issues=None, body="no refs at all")
+        self.assertEqual(tracks.issue_refs(t), set())
+
+    def test_ignores_non_int_frontmatter(self):
+        t = _track(name="a", issues=[1, "oops", None], body="")
+        self.assertEqual(tracks.issue_refs(t), {1})
+
+
+# ---------------------------------------------------------------------------
+# find_tier_duplicates pairing (helpers patched)
+# ---------------------------------------------------------------------------
+
+class TestFindTierDuplicates(unittest.TestCase):
+    def test_pairs_only_colliding_active_tracks(self):
+        shared = [_track(name="dup", tier="shared"), _track(name="only-shared", tier="shared")]
+        private = [_track(name="dup"), _track(name="only-private")]
+        cfg = {"notes_root": "/tmp/does-not-exist-xyz", "repos": {}}
+        with patch.object(tracks, "_discover_shared_tracks") as ds, \
+             patch.object(tracks, "_discover_private_tracks", return_value=private):
+            # active call returns `shared`; archive-only call returns []
+            ds.side_effect = lambda cfg, include_archive=False, archive_only=False: (
+                [] if archive_only else shared)
+            pairs = tracks.find_tier_duplicates(cfg)
+        names = [(s.name, p.name) for (s, p) in pairs]
+        self.assertEqual(names, [("dup", "dup")])
+
+
+# ---------------------------------------------------------------------------
+# command: report / apply / safety
+# ---------------------------------------------------------------------------
+
+class TestDedupeCommand(unittest.TestCase):
+    def test_no_pairs_reports_nothing(self):
+        rc, out = _drive([], [])
+        self.assertEqual(rc, 0)
+        self.assertIn("Nothing to dedupe", out)
+
+    def test_dry_run_removes_nothing(self):
+        with tempfile.TemporaryDirectory() as d:
+            pf = Path(d) / "dup.md"
+            pf.write_text("# dup\n")
+            shared = _track(name="dup", issues=[1, 2], tier="shared")
+            private = _track(name="dup", issues=[1], path=str(pf))
+            rc, out = _drive([], [(shared, private)])
+            self.assertTrue(pf.exists(), "dry run must not delete")
+        self.assertEqual(rc, 0)
+        self.assertIn("Dry run", out)
+        self.assertIn("--apply", out)
+
+    def test_apply_removes_subset_orphan(self):
+        with tempfile.TemporaryDirectory() as d:
+            pf = Path(d) / "dup.md"
+            pf.write_text("# dup\n")
+            shared = _track(name="dup", issues=[1, 2, 3], tier="shared")
+            private = _track(name="dup", issues=[1, 3], path=str(pf))
+            rc, out = _drive(["--apply"], [(shared, private)])
+            self.assertEqual(rc, 0)
+            self.assertFalse(pf.exists(), "subset orphan must be removed on --apply")
+        self.assertIn("Removed 1 private orphan", out)
+
+    def test_apply_keeps_diverged_orphan(self):
+        with tempfile.TemporaryDirectory() as d:
+            pf = Path(d) / "dup.md"
+            pf.write_text("# dup\n")
+            # private references #99 which the shared twin lacks → must be kept
+            shared = _track(name="dup", issues=[1, 2], tier="shared")
+            private = _track(name="dup", issues=[1], body="leftover #99", path=str(pf))
+            rc, out = _drive(["--apply"], [(shared, private)])
+            self.assertEqual(rc, 0)
+            self.assertTrue(pf.exists(), "diverged orphan must NOT be removed")
+        self.assertIn("#99", out)
+        self.assertIn("manual review", out)
+
+    def test_repo_filter_scopes_pairs(self):
+        a_shared = _track(name="a", repo="org/a", folder="a", issues=[1], tier="shared")
+        a_priv = _track(name="a", repo="org/a", folder="a", issues=[1])
+        b_shared = _track(name="b", repo="org/b", folder="b", issues=[1], tier="shared")
+        b_priv = _track(name="b", repo="org/b", folder="b", issues=[1])
+        rc, out = _drive(["--repo=a"], [(a_shared, a_priv), (b_shared, b_priv)])
+        self.assertEqual(rc, 0)
+        self.assertIn("a  (repo org/a)", out)
+        self.assertNotIn("org/b", out)
+
+    def test_repo_flag_without_value_is_usage_error(self):
+        rc, _ = _drive(["--repo"], [])
+        self.assertEqual(rc, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -33,6 +33,38 @@ class DetectDriftTest(unittest.TestCase):
     def test_no_table_returns_empty(self):
         self.assertEqual(detect_drift("# No table\n", [{"number": 1, "state": "CLOSED"}]), [])
 
+    # --- OPEN-side + ambiguous-body cases: pin the *intentional asymmetry* ----
+    # CLOSED is terminal → broad check (anything not-closed drifts). OPEN is not
+    # terminal → narrow check (only an explicit closed marker drifts). These
+    # guard against someone "restoring symmetry" with a `not looks_open` open-side
+    # check, which would false-positive every in-progress row.
+
+    def _body(self, status: str) -> str:
+        return ("| # | Title | Status |\n"
+                "|---|---|---|\n"
+                f"| #1 | foo | {status} |\n")
+
+    def test_drift_when_closed_in_md_open_in_github(self):
+        # OPEN-side condition (was untested): body says shipped, GitHub reopened it.
+        drift = detect_drift(self._body("✅ Shipped"), [{"number": 1, "state": "OPEN"}])
+        self.assertEqual(len(drift), 1)
+        self.assertEqual(drift[0]["github_state"], "OPEN")
+
+    def test_no_drift_when_open_in_md_open_in_github(self):
+        self.assertEqual(detect_drift(self._body("🔲 Open"), [{"number": 1, "state": "OPEN"}]), [])
+
+    def test_open_with_ambiguous_status_is_NOT_drift(self):
+        # The deliberate narrow OPEN-side: an in-progress row must not be flagged.
+        self.assertEqual(
+            detect_drift(self._body("🚧 In progress"), [{"number": 1, "state": "OPEN"}]), [])
+
+    def test_closed_with_ambiguous_status_IS_drift(self):
+        # The deliberate broad CLOSED-side: a closed issue whose row doesn't read
+        # closed (here: ambiguous) is drift.
+        drift = detect_drift(self._body("🚧 In progress"), [{"number": 1, "state": "CLOSED"}])
+        self.assertEqual(len(drift), 1)
+        self.assertEqual(drift[0]["github_state"], "CLOSED")
+
 
 if __name__ == "__main__":
     unittest.main()

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

@@ -49,6 +49,69 @@ class BuildExportTest(unittest.TestCase):
         self.assertIsNone(out["tracks"][0]["path"])
         json.dumps(out)  # null is serializable
 
+class BuildExportNextUpAutoTest(unittest.TestCase):
+    """next_up_auto: true → export derives next_up live via the ranking preset."""
+
+    def _open(self, n, pri, ms="v1"):
+        return {"number": n, "state": "open", "title": f"#{n}",
+                "labels": [{"name": f"priority/{pri}"}], "milestone": {"title": ms},
+                "updatedAt": "2026-06-10T00:00:00Z", "blocked_by": [], "blocking": []}
+
+    def _track_auto(self, auto):
+        meta = {"status": "active", "launch_priority": "P2", "milestone_alignment": "v1",
+                "blockers": [], "next_up": [7], "depends_on": [],
+                "github": {"repo": "o/r", "issues": [1, 2, 3]}}
+        if auto:
+            meta["next_up_auto"] = True
+        return SimpleNamespace(name="t", repo="o/r", tier="private",
+                               path=Path("/tmp/notes/t.md"), folder="myrepo", meta=meta)
+
+    def _issues(self):
+        # P0 #3, P1 #2, P2 #1 — flow ranks by priority within the same milestone.
+        return [self._open(1, "P2"), self._open(2, "P1"), self._open(3, "P0")]
+
+    def test_auto_derives_and_flags(self):
+        out = build_export([self._track_auto(True)],
+                           {("o/r", "t"): self._issues()},
+                           {"o/r": "PRIVATE"}, now="t")
+        tr = out["tracks"][0]
+        self.assertEqual(tr["next_up"], [3, 2, 1])      # P0 → P1 → P2 (ignores stored [7])
+        self.assertTrue(tr["next_up_auto"])
+
+    def test_no_auto_uses_stored_list(self):
+        out = build_export([self._track_auto(False)],
+                           {("o/r", "t"): self._issues()},
+                           {"o/r": "PRIVATE"}, now="t")
+        tr = out["tracks"][0]
+        self.assertEqual(tr["next_up"], [7])            # the curated list, unchanged
+        self.assertFalse(tr["next_up_auto"])
+
+    def test_auto_on_with_zero_open_issues_still_exports_flag_true(self):
+        """next_up_auto: true + zero fetched issues → next_up_auto=True in export (the
+        SETTING, not whether auto-derivation actually ran).  Viewer toggle must show
+        On even when there are no issues to rank.
+
+        When no issues are fetched, the auto-derivation branch does not run (there's
+        nothing to rank); the export still emits next_up_auto=True so the viewer
+        knows the flag is on.  The next_up list itself falls through to the curated
+        list (which may be non-empty — that's acceptable and a separate concern)."""
+        # Use a track with no stored next_up to isolate the flag assertion cleanly.
+        meta = {"status": "active", "launch_priority": "P2", "milestone_alignment": "v1",
+                "blockers": [], "next_up": [], "depends_on": [],
+                "next_up_auto": True,
+                "github": {"repo": "o/r", "issues": []}}
+        from types import SimpleNamespace
+        from pathlib import Path
+        t = SimpleNamespace(name="t", repo="o/r", tier="private",
+                            path=Path("/tmp/notes/t.md"), folder="myrepo", meta=meta)
+        out = build_export([t],
+                           {("o/r", "t"): []},           # zero issues fetched
+                           {"o/r": "PRIVATE"}, now="t")
+        tr = out["tracks"][0]
+        self.assertTrue(tr["next_up_auto"])              # flag reflects setting, not derivation
+        self.assertEqual(tr["next_up"], [])              # no issues → empty list
+
+
 class BuildExportNextUpFilterTest(unittest.TestCase):
     """next_up entries whose issue is closed in the fetched payload are filtered out."""
 

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

@@ -151,6 +151,49 @@ class ExportRunJsonTest(unittest.TestCase):
         self.assertEqual(rc, 0)
         self.assertEqual(out["tracks"][0]["issues"], [])
 
+    # --- tier_duplicates (#361) -------------------------------------------
+
+    def _dup_track(self, *, issues, body="", path):
+        return SimpleNamespace(
+            repo=_SHARED_REPO, folder="myrepo", name="dup", path=Path(path),
+            meta={"github": {"repo": _SHARED_REPO, "issues": issues}}, body=body,
+        )
+
+    def test_tier_duplicates_empty_when_none(self):
+        """With no notes_root in cfg (mock returns {}), the field is an empty
+        list — present but quiet, so the viewer can rely on its shape."""
+        tracks = [_track("alpha", _SHARED_REPO, [1])]
+        rc, out, _ = self._run_with_mocks(tracks, _EXPORT_MAP)
+        self.assertEqual(rc, 0)
+        self.assertEqual(out["tier_duplicates"], [])
+
+    def test_tier_duplicate_subset_is_safe(self):
+        shared = self._dup_track(issues=[1, 2, 3], path="/repo/.work-plan/dup.md")
+        private = self._dup_track(issues=[1, 3], path="/notes/myrepo/dup.md")
+        with patch("commands.export.find_tier_duplicates",
+                   return_value=[(shared, private)]):
+            rc, out, _ = self._run_with_mocks([_track("a", _SHARED_REPO, [1])], _EXPORT_MAP)
+        self.assertEqual(rc, 0)
+        td = out["tier_duplicates"]
+        self.assertEqual(len(td), 1)
+        self.assertEqual(td[0]["name"], "dup")
+        self.assertEqual(td[0]["repo"], _SHARED_REPO)
+        self.assertEqual(td[0]["folder"], "myrepo")
+        self.assertTrue(td[0]["safe"])
+        self.assertEqual(td[0]["shared_path"], str(Path("/repo/.work-plan/dup.md")))
+        self.assertEqual(td[0]["private_path"], str(Path("/notes/myrepo/dup.md")))
+
+    def test_tier_duplicate_diverged_is_unsafe(self):
+        # private references #99, which the shared twin lacks → not safe to remove
+        shared = self._dup_track(issues=[1, 2], path="/repo/.work-plan/dup.md")
+        private = self._dup_track(issues=[1], body="leftover #99",
+                                  path="/notes/myrepo/dup.md")
+        with patch("commands.export.find_tier_duplicates",
+                   return_value=[(shared, private)]):
+            rc, out, _ = self._run_with_mocks([_track("a", _SHARED_REPO, [1])], _EXPORT_MAP)
+        self.assertEqual(rc, 0)
+        self.assertFalse(out["tier_duplicates"][0]["safe"])
+
     def test_visibility_included_in_output(self):
         tracks = [_track("alpha", _SHARED_REPO, [1])]
         rc, out, _ = self._run_with_mocks(tracks, _EXPORT_MAP, vis={_SHARED_REPO: "PUBLIC"})
@@ -290,6 +333,19 @@ class ExportCommandUntrackedTest(unittest.TestCase):
         self.assertEqual(rc, 0)
         self.assertEqual(out["untracked"], [])
 
+    def test_empty_track_still_surfaces_untracked(self):
+        """A repo whose only track has issues:[] must still surface its open
+        issues as untracked (#342). repo_to_numbers omits such a track, so the
+        untracked loop must key off repos-with-tracks, not tracked issues."""
+        tracks = [_track("general", _SHARED_REPO, [])]  # empty track
+        export_map = {}  # no tracked issues to fetch
+        open_rows = {_SHARED_REPO: [_ISSUE_A, _ISSUE_C]}  # but the repo has open issues
+        rc, out = self._run_with_mocks(tracks, export_map, open_rows)
+        self.assertEqual(rc, 0)
+        entry = next(e for e in out["untracked"] if e["repo"] == _SHARED_REPO)
+        nums = sorted(i["number"] for i in entry["issues"])
+        self.assertEqual(nums, [1, 3])  # both open issues are untracked
+
     def test_schema_stays_1_with_untracked(self):
         tracks = [_track("alpha", _SHARED_REPO, [1])]
         open_rows = {_SHARED_REPO: [_ISSUE_A, _ISSUE_B]}

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

@@ -0,0 +1,130 @@
+"""Tests for `handoff --suggest-next` — the read-only JSON suggestion mode (#274).
+
+The VS Code native auto-next picker needs the algorithmic next_up suggestion
+WITHOUT a write or a TTY prompt (the CLI's prompt helpers no-op under VS Code's
+non-TTY stdin). `--suggest-next` computes the same sibling-filtered suggestion as
+`--auto-next` and prints it as JSON; the extension renders + confirms it and
+writes back via `--set-next`. These tests assert: valid JSON shape, sibling-claim
+skips surface in `skipped` (not written), no frontmatter is mutated, and the
+soft-error payloads (no repo / no issues) stay parseable with exit 0.
+"""
+import io
+import json
+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([100, 200] if issues is None else issues),
+                   "branches": []},
+        "next_up": list(next_up or []),
+    }
+    path = dir_path / f"{slug}.md"
+    write_file(path, meta, f"\n# {slug}\n\nBody.\n")
+    return path
+
+
+def _open_issue(num: int, *, priority: str = "P1", milestone=None) -> dict:
+    return {
+        "number": num,
+        "title": f"issue-{num}",
+        "state": "OPEN",
+        "labels": [{"name": f"priority/{priority}"}],
+        "updatedAt": "2026-04-30T00:00:00Z",
+        "milestone": milestone,
+    }
+
+
+class SuggestNextJsonTest(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(self, track_name, *, issues_response):
+        buf = io.StringIO()
+        with mock.patch("commands.handoff.fetch_issues", return_value=issues_response), \
+             redirect_stdout(buf):
+            rc = handoff.run([track_name, "--suggest-next"])
+        return rc, buf.getvalue()
+
+    def test_emits_valid_json_with_decorated_suggestions(self):
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo",
+                             issues=[100, 200])
+        rc, out = self._run("track-a",
+                            issues_response=[_open_issue(100, milestone={"title": "v1.0.0"}),
+                                             _open_issue(200)])
+        self.assertEqual(rc, 0)
+        payload = json.loads(out)
+        self.assertEqual(payload["track"], "track-a")
+        self.assertEqual(payload["repo"], "stylusnexus/Demo")
+        nums = [s["number"] for s in payload["suggested"]]
+        self.assertEqual(sorted(nums), [100, 200])
+        first = next(s for s in payload["suggested"] if s["number"] == 100)
+        self.assertEqual(first["title"], "issue-100")
+        self.assertEqual(first["priority"], "P1")
+        self.assertEqual(first["milestone"], "v1.0.0")
+
+    def test_read_only_does_not_write_next_up(self):
+        target = _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo",
+                             issues=[100, 200], next_up=[7])
+        rc, out = self._run("track-a",
+                            issues_response=[_open_issue(100), _open_issue(200)])
+        self.assertEqual(rc, 0)
+        meta, _ = parse_file(target)
+        self.assertEqual(meta["next_up"], [7])  # untouched by a read-only suggest
+
+    def test_sibling_claimed_issue_lands_in_skipped_not_suggested(self):
+        _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("track-a",
+                            issues_response=[_open_issue(100), _open_issue(200)])
+        payload = json.loads(out)
+        self.assertEqual([s["number"] for s in payload["suggested"]], [200])
+        self.assertEqual(payload["skipped"], [{"number": 100, "claimed_by": "track-b"}])
+
+    def test_no_issues_attached_is_soft_error_with_empty_suggested(self):
+        _make_track(self.repo_dir, "track-a", repo="stylusnexus/Demo", issues=[])
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = handoff.run(["track-a", "--suggest-next"])
+        self.assertEqual(rc, 0)
+        payload = json.loads(buf.getvalue())
+        self.assertEqual(payload["suggested"], [])
+        self.assertIn("error", payload)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,114 @@
+"""Tests for lib.heuristic_triage — the offline (no-LLM) track scorer (#373).
+
+Covers: milestone match, track-label overlap (incl. the track/<slug> default),
+keyword overlap, abstain when nothing clears the bar, margin clear-vs-narrow from
+the top-vs-runner gap, and the v2 entry shape.
+"""
+import sys
+import unittest
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.heuristic_triage import score_suggestions
+
+
+def _iss(number, title="", milestone=None, labels=()):
+    return {
+        "number": number,
+        "title": title,
+        "milestone": {"title": milestone} if milestone else None,
+        "labels": [{"name": n} for n in labels],
+    }
+
+
+def _trk(slug, name=None, milestone=None, scope="", labels=None):
+    return {"slug": slug, "name": name or slug, "milestone": milestone,
+            "scope": scope, "labels": labels}
+
+
+class HeuristicScoreTest(unittest.TestCase):
+
+    def _one(self, entries):
+        self.assertEqual(len(entries), 1)
+        return entries[0]
+
+    def test_milestone_match_suggests(self):
+        e = self._one(score_suggestions(
+            [_iss(1, "rate limit", milestone="v0.4")],
+            [_trk("auth-flow", milestone="v0.4")],
+        ))
+        self.assertEqual(e["verdict"], "suggest")
+        self.assertEqual(e["track"], "auth-flow")
+        self.assertIn("milestone v0.4", e["rationale"])
+
+    def test_track_label_overlap_suggests(self):
+        e = self._one(score_suggestions(
+            [_iss(2, "something", labels=["area/auth"])],
+            [_trk("auth-flow", labels=["area/auth"])],
+        ))
+        self.assertEqual(e["verdict"], "suggest")
+        self.assertIn("label area/auth", e["rationale"])
+
+    def test_default_track_slug_label(self):
+        # No github.labels on the track → default `track/<slug>` is matched.
+        e = self._one(score_suggestions(
+            [_iss(3, "x", labels=["track/auth-flow"])],
+            [_trk("auth-flow", labels=None)],
+        ))
+        self.assertEqual(e["verdict"], "suggest")
+
+    def test_keyword_only_below_bar_abstains(self):
+        # A single keyword hit (0.1) is below the 0.3 suggest bar → abstain.
+        e = self._one(score_suggestions(
+            [_iss(4, "sessions cleanup")],
+            [_trk("tabletop-sessions", name="tabletop sessions")],
+        ))
+        self.assertEqual(e["verdict"], "abstain")
+
+    def test_no_signal_abstains(self):
+        e = self._one(score_suggestions(
+            [_iss(5, "totally unrelated billing thing")],
+            [_trk("auth-flow", milestone="v0.4")],
+        ))
+        self.assertEqual(e["verdict"], "abstain")
+        self.assertNotIn("track", e)
+
+    def test_margin_narrow_when_two_tracks_tie(self):
+        # Both tracks share the milestone → equal top score → narrow margin.
+        e = self._one(score_suggestions(
+            [_iss(6, "x", milestone="v0.4")],
+            [_trk("auth-flow", milestone="v0.4"), _trk("idea-mode", milestone="v0.4")],
+        ))
+        self.assertEqual(e["verdict"], "suggest")
+        self.assertEqual(e["margin"], "narrow")
+        self.assertIn("runner_up", e)
+
+    def test_margin_clear_when_one_track_dominates(self):
+        e = self._one(score_suggestions(
+            [_iss(7, "auth rate limit", milestone="v0.4", labels=["area/auth"])],
+            [_trk("auth-flow", name="auth flow", milestone="v0.4", labels=["area/auth"]),
+             _trk("idea-mode", milestone="v9.9")],
+        ))
+        self.assertEqual(e["margin"], "clear")
+        self.assertEqual(e["track"], "auth-flow")
+
+    def test_confidence_clamped_and_in_range(self):
+        e = self._one(score_suggestions(
+            [_iss(8, "auth flow rate limit session token scope",
+                  milestone="v0.4", labels=["area/auth"])],
+            [_trk("auth-flow", name="auth flow", milestone="v0.4",
+                  scope="auth rate limit session token scope", labels=["area/auth"])],
+        ))
+        self.assertLessEqual(e["confidence"], 1.0)
+        self.assertGreaterEqual(e["confidence"], 0.3)
+
+    def test_malformed_issue_number_skipped(self):
+        entries = score_suggestions([{"number": "not-an-int", "title": "x"}],
+                                    [_trk("a")])
+        self.assertEqual(entries, [])
+
+
+if __name__ == "__main__":
+    unittest.main()