@stylusnexus/work-plan 2026.6.11 → 2026.6.13

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

@@ -0,0 +1,314 @@
+"""plan-branch subcommand — bootstrap + share a repo's canonical plan branch (#260).
+
+The shared (`.work-plan/`) tier is pinned to ONE per-repo `plan_branch`, read and
+written through a dedicated git worktree (Phases 1+2). This command sets that up
+and shares it:
+
+  init <repo>   Create the plan branch + `.work-plan/` skeleton for <repo>, or
+                connect to a teammate's already-published one, and record
+                `plan_branch` in config. LOCAL ONLY — no network push. Default
+                branch is an ORPHAN `work-plan/plan` (zero shared history with
+                code, like gh-pages); override with --branch=<name>.
+  status <repo> Report the configured plan_branch: does it exist, is it
+                published to origin, how many local commits are unpushed.
+                Add --json for the machine shape.
+  push <repo>   Push the plan branch to origin to share it. This is the exposure
+                point: on a PUBLIC repo it prints a confirm heads-up + token and
+                exits; re-run with --confirm=<token>. --dry-run previews the
+                commits that would be pushed without pushing.
+
+Usage:
+  plan-branch <init|status|push> <repo> [--branch=<name>] [--confirm=<token>]
+                                        [--dry-run] [--json]
+"""
+import json
+import os
+import re
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from lib.config import (
+    load_config, ConfigError, DEFAULT_CONFIG_PATH, is_valid_git_repo,
+)
+from lib.git_state import is_safe_ref
+from lib.notes_readme import seed_readme
+from lib.prompts import parse_flags
+from lib.write_guard import needs_confirm, make_token, valid_token
+from lib import plan_worktree as pw
+
+_ACTIONS = ("init", "status", "push")
+_DEFAULT_BRANCH = "work-plan/plan"
+# A git refname segment: starts alnum, then alnum / . _ - and / separators. We
+# additionally reject `..`, leading/trailing `/`, and `//` below.
+_BRANCH_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._/-]*$")
+_KEY_RE = re.compile(r"^[A-Za-z0-9._-]+$")  # safe for the yq config path
+
+
+def _valid_branch(name: str) -> bool:
+    return (
+        is_safe_ref(name)
+        and bool(_BRANCH_RE.fullmatch(name))
+        and ".." not in name
+        and "//" not in name
+        and not name.startswith("/")
+        and not name.endswith("/")
+        and not name.endswith(".lock")
+    )
+
+
+def _set_plan_branch(key: str, branch: str) -> bool:
+    """Persist .repos.<key>.plan_branch=<branch> into config via yq. The branch
+    travels as an opaque env value (strenv), never interpolated. `key` is the
+    config repo key (validated by the caller). Returns True on success."""
+    env = {**os.environ, "WP_PLAN_BRANCH": branch}
+    expr = f".repos.{key}.plan_branch = strenv(WP_PLAN_BRANCH)"
+    try:
+        subprocess.run(
+            ["yq", "-i", expr, str(DEFAULT_CONFIG_PATH)],
+            check=True, capture_output=True, text=True, env=env, timeout=20,
+        )
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"ERROR: yq failed to update config: {e.stderr}")
+        return False
+    except (OSError, subprocess.TimeoutExpired) as e:
+        # yq missing / hung — degrade cleanly rather than crash with a traceback.
+        print(f"ERROR: could not run yq to update config: {e}")
+        return False
+
+
+def _resolve_repo(cfg: dict, repo_arg: Optional[str]):
+    """Return (key, entry, github, local_path) for a CONFIGURED repo, or print an
+    error and return None. plan-branch writes into a repo's config entry, so the
+    repo must be registered (init-repo) and have a local clone path."""
+    repos = cfg.get("repos") or {}
+    if repo_arg is None:
+        if len(repos) == 1:
+            key = next(iter(repos))
+        else:
+            print("ERROR: specify which repo — e.g. `plan-branch init <key>`. "
+                  f"Configured: {', '.join(repos) or '(none)'}.")
+            return None
+    elif repo_arg in repos:
+        key = repo_arg
+    else:
+        print(f"ERROR: '{repo_arg}' is not a configured repo. Register it first "
+              "with `init-repo <key> --github=org/repo --local=<path>`.")
+        return None
+
+    if not _KEY_RE.fullmatch(key):
+        print(f"ERROR: repo key '{key}' has unexpected characters; refusing to "
+              "edit config for it.")
+        return None
+    entry = repos[key] or {}
+    github = entry.get("github")
+    local_raw = entry.get("local")
+    if not local_raw:
+        print(f"ERROR: repo '{key}' has no local clone path in config. Add one "
+              f"with `init-repo {key} --github={github or 'org/repo'} --local=<path>`.")
+        return None
+    local_path = Path(local_raw).expanduser()
+    if not is_valid_git_repo(local_path):
+        print(f"ERROR: {local_path} is not a git repository.")
+        return None
+    return key, entry, github, local_path
+
+
+def _do_init(cfg, key, entry, github, local_path, flags) -> int:
+    raw = flags.get("--branch")
+    branch = raw if isinstance(raw, str) and raw else _DEFAULT_BRANCH
+    if not _valid_branch(branch):
+        print(f"ERROR: '{branch}' is not a valid branch name.")
+        return 2
+
+    existing = entry.get("plan_branch")
+    if existing and existing != branch:
+        print(f"ERROR: repo '{key}' already has plan_branch '{existing}'. "
+              "Refusing to silently switch it — edit config to change.")
+        return 1
+
+    # Fetch so the connect-vs-create decision sees a teammate's published branch.
+    pw.fetch_branch(local_path, branch)
+
+    if pw._branch_exists(local_path, branch):
+        # Connect: a branch already exists (local or origin) — reuse it.
+        wt = pw.ensure_worktree(local_path, branch)
+        if wt is None:
+            print(f"ERROR: branch '{branch}' exists but its worktree could not be "
+                  "created. Resolve any conflicting worktree and retry.")
+            return 1
+        # The branch already carries its own .work-plan/ — connecting just wires
+        # it up; no seeding (and no write into a possibly-absent dir).
+        print(f"✓ Connected repo '{key}' to existing plan branch '{branch}'.")
+        published = pw.is_published(local_path, branch)
+        print(f"  Source: {'origin (a teammate published it)' if published else 'local'}.")
+    else:
+        # Create a fresh orphan branch with only .work-plan/.
+        dest = pw.create_orphan_worktree(local_path, branch)
+        if dest is None:
+            print(f"ERROR: could not create the plan worktree for '{branch}'. "
+                  "Is there a stale worktree at the cache path, or no commits in "
+                  "the repo yet?")
+            return 1
+        seed_readme(dest / ".work-plan")
+        paths = pw.dirty_work_plan_paths(dest)
+        sha = pw.commit_shared_tier(
+            dest, f"work-plan: initialize plan branch {branch}", paths)
+        if sha is None:
+            print(f"ERROR: created the worktree but the initial commit failed.")
+            return 1
+        print(f"✓ Created orphan branch '{branch}' for '{key}' ({sha}, local only).")
+        print("  It holds only plan data — no shared history with your code, so "
+              "it won't appear in pull requests or deploys.")
+
+    if not _set_plan_branch(key, branch):
+        return 1
+    print(f"✓ Recorded plan_branch '{branch}' in config for '{key}'.")
+    print()
+    print("Next:")
+    print(f"  • Add a shared track:  /work-plan new-track {key} <slug>")
+    print(f"  • Share the branch:    /work-plan plan-branch push {key}")
+    if github and needs_confirm(github, cfg):
+        print(f"    ⚠ {github} is public — `push` will make the plan visible to anyone.")
+    return 0
+
+
+def _do_status(cfg, key, entry, github, local_path, flags) -> int:
+    branch = entry.get("plan_branch")
+    want_json = "--json" in flags
+    if not branch:
+        if want_json:
+            print(json.dumps({"repo": key, "plan_branch": None,
+                              "configured": False}))
+        else:
+            print(f"repo '{key}': no plan_branch configured.")
+            print(f"  Run `plan-branch init {key}` to set one up.")
+        return 0
+
+    pw.fetch_branch(local_path, branch)  # best-effort: accurate published/unpushed
+    local_exists = pw.local_branch_exists(local_path, branch)
+    published = pw.is_published(local_path, branch)
+    unpushed = pw.unpushed_oneline(local_path, branch)
+
+    if want_json:
+        print(json.dumps({
+            "repo": key, "plan_branch": branch, "configured": True,
+            "local_exists": local_exists, "published": published,
+            "unpushed_count": len(unpushed),
+        }))
+        return 0
+
+    print(f"repo '{key}': plan_branch '{branch}'")
+    print(f"  local branch: {'✓ present' if local_exists else '✗ missing (run init)'}")
+    print(f"  published:    {'✓ on origin' if published else '✗ local only — not shared yet'}")
+    if unpushed:
+        print(f"  unpushed:     {len(unpushed)} commit(s) — run "
+              f"`plan-branch push {key}` to share:")
+        for line in unpushed[:10]:
+            print(f"      {line}")
+        if len(unpushed) > 10:
+            print(f"      … and {len(unpushed) - 10} more")
+    else:
+        print("  unpushed:     none — origin is up to date.")
+    return 0
+
+
+def _do_push(cfg, key, entry, github, local_path, flags) -> int:
+    branch = entry.get("plan_branch")
+    if not branch:
+        print(f"ERROR: repo '{key}' has no plan_branch. Run `plan-branch init "
+              f"{key}` first.")
+        return 1
+    if not pw.local_branch_exists(local_path, branch):
+        print(f"ERROR: plan branch '{branch}' doesn't exist locally. Run "
+              f"`plan-branch init {key}` first.")
+        return 1
+
+    pw.fetch_branch(local_path, branch)
+    commits = pw.unpushed_oneline(local_path, branch)
+
+    if "--dry-run" in flags:
+        if not commits:
+            print(f"Nothing to push — origin/{branch} is up to date.")
+            return 0
+        print(f"Would push {len(commits)} commit(s) to origin/{branch}:")
+        for line in commits:
+            print(f"  {line}")
+        return 0
+
+    if not commits:
+        print(f"Nothing to push — origin/{branch} is up to date.")
+        return 0
+
+    # Exposure gate: publishing planning notes to a PUBLIC repo is a meaningful,
+    # effectively-permanent disclosure. Same confirm-token flow as other public
+    # writes, with concrete wording about what becomes visible. No `github and`
+    # short-circuit — needs_confirm() fails CLOSED on empty/unknown visibility,
+    # and that fail-closed behaviour must NOT be defeated (a config entry with a
+    # null/empty github would otherwise push unguarded).
+    if needs_confirm(github, cfg):
+        confirm = flags.get("--confirm")
+        if not (isinstance(confirm, str) and valid_token(confirm, github, branch)):
+            print(json.dumps({
+                "needs_confirm": True,
+                "reason": (
+                    f"{github} is PUBLIC (or its visibility is unknown). Pushing "
+                    f"'{branch}' makes your plan files — issue notes, priorities, "
+                    "and planning text — visible to anyone on the internet, and "
+                    "they remain in public git history even if the branch is "
+                    "later deleted."
+                ),
+                "token": make_token(github, branch),
+            }))
+            return 0
+
+    proc = pw.push_plan_branch(local_path, branch)
+    if proc is None:
+        print("ERROR: could not run git to push.")
+        return 1
+    if proc.returncode != 0:
+        err = (proc.stderr or "").strip()
+        if "protected" in err.lower() or "pull request" in err.lower():
+            print(f"ERROR: origin rejected the push — '{branch}' looks protected. "
+                  f"Exempt '{branch.split('/')[0]}/**' from PR/branch-protection "
+                  "rules for the plan branch, or push it manually once.")
+        else:
+            print(f"ERROR: push failed: {err or 'unknown git error'}")
+        return 1
+    print(f"✓ Pushed '{branch}' to origin ({len(commits)} commit(s)). "
+          "Teammates can `plan-branch init` to connect.")
+    return 0
+
+
+def run(args: list[str]) -> int:
+    flags, positional = parse_flags(
+        args, {"--branch", "--confirm", "--dry-run", "--json"})
+
+    action = positional[0] if positional else None
+    if action not in _ACTIONS:
+        print(f"usage: work_plan.py plan-branch <{'|'.join(_ACTIONS)}> <repo> "
+              "[--branch=<name>] [--confirm=<token>] [--dry-run] [--json]")
+        return 2
+
+    repo_arg = positional[1] if len(positional) > 1 else None
+
+    try:
+        cfg = load_config()
+    except (ConfigError, subprocess.CalledProcessError, OSError) as e:
+        # ConfigError is the expected case; CalledProcessError / OSError cover a
+        # malformed config or a missing `yq` so the command degrades to a clean
+        # error instead of a traceback (never-raise contract).
+        print(f"ERROR: could not load config: {e}")
+        return 1
+
+    resolved = _resolve_repo(cfg, repo_arg)
+    if resolved is None:
+        return 1
+    key, entry, github, local_path = resolved
+
+    if action == "init":
+        return _do_init(cfg, key, entry, github, local_path, flags)
+    if action == "status":
+        return _do_status(cfg, key, entry, github, local_path, flags)
+    return _do_push(cfg, key, entry, github, local_path, flags)

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

@@ -19,7 +19,7 @@ from lib.scratch import cache_dir
 from lib.prompts import parse_flags, prompt_yes_no
 
 KNOWN = {"--repo", "--json", "--since-days", "--type", "--stamp", "--draft",
-         "--llm", "--apply", "--archive", "--issues"}
+         "--llm", "--apply", "--archive", "--issues", "--stall-days"}
 _ORDER = ["shipped", "partial", "dead", "foreign", "manifest-less"]
 
 
@@ -35,8 +35,54 @@ def _resolve_repo_root(flags) -> Path:
     return Path.cwd()
 
 
-def _evaluate(doc, repo_root, today, dead_days) -> dict:
-    text = doc.path.read_text(encoding="utf-8", errors="replace")
+def _resolve_stall_days(flags) -> int:
+    """Precedence for the staleness threshold (#164):
+    --stall-days flag (int) -> config.yml `stall_days` (int) -> default 14.
+    A non-integer flag value falls through to the config/default tier.
+    """
+    raw = flags.get("--stall-days")
+    if raw not in (None, True):
+        try:
+            return int(raw)
+        except (TypeError, ValueError):
+            pass
+    cfg_val = config_mod.load_config().get("stall_days")
+    if isinstance(cfg_val, int):
+        return cfg_val
+    return verdict_mod.STALL_DAYS
+
+
+def _read(path) -> str:
+    """Read a doc's text. Indirected so tests can patch it without a real file."""
+    return path.read_text(encoding="utf-8", errors="replace")
+
+
+def _declared_paths_on_disk(decls, repo_root) -> list:
+    """Repo-relative declared paths that point at a real FILE inside repo_root.
+
+    Both guards matter for the staleness clock: a junk declared path like `/`
+    resolves (via `repo_root / "/"`) to the filesystem root — a directory that
+    exists — and an out-of-tree `../x` path can exist too. Either one passed to
+    `git log -- <paths…>` poisons the WHOLE call (it returns nothing), which
+    would falsely mark an actively-built plan as stalled. So require an actual
+    file (`is_file`) that resolves under repo_root."""
+    root = Path(repo_root).resolve()
+    out = []
+    for d in decls:
+        p = Path(repo_root) / d.path
+        try:
+            if not p.is_file():
+                continue
+            resolved = p.resolve()
+        except OSError:
+            continue
+        if resolved == root or root in resolved.parents:
+            out.append(d.path)
+    return out
+
+
+def _evaluate(doc, repo_root, today, dead_days, stall_days) -> dict:
+    text = _read(doc.path)
     decls = manifest.parse_declared_paths(text)
     pdate = manifest.plan_date_from_filename(doc.path.name)
     score = manifest.score_manifest(decls, repo_root, pdate)
