@stylusnexus/work-plan 2026.6.14 → 2026.6.15-2

package/README.md

@@ -108,6 +108,7 @@ flowchart TB
   - `handoff <track> --set-next 4167,4148` — explicit numbers when you know exactly which issues are next.
   - Free-form via Claude in your agent session, which can review project memory and write a curated list back. The two `--*-next` flags are the no-LLM paths.
   - For tracks where you don't want to bother curating at all, set `next_up_auto: true` in the track's frontmatter — `brief` will then derive the list live each invocation, ignoring whatever's stored.
+  - **Ranking presets** — when `next_up_auto: true` is on, the default ranking is `flow` (milestone → dependency → priority → recency). Override per-track with `set-next-up <track> --preset=<name>`, or set `next_up_default: <name>` in your config for a global fallback. Named presets: `flow` (the default), `priority-driven` (priority first, no milestone bias — good for backlogs with no milestones), `backlog` (oldest issues first — surfaces stalled work). Custom criterion order: `set-next-up <track> --order=aging,priority,dependency`. Clear a track's override with `--clear`. Toggle auto-derivation itself with `--auto=on|off` (no hand-editing frontmatter required).
 - **Weekly** → `hygiene` runs `refresh-md --all` + `reconcile --all` + `duplicates` in sequence to keep status icons, GitHub labels, and dedup state honest.
 
 > **When should I run `refresh-md`?** Any time you close or merge issues and want the track body to reflect the new state. `handoff` rewrites the status table for one track on every run, but `brief` reads GitHub live without writing anything back — so a track you haven't `handoff`'d recently stays stale on disk. `refresh-md <track>` (or **Sync Issue States from GitHub** in VS Code) fixes that on-demand; `hygiene` sweeps all tracks weekly.
@@ -300,7 +301,7 @@ To install for **both** Claude Code AND Codex, run the installer twice with diff
 
 ### VS Code extension
 
