@stylusnexus/work-plan 2026.7.13 → 2026.7.15

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

@@ -433,6 +433,31 @@ def repo_visibility(repo: str) -> Optional[str]:
     return vis
 
 
+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_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()