@@ -48,12 +94,36 @@ def _evaluate(doc, repo_root, today, dead_days) -> dict:
             "foreign", "🧳", "declared paths point outside this repo — misfiled?")
     else:
         v = verdict_mod.classify(score, done, total_chk, last_d, today, dead_days)
+
+    # Staleness clock (#164): a partial plan whose declared manifest files have
+    # gone cold = "started executing, then drifted off." Key off the manifest
+    # files' commit date, NOT the plan doc's git date — plan docs are gitignored,
+    # so the doc date is null and would make this a silent no-op.
+    manifest_dt = None
+    stalled = False
+    if v.label == "partial":
+        on_disk = _declared_paths_on_disk(decls, repo_root)
+        if on_disk:
+            manifest_dt = git_state.paths_last_commit_date(on_disk, repo_root)
+            if manifest_dt is None:
+                stalled = True  # present on disk but never committed
+            else:
+                stalled = (today - manifest_dt.date()).days >= stall_days
+        # else: no declared files on disk yet -> brand-new, not stalled.
+
+    lie_gap = (v.label == "shipped" and total_chk > 0
+               and done / total_chk < 0.25)
     return {
         "rel": doc.rel, "kind": doc.kind,
         "verdict": v.label, "glyph": v.glyph, "rationale": v.rationale,
         "files_present": score.satisfied, "files_declared": score.total,
         "checkboxes_done": done, "checkboxes_total": total_chk,
         "last_touched": last_d.isoformat() if last_d else None,
+        "manifest_last_touched": manifest_dt.date().isoformat() if manifest_dt else None,
+        "stalled": stalled,
+        "lie_gap": lie_gap,
+        "unchecked_items": manifest.unchecked_checkbox_labels(text),
+        "stall_days": stall_days,
     }
 
 