-The **Work Plan** extension is the visual face of the CLI — a sidebar tree (repos → tracks, with per-track open/closed counts and an **activity-bar badge** for blocked/open status), a Mermaid dependency graph (with focus toggle and repo-scoped full map), per-track detail with an **open/closed progress bar** and a one-click **Plan** link, the Untracked bucket, cross-track dependency chips, per-issue move/close buttons, **keyword issue search** (`%wildcard%` substitution, results in a dedicated tab), the daily-driver **Brief / Re-orient / Handoff** commands, an inline **active lens + sort** indicator under the view title, a **Plans view** with confirm-gated frontmatter writes (verdict / acknowledge / drift-baseline) and a fast-fail GitHub-auth banner, and full read/write (slot/close/edit/move/new-track/push-track/…) with a public-repo confirm modal.
+The **Work Plan** extension is the visual face of the CLI — a sidebar tree (repos → tracks, with per-track open/closed counts and an **activity-bar badge** for blocked/open status), a Mermaid dependency graph (with focus toggle and repo-scoped full map) that draws **GitHub-native blocked-by edges**, per-track detail with an **open/closed progress bar**, a one-click **Plan** link, a **per-issue in-progress badge + toggle**, expandable **blocked-by / blocking dependency chips**, the Untracked bucket, cross-track dependency chips, per-issue move/close buttons, **keyword issue search** (`%wildcard%` substitution, results in a dedicated tab), the daily-driver **Brief / Re-orient / Handoff** commands, **next-up controls** — a **Set Next-Up** button and a **Set Next-Up Order…** preset picker (`flow` / `priority-driven` / `backlog`) with the active preset shown inline, an inline **active lens + sort** indicator under the view title, a **Plans view** with confirm-gated frontmatter writes (verdict / acknowledge / drift-baseline) and a fast-fail GitHub-auth banner, and full read/write (slot/close/edit/move/new-track/push-track/…) with a public-repo confirm modal.
 
 ![Work Plan VS Code extension — sidebar and dependency graph](https://raw.githubusercontent.com/stylusnexus/work-plan-toolkit/main/vscode/media/screenshots/dependency-graph.png)
 
@@ -522,6 +523,7 @@ See `docs/usage-examples.md` for end-to-end scenarios (morning brief, mid-work h
 | `remove-repo <key>` | Unregister a repo: delete its block from your config. **Config-only** — the notes folder, any tracks, and the local clone are left untouched (a notes folder or tracks that referenced it are now orphaned and can be removed by hand). Completes the add/update/remove trio with `init-repo`. |
 | `new-track <repo> <slug> [--priority=P0..P3] [--milestone=<m>]` | One-shot, non-interactive: create a new track file under `notes_root` for `<repo>` (a config key **or** an `org/repo` slug) with frontmatter. Unlike `init`, it makes the file for you — the headless creation path the VS Code viewer uses. |
 | `rename-track <old-slug \| old@repo> <new-slug> [--repo=<key>] [--fix-refs] [--commit]` | Rename an active track's slug: moves its `.md` file and updates the frontmatter `track` field + `last_touched`. Validates `<new-slug>` like `new-track` and rejects a name already taken in the same repo/tier. For shared tracks, `--commit` stages + commits the move (otherwise it prints a "commit to share" hint). `--fix-refs` rewrites sibling tracks' `depends_on` that reference the old slug; without it they're just warned about. Archived tracks are immutable. Public-repo gated. |
+| `set-next-up <track> (--preset=<name> \| --order=a,b,c \| --clear \| --auto=on\|off) [--repo=<key>] [--confirm=<token>]` | Configure the ranking preset and/or auto-derivation flag for a track's next_up list. `--preset` sets a named preset: `flow` (default — milestone → dependency → priority → recency), `priority-driven` (priority first, ignores milestone bias, for backlogs with no milestones), `backlog` (oldest issues first — surfaces stalled work), or `custom` (requires `--order`). `--order=a,b,c` sets a custom comma-separated criterion list (`milestone`, `dependency`, `priority`, `recency`, `aging`). `--clear` reverts to the global `next_up_default` config or the default `flow`. `--auto=on` activates `next_up_auto` so brief/orient/export auto-derive the next-up list live from the ranking preset (ignoring the curated list); `--auto=off` clears it to revert to the curated list. `--auto` can be used standalone or combined with `--preset`/`--order`/`--clear`. Writes `next_up_order` and/or `next_up_auto` into the track's frontmatter; does NOT touch the `next_up` issue-list. Global default: add `next_up_default: <preset>` to `~/.claude/work-plan/config.yml`. Public-repo gated. |
 | `set-notes-root <path>` | Relocate where your private track notes live (updates `notes_root` in config). Does not move existing tracks — it warns if any would be orphaned. |
 | `notes-vcs <init\|enable\|disable\|status\|undo> [<sha>] [--no-enable] [--json]` | Opt-in **local** version control for the private `notes_root` tier — history/undo for tracks on your machine, never pushed. `init` git-inits `notes_root` as a personal repo (baseline commit of existing tracks) and turns on auto-commit (`--no-enable` skips that). For safety it **refuses** a `notes_root` that already has a git remote or is a repo work-plan didn't create. When on, every track-mutating command (`slot`/`group`/`handoff`/`close`/`set`/…) commits **only the files it changed** (pre-existing uncommitted edits are left alone) as an undoable commit. The shared tier is unaffected — it's versioned by its own repo. `status` shows whether `notes_root` is a repo, whether auto-commit is on, and the last commit (`--json` for the machine shape the VS Code viewer polls). `undo [<sha>]` reverts a commit (default HEAD) — reverses the last edit. |
 | `push-track <track\|track@repo> [--repo=<key>] [--no-push] [--confirm=<token>]` | **Promote a private track to the shared tier and publish it** (#306). Moves the track's `.md` from `notes_root` into the repo's `.work-plan/` (on its `plan_branch`, via a worktree), removes the private copy so it isn't duplicated, commits to the plan branch, and pushes — unless `--no-push`. Tier is derived from location, so this is a file move, not a frontmatter edit. Requires a local clone + a configured `plan_branch` (else hints `plan-branch init`). Pushing to a **public** repo makes the track world-visible → confirm-token gated. |

package/VERSION

@@ -1 +1 @@
-2026.06.14+ef58902
+2026.06.15+c80ece1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stylusnexus/work-plan",
-  "version": "2026.6.14",
+  "version": "2026.6.15-2",
   "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

@@ -17,7 +17,7 @@ from lib.git_state import (
 from lib.in_progress import issue_in_progress
 from lib.closure import compute_signals, is_closure_ready
 from lib.new_issues import build_slug_labels, find_new_issues_for_tracks
-from lib.next_up import suggest_next_up
+from lib.next_up import suggest_next_up, resolve_next_up_order
 from lib.drift import detect_drift
 from lib.render import time_aware_framing, render_track_row, render_archived_reopen
 
@@ -121,15 +121,22 @@ def _build_track_block(track, cfg, now: datetime) -> dict:
     # for display purposes — useful for tracks where you don't want to
     # hand-curate but still want a sensible "what's next" surfaced.
     track_milestone = meta.get("milestone_alignment") or None
+    hot_nums = hot_issue_numbers(local) if local else set()
     if meta.get("next_up_auto") and issues:
         blocker_nums = meta.get("blockers") or []
-        next_up_nums = suggest_next_up(issues, blocker_nums, track_milestone=track_milestone)
+        in_progress_set = {i["number"] for i in issues if issue_in_progress(i, hot_nums)}
+        _, order = resolve_next_up_order(meta, cfg.get("next_up_default"))
+        next_up_nums = suggest_next_up(
+            issues, blocker_nums,
+            track_milestone=track_milestone,
+            in_progress_nums=in_progress_set,
+            order=order,
+        )
     else:
         next_up_nums = stored_next_up
 
     next_up_items = []
     next_up_closed_count = 0
-    hot_nums = hot_issue_numbers(local) if local else set()
     for num in next_up_nums:
         i = issues_by_num.get(num)
         if not i:

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

@@ -140,13 +140,15 @@ def run(args: list[str]) -> int:
             if nums:
                 hot_by_track[(t.repo, t.name)] = nums
 
+    next_up_default = cfg.get("next_up_default")
     now = datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
     print(json.dumps(
         build_export(tracks, issues_by_track, visibility, now,
                      untracked_by_repo=untracked_by_repo,
                      config_repos=config_repos,
                      plan_by_track=plan_by_track,
-                     hot_by_track=hot_by_track),
+                     hot_by_track=hot_by_track,
+                     next_up_default=next_up_default),
         indent=2,
     ))
     return 0

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

@@ -19,12 +19,13 @@ from lib.session_log import append_session_log, SESSION_LOG_HEADER
 from lib.git_state import (
     has_uncommitted, current_branch, parse_iso_timestamp,
     gap_seconds_to_label, uncommitted_file_count, commits_ahead,
-    is_safe_ref, GIT_TIMEOUT,
+    is_safe_ref, GIT_TIMEOUT, hot_issue_numbers,
 )
 from lib.github_state import fetch_issues, state_to_status_label, extract_priority, short_milestone
+from lib.in_progress import issue_in_progress
 from lib.status_table import update_row_status, sync_missing_rows, find_canonical_status_tables, ISSUE_NUM_RE
 from lib.new_issues import build_slug_labels, find_new_issues_for_tracks
-from lib.next_up import suggest_next_up
+from lib.next_up import suggest_next_up, resolve_next_up_order
 from lib.prompts import prompt_lines, parse_flags, prompt_input
 
 
@@ -152,7 +153,15 @@ def _apply_auto_next(track, cfg: dict) -> int:
     issues = fetch_issues(track.repo, issue_nums)
     blocker_nums = track.meta.get("blockers") or []
     track_milestone = track.meta.get("milestone_alignment") or None
-    raw_suggestion = suggest_next_up(issues, blocker_nums, track_milestone=track_milestone)
+    hot_nums = hot_issue_numbers(track.local_path) if track.local_path else set()
+    in_progress_set = {i["number"] for i in issues if issue_in_progress(i, hot_nums)}
+    _, order = resolve_next_up_order(track.meta, cfg.get("next_up_default"))
+    raw_suggestion = suggest_next_up(
+        issues, blocker_nums,
+        track_milestone=track_milestone,
+        in_progress_nums=in_progress_set,
+        order=order,
+    )
     if not raw_suggestion:
         print(f"No open, non-blocker issues for {track.name}; next_up unchanged.")
         return 0

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

@@ -0,0 +1,210 @@
+"""set-next-up subcommand — guarded edit of a track's next_up ranking preset.
+
+Usage:
+  work_plan.py set-next-up <track> [--repo=<key>]
+      (--preset=<name> | --order=a,b,c | --clear | --auto=on|off)
+      [--confirm=<token>]
+
+Writes `next_up_order` and/or `next_up_auto` into the track's frontmatter.
+Does NOT touch the `next_up` issue-list key.
+
+  --preset=<name>   Set one of the named ranking presets (flow, priority-driven,
+                    backlog) or 'custom' (which requires --order).
+  --order=a,b,c     Set a custom comma-separated criterion list.
+  --clear           Remove the next_up_order key (reverts to global/default).
+  --auto=on|off     Toggle the next_up_auto flag. When on, brief/orient/export
+                    auto-derive the next-up list via the ranking preset (#326).
+                    Can be used standalone or combined with --preset/--order/--clear.
+
+Public-repo gated: without --confirm it prints {needs_confirm, reason, token}
+and makes no change. The VS Code extension surfaces that as a modal then
+re-invokes with --confirm=<token>.
+"""
+import json
+import sys
+from lib.config import load_config, ConfigError
+from lib.tracks import discover_tracks, find_track_by_name, parse_track_repo_arg, AmbiguousTrackError
+from lib.frontmatter import write_file
+from lib.write_guard import needs_confirm, make_token, valid_token
+from lib.prompts import parse_flags
+from lib.next_up import CRITERIA, PRESETS
+
+
+def run(args: list[str]) -> int:
+    flags, positional = parse_flags(
+        args, {"--confirm", "--repo", "--clear", "--preset", "--order", "--auto"}
+    )
+    if not positional:
+        print(
+            "usage: work_plan.py set-next-up <track> "
+            "(--preset=<name> | --order=a,b,c | --clear | --auto=on|off) "
+            "[--repo=<key>] [--confirm=<token>]"
+        )
+        return 2
+
+    track_arg = positional[0]
+    name_from_arg, repo_from_arg = parse_track_repo_arg(track_arg)
+    name = name_from_arg
+    repo_flag = flags.get("--repo") if flags.get("--repo") is not True else None
+    repo_qualifier = repo_from_arg or repo_flag
+
+    clear = bool(flags.get("--clear"))
+    preset_flag = flags.get("--preset") if flags.get("--preset") is not True else None
+    order_flag = flags.get("--order") if flags.get("--order") is not True else None
+    auto_raw = flags.get("--auto") if flags.get("--auto") is not True else None
+
+    # Parse and validate --auto value
+    auto_value = None  # None means not specified
+    if auto_raw is not None:
+        auto_lower = auto_raw.lower() if isinstance(auto_raw, str) else ""
+        if auto_lower == "on":
+            auto_value = True
+        elif auto_lower == "off":
+            auto_value = False
+        else:
+            print(
+                f"ERROR: --auto must be 'on' or 'off', got {auto_raw!r}",
+                file=sys.stderr,
+            )
+            return 2
+
+    # Must have at least one of --preset, --order, --clear, or --auto
+    if not clear and preset_flag is None and order_flag is None and auto_value is None:
+        print(
+            "ERROR: specify --preset=<name>, --order=a,b,c, --clear, or --auto=on|off",
+            file=sys.stderr,
+        )
+        return 2
+
+    # Validate preset name
+    if preset_flag is not None:
+        valid_presets = set(PRESETS.keys()) | {"custom"}
+        if preset_flag not in valid_presets:
+            print(
+                f"ERROR: unknown preset {preset_flag!r} "
+                f"(allowed: {sorted(valid_presets)})",
+                file=sys.stderr,
+            )
+            return 2
+        # 'custom' requires --order
+        if preset_flag == "custom" and order_flag is None:
+            print(
+                "ERROR: --preset=custom requires --order=<criteria>",
+                file=sys.stderr,
+            )
+            return 2
+
+    # Validate order criteria
+    order_list = None
+    if order_flag is not None:
+        raw_criteria = [c.strip() for c in order_flag.split(",") if c.strip()]
+        invalid = [c for c in raw_criteria if c not in CRITERIA]
+        if invalid:
+            print(
+                f"ERROR: unknown criteria {invalid!r} "
+                f"(allowed: {list(CRITERIA)})",
+                file=sys.stderr,
+            )
+            return 2
+        if not raw_criteria:
+            print("ERROR: --order requires at least one criterion", file=sys.stderr)
+            return 2
+        order_list = raw_criteria
+
+    try:
+        cfg = load_config()
+    except ConfigError as e:
+        print(f"ERROR: {e}")
+        return 1
+
+    try:
+        track = find_track_by_name(name, discover_tracks(cfg), repo=repo_qualifier)
+    except AmbiguousTrackError as e:
+        print(str(e))
+        return 1
+    if not track:
+        print(f"No track matching {name!r}.")
+        return 1
+
+    # Public-repo confirm gate
+    confirm = flags.get("--confirm")
+    if (
+        track.repo
+        and needs_confirm(track.repo, cfg)
+        and not (isinstance(confirm, str) and valid_token(confirm, track.repo, track.name))
+    ):
+        print(
+            json.dumps(
+                {
+                    "needs_confirm": True,
+                    "reason": (
+                        f"{track.repo} is PUBLIC (or visibility unknown); "
+                        "edit will be written there."
+                    ),
+                    "token": make_token(track.repo, track.name),
+                }
+            )
+        )
+        return 0
+
+    if clear:
+        track.meta.pop("next_up_order", None)
+        if auto_value is not None:
+            _apply_auto(track, auto_value)
+        write_file(track.path, track.meta, track.body)
+        print(f"✓ cleared next_up_order on {track.name}")
+        if auto_value is not None:
+            _print_auto_result(track, auto_value)
+        return 0
+
+    # If --auto is the only flag (no preset/order/clear), write just the auto flag.
+    if preset_flag is None and order_list is None and auto_value is not None:
+        _apply_auto(track, auto_value)
+        write_file(track.path, track.meta, track.body)
+        _print_auto_result(track, auto_value)
+        return 0
+
+    # Build the next_up_order mapping
+    if preset_flag == "custom" or (preset_flag is None and order_list is not None):
+        # Custom order (either explicit --preset=custom or bare --order)
+        nuo = {"preset": "custom", "order": order_list}
+    else:
+        # Named preset. A named preset supplies its own criterion order, so a
+        # co-supplied --order has no effect — warn (advisory, don't reject) so
+        # the user isn't surprised it was dropped.
+        nuo = {"preset": preset_flag}
+        if order_list is not None:
+            print(
+                f"WARN: --order is ignored when a named preset "
+                f"(--preset={preset_flag}) is given; use --preset=custom "
+                "to supply your own order.",
+                file=sys.stderr,
+            )
+
+    track.meta["next_up_order"] = nuo
+    if auto_value is not None:
+        _apply_auto(track, auto_value)
+    write_file(track.path, track.meta, track.body)
+
+    if preset_flag and preset_flag != "custom":
+        print(f"✓ set next_up_order preset={preset_flag!r} on {track.name}")
+    elif order_list is not None:
+        print(f"✓ set next_up_order custom order={order_list!r} on {track.name}")
+    if auto_value is not None:
+        _print_auto_result(track, auto_value)
+    return 0
+
+
+def _apply_auto(track: "SimpleNamespace", auto_value: bool) -> None:
+    """Mutate track.meta to set or remove next_up_auto."""
+    if auto_value:
+        track.meta["next_up_auto"] = True
+    else:
+        track.meta.pop("next_up_auto", None)
+
+
+def _print_auto_result(track: "SimpleNamespace", auto_value: bool) -> None:
+    if auto_value:
+        print(f"✓ set next_up_auto=true on {track.name}")
+    else:
+        print(f"✓ cleared next_up_auto on {track.name}")

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

@@ -1,5 +1,6 @@
 """Build the versioned viewer export structure from tracks + fetched issues."""
 from lib.github_state import format_assignees, short_milestone
+from lib.next_up import resolve_next_up_order, suggest_next_up
 
 SCHEMA = 1
 
@@ -84,7 +85,8 @@ def normalize_issue(i: dict, in_progress: bool = False,
 
 def build_export(tracks, issues_by_track, visibility, now: str,
                  untracked_by_repo=None, config_repos=None,
-                 plan_by_track=None, hot_by_track=None) -> dict:
+                 plan_by_track=None, hot_by_track=None,
+                 next_up_default=None) -> dict:
     plan_by_track = plan_by_track or {}
     hot_by_track = hot_by_track or {}
     out = {"schema": SCHEMA, "generated_at": now, "tracks": []}
@@ -108,8 +110,22 @@ def build_export(tracks, issues_by_track, visibility, now: str,
         issues.sort(key=lambda i: milestone_sort_key(i, milestone_alignment))
         opened = sum(1 for i in issues if i["state"] == "open")
         closed_nums = {i["number"] for i in issues if i["state"] == "closed"}
-        next_up = [n for n in (t.meta.get("next_up") or []) if n not in closed_nums]
         track_path = getattr(t, "path", None)
+        next_up_preset_name, next_up_order = resolve_next_up_order(t.meta, next_up_default)
+        # When `next_up_auto: true`, derive the next-up list live from the track's
+        # open issues using the resolved ranking preset — same as brief/orient —
+        # instead of reading the curated `next_up` frontmatter list. This is what
+        # surfaces the ranking in the viewer (which only reads this export). #326.
+        if t.meta.get("next_up_auto") and raw:
+            in_progress_set = {i["number"] for i in raw if issue_in_progress(i, hot)}
+            next_up = suggest_next_up(
+                raw, t.meta.get("blockers") or [],
+                track_milestone=milestone_alignment or None,
+                in_progress_nums=in_progress_set,
+                order=next_up_order,
+            )
+        else:
+            next_up = [n for n in (t.meta.get("next_up") or []) if n not in closed_nums]
         out["tracks"].append({
             "name": t.name,
             "repo": t.repo,
@@ -135,6 +151,13 @@ def build_export(tracks, issues_by_track, visibility, now: str,
             # null when the track declares no `plan:`. `{rel, resolved:false}` when
             # the link can't be resolved (no local clone / file absent).
             "plan": plan_by_track.get(t.name),
+            # Effective next_up ranking preset for this track (#326 Phase 2).
+            "next_up_preset": next_up_preset_name,
+            # True when the track has `next_up_auto: true` set in its frontmatter,
+            # meaning the next-up list is auto-derived from the ranking preset (#326).
+            # Reflects the SETTING, not whether derivation actually ran (so the
+            # viewer toggle shows On even when a track has zero open issues).
+            "next_up_auto": bool(t.meta.get("next_up_auto")),
         })
     out["untracked"] = [
         {"repo": repo, "issues": [normalize_issue(r) for r in rows]}

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

@@ -139,28 +139,67 @@ def branch_in_progress(branch_name: str, repo_path: Path) -> bool:
 _BRANCH_ISSUE_RE = re.compile(r"^(?:feat|fix)/(\d+)-")
 
 
-def hot_issue_numbers(repo_path: Path) -> set:
-    """Issue numbers with a 'hot' branch in `repo_path`.
+# Per-process memo for hot_issue_numbers, keyed by resolved repo path. A single
+# export/brief/orient run calls hot_issue_numbers once per track, but many tracks
+# share one clone (e.g. ~25 CritForge tracks → one checkout). Live git state can't
+# change mid-run, so caching by resolved path turns an O(tracks) rescan into
+# O(distinct clones). The CLI is one-shot, so the cache dies with the process;
+# tests reset it via _reset_hot_cache(). (#257 follow-up: pre-memo this was
+# ~40s × 25 tracks ≈ 16min for CritForge on every VS Code reload.)
+_HOT_CACHE: dict = {}
+
+
+def _reset_hot_cache() -> None:
+    """Clear the hot_issue_numbers memo (test hook; not used in production)."""
+    _HOT_CACHE.clear()
 
-    Enumerates local branches with `git branch --format=%(refname:short)` (the
-    --format is load-bearing: plain `git branch` prefixes lines with `  `/`* `/`+ `,
-    which would defeat the anchored regex), maps each `feat/<n>-`/`fix/<n>-` name
-    to <n>, and keeps those whose branch is `branch_in_progress`.
 
-    Failure contract: if the enumeration call fails -> empty set. A per-branch heat
-    check that fails collapses to cold (that branch is simply not added). Never raises.
+def hot_issue_numbers(repo_path: Path) -> set:
+    """Issue numbers with a 'hot' (in-progress) feat/<n>-/fix/<n>- branch in `repo_path`.
+
+    A branch is hot when its tip was committed in the last 24h, OR it is the
+    checked-out branch with uncommitted changes. Enumerates every branch and its
+    tip commit time in ONE `git for-each-ref` call (the recency signal), then does
+    a single current-branch/uncommitted check — so the cost is O(1) git calls, not
+    O(branches). (Previously each of the N branches incurred ~4 git subprocesses
+    via branch_in_progress; on a clone with hundreds of feat/fix branches that was
+    tens of seconds per call.) Result is memoized per resolved path for the process.
+
+    Failure contract: any git enumeration failure -> empty set (not cached, so a
+    later call in the same run can still succeed). Never raises.
     """
     if not repo_path or not Path(repo_path).exists():
         return set()
-    proc = _git(repo_path, "branch", "--format=%(refname:short)", "--list")
+    key = str(Path(repo_path).resolve())
+    cached = _HOT_CACHE.get(key)
+    if cached is not None:
+        return cached
+    proc = _git(repo_path, "for-each-ref", "refs/heads",
+                "--format=%(refname:short)%09%(committerdate:unix)")
     if proc is None or proc.returncode != 0:
         return set()
-    out = set()
+    cutoff = (datetime.now() - timedelta(hours=24)).timestamp()
+    hot = set()
+    candidates: dict = {}  # feat/fix branch name -> issue number
     for line in proc.stdout.splitlines():
-        m = _BRANCH_ISSUE_RE.match(line.strip())
-        if m and branch_in_progress(line.strip(), repo_path):
-            out.add(int(m.group(1)))
-    return out
+        name, _tab, ts = line.strip().partition("\t")
+        m = _BRANCH_ISSUE_RE.match(name)
+        if not m:
+            continue
+        num = int(m.group(1))
+        candidates[name] = num
+        try:
+            if float(ts) >= cutoff:
+                hot.add(num)
+        except ValueError:
+            pass  # missing/odd committerdate -> not hot by recency
+    # Uncommitted-changes-on-the-checked-out-branch case: 2 git calls total,
+    # independent of branch count (mirrors branch_in_progress's first clause).
+    cur = current_branch(repo_path)
+    if cur in candidates and has_uncommitted(repo_path):
+        hot.add(candidates[cur])
+    _HOT_CACHE[key] = hot
+    return hot
 
 
 def last_commit_date(branch_name: str, repo_path: Path) -> Optional[datetime]: