@stylusnexus/work-plan 2026.6.13-2 → 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])
@@ -295,7 +295,7 @@ class BuildExportPlanTest(unittest.TestCase):
 
     def test_plan_null_when_no_badge(self):
         tracks = [_track("alpha", "o/r", [1])]
-        out = build_export(tracks, {"alpha": []}, {"o/r": "PRIVATE"}, now="t")
+        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):
@@ -304,13 +304,13 @@ class BuildExportPlanTest(unittest.TestCase):
                  "glyph": "✅", "files_present": 9, "files_declared": 9,
                  "checkboxes_done": 0, "checkboxes_total": 24, "lie_gap": False,
                  "stalled": False, "override": "shipped"}
-        out = build_export(tracks, {"alpha": []}, {"o/r": "PRIVATE"}, now="t",
+        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, {"alpha": []}, {"o/r": "PRIVATE"}, now="t",
+        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})
 
@@ -320,7 +320,7 @@ class BuildExportDependsOnTest(unittest.TestCase):
 
     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")
@@ -328,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")
@@ -341,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"},
@@ -357,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

@@ -386,5 +386,32 @@ class ExportPlanBadgeTest(unittest.TestCase):
         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()

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

@@ -0,0 +1,166 @@
+"""in-progress label write (#271). Offline — gh subprocess mocked."""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout, redirect_stderr
+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 lib import github_state
+
+
+def _proc(rc, stdout="", stderr=""):
+    return SimpleNamespace(returncode=rc, stdout=stdout, stderr=stderr)
+
+
+class SetIssueInProgressHelperTest(unittest.TestCase):
+    def test_add_creates_label_then_adds_with_repo(self):
+        calls = []
+        def fake_run(args, **kw):
+            calls.append(args)
+            return _proc(0)
+        with mock.patch("lib.github_state.subprocess.run", side_effect=fake_run):
+            ok, msg = github_state.set_issue_in_progress("o/r", 271)
+        self.assertTrue(ok)
+        self.assertEqual(calls[0], [
+            "gh", "label", "create", "work-plan:in-progress", "--repo", "o/r",
+            "--color", "FBCA04", "--description", "Actively being worked (work-plan)",
+            "--force"])
+        self.assertEqual(calls[1], [
+            "gh", "issue", "edit", "271", "--repo", "o/r",
+            "--add-label", "work-plan:in-progress"])
+
+    def test_clear_removes_label_without_creating(self):
+        calls = []
+        with mock.patch("lib.github_state.subprocess.run",
+                        side_effect=lambda args, **kw: calls.append(args) or _proc(0)):
+            ok, msg = github_state.set_issue_in_progress("o/r", 271, clear=True)
+        self.assertTrue(ok)
+        self.assertEqual(calls, [[
+            "gh", "issue", "edit", "271", "--repo", "o/r",
+            "--remove-label", "work-plan:in-progress"]])
+
+    def test_invalid_repo_rejected(self):
+        ok, msg = github_state.set_issue_in_progress("not-a-slug", 5)
+        self.assertFalse(ok)
+        self.assertIn("invalid repo", msg)
+
+    def test_gh_failure_surfaces_stderr(self):
+        with mock.patch("lib.github_state.subprocess.run",
+                        return_value=_proc(1, stderr="no write access")):
+            ok, msg = github_state.set_issue_in_progress("o/r", 5)
+        self.assertFalse(ok)
+        self.assertIn("no write access", msg)
+
+    def test_never_raises(self):
+        with mock.patch("lib.github_state.subprocess.run", side_effect=OSError("boom")):
+            ok, msg = github_state.set_issue_in_progress("o/r", 5)
+        self.assertFalse(ok)
+
+
+from commands import in_progress as inprog_cmd
+
+
+def _track(name, repo, issues):
+    return SimpleNamespace(name=name, repo=repo, folder=name,
+                           has_frontmatter=True,
+                           meta={"github": {"issues": issues}, "track": name})
+
+
+class InProgressCommandTest(unittest.TestCase):
+    def _drive(self, args, tracks, vis="PRIVATE", write_ret=(True, "ok")):
+        with mock.patch("commands.in_progress.load_config", return_value={"repos": {}}), \
+             mock.patch("commands.in_progress.discover_tracks", return_value=tracks), \
+             mock.patch("commands.in_progress.needs_confirm", return_value=(vis != "PRIVATE")), \
+             mock.patch("commands.in_progress.set_issue_in_progress",
+                        return_value=write_ret) as mw:
+            out, err = io.StringIO(), io.StringIO()
+            with redirect_stdout(out), redirect_stderr(err):
+                rc = inprog_cmd.run(args)
+        return rc, out.getvalue(), err.getvalue(), mw
+
+    def test_marks_resolving_repo_from_single_track(self):
+        rc, out, err, mw = self._drive(["271"], [_track("alpha", "o/r", [271])])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once_with("o/r", 271, clear=False)
+
+    def test_clear_flag(self):
+        rc, out, err, mw = self._drive(["271", "--clear"], [_track("alpha", "o/r", [271])])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once_with("o/r", 271, clear=True)
+
+    def test_ambiguous_number_across_repos_rejected(self):
+        rc, out, err, mw = self._drive(
+            ["271"], [_track("a", "o/r1", [271]), _track("b", "o/r2", [271])])
+        self.assertEqual(rc, 1)
+        mw.assert_not_called()
+        self.assertIn("ambiguous", (out + err).lower())
+
+    def test_repo_flag_disambiguates(self):
+        rc, out, err, mw = self._drive(
+            ["271", "--repo=o/r2"],
+            [_track("a", "o/r1", [271]), _track("b", "o/r2", [271])])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once_with("o/r2", 271, clear=False)
+
+    def test_public_repo_without_token_emits_needs_confirm(self):
+        rc, out, err, mw = self._drive(["271"], [_track("alpha", "o/r", [271])], vis="PUBLIC")
+        self.assertEqual(rc, 0)
+        self.assertIn("needs_confirm", out)
+        mw.assert_not_called()
+
+    def test_public_repo_with_valid_token_writes(self):
+        from lib.write_guard import make_token
+        token = make_token("o/r", "271")
+        rc, out, err, mw = self._drive(
+            [f"--confirm={token}", "271"], [_track("alpha", "o/r", [271])], vis="PUBLIC")
+        self.assertEqual(rc, 0)
+        mw.assert_called_once_with("o/r", 271, clear=False)
+
+    def test_non_integer_rejected(self):
+        rc, out, err, mw = self._drive(["abc"], [_track("alpha", "o/r", [271])])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+
+    def test_unresolvable_number_returns_1(self):
+        rc, out, err, mw = self._drive(["999"], [_track("alpha", "o/r", [271])])
+        self.assertEqual(rc, 1)
+        mw.assert_not_called()
+
+    # --- _resolve_repo --repo validation tests ---
+
+    def test_repo_flag_matching_tracked_repo_allowed(self):
+        """--repo=o/r2 when 271 is tracked in o/r2 → allowed (legit disambiguation)."""
+        rc, out, err, mw = self._drive(
+            ["271", "--repo=o/r2"],
+            [_track("a", "o/r1", []), _track("b", "o/r2", [271])])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once_with("o/r2", 271, clear=False)
+
+    def test_repo_flag_pointing_to_untracked_repo_rejected(self):
+        """--repo=o/r2 when 271 is tracked only in o/r1 → rejected (typo guard)."""
+        rc, out, err, mw = self._drive(
+            ["271", "--repo=o/r2"],
+            [_track("a", "o/r1", [271]), _track("b", "o/r2", [])])
+        self.assertEqual(rc, 1)
+        mw.assert_not_called()
+        combined = (out + err).lower()
+        self.assertTrue(
+            "refusing" in combined or "not" in combined,
+            f"expected 'refusing' or 'not' in stderr/stdout, got: {out!r} {err!r}")
+
+    def test_repo_flag_for_issue_tracked_nowhere_allowed(self):
+        """--repo=o/r9 when 271 is not in any track → allowed (explicit target)."""
+        rc, out, err, mw = self._drive(
+            ["271", "--repo=o/r9"],
+            [_track("a", "o/r1", [99])])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once_with("o/r9", 271, clear=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -45,15 +45,20 @@ class ListOpenIssuesTest(unittest.TestCase):
         rc, out = _run(["--repo=o/r"], rows)
         self.assertEqual(rc, 0)
         self.assertEqual(out["repo"], "o/r")
-        # Same Issue shape as the export (number/title/state/assignee/milestone).
+        # Same Issue shape as the export (number/title/state/assignee/milestone,
+        # plus the always-present in_progress flag — #271 keeps the two surfaces
+        # identical, so list-open-issues carries it too, default False here since
+        # this command has no track/branch context).
         self.assertEqual(
             out["issues"][0],
             {"number": 91, "title": "Rate-limit login", "state": "open",
-             "assignee": "@eve", "milestone": "v0.6"},
+             "assignee": "@eve", "milestone": "v0.6", "in_progress": False,
+             "in_progress_label": False, "blocked_by": [], "blocking": []},
         )
         self.assertEqual(out["issues"][1],
                          {"number": 87, "title": "Fix auth", "state": "open",
-                          "assignee": "—", "milestone": None})
+                          "assignee": "—", "milestone": None, "in_progress": False,
+                          "in_progress_label": False, "blocked_by": [], "blocking": []})
 
     def test_exclude_filters_given_numbers(self):
         rows = [_row(1), _row(2), _row(3)]

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

@@ -0,0 +1,22 @@
+"""in-progress is dispatchable + documented (#271)."""
+import sys
+import unittest
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+import work_plan
+
+
+class RegisterInProgressTest(unittest.TestCase):
+    def test_in_subcommands(self):
+        self.assertEqual(work_plan.SUBCOMMANDS["in-progress"], "commands.in_progress")
+
+    def test_in_descriptions(self):
+        names = {row[0] for row in work_plan.DESCRIPTIONS}
+        self.assertIn("in-progress", names)
+
+
+if __name__ == "__main__":
+    unittest.main()