@@ -62,11 +132,7 @@ def _render(rows, repo_root) -> None:
     by = {}
     for r in rows:
         by.setdefault(r["verdict"], []).append(r)
-    lie_gap = sum(
-        1 for r in rows
-        if r["verdict"] == "shipped" and r["checkboxes_total"]
-        and r["checkboxes_done"] / r["checkboxes_total"] < 0.25
-    )
+    lie_gap = sum(1 for r in rows if r["lie_gap"])
     summary = " · ".join(f"{len(by[k])} {k}" for k in _ORDER if by.get(k))
     print(f"{len(rows)} docs · {summary}")
     print(f"lie-gap (shipped but <25% boxes checked): {lie_gap}\n")
@@ -271,7 +337,8 @@ def run(args: list) -> int:
     if type_filter and type_filter is not True:
         docs = [d for d in docs if d.kind == type_filter]
 
-    rows = [_evaluate(d, repo_root, today, dead_days) for d in docs]
+    stall_days = _resolve_stall_days(flags)
+    rows = [_evaluate(d, repo_root, today, dead_days, stall_days) for d in docs]
 
     if flags.get("--llm"):
         if flags.get("--apply"):

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

@@ -41,6 +41,20 @@ from lib.write_guard import needs_confirm
 PER_TRACK_TIMEOUT = 15  # seconds; each gh call gets this budget
 
 
