@stylusnexus/work-plan 2026.7.15 → 2026.7.16

package/VERSION

@@ -1 +1 @@
-2026.07.15+cc41310
+2026.07.16+bcb403e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stylusnexus/work-plan",
-  "version": "2026.7.15",
+  "version": "2026.7.16",
   "description": "Track-aware daily work planning over GitHub issues. Shared tracks (git-synced .work-plan/ in each repo), AI clustering (group/auto-triage), VS Code viewer, Claude Code + Codex plugins. Pure Python stdlib.",
   "bin": {
     "work-plan": "bin/work-plan"

package/skills/work-plan/commands/brief.py

@@ -1,4 +1,6 @@
 """brief subcommand — fully featured."""
+from __future__ import annotations
+
 import os
 from datetime import datetime
 from pathlib import Path
@@ -108,9 +110,43 @@ def run(args: list[str]) -> int:
     print(framing)
     print()
 
+    # Batch same-repo GitHub reads across tracks (#420): tracks sharing a repo
+    # otherwise each re-fetch the same issue set / recent-issues list from
+    # scratch. Fetch once per repo here, then partition back into each track
+    # in _build_track_block — field coverage, ordering, and fail-soft fallback
+    # stay identical to the old per-track fetch (same underlying helpers, same
+    # per-track number/slug subsets, just fetched once instead of N times).
+    repo_tracks: dict = {}
+    for t in active:
+        if t.repo:
+            repo_tracks.setdefault(t.repo, []).append(t)
+
+    issues_by_repo: dict = {}
+    new_issues_by_repo: dict = {}
+    for repo, rtracks in repo_tracks.items():
+        all_nums = _numeric_refs(*[
+            ref_list
+            for rt in rtracks
+            for ref_list in (rt.meta.get("github", {}).get("issues") or [],
+                             rt.meta.get("next_up") or [])
+        ])
+        issues_by_repo[repo] = (
+            {i["number"]: i for i in fetch_issues(repo, all_nums)} if all_nums else {}
+        )
+
+        slugs = [rt.meta.get("track", rt.name) for rt in rtracks]
+        slug_labels = build_slug_labels(rtracks)
+        new_issues_by_repo[repo] = find_new_issues_for_tracks(
+            repo, slugs, slug_labels=slug_labels, since_days=7,
+        )
+
     blocks = []
     for t in active:
-        b = _build_track_block(t, cfg, now)
+        b = _build_track_block(
+            t, cfg, now,
+            repo_issues_by_num=issues_by_repo.get(t.repo, {}),
+            repo_new_issues=new_issues_by_repo.get(t.repo, {}),
+        )
         blocks.append((b["sort_key"], b))
 
     blocks.sort(key=lambda x: x[0])
@@ -142,10 +178,14 @@ def run(args: list[str]) -> int:
     return 0
 
 
-def _build_track_block(track, cfg, now: datetime) -> dict:
+def _build_track_block(track, cfg, now: datetime, *,
+                       repo_issues_by_num: dict | None = None,
+                       repo_new_issues: dict | None = None) -> dict:
     meta = track.meta
     repo = track.repo
     local = track.local_path
+    repo_issues_by_num = repo_issues_by_num or {}
+    repo_new_issues = repo_new_issues or {}
 
     issue_nums = meta.get("github", {}).get("issues") or []
     stored_next_up = meta.get("next_up") or []
@@ -153,7 +193,9 @@ def _build_track_block(track, cfg, now: datetime) -> dict:
     # so stale closed entries surface as a clear signal rather than vanishing.
     # Only numeric refs are fetchable; string tokens in next_up are dropped (#417).
     fetch_nums = _numeric_refs(issue_nums, stored_next_up)
-    issues = fetch_issues(repo, fetch_nums) if (repo and fetch_nums) else []
+    # Partition this track's slice out of the repo-batched fetch (#420) instead
+    # of fetching it directly — same order, same skip-if-missing fallback.
+    issues = [repo_issues_by_num[n] for n in fetch_nums if n in repo_issues_by_num]
     issues_by_num = {i["number"]: i for i in issues}
 
     # When `next_up_auto: true` is set in track frontmatter, derive the list
@@ -225,18 +267,16 @@ def _build_track_block(track, cfg, now: datetime) -> dict:
         operational_status = stored_status
 
     track_slug = meta.get("track", track.name)
-    slug_labels = build_slug_labels([track])
-    new_issues_map = find_new_issues_for_tracks(repo, [track_slug], slug_labels=slug_labels, since_days=7) if repo else {}
     listed_set = set(issue_nums)
     new_issues = []
-    for issue in new_issues_map.get(track_slug, []):
+    for issue in repo_new_issues.get(track_slug, []):
         if issue["number"] in listed_set:
             continue
         new_issues.append({"number": issue["number"], "title": issue["title"]})
 
     drift_items = detect_drift(track.body, issues) if issues else []
 
-    related_recent_count = len(new_issues_map.get(track_slug, []))
+    related_recent_count = len(repo_new_issues.get(track_slug, []))
     signals = compute_signals(meta, issues, local, related_recent_count)
     closure_ready, _ = is_closure_ready(signals)
     if closure_ready:

package/skills/work-plan/commands/export.py

@@ -4,24 +4,33 @@ from datetime import datetime, date
 from pathlib import Path
 from lib.config import load_config, ConfigError, resolve_local_path_for_folder
 from lib.tracks import discover_tracks, discover_archived_tracks, find_tier_duplicates, issue_refs
-from lib.github_state import fetch_export_issues, fetch_open_issues, repo_visibility
-from lib.git_state import hot_issue_numbers
+from lib.github_state import (
+    fetch_export_issues, fetch_open_issues_concurrent, fetch_visibility_concurrent,
+)
+from lib.git_state import hot_issue_numbers, paths_last_commit_dates
 from lib.export_model import build_export, track_key
 from lib.prompts import parse_flags
-from lib import doc_discovery
+from lib import doc_discovery, manifest
 from lib import verdict as verdict_mod
 from commands.plan_status import evaluate_doc
 
 
-def _plan_badge(track, cfg, today, dead_days, stall_days):
-    """Resolve a track's declared `plan:` link into an execution badge (#285).
+def _read_plan_text(path) -> str:
+    """Read a plan doc's text. Indirected so tests can patch it (mirrors
+    commands.plan_status._read)."""
+    return path.read_text(encoding="utf-8", errors="replace")
 
-    Returns None when the track declares no plan, `{rel, resolved: false}` when
-    the link can't be resolved (no local clone, or the file is absent), and the
-    full badge — verdict/glyph/files/phases/lie_gap/stalled/override — when it
-    resolves. The verdict is computed by the SAME evaluator plan-status uses, so a
-    badge never disagrees with the Plans view. Only the declared link is trusted;
-    there is no name-matching fallback (#285 acceptance criteria)."""
+
+def _resolve_plan_doc(track, cfg):
+    """Resolve a track's declared `plan:` link to (local, doc), ready for
+    scoring — or a final answer when resolution can't reach that point.
+
+    Returns None (no plan declared), `{rel, resolved: false}` (unresolvable —
+    absolute path, no local clone, file absent, or unsafe path), or the tuple
+    `(local: Path, doc: doc_discovery.Doc)`. Split out from the old _plan_badge
+    (#422) so run()'s batching pre-pass can discover which local clone each
+    track's plan doc lives in — grouping by clone, not just calling
+    _plan_badge fresh per track — without duplicating this resolution logic."""
     rel = track.meta.get("plan")
     if not isinstance(rel, str) or not rel.strip():
         return None
