@stylusnexus/work-plan 2026.7.13 → 2026.7.16

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/commands/init_repo.py

@@ -61,6 +61,8 @@ def _update_existing(key: str, github: str, local: "str | None", clear_local: bo
     while keeping github + every other field. Mutually exclusive with `local`
     (enforced in run() before this is called).
     """
+    from lib.config import write_repo_field
+
     updates = {}
     if clear_local:
         # JSON null → YAML null; the * merge overwrites local with null, leaving
@@ -77,13 +79,8 @@ def _update_existing(key: str, github: str, local: "str | None", clear_local: bo
     # `key` is validated against ^[a-z][a-z0-9-]*$ in run() before this is called,
     # so it's safe in the yq path. Field values travel as an OPAQUE env value via
     # env() (parsed as JSON), never interpolated — uniform with the add path.
-    env = {**os.environ, "WP_REPO_UPDATES": json.dumps(updates)}
-    yq_expr = f".repos.{key} = (.repos.{key} // {{}}) * env(WP_REPO_UPDATES)"
     try:
-        subprocess.run(
-            ["yq", "-i", yq_expr, str(DEFAULT_CONFIG_PATH)],
-            check=True, capture_output=True, text=True, env=env,
-        )
+        write_repo_field(key, updates)
     except subprocess.CalledProcessError as e:
         print(f"ERROR: yq failed to update config: {e.stderr}")
         return 1

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

@@ -1,5 +1,6 @@
 """Load + validate ~/.claude/work-plan/config.yml."""
 import json
+import os
 import subprocess
 from pathlib import Path
 from typing import Optional
@@ -57,9 +58,11 @@ def load_config(path: Path = DEFAULT_CONFIG_PATH,
     if "notes_root" not in cfg:
         raise ConfigError("config.yml missing required key 'notes_root'.")
     cfg.setdefault("repos", {})
+    scalar_shape_keys = set()
     # Normalize string-shape entries to dict shape
     for folder, val in list(cfg["repos"].items()):
         if isinstance(val, str):
+            scalar_shape_keys.add(folder)
             cfg["repos"][folder] = {"github": val, "local": None}
         elif isinstance(val, dict):
             val.setdefault("local", None)
@@ -67,6 +70,7 @@ def load_config(path: Path = DEFAULT_CONFIG_PATH,
                 raise ConfigError(f"repo '{folder}' missing 'github' key")
         else:
             raise ConfigError(f"repo '{folder}' must be string or dict, got {type(val).__name__}")
+    cfg["_scalar_shape_keys"] = scalar_shape_keys
     return cfg
 
 
@@ -97,3 +101,28 @@ def resolve_local_path_for_folder(folder_name: str, cfg: dict) -> Optional[Path]
     if not entry or not entry.get("local"):
         return None
     return Path(entry["local"]).expanduser()
+
+
+def write_repo_field(key: str, updates: dict, path: Path = DEFAULT_CONFIG_PATH) -> None:
+    """Merge `updates` into `repos.<key>` in config.yml via an opaque-env `yq`
+    merge — the same mechanic `init_repo.py::_update_existing` already used
+    (extracted here so `doctor` and `init-repo` share one implementation).
+
+    `updates` values travel as JSON through an env var, never interpolated
+    into the yq expression, so they can't break out of the merge. `key` is
+    interpolated directly into the yq path — callers MUST validate it against
+    a safe-key pattern (e.g. `^[a-z][a-z0-9-]*$`) before calling this; this
+    function does not re-validate, matching `_update_existing`'s existing
+    contract (its caller already validates via `init-repo`'s own regex check).
+
+    Raises `subprocess.CalledProcessError` on any yq failure — including the
+    known case of `repos.<key>` being a scalar string on disk (yq cannot
+    multiply a string with a map). Callers must catch this and treat it as
+    "entry not fixable this way", not crash the whole command.
+    """
+    env = {**os.environ, "WP_REPO_UPDATES": json.dumps(updates)}
+    yq_expr = f".repos.{key} = (.repos.{key} // {{}}) * env(WP_REPO_UPDATES)"
+    subprocess.run(
+        ["yq", "-i", yq_expr, str(path)],
+        check=True, capture_output=True, text=True, env=env,
+    )

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,47 @@ 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`.
+
+    Returns the repo's current canonical `owner/repo` — following GitHub's own
+    rename redirect if `slug` was renamed and the redirect is still live — or
+    None on any failure (404, no access, rate-limited, offline, bad slug
+    shape). Never raises. Used by `doctor` to detect a GitHub-confirmed rename;
+    NOT a stable identity check (see doctor's own docs) — a slug that was
+    reused by an unrelated repo after the redirect lapses is indistinguishable
+    from a genuine rename here.
+    """
+    if not _valid_repo(slug):
+        return None
+    try:
+        proc = subprocess.run(
+            ["gh", "api", f"repos/{slug}", "--jq", ".full_name"],
+            capture_output=True, text=True, timeout=GH_TIMEOUT,
+        )
+    except Exception:
+        return None
+    if proc.returncode != 0:
+        return None
+    return proc.stdout.strip() or None
+
+
 def extract_priority(labels: list[dict]) -> str:
     label_names = {lbl["name"] for lbl in labels}
     for p in PRIORITY_LABELS:

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

@@ -132,26 +132,38 @@ def head_parent_sha(notes_root: Path) -> Optional[str]:
     return proc.stdout.strip()
 
 
-def dirty_paths(notes_root: Path) -> set:
-    """Set of work-tree paths with staged/unstaged changes (raw, quotepath off).
-
-    Empty set on any failure. Renames collapse to the destination path. Used by
-    the dispatcher to commit ONLY what a command changed, leaving pre-existing
-    dirty files untouched.
+def dirty_paths_checked(notes_root: Path) -> tuple:
+    """Like `dirty_paths`, but distinguishes "clean tree" from "the git status
+    call itself failed" (timeout, spawn error, not a repo) — both of which
+    `dirty_paths` alone reports as an empty set. Returns (call_succeeded, paths).
+
+    Callers that need to know WHETHER they can trust an empty result (e.g.
+    doctor's dirty-file safety check, which must not treat "couldn't check" as
+    "definitely clean") should call this instead of `dirty_paths`.
     """
     proc = _git(notes_root, "-c", "core.quotepath=false", "status", "--porcelain")
     if proc is None or proc.returncode != 0:
-        return set()
+        return (False, set())
     paths = set()
     for line in proc.stdout.splitlines():
         if len(line) < 4:
             continue
         path = line[3:]
-        if " -> " in path:  # rename / copy → the destination path
+        if " -> " in path:
             path = path.split(" -> ", 1)[1]
         if path:
             paths.add(path)
-    return paths
+    return (True, paths)
+
+
+def dirty_paths(notes_root: Path) -> set:
+    """Set of work-tree paths with staged/unstaged changes (raw, quotepath off).
+
+    Empty set on any failure. Renames collapse to the destination path. Used by
+    the dispatcher to commit ONLY what a command changed, leaving pre-existing
+    dirty files untouched.
+    """
+    return dirty_paths_checked(notes_root)[1]
 
 
 def last_commit_summary(notes_root: Path) -> Optional[str]:

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

@@ -327,15 +327,29 @@ def _build_shared_track(md_path: Path, folder_key: str,
     )
 
 
-def _walk(notes_root: Path, cfg: dict, include_archive: bool) -> list[Track]:
+def iter_private_track_paths(notes_root: Path, include_archive: bool) -> list:
+    """Eligible track markdown paths under `notes_root`, in sorted order.
+
+    Recursive. Skips `archive/` subtrees unless `include_archive` is True.
+    Skips filenames starting with '.', '_', or '-' (dotfiles, drafts, and
+    dash-led names that would otherwise misparse as a CLI flag, #194). This is
+    the single shared definition of "which private track files count" — both
+    `_walk` (track discovery) and `doctor` (drift scanning) call this, so they
+    cannot diverge on which files are in scope.
+    """
     out = []
     for md_path in sorted(notes_root.rglob("*.md")):
         if not include_archive and "archive" in md_path.parts:
             continue
-        # '-' prefix rejected so a `--repo.md` file can't become a `--repo`
-        # track that the CLI misparses as a flag (#194).
         if md_path.name.startswith((".", "_", "-")):
             continue
+        out.append(md_path)
+    return out
+
+
+def _walk(notes_root: Path, cfg: dict, include_archive: bool) -> list[Track]:
+    out = []
+    for md_path in iter_private_track_paths(notes_root, include_archive):
         out.append(_build_track(md_path, notes_root, cfg))
     return out
 

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_config.py

@@ -2,6 +2,7 @@
 import unittest
 import tempfile
 import sys
+import subprocess
 from pathlib import Path
 
 SKILL_ROOT = Path(__file__).resolve().parents[1]
@@ -10,6 +11,7 @@ sys.path.insert(0, str(SKILL_ROOT))
 from lib.config import (
     load_config, ConfigError,
     resolve_github_for_folder, resolve_local_path_for_folder,
+    write_repo_field,
 )
 
 
@@ -81,5 +83,62 @@ class ResolveTest(unittest.TestCase):
         self.assertIsNone(resolve_local_path_for_folder("unknown", self.cfg))
 
 
+class BaseConfigWriteTest(unittest.TestCase):
+    """Base class for tests that need to write and read config files."""
+    def _write_config(self, content):
+        """Write content to a temporary config file and return its path."""
+        d = tempfile.mkdtemp()
+        path = Path(d) / "config.yml"
+        path.write_text(content, encoding="utf-8")
+        return path
+
+
+class TestScalarShapeKeys(BaseConfigWriteTest):
+    def test_scalar_entry_is_tracked(self):
+        cfg_path = self._write_config(
+            "notes_root: /tmp/notes\n"
+            "repos:\n"
+            "  foo: org/foo\n"
+            "  bar:\n"
+            "    github: org/bar\n"
+        )
+        cfg = load_config(path=cfg_path, notes_root=Path("/tmp/notes"))
+        self.assertEqual(cfg["_scalar_shape_keys"], {"foo"})
+
+    def test_no_scalar_entries_is_empty_set(self):
+        cfg_path = self._write_config(
+            "notes_root: /tmp/notes\n"
+            "repos:\n"
+            "  bar:\n"
+            "    github: org/bar\n"
+        )
+        cfg = load_config(path=cfg_path, notes_root=Path("/tmp/notes"))
+        self.assertEqual(cfg["_scalar_shape_keys"], set())
+
+
+class TestWriteRepoField(BaseConfigWriteTest):
+    def test_writes_only_the_given_fields(self):
+        cfg_path = self._write_config(
+            "notes_root: /tmp/notes\n"
+            "repos:\n"
+            "  bar:\n"
+            "    github: org/bar\n"
+            "    local: /code/bar\n"
+        )
+        write_repo_field("bar", {"github": "org/bar-renamed"}, path=cfg_path)
+        cfg = load_config(path=cfg_path, notes_root=Path("/tmp/notes"))
+        self.assertEqual(cfg["repos"]["bar"]["github"], "org/bar-renamed")
+        self.assertEqual(cfg["repos"]["bar"]["local"], "/code/bar")
+
+    def test_raises_on_scalar_entry(self):
+        cfg_path = self._write_config(
+            "notes_root: /tmp/notes\n"
+            "repos:\n"
+            "  foo: org/foo\n"
+        )
+        with self.assertRaises(subprocess.CalledProcessError):
+            write_repo_field("foo", {"github": "org/foo-renamed"}, path=cfg_path)
+
+
 if __name__ == "__main__":
     unittest.main()