+def _track_key(track) -> tuple:
+    """Stable, unique identity for a track across a reconcile run.
+
+    Track slugs are NOT unique — the same slug can name a track in two different
+    repos (this is explicitly supported). Keying reconcile's in-flight state by
+    slug let a later repo's fetch overwrite an earlier same-slug track's, so
+    under `--all --yes` issues from one repo could be written into the
+    same-named track in ANOTHER repo — cross-repo membership corruption (#255).
+    The (repo, path) pair is unique per track file and stable for the whole run.
+    Display still uses `track.name`; only dict keys use this.
+    """
+    return (track.repo, str(track.path))
+
+
 def _resolve_labels(track) -> list[str]:
     """Return the GitHub label(s) marking issues as belonging to this track.
 
@@ -143,7 +157,7 @@ def run(args: list[str]) -> int:
 
     # Phase 1: parallel fetch of labeled issues for all tracks
     work_items = [(track, _resolve_labels(track)) for track in targets if track.repo]
-    results: dict = {}  # track.name → list[dict] or None (timeout/error)
+    results: dict = {}  # _track_key(track) → list[dict] or None (timeout/error)
 
     total = len(work_items)
     if total > 1:
@@ -156,21 +170,21 @@ def run(args: list[str]) -> int:
             # Iterate in submit order for readable output; futures run in parallel
             for i, track, future in submitted:
                 try:
-                    results[track.name] = future.result()
-                    print(f"  [{i}/{total}] ✓ {track.name}")
+                    results[_track_key(track)] = future.result()
+                    print(f"  [{i}/{total}] ✓ {track.name} ({track.repo})")
                 except RuntimeError as e:
-                    print(f"  [{i}/{total}] ⚠ {track.name}: {e} — skipping")
-                    results[track.name] = None
+                    print(f"  [{i}/{total}] ⚠ {track.name} ({track.repo}): {e} — skipping")
+                    results[_track_key(track)] = None
     else:
         # Single track: fetch directly (no thread overhead)
         for i, (track, labels) in enumerate(work_items, 1):
             print(f"  [{i}/{total}] fetching {track.repo} ({track.name})...", flush=True)
             try:
-                results[track.name] = _fetch_labeled_issues(track.repo, labels)
-                print(f"  [{i}/{total}] ✓ {track.name}")
+                results[_track_key(track)] = _fetch_labeled_issues(track.repo, labels)
+                print(f"  [{i}/{total}] ✓ {track.name} ({track.repo})")
             except RuntimeError as e:
-                print(f"  [{i}/{total}] ⚠ {track.name}: {e} — skipping")
-                results[track.name] = None
+                print(f"  [{i}/{total}] ⚠ {track.name} ({track.repo}): {e} — skipping")
+                results[_track_key(track)] = None
 
     # Phase 2a: index which fetched track(s) label each issue. Used to turn a
     # bare FLAG (in a track's frontmatter, but it has lost that track's label)
@@ -178,45 +192,46 @@ def run(args: list[str]) -> int:
     # track in the same repo.
     labeled_index: dict = {}  # issue number -> list[track]
     for track in targets:
-        if not track.repo or results.get(track.name) is None:
+        if not track.repo or results.get(_track_key(track)) is None:
             continue
-        for num in {i["number"] for i in results[track.name]}:
+        for num in {i["number"] for i in results[_track_key(track)]}:
             labeled_index.setdefault(num, []).append(track)
 
     # Phase 2b: detect cross-track moves (#163). An issue qualifies when it is
     # in track A's frontmatter, no longer carries A's label, and is now labeled
     # by exactly one OTHER active track B in the same repo. Ambiguous cases
     # (two or more candidate targets) stay as plain FLAGs.
-    moved_out: dict = {}  # src track name -> set(num)
-    moved_in: dict = {}   # dst track name -> set(num)
-    move_dst: dict = {}   # (src track name, num) -> dst track
+    moved_out: dict = {}  # _track_key(src) -> set(num)
+    moved_in: dict = {}   # _track_key(dst) -> set(num)
+    move_dst: dict = {}   # (_track_key(src), num) -> dst track
     for track in targets:
-        if not track.repo or results.get(track.name) is None:
+        if not track.repo or results.get(_track_key(track)) is None:
             continue
-        labeled_nums = {i["number"] for i in results[track.name]}
+        labeled_nums = {i["number"] for i in results[_track_key(track)]}
         listed_nums = set(track.meta.get("github", {}).get("issues") or [])
         for num in sorted(listed_nums - labeled_nums):
             cands = [b for b in labeled_index.get(num, [])
                      if b is not track and b.repo == track.repo]
             if len(cands) == 1:
                 dst = cands[0]
-                moved_out.setdefault(track.name, set()).add(num)
-                moved_in.setdefault(dst.name, set()).add(num)
-                move_dst[(track.name, num)] = dst
+                moved_out.setdefault(_track_key(track), set()).add(num)
+                moved_in.setdefault(_track_key(dst), set()).add(num)
+                move_dst[(_track_key(track), num)] = dst
 
     # Phase 2c: per-track diff, report, confirm. Membership changes accumulate
-    # in `final` (track name -> desired issue set); each affected track is
+    # in `final` (_track_key -> desired issue set); each affected track is
     # written exactly ONCE at the end, so a move that touches two tracks never
     # double-writes or clobbers a sibling's accepted ADDs. A move is governed by
     # the confirmation on its SOURCE track (where the issue currently lives).
-    final: dict = {}     # track name -> set(num)
-    affected: dict = {}  # track name -> track (only those we may write)
+    final: dict = {}     # _track_key(track) -> set(num)
+    affected: dict = {}  # _track_key(track) -> track (only those we may write)
 
     def _final_for(t):
-        if t.name not in final:
-            final[t.name] = set(t.meta.get("github", {}).get("issues") or [])
-            affected[t.name] = t
-        return final[t.name]
+        key = _track_key(t)
+        if key not in final:
+            final[key] = set(t.meta.get("github", {}).get("issues") or [])
+            affected[key] = t
+        return final[key]
 
     any_changes = False
     for track in targets:
@@ -224,19 +239,19 @@ def run(args: list[str]) -> int:
         if not track.repo:
             continue
 
-        labeled = results.get(track.name)
+        labeled = results.get(_track_key(track))
         if labeled is None:
             continue
 
         labels = _resolve_labels(track)
         labeled_nums = {i["number"] for i in labeled}
         listed_nums = set(track.meta.get("github", {}).get("issues") or [])
-        out_moves = sorted(moved_out.get(track.name, set()))
+        out_moves = sorted(moved_out.get(_track_key(track), set()))
 
         # MOVE issues are reported (and applied) as moves, not as ADD on the
         # destination or FLAG on the source.
-        adds = sorted(labeled_nums - listed_nums - moved_in.get(track.name, set()))
-        flag_nums = sorted(listed_nums - labeled_nums - moved_out.get(track.name, set()))
+        adds = sorted(labeled_nums - listed_nums - moved_in.get(_track_key(track), set()))
+        flag_nums = sorted(listed_nums - labeled_nums - moved_out.get(_track_key(track), set()))
 
         if not adds and not flag_nums and not out_moves:
             continue
@@ -253,7 +268,7 @@ def run(args: list[str]) -> int:
         if out_moves:
             print(f"  MOVE ({len(out_moves)}) — relabeled to another track in this repo:")
             for num in out_moves:
-                dst = move_dst[(track.name, num)]
+                dst = move_dst[(_track_key(track), num)]
                 dst_slug = dst.meta.get("track", dst.name)
                 pub = " [dst PUBLIC]" if needs_confirm(dst.repo, cfg) else ""
                 print(f"    #{num}  {slug} → {dst_slug}{pub}")
@@ -286,7 +301,7 @@ def run(args: list[str]) -> int:
         if adds:
             _final_for(track).update(adds)
         for num in out_moves:
-            dst = move_dst[(track.name, num)]
+            dst = move_dst[(_track_key(track), num)]
             # Public-repo guard (#163): under --yes we never silently write
             # membership into a PUBLIC/shared destination track — that move is
             # skipped with a pointer to the gated `move` verb. Interactive runs
@@ -300,8 +315,8 @@ def run(args: list[str]) -> int:
             _final_for(dst).add(num)
 
     # Write each affected track exactly once, only if its set actually changed.
-    for name, issues in final.items():
-        track = affected[name]
+    for key, issues in final.items():
+        track = affected[key]
         original = set(track.meta.get("github", {}).get("issues") or [])
         if issues == original:
             continue