@@ -35,9 +44,31 @@ def _plan_badge(track, cfg, today, dead_days, stall_days):
     if not doc_discovery.is_safe_doc_path(doc_path, local):
         return {"rel": rel, "resolved": False}
     doc = doc_discovery.Doc(path=doc_path, rel=rel, kind=doc_discovery.classify_kind(rel))
-    row = evaluate_doc(doc, local, today, dead_days, stall_days)
+    return (local, doc)
+
+
+def _plan_badge(track, cfg, today, dead_days, stall_days, last_dates=None):
+    """Resolve a track's declared `plan:` link into an execution badge (#285).
+
+    Returns None when the track declares no plan, `{rel, resolved: false}` when
+    the link can't be resolved (no local clone, or the file is absent), and the
+    full badge — verdict/glyph/files/phases/lie_gap/stalled/override — when it
+    resolves. The verdict is computed by the SAME evaluator plan-status uses, so a
+    badge never disagrees with the Plans view. Only the declared link is trusted;
+    there is no name-matching fallback (#285 acceptance criteria).
+
+    `last_dates` (#422): an optional {rel: datetime} batched commit-date map for
+    this track's local clone, built once per clone by run() instead of once per
+    track — forwarded to evaluate_doc so it skips its own per-path git calls.
+    Omitted (None), evaluate_doc falls back to its original per-path behavior,
+    unchanged for direct callers/tests."""
+    resolved = _resolve_plan_doc(track, cfg)
+    if resolved is None or isinstance(resolved, dict):
+        return resolved
+    local, doc = resolved
+    row = evaluate_doc(doc, local, today, dead_days, stall_days, last_dates)
     return {
-        "rel": rel,
+        "rel": doc.rel,
         "resolved": True,
         "verdict": row["verdict"],
         "glyph": row["glyph"],
@@ -87,10 +118,29 @@ def run(args: list[str]) -> int:
     # Bulk-fetch per repo (one gh call per repo) with per-issue fallback for misses.
     issue_map = fetch_export_issues(repo_to_numbers)
 
+    # First-seen order (not a set): out["untracked"] below iterates this
+    # directly to build JSON output, and Python's hash randomization makes set
+    # iteration order vary run-to-run — a real, silent nondeterminism bug in
+    # the emitted `untracked` array ordering.
+    tracked_repos = list(dict.fromkeys(t.repo for t in tracks if t.repo))
+    config_repo_slugs = [
+        block.get("github") for block in (cfg.get("repos") or {}).values()
+        if isinstance(block, dict) and block.get("github")
+    ]
+
+    # Bounded per-repo metadata phase (#424): visibility and open-issue reads
+    # were each a serial gh call per unique repo (viewer refresh latency grew
+    # linearly with repo count). Compute the full repo sets up front and fetch
+    # both concurrently — same shape as fetch_export_issues above — instead of
+    # blocking on one repo's network round-trip before starting the next.
+    visibility = fetch_visibility_concurrent(
+        list(dict.fromkeys(tracked_repos + config_repo_slugs))
+    )
+    open_issues_by_repo = fetch_open_issues_concurrent(tracked_repos)
+
     # Reassemble per-track lists, preserving each track's declared issue order.
     # Canonical track identity keeps same-named tracks in different repos apart.
     issues_by_track: dict[tuple[str, str], list] = {}
-    visibility: dict[str, object] = {}
     for t in tracks:
         nums = (t.meta.get("github", {}).get("issues")) or []
         if t.repo and nums:
@@ -101,8 +151,6 @@ def run(args: list[str]) -> int:
             ]
         else:
             issues_by_track[track_key(t)] = []
