@stylusnexus/work-plan 2026.6.13 → 2026.6.14

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

@@ -17,7 +17,7 @@ def _track(name, repo, issues, blockers=None, next_up=None, status="active", dep
 class BuildExportTest(unittest.TestCase):
     def test_schema_and_shape(self):
         tracks = [_track("ph", "o/r", [1, 2], blockers=[9], next_up=[1])]
-        issues_by_track = {"ph": [
+        issues_by_track = {("o/r", "ph"): [
             {"number": 1, "title": "a", "state": "OPEN", "assignees": [{"login": "eve"}]},
             {"number": 2, "title": "b", "state": "CLOSED", "assignees": []}]}
         vis = {"o/r": "PRIVATE"}
@@ -34,7 +34,7 @@ class BuildExportTest(unittest.TestCase):
         self.assertEqual(t["folder"], "myrepo")
         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})
+        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": []})
         json.dumps(out)  # must be serializable
 
     def test_path_is_null_when_track_has_no_path(self):
@@ -42,7 +42,7 @@ class BuildExportTest(unittest.TestCase):
         viewer disables its open-file affordance instead of erroring (#211)."""
         t0 = SimpleNamespace(name="np", repo="o/r", tier="private",
             meta={"status": "active", "github": {"repo": "o/r", "issues": []}})
-        out = build_export([t0], {"np": []}, {"o/r": "PRIVATE"}, now="2026-06-12T00:00")
+        out = build_export([t0], {("o/r", "np"): []}, {"o/r": "PRIVATE"}, now="2026-06-12T00:00")
         self.assertIsNone(out["tracks"][0]["path"])
         json.dumps(out)  # null is serializable
 
@@ -56,7 +56,7 @@ class BuildExportNextUpFilterTest(unittest.TestCase):
             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")
+        out = build_export(tracks, {("o/r", "t1"): raw_issues}, {"o/r": "PRIVATE"}, now="t")
         return out["tracks"][0]["next_up"]
 
     def test_closed_next_up_filtered(self):
@@ -79,7 +79,7 @@ class BuildExportNextUpFilterTest(unittest.TestCase):
         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")
+        out = build_export(tracks, {("o/r", "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])
@@ -290,12 +290,37 @@ class GroupIssuesByMilestoneTest(unittest.TestCase):
         self.assertEqual(group_issues_by_milestone([]), [])
 
 
+class BuildExportPlanTest(unittest.TestCase):
+    """The track↔plan link badge on each Track (#285)."""
+
+    def test_plan_null_when_no_badge(self):
+        tracks = [_track("alpha", "o/r", [1])]
+        out = build_export(tracks, {("o/r", "alpha"): []}, {"o/r": "PRIVATE"}, now="t")
+        self.assertIsNone(out["tracks"][0]["plan"])
+
+    def test_plan_badge_passed_through(self):
+        tracks = [_track("alpha", "o/r", [1])]
+        badge = {"rel": "docs/plans/p.md", "resolved": True, "verdict": "shipped",
+                 "glyph": "✅", "files_present": 9, "files_declared": 9,
+                 "checkboxes_done": 0, "checkboxes_total": 24, "lie_gap": False,
+                 "stalled": False, "override": "shipped"}
+        out = build_export(tracks, {("o/r", "alpha"): []}, {"o/r": "PRIVATE"}, now="t",
+                           plan_by_track={"alpha": badge})
+        self.assertEqual(out["tracks"][0]["plan"], badge)
+
+    def test_unresolved_badge_passed_through(self):
+        tracks = [_track("alpha", "o/r", [1])]
+        out = build_export(tracks, {("o/r", "alpha"): []}, {"o/r": "PRIVATE"}, now="t",
+                           plan_by_track={"alpha": {"rel": "docs/plans/p.md", "resolved": False}})
+        self.assertEqual(out["tracks"][0]["plan"], {"rel": "docs/plans/p.md", "resolved": False})
+
+
 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": [
+        issues_by_track = {("o/r", "alpha"): [
             {"number": 1, "title": "a", "state": "OPEN", "assignees": []},
         ]}
         out = build_export(tracks, issues_by_track, {"o/r": "PRIVATE"}, now="t")
@@ -303,7 +328,7 @@ class BuildExportDependsOnTest(unittest.TestCase):
 
     def test_depends_on_empty_by_default(self):
         tracks = [_track("alpha", "o/r", [1])]
-        issues_by_track = {"alpha": [
+        issues_by_track = {("o/r", "alpha"): [
             {"number": 1, "title": "a", "state": "OPEN", "assignees": []},
         ]}
         out = build_export(tracks, issues_by_track, {"o/r": "PRIVATE"}, now="t")
@@ -316,7 +341,7 @@ class BuildExportReposListTest(unittest.TestCase):
 
     def test_emits_config_repos_including_trackless(self):
         tracks = [_track("ph", "o/r", [1])]
-        issues_by_track = {"ph": [{"number": 1, "title": "a", "state": "OPEN", "assignees": []}]}
+        issues_by_track = {("o/r", "ph"): [{"number": 1, "title": "a", "state": "OPEN", "assignees": []}]}
         config_repos = [
             {"folder": "r", "repo": "o/r", "local": "/x/r", "has_local": True, "visibility": "PRIVATE"},
             {"folder": "fresh", "repo": "o/fresh", "local": None, "has_local": False, "visibility": "PUBLIC"},
@@ -332,3 +357,131 @@ class BuildExportReposListTest(unittest.TestCase):
     def test_repos_defaults_to_empty_list(self):
         out = build_export([], {}, {}, now="2026-06-12T00:00")
         self.assertEqual(out["repos"], [])
+
+
+class InProgressExportTest(unittest.TestCase):
+    def _track(self, name, repo):
+        from types import SimpleNamespace
+        return SimpleNamespace(name=name, repo=repo, path=None, folder=None,
+                               tier="private",
+                               meta={"github": {"issues": []}, "next_up": []})
+
+    def test_in_progress_flag_set_from_hot_by_track(self):
+        t = self._track("alpha", "o/r")
+        issues_by_track = {("o/r", "alpha"): [
+            {"number": 1, "title": "a", "state": "open", "assignees": [],
+             "milestone": None, "labels": []},
+            {"number": 2, "title": "b", "state": "open", "assignees": [],
+             "milestone": None, "labels": []},
+        ]}
+        out = build_export([t], issues_by_track, {"o/r": "PRIVATE"},
+                           "2026-06-14T00:00:00",
+                           hot_by_track={("o/r", "alpha"): {1}})
+        issues = out["tracks"][0]["issues"]
+        self.assertTrue(next(i for i in issues if i["number"] == 1)["in_progress"])
+        self.assertFalse(next(i for i in issues if i["number"] == 2)["in_progress"])
+
+    def test_same_name_tracks_in_different_repos_do_not_bleed(self):
+        """Two same-named tracks in different repos must not share issue rows.
+
+        With (repo,name) keying, a single build_export call with both tracks
+        must give each track its own distinct issue list and correct
+        in_progress flags — no overwrite, no bleed.
+        """
+        t1 = self._track("dup", "o/r1")
+        t2 = self._track("dup", "o/r2")
+        # Deliberately different issue numbers AND titles so any bleed is obvious.
+        issues_r1 = [
+            {"number": 10, "title": "r1-issue", "state": "open", "assignees": [],
+             "milestone": None, "labels": []},
+        ]
+        issues_r2 = [
+            {"number": 20, "title": "r2-issue", "state": "open", "assignees": [],
+             "milestone": None, "labels": []},
+        ]
+        issues_by_track = {
+            ("o/r1", "dup"): issues_r1,
+            ("o/r2", "dup"): issues_r2,
+        }
+        hot_by_track = {
+            ("o/r1", "dup"): {10},   # issue 10 is in-progress in r1
+            # r2 has NO hot issues
+        }
+        out = build_export(
+            [t1, t2], issues_by_track, {"o/r1": "PRIVATE", "o/r2": "PRIVATE"},
+            "2026-06-14T00:00:00", hot_by_track=hot_by_track,
+        )
+        by_repo = {tr["repo"]: tr for tr in out["tracks"]}
+        r1_issues = by_repo["o/r1"]["issues"]
+        r2_issues = by_repo["o/r2"]["issues"]
+
+        # Each track got its own issue rows — no bleed
+        self.assertEqual(len(r1_issues), 1)
+        self.assertEqual(r1_issues[0]["number"], 10)
+        self.assertEqual(len(r2_issues), 1)
+        self.assertEqual(r2_issues[0]["number"], 20)
+
+        # in_progress flags are per-repo: r1/#10 hot, r2/#20 not
+        self.assertTrue(r1_issues[0]["in_progress"])
+        self.assertFalse(r2_issues[0]["in_progress"])
+
+    def test_no_hot_map_defaults_all_false(self):
+        t = self._track("alpha", "o/r")
+        ibt = {("o/r", "alpha"): [{"number": 1, "title": "a", "state": "open",
+                                    "assignees": [], "milestone": None, "labels": []}]}
+        out = build_export([t], ibt, {"o/r": "PRIVATE"}, "2026-06-14T00:00:00")
+        self.assertFalse(out["tracks"][0]["issues"][0]["in_progress"])
+
+    def test_label_presence_emitted_as_in_progress_label(self):
+        """Issue carrying the label gets in_progress_label=True regardless of hot."""
+        from lib.in_progress import IN_PROGRESS_LABEL
+        t = self._track("alpha", "o/r")
+        ibt = {("o/r", "alpha"): [
+            {"number": 1, "title": "a", "state": "open", "assignees": [],
+             "milestone": None, "labels": [{"name": IN_PROGRESS_LABEL}]},
+        ]}
+        out = build_export([t], ibt, {"o/r": "PRIVATE"}, "2026-06-14T00:00:00")
+        issue = out["tracks"][0]["issues"][0]
+        self.assertTrue(issue["in_progress"])        # union: label alone is enough
+        self.assertTrue(issue["in_progress_label"])  # label-only signal
+
+    def test_hot_branch_only_sets_union_not_label(self):
+        """Issue in hot_by_track (no label) → in_progress True but in_progress_label False."""
+        t = self._track("alpha", "o/r")
+        ibt = {("o/r", "alpha"): [
+            {"number": 5, "title": "b", "state": "open", "assignees": [],
+             "milestone": None, "labels": []},
+        ]}
+        out = build_export([t], ibt, {"o/r": "PRIVATE"}, "2026-06-14T00:00:00",
+                           hot_by_track={("o/r", "alpha"): {5}})
+        issue = out["tracks"][0]["issues"][0]
+        self.assertTrue(issue["in_progress"])         # union: hot branch fires
+        self.assertFalse(issue["in_progress_label"])  # no label present
+
+
+class BlockedByExportTest(unittest.TestCase):
+    def _track(self, name, repo):
+        from types import SimpleNamespace
+        return SimpleNamespace(name=name, repo=repo, path=None, folder=None,
+                               tier="private", meta={"github": {"issues": []}, "next_up": []})
+
+    def test_emits_blocked_by_and_blocking(self):
+        t = self._track("alpha", "o/r")
+        issue = {"number": 1, "title": "a", "state": "open", "assignees": [],
+                 "milestone": None, "labels": [],
+                 "blocked_by": [{"number": 9, "repo": "o/r", "title": "dep"}], "blocking": []}
+        out = build_export([t], {("o/r", "alpha"): [issue]}, {"o/r": "PRIVATE"},
+                           "2026-06-14T00:00:00")
+        got = out["tracks"][0]["issues"][0]
+        self.assertEqual(got["blocked_by"], [{"number": 9, "repo": "o/r", "title": "dep"}])
+        self.assertEqual(got["blocking"], [])
+
+    def test_defaults_empty_when_absent(self):
+        t = self._track("alpha", "o/r")
+        issue = {"number": 1, "title": "a", "state": "open", "assignees": [],
+                 "milestone": None, "labels": []}
+        out = build_export([t], {("o/r", "alpha"): [issue]}, {"o/r": "PRIVATE"},
+                           "2026-06-14T00:00:00")
+        got = out["tracks"][0]["issues"][0]
+        self.assertEqual(got["blocked_by"], [])
+        self.assertEqual(got["blocking"], [])

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

@@ -310,5 +310,108 @@ class ExportCommandGateTest(unittest.TestCase):
         self.assertEqual(export_cmd.run([]), 2)
 
 
+class ExportPlanBadgeTest(unittest.TestCase):
+    """`_plan_badge` resolves a track's declared plan link into an execution
+    badge using the same evaluator as plan-status (#285). Real temp repo so the
+    manifest/checkbox/frontmatter read is exercised; git date is mocked."""
+
+    import tempfile as _tempfile
+
+    def _repo_with_plan(self, d, plan_text):
+        root = Path(d)
+        (root / "docs/plans").mkdir(parents=True)
+        (root / "docs/plans/p.md").write_text(plan_text)
+        (root / "src").mkdir()
+        (root / "src/new.ts").write_text("export const x = 1")  # 1/1 declared present
+        return root
+
+    def _track_with_plan(self, rel="docs/plans/p.md", folder="demo"):
+        return SimpleNamespace(
+            name="alpha", repo="o/r", tier="private", folder=folder,
+            path=Path("/tmp/notes/alpha.md"), has_frontmatter=True,
+            meta={"status": "active", "plan": rel, "github": {"repo": "o/r", "issues": []}})
+
+    def _badge(self, track, root):
+        with patch("commands.export.resolve_local_path_for_folder", return_value=root), \
+             patch("commands.plan_status.git_state.path_last_commit_date", return_value=None):
+            from datetime import date
+            return export_cmd._plan_badge(track, {"notes_root": "/tmp"}, date(2026, 6, 13), 60, 14)
+
+    # A shipped-by-files plan with 0/2 boxes -> lie_gap unless overridden.
+    BODY = ("# P\n\n**Files:**\n- Create: `src/new.ts`\n- [ ] Step 1\n- [ ] Step 2\n")
+
+    def test_no_plan_returns_none(self):
+        t = self._track_with_plan()
+        t.meta.pop("plan")
+        self.assertIsNone(self._badge(t, Path("/tmp")))
+
+    def test_resolved_badge_with_lie_gap(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo_with_plan(d, self.BODY)
+            badge = self._badge(self._track_with_plan(), root)
+            self.assertTrue(badge["resolved"])
+            self.assertEqual(badge["verdict"], "shipped")
+            self.assertEqual(badge["files_present"], 1)
+            self.assertEqual(badge["files_declared"], 1)
+            self.assertTrue(badge["lie_gap"])
+            self.assertIsNone(badge["override"])
+
+    def test_override_silences_lie_gap_in_badge(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo_with_plan(d, f"---\nverdict_override: shipped\n---\n{self.BODY}")
+            badge = self._badge(self._track_with_plan(), root)
+            self.assertEqual(badge["override"], "shipped")
+            self.assertFalse(badge["lie_gap"])
+
+    def test_unresolved_when_no_local_clone(self):
+        t = self._track_with_plan()
+        with patch("commands.export.resolve_local_path_for_folder", return_value=None):
+            from datetime import date
+            badge = export_cmd._plan_badge(t, {"notes_root": "/tmp"}, date(2026, 6, 13), 60, 14)
+        self.assertEqual(badge, {"rel": "docs/plans/p.md", "resolved": False})
+
+    def test_unresolved_when_file_absent(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            root = Path(d)  # empty repo — declared plan file does not exist
+            badge = self._badge(self._track_with_plan(rel="docs/plans/missing.md"), root)
+            self.assertEqual(badge, {"rel": "docs/plans/missing.md", "resolved": False})
+
+    def test_no_folder_is_unresolved(self):
+        t = self._track_with_plan(folder=None)
+        from datetime import date
+        badge = export_cmd._plan_badge(t, {"notes_root": "/tmp"}, date(2026, 6, 13), 60, 14)
+        self.assertEqual(badge, {"rel": "docs/plans/p.md", "resolved": False})
+
+
+class ExportHotByTrackTest(unittest.TestCase):
+    def test_export_marks_in_progress_from_hot_branch(self):
+        import io
+        from contextlib import redirect_stdout, redirect_stderr
+        track = SimpleNamespace(name="alpha", repo="o/r", folder="alpha",
+                                path=None, tier="private", has_frontmatter=True,
+                                meta={"github": {"issues": [1]}, "next_up": []})
+        issue = {"number": 1, "title": "a", "state": "open", "assignees": [],
+                 "milestone": None, "labels": []}
+        with patch("commands.export.load_config", return_value={"repos": {}}), \
+             patch("commands.export.discover_tracks", return_value=[track]), \
+             patch("commands.export.fetch_export_issues",
+                   return_value={("o/r", 1): issue}), \
+             patch("commands.export.fetch_open_issues", return_value=[]), \
+             patch("commands.export.repo_visibility", return_value="PRIVATE"), \
+             patch("commands.export.resolve_local_path_for_folder",
+                   return_value=Path("/repo")), \
+             patch("commands.export.hot_issue_numbers", return_value={1}), \
+             patch.object(Path, "exists", return_value=True):
+            out, err = io.StringIO(), io.StringIO()
+            with redirect_stdout(out), redirect_stderr(err):
+                rc = export_cmd.run(["--json"])
+        self.assertEqual(rc, 0)
+        payload = json.loads(out.getvalue())
+        self.assertTrue(payload["tracks"][0]["issues"][0]["in_progress"])
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -2,13 +2,14 @@
 import unittest
 import sys
 from pathlib import Path
+from unittest import mock
 
 SKILL_ROOT = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(SKILL_ROOT))
 
 from lib.git_state import (
     gap_seconds_to_label, parse_iso_timestamp,
-    branch_in_progress,
+    branch_in_progress, hot_issue_numbers,
 )
 
 
@@ -47,5 +48,41 @@ class BranchInProgressTest(unittest.TestCase):
         self.assertFalse(branch_in_progress("any-branch", Path("/nonexistent")))
 
 
+class HotIssueNumbersTest(unittest.TestCase):
+    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))
+        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")):
+            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.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.assertEqual(hot_issue_numbers(Path("/repo")), set())
+
+    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())
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -13,6 +13,8 @@ from lib.github_state import (
     fetch_repo_issues_graphql, fetch_export_issues, _normalize_gql_node,
     extract_priority, fetch_recent_issues, short_milestone,
     repo_visibility, _VIS_CACHE, fetch_open_issues,
+    _GQL_FIELDS_LEAN, _GQL_FIELDS_FULL,
+    _gql_query, _GQL_ISSUE_DEPS,
 )
 
 
@@ -542,5 +544,69 @@ class FetchOpenIssuesTest(unittest.TestCase):
         self.assertIsInstance(result, list)
 
 
+class GqlFieldSetsTest(unittest.TestCase):
+    def test_lean_set_requests_labels(self):
+        # The export path uses the lean set; without labels the in-progress
+        # label signal is silently always false in the viewer (#271).
+        self.assertIn("labels(first: 50)", _GQL_FIELDS_LEAN)
+
+    def test_full_set_label_bound_is_50(self):
+        self.assertIn("labels(first: 50)", _GQL_FIELDS_FULL)
+
+
+class GqlIssueOnlyDepsTest(unittest.TestCase):
+    def test_deps_constant_has_both_connections(self):
+        self.assertIn("blockedBy(first: 50)", _GQL_ISSUE_DEPS)
+        self.assertIn("blocking(first: 50)", _GQL_ISSUE_DEPS)
+        self.assertIn("totalCount", _GQL_ISSUE_DEPS)
+
+    def test_query_puts_deps_under_issue_not_pullrequest(self):
+        q = _gql_query("o", "r", [5])
+        issue_frag = q.split("... on PullRequest")[0]
+        pr_frag = q.split("... on PullRequest")[1]
+        self.assertIn("blockedBy", issue_frag)
+        self.assertNotIn("blockedBy", pr_frag)
+
+
+class NormalizeDepsTest(unittest.TestCase):
+    def _node(self, blocked=None, blocking=None, bb_total=None, bl_total=None):
+        blocked = blocked or []
+        blocking = blocking or []
+        return {"number": 1, "title": "x", "state": "OPEN",
+                "blockedBy": {"totalCount": bb_total if bb_total is not None else len(blocked), "nodes": blocked},
+                "blocking": {"totalCount": bl_total if bl_total is not None else len(blocking), "nodes": blocking}}
+
+    def _edge(self, n, state="OPEN", repo="o/r", title="t"):
+        return {"number": n, "state": state, "title": title,
+                "repository": {"nameWithOwner": repo}}
+
+    def test_open_only_and_shape(self):
+        from lib.github_state import _normalize_gql_node
+        out = _normalize_gql_node(self._node(
+            blocked=[self._edge(10), self._edge(11, state="CLOSED")]))
+        self.assertEqual(out["blocked_by"], [{"number": 10, "repo": "o/r", "title": "t"}])
+        self.assertEqual(out["blocking"], [])
+        self.assertFalse(out["deps_truncated"])
+
+    def test_cross_repo_preserved(self):
+        from lib.github_state import _normalize_gql_node
+        out = _normalize_gql_node(self._node(
+            blocked=[self._edge(42, repo="other/repo")]))
+        self.assertEqual(out["blocked_by"][0]["repo"], "other/repo")
+
+    def test_truncation_flag_when_totalcount_exceeds_nodes(self):
+        from lib.github_state import _normalize_gql_node
+        out = _normalize_gql_node(self._node(
+            blocked=[self._edge(10)], bb_total=99))
+        self.assertTrue(out["deps_truncated"])
+
+    def test_missing_connections_default_empty(self):
+        from lib.github_state import _normalize_gql_node
+        out = _normalize_gql_node({"number": 1, "title": "x", "state": "OPEN"})
+        self.assertEqual(out["blocked_by"], [])
+        self.assertEqual(out["blocking"], [])
+        self.assertFalse(out["deps_truncated"])
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -0,0 +1,43 @@
+"""issue_in_progress union-merge truth table (#271). Pure — no subprocess."""
+import sys
+import unittest
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.in_progress import issue_in_progress, IN_PROGRESS_LABEL
+
+
+def _issue(number, state="OPEN", labels=None):
+    return {"number": number, "state": state,
+            "labels": [{"name": n} for n in (labels or [])]}
+
+
+class IssueInProgressTest(unittest.TestCase):
+    def test_open_hot_no_label(self):
+        self.assertTrue(issue_in_progress(_issue(271), {271}))
+
+    def test_open_cold_with_label(self):
+        self.assertTrue(issue_in_progress(_issue(271, labels=[IN_PROGRESS_LABEL]), set()))
+
+    def test_open_cold_no_label(self):
+        self.assertFalse(issue_in_progress(_issue(271), set()))
+
+    def test_closed_hot_and_label_is_not_in_progress(self):
+        self.assertFalse(
+            issue_in_progress(_issue(271, state="CLOSED", labels=[IN_PROGRESS_LABEL]), {271}))
+
+    def test_merged_with_label_is_not_in_progress(self):
+        self.assertFalse(
+            issue_in_progress(_issue(271, state="MERGED", labels=[IN_PROGRESS_LABEL]), {271}))
+
+    def test_lowercase_state_open(self):
+        self.assertTrue(issue_in_progress(_issue(5, state="open"), {5}))
+
+    def test_missing_labels_key_treated_as_none(self):
+        self.assertFalse(issue_in_progress({"number": 9, "state": "OPEN"}, set()))
+
+
+if __name__ == "__main__":
+    unittest.main()