-        if t.repo and t.repo not in visibility:
-            visibility[t.repo] = repo_visibility(t.repo)
 
     # Compute untracked: open issues not referenced by any track, per repo.
     # Iterate over every repo that has ANY track — NOT just repos in
@@ -112,24 +160,19 @@ def run(args: list[str]) -> int:
     # previously-trackless repo makes its open issues vanish — neither in the
     # (empty) track nor in untracked, and the viewer's trackless fallback
     # (treeModel.mergeFetchedUntracked) shuts off the moment a track exists (#342).
-    # One `gh issue list` call per repo — bounded by the number of tracked repos
-    # (typically a handful), not by issue count, so a serial loop is fine.
-    tracked_repos = {t.repo for t in tracks if t.repo}
     untracked_by_repo: dict[str, list] = {}
     for repo in tracked_repos:
         tracked = set(repo_to_numbers.get(repo, []))
-        open_rows = fetch_open_issues(repo)
+        open_rows = open_issues_by_repo.get(repo, [])
         untracked_by_repo[repo] = [r for r in open_rows if r.get("number") not in tracked]
 
     # Every CONFIGURED repo, regardless of whether any track references it (#288).
     # Lets the viewer show a registered-but-empty repo so the user can start
-    # adding tracks to it. visibility is filled here for repos no track covered.
+    # adding tracks to it.
     config_repos = []
     for folder, block in (cfg.get("repos") or {}).items():
         slug = block.get("github") if isinstance(block, dict) else None
         local = resolve_local_path_for_folder(folder, cfg)
-        if slug and slug not in visibility:
-            visibility[slug] = repo_visibility(slug)
         config_repos.append({
             "folder": folder,
             "repo": slug,
@@ -143,9 +186,39 @@ def run(args: list[str]) -> int:
     today = date.today()
     cfg_stall = cfg.get("stall_days")
     stall_days = cfg_stall if isinstance(cfg_stall, int) else verdict_mod.STALL_DAYS
+
+    # Batch git history for linked plans (#422): group resolvable plan docs by
+    # local clone (the same repo root plan-status batches per-invocation, #391)
+    # instead of evaluate_doc falling back to one git spawn per declared path
+    # per doc. Resolution itself (_resolve_plan_doc) is filesystem-only — no
+    # git calls — so doing it once here for grouping, and again inside
+    # _plan_badge below, costs nothing worth avoiding.
+    resolved_by_track: dict = {}
+    docs_by_local: dict = {}
+    for t in tracks:
+        r = _resolve_plan_doc(t, cfg)
+        resolved_by_track[track_key(t)] = r
+        if isinstance(r, tuple):
+            plan_local, doc = r
+            docs_by_local.setdefault(plan_local, []).append(doc)
+
+    last_dates_by_local: dict = {}
+    for plan_local, docs in docs_by_local.items():
+        batch_paths = set()
+        for doc in docs:
+            batch_paths.add(doc.rel)
+            try:
+                for dp in manifest.parse_declared_paths(_read_plan_text(doc.path)):
+                    batch_paths.add(dp.path)
+            except OSError:
+                pass
+        last_dates_by_local[plan_local] = paths_last_commit_dates(sorted(batch_paths), plan_local)
+
     plan_by_track: dict[tuple[str, str], dict] = {}
     for t in tracks:
-        badge = _plan_badge(t, cfg, today, verdict_mod.DEAD_DAYS, stall_days)
+        r = resolved_by_track[track_key(t)]
+        last_dates = last_dates_by_local[r[0]] if isinstance(r, tuple) else None
+        badge = _plan_badge(t, cfg, today, verdict_mod.DEAD_DAYS, stall_days, last_dates)
         if badge is not None:
             plan_by_track[track_key(t)] = badge
 

package/skills/work-plan/lib/github_state.py

@@ -378,6 +378,19 @@ def fetch_open_issues(repo: str, limit: int = 1000) -> list[dict]:
         return []
 
 
+def fetch_open_issues_concurrent(repos: Iterable[str], max_workers: int = MAX_FETCH_WORKERS) -> dict:
+    """Fetch fetch_open_issues() for each of `repos` concurrently, deduped
+    (first-seen order irrelevant — result is keyed by repo). Returns
+    {repo: [issue_row, ...]}. Empty/falsy repos filtered; empty input -> {}.
+    Never raises — fetch_open_issues() is itself fail-soft per repo."""
+    unique_repos = list(dict.fromkeys(r for r in repos if r))
+    if not unique_repos:
+        return {}
+    with ThreadPoolExecutor(max_workers=min(max_workers, len(unique_repos))) as ex:
+        results = list(ex.map(fetch_open_issues, unique_repos))
+    return dict(zip(unique_repos, results))
+
+
 def fetch_recent_issues(repo: str, since_iso: str, extra_labels: Optional[list[str]] = None) -> list[dict]:
     """Fetch issues created since `since_iso` (date YYYY-MM-DD)."""
     if not _valid_repo(repo):
@@ -433,6 +446,22 @@ def repo_visibility(repo: str) -> Optional[str]:
     return vis
 
 
+def fetch_visibility_concurrent(repos: Iterable[str], max_workers: int = MAX_FETCH_WORKERS) -> dict:
+    """Fetch repo_visibility() for each of `repos` concurrently, deduped.
+    Returns {repo: 'PUBLIC'|'PRIVATE'|None}. Empty/falsy repos filtered;
+    empty input -> {}. Never raises — repo_visibility() is itself fail-soft.
+    repo_visibility()'s own _VIS_CACHE dict may see a benign redundant gh
+    call under a race on first-ever lookup for a repo (plain dict, no lock)
+    — never incorrect data, just a duplicate subprocess in the rare case two
+    threads both miss the cache for the same repo simultaneously."""
+    unique_repos = list(dict.fromkeys(r for r in repos if r))
+    if not unique_repos:
+        return {}
+    with ThreadPoolExecutor(max_workers=min(max_workers, len(unique_repos))) as ex:
+        results = list(ex.map(repo_visibility, unique_repos))
+    return dict(zip(unique_repos, results))
+
+
 def repo_full_name(slug: str) -> Optional[str]:
     """Live GitHub identity check via `gh api repos/<slug> --jq .full_name`.
 

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

@@ -0,0 +1,140 @@
+"""brief batches same-repo GitHub reads across tracks (#420).
+
+Before this change, `brief` called `fetch_issues` and `find_new_issues_for_tracks`
+once PER TRACK. Tracks sharing a repo therefore repeated the same issue /
+recent-issues queries. These tests assert the batched call count (once per
+repo, not once per track) AND that each track still gets exactly the same
+data it would have gotten from its own per-track fetch — the batching must
+not change output, only call count.
+"""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from datetime import datetime
+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 brief
+from lib.tracks import Track
+
+
+def _track(name, repo, track_slug, issue_nums, next_up):
+    return Track(
+        path=Path(f"/notes/{repo.split('/')[-1]}/{name}.md"),
+        name=name,
+        has_frontmatter=True,
+        needs_init=False,
+        needs_filing=False,
+        repo=repo,
+        folder=repo.split("/")[-1],
+        local_path=None,
+        meta={
+            "status": "active",
+            "track": track_slug,
+            "github": {"issues": issue_nums},
+            "next_up": next_up,
+        },
+        body="",
+    )
+
+
+def _issue(number, title, state="OPEN"):
+    return {"number": number, "title": title, "state": state, "labels": [],
+            "milestone": None, "blocked_by": [], "assignees": []}
+
+
+TRACK_ALPHA = _track("alpha", "org/repo1", "alpha", [1, 2], [1])
+TRACK_BETA = _track("beta", "org/repo1", "beta", [3], [3])
+TRACK_GAMMA = _track("gamma", "org/repo2", "gamma", [10], [10])
+
+REPO1_ISSUES = [_issue(1, "Alpha issue one"), _issue(2, "Alpha issue two"),
+                _issue(3, "Beta issue")]
+REPO2_ISSUES = [_issue(10, "Gamma issue")]
+
+
+def _fake_fetch_issues(repo, nums):
+    pool = {1: REPO1_ISSUES[0], 2: REPO1_ISSUES[1], 3: REPO1_ISSUES[2], 10: REPO2_ISSUES[0]}
+    return [pool[n] for n in nums if n in pool]
+
+
+def _fake_find_new_issues(repo, slugs, *, slug_labels=None, since_days=7):
+    if repo == "org/repo1":
+        return {"alpha": [{"number": 100, "title": "New for alpha"}], "beta": []}
+    if repo == "org/repo2":
+        return {"gamma": [{"number": 200, "title": "New for gamma"}]}
+    return {s: [] for s in slugs}
+
+
+class BriefBatchFetchTest(unittest.TestCase):
+    def _run(self, tracks):
+        cfg = {"repos": {}}
+        buf = io.StringIO()
+        with mock.patch.object(brief, "load_config", return_value=cfg), \
+             mock.patch.object(brief, "discover_tracks", return_value=list(tracks)), \
+             mock.patch.object(brief, "_surface_archived_reopens"), \
+             mock.patch.object(brief, "resolve_repo_for_dir"), \
+             mock.patch.object(brief, "fetch_issues",
+                                side_effect=_fake_fetch_issues) as fetch_mock, \
+             mock.patch.object(brief, "find_new_issues_for_tracks",
+                                side_effect=_fake_find_new_issues) as new_issues_mock:
+            with redirect_stdout(buf):
+                brief.run(["--repo=all"])
+        return buf.getvalue(), fetch_mock, new_issues_mock
+
+    def test_two_tracks_same_repo_fetch_issues_called_once(self):
+        _, fetch_mock, _ = self._run([TRACK_ALPHA, TRACK_BETA])
+        self.assertEqual(fetch_mock.call_count, 1)
+        (repo, nums), _ = fetch_mock.call_args
+        self.assertEqual(repo, "org/repo1")
+        self.assertEqual(nums, [1, 2, 3])
+
+    def test_two_tracks_same_repo_new_issues_called_once(self):
+        _, _, new_issues_mock = self._run([TRACK_ALPHA, TRACK_BETA])
+        self.assertEqual(new_issues_mock.call_count, 1)
+        (repo, slugs), kwargs = new_issues_mock.call_args
+        self.assertEqual(repo, "org/repo1")
+        self.assertEqual(sorted(slugs), ["alpha", "beta"])
+        self.assertEqual(kwargs.get("since_days"), 7)
+
+    def test_different_repos_stay_isolated_one_call_each(self):
+        _, fetch_mock, new_issues_mock = self._run([TRACK_ALPHA, TRACK_GAMMA])
+        self.assertEqual(fetch_mock.call_count, 2)
+        self.assertEqual(new_issues_mock.call_count, 2)
+        repos_fetched = sorted(c.args[0] for c in fetch_mock.call_args_list)
+        self.assertEqual(repos_fetched, ["org/repo1", "org/repo2"])
+
+    def test_each_track_still_gets_its_own_next_up_content(self):
+        out, _, _ = self._run([TRACK_ALPHA, TRACK_BETA])
+        # alpha's next_up is #1 "Alpha issue one"; beta's is #3 "Beta issue" —
+        # each track must render its OWN issue, not a neighbour's, despite the
+        # shared batched fetch.
+        self.assertIn("#1 Alpha issue one", out)
+        self.assertIn("#3 Beta issue", out)
+        self.assertNotIn("#2 Alpha issue two", out)  # not in next_up for either track
+
+    def test_each_track_still_gets_its_own_new_issues(self):
+        out, _, _ = self._run([TRACK_ALPHA, TRACK_BETA, TRACK_GAMMA])
+        self.assertIn("#100 New for alpha", out)
+        self.assertIn("#200 New for gamma", out)
+        self.assertNotIn("#100 New for alpha", out.split("▸ beta")[1].split("▸")[0]
+                          if "▸ beta" in out else "")
+
+    def test_track_with_no_repo_is_skipped_without_crashing(self):
+        no_repo_track = Track(
+            path=Path("/notes/unfiled/solo.md"), name="solo",
+            has_frontmatter=True, needs_init=False, needs_filing=False,
+            repo=None, folder=None, local_path=None,
+            meta={"status": "active", "track": "solo"}, body="",
+        )
+        out, fetch_mock, new_issues_mock = self._run([no_repo_track])
+        self.assertEqual(fetch_mock.call_count, 0)
+        self.assertEqual(new_issues_mock.call_count, 0)
+        self.assertIn("solo", out)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -59,7 +59,8 @@ class ExportRunJsonTest(unittest.TestCase):
         with patch("commands.export.load_config", return_value={}), \
              patch("commands.export.discover_tracks", return_value=tracks), \
              patch("commands.export.fetch_export_issues", return_value=export_map) as mock_fei, \
-             patch("commands.export.repo_visibility", side_effect=lambda r: vis.get(r)), \
+             patch("commands.export.fetch_visibility_concurrent",
+                   side_effect=lambda repos: {r: vis.get(r) for r in repos}), \
              patch("commands.export.datetime") as mock_dt:
             mock_dt.now.return_value.strftime.return_value = "2026-06-07T12:00:00"
             buf = io.StringIO()
@@ -320,14 +321,13 @@ class ExportCommandUntrackedTest(unittest.TestCase):
 
         vis = vis or {_SHARED_REPO: "PUBLIC"}
 
-        def _fake_open_issues(repo, limit=1000):
-            return open_rows_by_repo.get(repo, [])
-
         with patch("commands.export.load_config", return_value={}), \
              patch("commands.export.discover_tracks", return_value=tracks), \
              patch("commands.export.fetch_export_issues", return_value=export_map), \
-             patch("commands.export.fetch_open_issues", side_effect=_fake_open_issues), \
-             patch("commands.export.repo_visibility", side_effect=lambda r: vis.get(r)), \
+             patch("commands.export.fetch_open_issues_concurrent",
+                   side_effect=lambda repos: {r: open_rows_by_repo.get(r, []) for r in repos}), \
+             patch("commands.export.fetch_visibility_concurrent",
+                   side_effect=lambda repos: {r: vis.get(r) for r in repos}), \
              patch("commands.export.datetime") as mock_dt:
             mock_dt.now.return_value.strftime.return_value = "2026-06-07T12:00:00"
             buf = io.StringIO()
@@ -407,6 +407,25 @@ class ExportCommandUntrackedTest(unittest.TestCase):
         rc, out = self._run_with_mocks(tracks, export_map, open_rows)
         json.dumps(out)  # must not raise
 
+    def test_untracked_order_is_deterministic_across_many_repos(self):
+        """`tracked_repos` must be a first-seen-order list, not a set — a set's
+        iteration order varies run-to-run (hash randomization), which would
+        make `out["untracked"]`'s ordering nondeterministic since it iterates
+        that structure directly to build output (no sort downstream)."""
+        repo_names = [f"org/repo{i}" for i in range(8)]
+        tracks = [_track(f"t{i}", repo_names[i], [i]) for i in range(8)]
+        export_map = {(repo_names[i], i): {"number": i, "title": f"issue{i}",
+                                            "state": "OPEN", "assignees": [], "milestone": None}
+                      for i in range(8)}
+        open_rows = {r: [{"number": 900 + idx, "title": "extra", "state": "OPEN",
+                          "assignees": [], "milestone": None}]
+                     for idx, r in enumerate(repo_names)}
+        vis = {r: "PUBLIC" for r in repo_names}
+        rc, out = self._run_with_mocks(tracks, export_map, open_rows, vis=vis)
+        self.assertEqual(rc, 0)
+        seen_order = [entry["repo"] for entry in out["untracked"]]
+        self.assertEqual(seen_order, repo_names)
+
 
 class ExportCommandGateTest(unittest.TestCase):
     def test_requires_json_flag(self):
@@ -543,6 +562,139 @@ class ExportPlanBadgeTest(unittest.TestCase):
         self.assertEqual(badge, {"rel": "docs/plans/p.md", "resolved": False})
 
 
+class ExportPlanBadgeBatchingTest(unittest.TestCase):
+    """#422: linked plans sharing a local clone batch their git history into
+    ONE paths_last_commit_dates call instead of one per doc/declared path."""
+
+    def _write_plan(self, root, rel, body):
+        path = root / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(body)
+
+    def _track(self, name, folder, plan_rel):
+        return SimpleNamespace(
+            name=name, repo="o/r", tier="private", folder=folder,
+            path=Path(f"/tmp/notes/{name}.md"), has_frontmatter=True,
+            meta={"status": "active", "plan": plan_rel, "github": {"repo": "o/r", "issues": []}})
+
+    def _run(self, tracks, local_by_folder, paths_side_effect=None):
+        import io
+        import tempfile as _tf
+        from contextlib import redirect_stdout
+        from datetime import date as _date
+
+        def _resolve_local(folder, cfg):
+            return local_by_folder.get(folder)
+
+        with patch("commands.export.load_config", return_value={}), \
+             patch("commands.export.discover_tracks", return_value=tracks), \
+             patch("commands.export.fetch_export_issues", return_value={}), \
+             patch("commands.export.fetch_visibility_concurrent", return_value={}), \
+             patch("commands.export.fetch_open_issues_concurrent", return_value={}), \
+             patch("commands.export.resolve_local_path_for_folder", side_effect=_resolve_local), \
+             patch("commands.export.paths_last_commit_dates",
+                   side_effect=paths_side_effect or (lambda paths, root: {})) as mock_pld, \
+             patch("commands.export.datetime") as mock_dt:
+            mock_dt.now.return_value.strftime.return_value = "2026-06-07T12:00:00"
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = export_cmd.run(["--json"])
+            return rc, json.loads(buf.getvalue()), mock_pld
+
+    def test_two_tracks_same_clone_share_one_batched_call(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            root = Path(d)
+            self._write_plan(root, "docs/plans/a.md",
+                             "# A\n**Files:**\n- Create: `src/a.ts`\n")
+            self._write_plan(root, "docs/plans/b.md",
+                             "# B\n**Files:**\n- Create: `src/b.ts`\n")
+            (root / "src").mkdir()
+            (root / "src/a.ts").write_text("a")
+            (root / "src/b.ts").write_text("b")
+            track_a = self._track("alpha", "demo", "docs/plans/a.md")
+            track_b = self._track("beta", "demo", "docs/plans/b.md")
+
+            rc, out, mock_pld = self._run([track_a, track_b], {"demo": root})
+
+            self.assertEqual(rc, 0)
+            self.assertEqual(mock_pld.call_count, 1)
+            called_paths, called_root = mock_pld.call_args[0]
+            self.assertEqual(called_root, root)
+            self.assertEqual(
+                set(called_paths),
+                {"docs/plans/a.md", "docs/plans/b.md", "src/a.ts", "src/b.ts"},
+            )
+
+    def test_two_tracks_different_clones_batch_independently(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d1, tempfile.TemporaryDirectory() as d2:
+            root1, root2 = Path(d1), Path(d2)
+            self._write_plan(root1, "docs/plans/a.md", "# A\n")
+            self._write_plan(root2, "docs/plans/b.md", "# B\n")
+            track_a = self._track("alpha", "repo1", "docs/plans/a.md")
+            track_b = self._track("beta", "repo2", "docs/plans/b.md")
+
+            rc, out, mock_pld = self._run(
+                [track_a, track_b], {"repo1": root1, "repo2": root2})
+
+            self.assertEqual(rc, 0)
+            self.assertEqual(mock_pld.call_count, 2)
+            roots_called = {c.args[1] for c in mock_pld.call_args_list}
+            self.assertEqual(roots_called, {root1, root2})
+
+    def test_unresolved_tracks_never_trigger_a_batch_call(self):
+        track = self._track("alpha", "missing", "docs/plans/a.md")
+        rc, out, mock_pld = self._run([track], {})  # no local clone resolves
+        self.assertEqual(rc, 0)
+        mock_pld.assert_not_called()
+
+    def test_overlapping_declared_path_across_two_plans_deduped_in_one_call(self):
+        """Two linked plans in the same clone that both declare the SAME
+        path — the shared path appears once in the batched request."""
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            root = Path(d)
+            self._write_plan(root, "docs/plans/a.md",
+                             "# A\n**Files:**\n- Create: `src/shared.ts`\n")
+            self._write_plan(root, "docs/plans/b.md",
+                             "# B\n**Files:**\n- Modify: `src/shared.ts`\n")
+            (root / "src").mkdir()
+            (root / "src/shared.ts").write_text("shared")
+            track_a = self._track("alpha", "demo", "docs/plans/a.md")
+            track_b = self._track("beta", "demo", "docs/plans/b.md")
+
+            rc, out, mock_pld = self._run([track_a, track_b], {"demo": root})
+
+            self.assertEqual(mock_pld.call_count, 1)
+            called_paths = mock_pld.call_args[0][0]
+            self.assertEqual(called_paths.count("src/shared.ts"), 1)
+
+    def test_batched_run_produces_correct_verdict_and_lie_gap(self):
+        """Same body/expected verdict as ExportPlanBadgeTest's direct-call
+        test_resolved_badge_with_lie_gap — batching changes call count, not
+        verdict/lie_gap semantics."""
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            root = Path(d)
+            body = ("# P\n\n**Files:**\n- Create: `src/new.ts`\n"
+                    "- [ ] Step 1\n- [ ] Step 2\n")
+            self._write_plan(root, "docs/plans/p.md", body)
+            (root / "src").mkdir()
+            (root / "src/new.ts").write_text("export const x = 1")
+            track = self._track("alpha", "demo", "docs/plans/p.md")
+
+            rc, out, mock_pld = self._run([track], {"demo": root})
+
+        self.assertEqual(rc, 0)
+        badge = out["tracks"][0]["plan"]
+        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"])
+
+
 class ExportHotByTrackTest(unittest.TestCase):
     def test_export_marks_in_progress_from_hot_branch(self):
         import io
@@ -556,8 +708,9 @@ class ExportHotByTrackTest(unittest.TestCase):
              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.fetch_open_issues_concurrent", return_value={}), \
+             patch("commands.export.fetch_visibility_concurrent",
+                   side_effect=lambda repos: {r: "PRIVATE" for r in repos}), \
              patch("commands.export.resolve_local_path_for_folder",
                    return_value=Path("/repo")), \
              patch("commands.export.hot_issue_numbers", return_value={1}), \

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

@@ -13,6 +13,7 @@ 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, repo_full_name,
+    fetch_visibility_concurrent, fetch_open_issues_concurrent,
     gh_auth_status,
     _GQL_FIELDS_LEAN, _GQL_FIELDS_FULL,
     _gql_query, _GQL_ISSUE_DEPS,
@@ -105,6 +106,56 @@ class RepoVisibilityTest(unittest.TestCase):
         self.assertEqual(m.call_count, 1)
 
 
+class FetchVisibilityConcurrentTest(unittest.TestCase):
+    """Unit tests for the per-repo concurrent batch fetch_visibility_concurrent() (#424)."""
+
+    @patch("lib.github_state.repo_visibility")
+    def test_returns_keyed_dict_per_repo(self, mock_rv):
+        mock_rv.side_effect = lambda r: {"org/a": "PUBLIC", "org/b": "PRIVATE"}.get(r)
+        result = fetch_visibility_concurrent(["org/a", "org/b"])
+        self.assertEqual(result, {"org/a": "PUBLIC", "org/b": "PRIVATE"})
+
+    @patch("lib.github_state.repo_visibility")
+    def test_dedupes_repeated_repos(self, mock_rv):
+        mock_rv.return_value = "PUBLIC"
+        fetch_visibility_concurrent(["org/a", "org/a", "org/a"])
+        self.assertEqual(mock_rv.call_count, 1)
+
+    @patch("lib.github_state.repo_visibility")
+    def test_falsy_repos_filtered(self, mock_rv):
+        mock_rv.return_value = "PUBLIC"
+        result = fetch_visibility_concurrent(["org/a", None, "", "org/a"])
+        self.assertEqual(list(result.keys()), ["org/a"])
+
+    def test_empty_input_returns_empty_dict_no_gh_call(self):
+        with patch("lib.github_state.repo_visibility") as mock_rv:
+            self.assertEqual(fetch_visibility_concurrent([]), {})
+            mock_rv.assert_not_called()
+
+    @patch("lib.github_state.repo_visibility")
+    def test_concurrency_bound_is_respected(self, mock_rv):
+        """Peak simultaneous in-flight calls never exceeds max_workers, and
+        does exceed 1 — proving work is genuinely bounded-concurrent, not
+        serial (#424 acceptance criteria)."""
+        import threading, time
+        lock = threading.Lock()
+        state = {"current": 0, "peak": 0}
+
+        def _tracked(repo):
+            with lock:
+                state["current"] += 1
+                state["peak"] = max(state["peak"], state["current"])
+            time.sleep(0.05)
+            with lock:
+                state["current"] -= 1
+            return "PUBLIC"
+        mock_rv.side_effect = _tracked
+        repos = [f"org/repo{i}" for i in range(10)]
+        fetch_visibility_concurrent(repos, max_workers=3)
+        self.assertLessEqual(state["peak"], 3)
+        self.assertGreater(state["peak"], 1)
+
+
 _ISSUE_JSON = '{"number": 1, "state": "OPEN", "labels": [], "title": "t", "milestone": null, "url": "u", "closedAt": null, "body": "", "updatedAt": "2026-01-01T00:00:00Z", "assignees": []}'
 _ISSUE_DICT = {"number": 1, "state": "OPEN", "labels": [], "title": "t", "milestone": None, "url": "u", "closedAt": None, "body": "", "updatedAt": "2026-01-01T00:00:00Z", "assignees": []}
 
@@ -545,6 +596,57 @@ class FetchOpenIssuesTest(unittest.TestCase):
         self.assertIsInstance(result, list)
 
 
+class FetchOpenIssuesConcurrentTest(unittest.TestCase):
+    """Unit tests for the per-repo concurrent batch fetch_open_issues_concurrent() (#424)."""
+
+    @patch("lib.github_state.fetch_open_issues")
+    def test_returns_keyed_dict_per_repo(self, mock_foi):
+        mock_foi.side_effect = lambda repo: [{"number": 1, "repo": repo}]
+        result = fetch_open_issues_concurrent(["org/a", "org/b"])
+        self.assertEqual(result["org/a"], [{"number": 1, "repo": "org/a"}])
+        self.assertEqual(result["org/b"], [{"number": 1, "repo": "org/b"}])
+
+    @patch("lib.github_state.fetch_open_issues")
+    def test_dedupes_repeated_repos(self, mock_foi):
+        mock_foi.return_value = []
+        fetch_open_issues_concurrent(["org/a", "org/a", "org/a"])
+        self.assertEqual(mock_foi.call_count, 1)
+
+    @patch("lib.github_state.fetch_open_issues")
+    def test_falsy_repos_filtered(self, mock_foi):
+        mock_foi.return_value = []
+        result = fetch_open_issues_concurrent(["org/a", None, "", "org/a"])
+        self.assertEqual(list(result.keys()), ["org/a"])
+
+    def test_empty_input_returns_empty_dict_no_gh_call(self):
+        with patch("lib.github_state.fetch_open_issues") as mock_foi:
+            self.assertEqual(fetch_open_issues_concurrent([]), {})
+            mock_foi.assert_not_called()
+
+    @patch("lib.github_state.fetch_open_issues")
+    def test_concurrency_bound_is_respected(self, mock_foi):
+        """Peak simultaneous in-flight calls never exceeds max_workers, and
+        does exceed 1 — proving work is genuinely bounded-concurrent, not
+        serial (#424 acceptance criteria)."""
+        import threading, time
+        lock = threading.Lock()
+        state = {"current": 0, "peak": 0}
+
+        def _tracked(repo):
+            with lock:
+                state["current"] += 1
+                state["peak"] = max(state["peak"], state["current"])
+            time.sleep(0.05)
+            with lock:
+                state["current"] -= 1
+            return []
+        mock_foi.side_effect = _tracked
+        repos = [f"org/repo{i}" for i in range(10)]
+        fetch_open_issues_concurrent(repos, max_workers=3)
+        self.assertLessEqual(state["peak"], 3)
+        self.assertGreater(state["peak"], 1)
+
+
 class GqlFieldSetsTest(unittest.TestCase):
     def test_lean_set_requests_labels(self):
         # The export path uses the lean set; without labels the in-progress