@stylusnexus/work-plan 2026.6.9-4 → 2026.6.10

package/README.md

@@ -51,7 +51,7 @@ The five essentials you'll use 80% of the time are:
 | `/work-plan brief` | Morning. Multi-track snapshot — what's on your plate across every active track. Add `--repo=<key>` to scope to one project. |
 | `/work-plan handoff <track>` | End of a work block. Captures what you touched. Use `--auto-next` for an algorithmic priority-sorted `next_up` (no LLM), `--set-next 1,2,3` for explicit numbers, or pair with Claude in chat for a curated pick. |
 | `/work-plan orient <track>` | Switching context. ~15-line paste-block of priority / last session / next pick / git state — drop into a fresh Claude Code terminal. |
-| `/work-plan reconcile <track> \| --all \| --repo=<key> [--draft]` | Track frontmatter membership drifted from GitHub labels. Use on label-driven tracks only — for hand-curated tracks, use `refresh-md` instead. `--draft` previews proposed ADDs/FLAGs without prompting or writing. `--repo=<key>` scopes the sweep to one repo. |
+| `/work-plan reconcile <track> \| --all \| --repo=<key> [--draft] [--yes]` | Track frontmatter membership drifted from GitHub labels. Use on label-driven tracks only — for hand-curated tracks, use `refresh-md` instead. In an `--all`/`--repo` sweep it also moves issues relabeled from one track to another in the same repo. `--draft` previews proposed ADDs/MOVEs/FLAGs; `--yes` applies without prompting. `--repo=<key>` scopes the sweep to one repo. |
 | `/work-plan hygiene [--repo=<key>]` | **Weekly all-in-one cleanup.** Runs three steps: ① `refresh-md --all` (pull live GitHub state into every active track's status table), ② `reconcile --all` (sync frontmatter membership against GitHub labels), ③ `duplicates` (flag likely-duplicate issues). `--repo=<key>` scopes steps ① and ② to one repo; step ③ is skipped in scoped mode. |
 
 A dozen more subcommands cover slotting new issues into tracks, closing tracks (shipped/abandoned/parked), and one-time priority-label backfill. Three capabilities worth calling out explicitly:
@@ -493,7 +493,7 @@ See `docs/usage-examples.md` for end-to-end scenarios (morning brief, mid-work h
 | `close <track> [--state=shipped\|parked\|abandoned] [--note=<text>]` | Mark track shipped, parked, or abandoned. Moves to `archive/<state>/` for shipped/abandoned. Pass `--state=` (and an optional `--note=`) to run without prompts. |
 | `refresh-md <track>` `\|` `--all` `\|` `--repo=<key>` | Update issue STATE (open/closed, status labels) inside the track body's status table. Does NOT change track membership — this is the right tool for "refresh the work I just completed." `--all` sweeps every active track; `--repo=<key>` scopes the sweep to one repo. |
 | `hygiene [--repo=<key>]` | Weekly all-in-one: `refresh-md` + `reconcile` + `duplicates`. With `--repo=<key>`, steps 1 and 2 scope to that repo and the global `duplicates` step is skipped. |
-| `list [--all]` | List active tracks (or all including parked/archived). |
+| `list [--all] [--sort=recent\|priority]` | List active tracks (or all including parked/archived). `--sort=recent` orders by `last_touched` (most recent first); `--sort=priority` orders by `launch_priority` (P0→P3) with recency as tiebreaker. Default keeps discovery order. |
 | `init <path> [--priority=P0..P3] [--milestone=<m>]` | Add frontmatter to a brand-new track .md file (the file must already exist). Pass `--priority=`/`--milestone=` to skip the prompts. |
 | `init-repo <key> --github=<slug> [--local=<path>]` | Bootstrap a new repo: create `<notes_root>/<key>/archive/{shipped,abandoned}/` and add the repo block to your config. `--github` is required; `--local` is optional. |
 | `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. |
@@ -502,7 +502,7 @@ See `docs/usage-examples.md` for end-to-end scenarios (morning brief, mid-work h
 | `group [--milestone=X] [--label=Y] [--repo=Z] [--private] [--apply] [--limit=N]` | AI-cluster GitHub issues into thematic track files. Two-step: CLI prints prompt → you save JSON answer → `--apply` creates the tracks. `--private` routes to `notes_root` instead of `.work-plan/`. `--limit` controls how many issues are shown in the prompt (default 100). |
 | `auto-triage [--repo=<key>] [--apply] [--limit=N]` | AI-assign untracked open issues to existing tracks. Two-step (same pattern as `group`). Run `coverage` first to measure the gap. `--limit` controls how many untracked issues are shown (default 100). |
 | `coverage [--repo=<key>] [--list] [--limit=N]` | Report how many open issues are not in any track. `--list` prints titles. Read-only. |
-| `reconcile <track>` `\|` `--all` `\|` `--repo=<key> [--draft]` | Update track MEMBERSHIP (the `github.issues` list in frontmatter) by syncing against a GitHub label. Read-only on GitHub. Default label is `track/<slug>`; override per-track via `github.labels: [...]` in frontmatter (OR semantics). `--draft` previews ADDs/FLAGs without prompting or writing. `--repo=<key>` scopes the sweep to one repo. NOT for hand-curated tracks (it'll propose dropping curated issues every run) — use `refresh-md` if you only want to update issue state. When >50% of frontmatter issues lack the label, reconcile prints a hint pointing to `refresh-md`. |
+| `reconcile <track>` `\|` `--all` `\|` `--repo=<key> [--draft] [--yes]` | Update track MEMBERSHIP (the `github.issues` list in frontmatter) by syncing against a GitHub label. Read-only on GitHub. Default label is `track/<slug>`; override per-track via `github.labels: [...]` in frontmatter (OR semantics). In an `--all`/`--repo` sweep it also detects **MOVEs** — an issue relabeled from one track to another in the same repo is moved (removed from the old track, added to the new); ambiguous targets stay as FLAGs. `--draft` previews ADDs/MOVEs/FLAGs without prompting or writing. `--yes` applies without prompting (non-interactive, e.g. the VS Code extension); PUBLIC-repo move destinations are skipped under `--yes`. `--repo=<key>` scopes the sweep to one repo. NOT for hand-curated tracks (it'll propose dropping curated issues every run) — use `refresh-md` if you only want to update issue state. When >50% of frontmatter issues lack the label, reconcile prints a hint pointing to `refresh-md`. |
 | `duplicates [--repo=<key>]` | Find likely-duplicate issues by title similarity (stdlib `difflib`). Prints `gh issue close` consolidation commands. |
 | `canonicalize <track>` | Add a canonical issue table to a track file (so `refresh-md` knows where to update). |
 | `plan-status [--repo=<key>] [--json] [--stamp [--draft]] [--llm [--apply]] [--archive \| --issues] [--draft]` | Reach a verdict on every plan/spec doc in a repo by correlating its declared file-manifest against git + the filesystem: ✅ shipped / 🟡 partial / 💀 dead / 👻 manifest-less / 🧳 foreign. Read-only by default. `--stamp` writes an idempotent status header into each doc (`--draft` previews); `--llm` runs a two-step AI verdict on prose/ambiguous docs; `--archive` moves dead plans to `archive/abandoned/` and `--issues` opens issues for partial plans (both gated, both honor `--draft`); `--json` for machine output. |

package/VERSION

@@ -1 +1 @@
-2026.06.09+f25e6e1
+2026.06.10+a6052bf

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stylusnexus/work-plan",
-  "version": "2026.6.9-4",
+  "version": "2026.6.10",
   "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

@@ -3,7 +3,10 @@ from datetime import datetime
 from pathlib import Path
 
 from lib.config import load_config, ConfigError
-from lib.tracks import discover_tracks, discover_archived_tracks, filter_tracks_by_repo
+from lib.tracks import (
+    discover_tracks, discover_archived_tracks, filter_tracks_by_repo,
+    priority_rank, recency_sort_key,
+)
 from lib.github_state import fetch_issues, extract_priority, short_milestone
 from lib.prompts import parse_flags
 from lib.git_state import (
@@ -193,11 +196,8 @@ def _build_track_block(track, cfg, now: datetime) -> dict:
         return gap_seconds_to_label(int(gs))
 
     in_prog_rank = 0 if operational_status == "in-progress" else 1
-    pri_rank = {"P0": 0, "P1": 1, "P2": 2, "P3": 3}.get(meta.get("launch_priority", "P3"), 3)
-    recency_key = (
-        -parse_iso_timestamp(meta["last_touched"]).timestamp()
-        if meta.get("last_touched") else 0
-    )
+    pri_rank = priority_rank(meta)
+    recency_key = recency_sort_key(meta)
 
     return {
         "name": meta.get("track", track.name),

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

@@ -78,6 +78,8 @@ def run(args: list[str]) -> int:
     print(f"WEEKLY HYGIENE — step 2 of 3: reconcile{scope_label}")
     print("=" * 60)
     reconcile_args = [f"--repo={repo_key}"] if repo_key else ["--all"]
+    if yes:
+        reconcile_args.append("--yes")
     rc = reconcile.run(reconcile_args)
     if rc != 0:
         print(f"\n⚠ reconcile exited with code {rc}; continuing.")

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

@@ -1,10 +1,22 @@
 """list subcommand."""
 from lib.config import load_config, ConfigError
-from lib.tracks import discover_tracks, discover_archived_tracks
+from lib.tracks import (
+    discover_tracks, discover_archived_tracks,
+    priority_rank, recency_sort_key,
+)
+from lib.prompts import parse_flags
+
+_VALID_SORTS = ("recent", "priority")
 
 
 def run(args: list[str]) -> int:
-    show_all = "--all" in args
+    flags, _ = parse_flags(args, {"--all", "--sort"})
+    show_all = "--all" in flags
+    sort_mode = flags.get("--sort")
+    if sort_mode is True or (sort_mode and sort_mode not in _VALID_SORTS):
+        print(f"usage: work_plan.py list [--all] [--sort={'|'.join(_VALID_SORTS)}]")
+        return 2
+
     try:
         cfg = load_config()
     except ConfigError as e:
@@ -16,17 +28,19 @@ def run(args: list[str]) -> int:
         print(f"No tracks found under {cfg['notes_root']}")
         return 0
 
+    tracks = _sort_tracks(tracks, sort_mode)
+
     print(f"Tracks under {cfg['notes_root']}:\n")
     for t in tracks:
         status = t.meta.get("status", "(no frontmatter)")
         priority = t.meta.get("launch_priority", "—")
         repo = t.repo or "(no repo)"
-        flags = []
+        flags_out = []
         if t.needs_init:
-            flags.append("NEEDS INIT")
+            flags_out.append("NEEDS INIT")
         if t.needs_filing:
-            flags.append("NEEDS FILING")
-        flag_str = f" [{', '.join(flags)}]" if flags else ""
+            flags_out.append("NEEDS FILING")
+        flag_str = f" [{', '.join(flags_out)}]" if flags_out else ""
         print(f"  {t.name:30}  {status:14}  {priority:3}  {repo}{flag_str}")
 
     if show_all:
@@ -37,3 +51,17 @@ def run(args: list[str]) -> int:
                 end_state = a.meta.get("status", "?")
                 print(f"  {a.name:30}  {end_state:14}  {a.repo or '(no repo)'}")
     return 0
+
+
+def _sort_tracks(tracks: list, sort_mode):
+    """Order active tracks per --sort. None preserves discovery order.
+
+    - "recent": by last_touched descending (missing last_touched sorts last).
+    - "priority": by launch_priority ascending (P0→P3, then missing/other),
+      with last_touched recency as tiebreaker.
+    """
+    if sort_mode == "recent":
+        return sorted(tracks, key=lambda t: recency_sort_key(t.meta))
+    if sort_mode == "priority":
+        return sorted(tracks, key=lambda t: (priority_rank(t.meta), recency_sort_key(t.meta)))
+    return tracks

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

@@ -12,8 +12,11 @@ For a given track:
     of "anything closed looks unlabeled."
   - Compare against frontmatter `github.issues`.
   - Propose ADDS (labeled in GitHub but missing from frontmatter).
-  - Propose FLAGS (in frontmatter but no longer labeled — possible move out).
-  - User confirms before writing to the LOCAL frontmatter file.
+  - Propose MOVES (in track A's frontmatter, but now labeled for exactly one
+    other active track B in the same repo — a relabel; remove from A, add to B).
+  - Propose FLAGS (in frontmatter but no longer labeled, with no single move
+    target — possible orphan).
+  - User confirms before writing to the LOCAL frontmatter file(s).
 
 READ-ONLY GITHUB CONTRACT
   reconcile only READS GitHub via `gh issue list` and `gh pr list`. It NEVER
@@ -32,6 +35,7 @@ from lib.config import load_config, ConfigError
 from lib.tracks import discover_tracks, find_track_by_name, filter_tracks_by_repo, parse_track_repo_arg, AmbiguousTrackError
 from lib.frontmatter import write_file
 from lib.prompts import parse_flags, prompt_input
+from lib.write_guard import needs_confirm
 
 
 PER_TRACK_TIMEOUT = 15  # seconds; each gh call gets this budget
@@ -86,17 +90,18 @@ def _fetch_labeled_issues(repo: str, labels: list[str]) -> list[dict]:
 
 
 def run(args: list[str]) -> int:
-    flags, positional = parse_flags(args, {"--all", "--draft", "--repo"})
+    flags, positional = parse_flags(args, {"--all", "--draft", "--repo", "--yes"})
     do_all = flags.get("--all", False)
     draft = flags.get("--draft", False)
+    yes = flags.get("--yes", False)
     repo_key = flags.get("--repo")
     if repo_key is True:
-        print("usage: work_plan.py reconcile <track-name> | --all | --repo=<key> [--draft]")
+        print("usage: work_plan.py reconcile <track-name> | --all | --repo=<key> [--draft] [--yes]")
         return 2
     track_arg = positional[0] if positional else None
 
     if not do_all and not track_arg and not repo_key:
-        print("usage: work_plan.py reconcile <track-name> | --all | --repo=<key> [--draft]")
+        print("usage: work_plan.py reconcile <track-name> | --all | --repo=<key> [--draft] [--yes]")
         return 2
 
     track_name = track_arg
@@ -167,7 +172,52 @@ def run(args: list[str]) -> int:
                 print(f"  [{i}/{total}] ⚠ {track.name}: {e} — skipping")
                 results[track.name] = None
 
-    # Phase 2: serial diff, report, and confirm (prompts must NOT be in threads)
+    # 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)
+    # into a MOVE when the issue is now labeled for exactly one OTHER active
+    # 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:
+            continue
+        for num in {i["number"] for i in results[track.name]}:
+            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
+    for track in targets:
+        if not track.repo or results.get(track.name) is None:
+            continue
+        labeled_nums = {i["number"] for i in results[track.name]}
+        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
+
+    # Phase 2c: per-track diff, report, confirm. Membership changes accumulate
+    # in `final` (track name -> 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)
+
+    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]
+
     any_changes = False
     for track in targets:
         slug = track.meta.get("track", track.name)
@@ -181,11 +231,14 @@ def run(args: list[str]) -> int:
         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()))
 
-        adds = sorted(labeled_nums - listed_nums)
-        flag_nums = sorted(listed_nums - labeled_nums)
+        # 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()))
 
-        if not adds and not flag_nums:
+        if not adds and not flag_nums and not out_moves:
             continue
 
         any_changes = True
@@ -197,6 +250,13 @@ def run(args: list[str]) -> int:
             for num in adds:
                 i = issue_lookup[num]
                 print(f"    #{num} ({i['state'].lower()}) {i['title']}")
+        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_slug = dst.meta.get("track", dst.name)
+                pub = " [dst PUBLIC]" if needs_confirm(dst.repo, cfg) else ""
+                print(f"    #{num}  {slug} → {dst_slug}{pub}")
         if flag_nums:
             print(f"  FLAG ({len(flag_nums)}) — in frontmatter but missing every configured label:")
             for num in flag_nums:
@@ -204,8 +264,8 @@ def run(args: list[str]) -> int:
 
         if listed_nums and len(flag_nums) / len(listed_nums) > 0.5:
             print(f"\n  ⓘ {len(flag_nums)}/{len(listed_nums)} frontmatter issues lack the configured label(s).")
-            print(f"    This track looks hand-curated, not label-driven — reconcile may not be the right tool.")
-            print(f"    If you just want to update issue state in the body table, try:")
+            print("    This track looks hand-curated, not label-driven — reconcile may not be the right tool.")
+            print("    If you just want to update issue state in the body table, try:")
             print(f"      /work-plan refresh-md {slug}")
 
         if draft:
@@ -213,12 +273,41 @@ def run(args: list[str]) -> int:
             # Useful for sweep audits and scripted reports.
             continue
 
-        choice = prompt_input(f"\n  Apply ADDs to {track.path.name}? [y/N/skip-flags]").lower()
-        if choice == "y":
-            new_issues = sorted(listed_nums | labeled_nums)
-            track.meta.setdefault("github", {})["issues"] = new_issues
-            write_file(track.path, track.meta, track.body)
-            print(f"  ✓ Updated {track.path.name} ({len(adds)} added)")
+        if yes:
+            # Non-interactive: apply ADDs + MOVEs without prompting. All writes
+            # are local frontmatter — the read-only-GitHub contract is unchanged.
+            print(f"\n  --yes: applying changes from {track.path.name}")
+            choice = "y"
+        else:
+            choice = prompt_input(f"\n  Apply ADDs/MOVEs from {track.path.name}? [y/N]").lower()
+        if choice != "y":
+            continue
+
+        if adds:
+            _final_for(track).update(adds)
+        for num in out_moves:
+            dst = move_dst[(track.name, 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
+            # treat the prompt above as the confirmation.
+            if yes and needs_confirm(dst.repo, cfg):
+                dst_slug = dst.meta.get("track", dst.name)
+                print(f"  ⏭ skipped MOVE #{num} → {dst_slug} ({dst.repo} is PUBLIC; "
+                      f"run `/work-plan move {num} {slug} {dst_slug} --confirm` instead)")
+                continue
+            _final_for(track).discard(num)
+            _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]
+        original = set(track.meta.get("github", {}).get("issues") or [])
+        if issues == original:
+            continue
+        track.meta.setdefault("github", {})["issues"] = sorted(issues)
+        write_file(track.path, track.meta, track.body)
+        print(f"  ✓ Updated {track.path.name}")
 
     if not any_changes:
         print("All tracks in sync with configured labels.")

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

@@ -1,12 +1,35 @@
 """Shared CLI helpers: prompts and arg parsing."""
+import sys
+
+
+def _stdin_is_interactive() -> bool:
+    """True only when stdin is a real terminal we can block on for a reply.
+
+    When the CLI is launched with stdin wired to a pipe or socket that stays
+    open but never delivers a line — e.g. the VS Code extension spawning
+    `work_plan.py` — `input()` blocks forever (no data, no EOF). A closed pipe
+    raises EOFError and is handled; an *idle open* one hangs. Guarding on
+    `isatty()` lets the prompt helpers fall back to their default instead of
+    deadlocking. Non-interactive callers should pass an explicit flag
+    (`--yes`, `--draft`) rather than rely on the prompt.
+    """
+    try:
+        return bool(sys.stdin) and sys.stdin.isatty()
+    except (ValueError, AttributeError):
+        # stdin closed/detached, or replaced by an object without isatty.
+        return False
 
 
 def prompt_input(message: str, default: str = "") -> str:
     """Print prompt and read a free-form line. Treats EOF (no stdin) as default.
 
-    Returns the stripped input, or `default` if EOF or blank.
+    Returns the stripped input, or `default` if EOF, blank, or there is no
+    interactive terminal to read from.
     """
     print(message)
+    if not _stdin_is_interactive():
+        print(f"(no interactive terminal — using default {default!r})")
+        return default
     try:
         line = input().strip()
     except EOFError:
@@ -15,7 +38,12 @@ def prompt_input(message: str, default: str = "") -> str:
 
 
 def prompt_lines() -> list[str]:
-    """Read lines from stdin until blank line or EOF. Returns list of non-blank lines."""
+    """Read lines from stdin until blank line or EOF. Returns list of non-blank lines.
+
+    With no interactive terminal, returns an empty list rather than blocking.
+    """
+    if not _stdin_is_interactive():
+        return []
     out = []
     try:
         while True:
@@ -29,11 +57,14 @@ def prompt_lines() -> list[str]:
 
 
 def prompt_yes_no(message: str = "Apply? [y/N]") -> bool:
-    """Print prompt and read y/N. Treats EOF (no stdin) as no.
+    """Print prompt and read y/N. Treats EOF or no terminal as no.
 
     Returns True only if user explicitly types 'y' (case-insensitive).
     """
     print(message)
+    if not _stdin_is_interactive():
+        print("(no interactive terminal — defaulting to no)")
+        return False
     try:
         choice = input().strip().lower()
     except EOFError:

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

@@ -10,6 +10,33 @@ from lib.config import (
     resolve_local_path_for_folder,
     is_valid_git_repo,
 )
+from lib.git_state import parse_iso_timestamp
+
+_PRIORITY_RANK = {"P0": 0, "P1": 1, "P2": 2, "P3": 3}
+
+
+def priority_rank(meta: dict) -> int:
+    """Rank a track's launch_priority for ascending sort: P0<P1<P2<P3<anything.
+
+    Unknown / missing values (e.g. "—" or absent) sort after all known ranks.
+    """
+    return _PRIORITY_RANK.get(meta.get("launch_priority"), len(_PRIORITY_RANK))
+
+
+def recency_sort_key(meta: dict) -> float:
+    """Sort key for last_touched recency (most recent first when sorted ascending).
+
+    Returns the negative POSIX timestamp so that a plain ascending sort puts the
+    most-recently-touched track first. Tracks with no (or unparseable)
+    last_touched return +inf, sorting them LAST.
+    """
+    raw = meta.get("last_touched")
+    if not raw:
+        return float("inf")
+    try:
+        return -parse_iso_timestamp(raw).timestamp()
+    except (ValueError, TypeError):
+        return float("inf")
 
 
 @dataclass

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

@@ -0,0 +1,162 @@
+"""Tests for the `list --sort` flag (issue #181).
+
+Covers:
+- --sort=recent orders active tracks by last_touched descending.
+- Tracks missing last_touched sort LAST under --sort=recent.
+- --sort=priority orders P0→P3 with last_touched recency as tiebreaker;
+  tracks missing launch_priority sort after those that have it.
+- Default (no --sort) preserves discovery (filesystem) order exactly.
+- --all still appends the archived section, and works alongside --sort.
+- An invalid --sort value (or bare --sort) returns rc 2.
+"""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import list_cmd
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _track(name, *, repo="ok/repo", status="active", priority=None, last_touched=None):
+    meta = {"track": name, "status": status}
+    if priority is not None:
+        meta["launch_priority"] = priority
+    if last_touched is not None:
+        meta["last_touched"] = last_touched
+    return SimpleNamespace(
+        name=name,
+        path=Path(f"/tmp/fake/{name}.md"),
+        body="# fake",
+        meta=meta,
+        has_frontmatter=True,
+        needs_init=False,
+        needs_filing=False,
+        repo=repo,
+    )
+
+
+def _drive(args, tracks, archived=None):
+    """Run list_cmd.run(args) with config + discovery mocked. Returns (rc, output)."""
+    cfg = {"notes_root": "/tmp/fake-notes", "repos": {}}
+    with patch("commands.list_cmd.load_config", return_value=cfg), \
+         patch("commands.list_cmd.discover_tracks", return_value=tracks), \
+         patch("commands.list_cmd.discover_archived_tracks", return_value=archived or []):
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = list_cmd.run(args)
+    return rc, buf.getvalue()
+
+
+def _order(output, names):
+    """Return the names from `names` in the order they appear in output."""
+    positions = [(output.index(n), n) for n in names if n in output]
+    return [n for _, n in sorted(positions)]
+
+
+# ---------------------------------------------------------------------------
+# Test cases
+# ---------------------------------------------------------------------------
+
+class ListSortTest(unittest.TestCase):
+
+    def test_sort_recent_orders_by_last_touched_desc(self):
+        """--sort=recent orders tracks most-recently-touched first."""
+        tracks = [
+            _track("old", last_touched="2026-01-01"),
+            _track("newest", last_touched="2026-06-01"),
+            _track("middle", last_touched="2026-03-15"),
+        ]
+        rc, out = _drive(["--sort=recent"], tracks)
+        self.assertEqual(rc, 0)
+        self.assertEqual(_order(out, ["old", "newest", "middle"]),
+                         ["newest", "middle", "old"])
+
+    def test_sort_recent_missing_last_touched_sorts_last(self):
+        """Tracks with no last_touched sort after those that have one."""
+        tracks = [
+            _track("nodate"),
+            _track("dated", last_touched="2026-05-01"),
+        ]
+        rc, out = _drive(["--sort=recent"], tracks)
+        self.assertEqual(rc, 0)
+        self.assertEqual(_order(out, ["nodate", "dated"]), ["dated", "nodate"])
+
+    def test_sort_priority_orders_p0_to_p3_with_recency_tiebreak(self):
+        """--sort=priority orders P0→P3; equal priority breaks by recency."""
+        tracks = [
+            _track("p2", priority="P2", last_touched="2026-01-01"),
+            _track("p0", priority="P0", last_touched="2026-01-01"),
+            _track("p1_old", priority="P1", last_touched="2026-01-01"),
+            _track("p1_new", priority="P1", last_touched="2026-06-01"),
+        ]
+        rc, out = _drive(["--sort=priority"], tracks)
+        self.assertEqual(rc, 0)
+        # P0 first, then P1 (newest of the two first), then P2
+        self.assertEqual(
+            _order(out, ["p0", "p1_new", "p1_old", "p2"]),
+            ["p0", "p1_new", "p1_old", "p2"],
+        )
+
+    def test_sort_priority_missing_priority_sorts_after_known(self):
+        """Tracks missing launch_priority sort after those that have it."""
+        tracks = [
+            _track("none"),
+            _track("p3", priority="P3"),
+            _track("p0", priority="P0"),
+        ]
+        rc, out = _drive(["--sort=priority"], tracks)
+        self.assertEqual(rc, 0)
+        self.assertEqual(_order(out, ["none", "p3", "p0"]), ["p0", "p3", "none"])
+
+    def test_default_preserves_discovery_order(self):
+        """No --sort flag preserves the exact filesystem discovery order."""
+        tracks = [
+            _track("zebra", priority="P3", last_touched="2026-01-01"),
+            _track("alpha", priority="P0", last_touched="2026-06-01"),
+            _track("mango", priority="P1", last_touched="2026-03-01"),
+        ]
+        rc, out = _drive([], tracks)
+        self.assertEqual(rc, 0)
+        # Discovery order is preserved despite priority/recency differences.
+        self.assertEqual(_order(out, ["zebra", "alpha", "mango"]),
+                         ["zebra", "alpha", "mango"])
+
+    def test_all_appends_archived_section_with_sort(self):
+        """--all still appends the Archived section alongside --sort."""
+        tracks = [
+            _track("recent_active", last_touched="2026-06-01"),
+            _track("old_active", last_touched="2026-01-01"),
+        ]
+        archived = [_track("done_track", status="shipped")]
+        rc, out = _drive(["--all", "--sort=recent"], tracks, archived=archived)
+        self.assertEqual(rc, 0)
+        self.assertIn("Archived:", out)
+        self.assertIn("done_track", out)
+        # Active section still recency-sorted, and archived comes after.
+        self.assertLess(out.index("recent_active"), out.index("old_active"))
+        self.assertLess(out.index("old_active"), out.index("Archived:"))
+
+    def test_invalid_sort_value_returns_rc2(self):
+        """An unrecognized --sort value returns rc 2 (usage error)."""
+        rc, out = _drive(["--sort=bogus"], [_track("a")])
+        self.assertEqual(rc, 2)
+        self.assertIn("usage", out)
+
+    def test_bare_sort_flag_returns_rc2(self):
+        """--sort with no value returns rc 2."""
+        rc, out = _drive(["--sort"], [_track("a")])
+        self.assertEqual(rc, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,121 @@
+"""Non-interactive guard for the prompt helpers (regression test for #183).
+
+When `work_plan.py` is launched with stdin wired to a pipe/socket that stays
+open but never delivers a line (the VS Code extension does exactly this),
+`input()` blocks forever — no data, no EOF. The fix makes prompt_input /
+prompt_yes_no / prompt_lines fall back to their default when stdin is not a
+TTY, and only call input() when it is.
+
+These tests fake stdin's isatty() rather than touching the real terminal, and
+assert input() is NOT called on the non-TTY path (so a regression that drops
+the guard would deadlock under a real pipe — here it would call the patched
+input and the assertion would fire instead of hanging).
+"""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest import mock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib import prompts
+
+
+class _FakeStdin:
+    def __init__(self, tty: bool):
+        self._tty = tty
+
+    def isatty(self) -> bool:
+        return self._tty
+
+
+class NonInteractiveGuardTest(unittest.TestCase):
+    """No TTY → return the default immediately, never call input()."""
+
+    def test_prompt_input_returns_default_without_reading(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=False)), \
+             mock.patch("builtins.input", side_effect=AssertionError("input() must not be called")):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                out = prompts.prompt_input("Apply? [y/N]", default="N")
+        self.assertEqual(out, "N")
+
+    def test_prompt_input_default_is_empty_string_by_default(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=False)), \
+             mock.patch("builtins.input", side_effect=AssertionError("input() must not be called")):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                out = prompts.prompt_input("anything")
+        self.assertEqual(out, "")
+
+    def test_prompt_yes_no_returns_false_without_reading(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=False)), \
+             mock.patch("builtins.input", side_effect=AssertionError("input() must not be called")):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                out = prompts.prompt_yes_no()
+        self.assertFalse(out)
+
+    def test_prompt_lines_returns_empty_without_reading(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=False)), \
+             mock.patch("builtins.input", side_effect=AssertionError("input() must not be called")):
+            out = prompts.prompt_lines()
+        self.assertEqual(out, [])
+
+    def test_guard_false_when_stdin_is_none(self):
+        with mock.patch.object(prompts.sys, "stdin", None):
+            self.assertFalse(prompts._stdin_is_interactive())
+
+    def test_guard_false_when_isatty_raises(self):
+        class Broken:
+            def isatty(self):
+                raise ValueError("I/O operation on closed file")
+        with mock.patch.object(prompts.sys, "stdin", Broken()):
+            self.assertFalse(prompts._stdin_is_interactive())
+
+
+class InteractivePathStillReadsTest(unittest.TestCase):
+    """With a TTY, the helpers still call input() and honour the reply."""
+
+    def test_prompt_input_reads_when_tty(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=True)), \
+             mock.patch("builtins.input", return_value="  hello  "):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                out = prompts.prompt_input("q")
+        self.assertEqual(out, "hello")
+
+    def test_prompt_input_blank_reply_falls_back_to_default(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=True)), \
+             mock.patch("builtins.input", return_value="   "):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                out = prompts.prompt_input("q", default="def")
+        self.assertEqual(out, "def")
+
+    def test_prompt_yes_no_true_only_on_y(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=True)), \
+             mock.patch("builtins.input", return_value="Y"):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                self.assertTrue(prompts.prompt_yes_no())
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=True)), \
+             mock.patch("builtins.input", return_value="n"):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                self.assertFalse(prompts.prompt_yes_no())
+
+    def test_prompt_input_eof_returns_default_when_tty(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=True)), \
+             mock.patch("builtins.input", side_effect=EOFError):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                out = prompts.prompt_input("q", default="d")
+        self.assertEqual(out, "d")
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,154 @@
+"""Cross-track auto-move detection in reconcile (#163).
+
+When an issue sits in track A's frontmatter but is now labeled for exactly one
+OTHER active track B in the same repo (a relabel), reconcile proposes a MOVE:
+remove from A, add to B — instead of leaving it as a dangling FLAG on A and a
+fresh ADD on B (which would duplicate it across both tracks).
+
+All gh calls are mocked; tests run offline. needs_confirm is patched so the
+public-repo gate is exercised without a real `gh repo view`.
+"""
+import json
+import sys
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import reconcile
+
+
+def _track(*, slug, repo="ok/ok", issues=None):
+    return SimpleNamespace(
+        name=slug,
+        path=Path(f"/tmp/fake/{slug}.md"),
+        body="# fake",
+        meta={"track": slug, "status": "active",
+              "github": {"repo": repo, "issues": list(issues or [])}},
+        has_frontmatter=True,
+        repo=repo,
+    )
+
+
+class _Harness:
+    """Drives reconcile --all over a set of tracks with a label→issues map.
+
+    `labeled` maps a GitHub label string to the list of issue dicts that
+    `gh issue/pr list --label <label>` should return.
+    """
+
+    def __init__(self, tracks, labeled, *, private=True):
+        self.tracks = tracks
+        self.labeled = labeled
+        self.private = private
+        self.writes = []  # (path_name, issues) per write_file call
+
+    def _fake_run(self, argv, *a, **kw):
+        out = []
+        if "--label" in argv and argv[1] == "issue":  # only count issues once
+            lab = argv[argv.index("--label") + 1]
+            out = self.labeled.get(lab, [])
+        return MagicMock(returncode=0, stdout=json.dumps(out), stderr="")
+
+    def _fake_write(self, path, meta, body):
+        self.writes.append((path.name, list(meta.get("github", {}).get("issues") or [])))
+
+    def run(self, extra_args=None):
+        cfg = {"notes_root": "/tmp/n", "repos": {"ok": {"github": "ok/ok"}}}
+        with patch("commands.reconcile.subprocess.run", side_effect=self._fake_run), \
+             patch("commands.reconcile.load_config", return_value=cfg), \
+             patch("commands.reconcile.discover_tracks", return_value=self.tracks), \
+             patch("commands.reconcile.needs_confirm", return_value=not self.private), \
+             patch("commands.reconcile.write_file", side_effect=self._fake_write), \
+             patch("commands.reconcile.prompt_input", return_value="y"):
+            rc = reconcile.run(["--all"] + (extra_args or []))
+        return rc
+
+
+class AutoMoveTest(unittest.TestCase):
+    def test_relabel_moves_issue_from_a_to_b(self):
+        # #50 is in alpha's frontmatter but now carries only track/beta.
+        alpha = _track(slug="alpha", issues=[50])
+        beta = _track(slug="beta", issues=[])
+        labeled = {
+            "track/alpha": [],
+            "track/beta": [{"number": 50, "title": "moved", "state": "OPEN"}],
+        }
+        h = _Harness([alpha, beta], labeled)
+        rc = h.run(extra_args=["--yes"])
+        self.assertEqual(rc, 0)
+        writes = dict(h.writes)
+        self.assertEqual(writes["alpha.md"], [])      # removed from source
+        self.assertEqual(writes["beta.md"], [50])     # added to destination
+        self.assertEqual(len(h.writes), 2)            # each side written once
+
+    def test_ambiguous_target_is_not_moved_out_of_source(self):
+        # #50 lost alpha's label and is labeled for BOTH beta and gamma →
+        # ambiguous target, so reconcile must NOT move it out of alpha. (beta
+        # and gamma each legitimately ADD it, since it carries both labels —
+        # that's normal membership-follows-labels behaviour, not a move.) The
+        # point of this test: alpha keeps #50, the move logic does not fire.
+        alpha = _track(slug="alpha", issues=[50])
+        beta = _track(slug="beta", issues=[])
+        gamma = _track(slug="gamma", issues=[])
+        labeled = {
+            "track/alpha": [],
+            "track/beta": [{"number": 50, "title": "x", "state": "OPEN"}],
+            "track/gamma": [{"number": 50, "title": "x", "state": "OPEN"}],
+        }
+        h = _Harness([alpha, beta, gamma], labeled)
+        rc = h.run(extra_args=["--yes"])
+        self.assertEqual(rc, 0)
+        writes = dict(h.writes)
+        # alpha must NOT be rewritten — #50 stays (no unambiguous move target).
+        self.assertNotIn("alpha.md", writes)
+        # beta and gamma each ADD #50 (it is labeled for both).
+        self.assertEqual(writes.get("beta.md"), [50])
+        self.assertEqual(writes.get("gamma.md"), [50])
+
+    def test_draft_reports_move_but_writes_nothing(self):
+        alpha = _track(slug="alpha", issues=[50])
+        beta = _track(slug="beta", issues=[])
+        labeled = {
+            "track/alpha": [],
+            "track/beta": [{"number": 50, "title": "moved", "state": "OPEN"}],
+        }
+        h = _Harness([alpha, beta], labeled)
+        rc = h.run(extra_args=["--draft"])
+        self.assertEqual(rc, 0)
+        self.assertEqual(h.writes, [])
+
+    def test_public_destination_skipped_under_yes(self):
+        # Destination is PUBLIC → under --yes the move is skipped (no silent
+        # membership write to a shared track); source is left untouched too.
+        alpha = _track(slug="alpha", issues=[50])
+        beta = _track(slug="beta", issues=[])
+        labeled = {
+            "track/alpha": [],
+            "track/beta": [{"number": 50, "title": "moved", "state": "OPEN"}],
+        }
+        h = _Harness([alpha, beta], labeled, private=False)
+        rc = h.run(extra_args=["--yes"])
+        self.assertEqual(rc, 0)
+        self.assertEqual(h.writes, [])  # nothing written when dst is public
+
+    def test_move_does_not_duplicate_as_add_on_destination(self):
+        # The destination must NOT also try to ADD #50 (which would be the
+        # naive behaviour); it arrives exactly once, via the move.
+        alpha = _track(slug="alpha", issues=[50])
+        beta = _track(slug="beta", issues=[])
+        labeled = {
+            "track/alpha": [],
+            "track/beta": [{"number": 50, "title": "moved", "state": "OPEN"}],
+        }
+        h = _Harness([alpha, beta], labeled)
+        h.run(extra_args=["--yes"])
+        writes = dict(h.writes)
+        self.assertEqual(writes["beta.md"].count(50), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -142,6 +142,25 @@ class ReadOnlyContractTest(unittest.TestCase):
         self._assert_read_only(captured)
         mock_write.assert_called_once()
 
+    def test_yes_applies_without_prompt_and_writes_local_only(self):
+        # --yes (non-interactive, e.g. from the VS Code extension) applies the
+        # proposed ADDs without ever calling prompt_input, and the only write
+        # is the local frontmatter file — never gh. This is the #183 fix: a
+        # piped/no-TTY run must not hang on the prompt.
+        track = _fake_track(slug="epsilon", repo="ok/ok", issues=[5])
+        gh_response = [
+            {"number": 5, "title": "x", "state": "OPEN"},
+            {"number": 99, "title": "new", "state": "OPEN"},
+        ]
+        rc, captured, mock_write, mock_prompt = self._drive(
+            track=track, gh_response=gh_response,
+            user_choice="n", extra_args=["--yes"],
+        )
+        self.assertEqual(rc, 0)
+        self._assert_read_only(captured)
+        mock_prompt.assert_not_called()
+        mock_write.assert_called_once()
+
     def test_draft_skips_user_prompt_and_write(self):
         # --draft prints the analysis but never prompts and never writes.
         # Even with proposed ADDs (so the report path is exercised), the user

package/skills/work-plan/work_plan.py

@@ -90,9 +90,9 @@ DESCRIPTIONS = [
      "Update issue STATE (open/closed, status labels) inside the track body's status table. Does not change track membership.",
      "Usually NOT needed directly: `handoff` already refreshes the body table for its own track, and `brief` reads GitHub live. Reach for this when a sibling track has drifted because you haven't `handoff`'d it lately. `--all` sweeps every active track; `--repo=<key>` scopes the sweep to one repo (also runs as part of weekly `hygiene`).",
      "/work-plan refresh-md --repo=critforge"),
-    ("list", "[--all]",
+    ("list", "[--all] [--sort=recent|priority]",
      "List active tracks (or all including parked/archived).",
-     "Quick scan of what tracks exist; --all to see archived.",
+     "Quick scan of what tracks exist; --all to see archived. --sort orders by last_touched recency or launch_priority.",
      "/work-plan list --all"),
     ("init", "<path-to-md>",
      "Add frontmatter to an existing track .md file.",
@@ -114,8 +114,8 @@ DESCRIPTIONS = [
      "AI-assign untracked open issues to existing tracks. Step 1 (no --apply): fetches untracked issues + existing tracks, prints AI prompt. Step 2 (--apply): reads AI's JSON answers and slots each assignment into track frontmatter. Complements `group` (which creates new tracks); `auto-triage` assigns to tracks that already exist. --limit controls how many untracked issues are shown (default 100).",
      "Periodically — when new issues have piled up outside the track model. Run /work-plan coverage first to confirm there's a gap worth triaging.",
      "/work-plan auto-triage --repo=critforge"),
-    ("reconcile", "<track> | --all | --repo=<key> [--draft]",
-     "Update track MEMBERSHIP (the `github.issues` list in frontmatter) by syncing it against a GitHub label. Default label is `track/<slug>`; override per-track via `github.labels: [...]` in frontmatter. Read-only on GitHub. Add --draft to preview proposed ADDs/FLAGs without prompting or writing. NOT for hand-curated tracks — see `refresh-md` if you only want to update issue state.",
+    ("reconcile", "<track> | --all | --repo=<key> [--draft] [--yes]",
+     "Update track MEMBERSHIP (the `github.issues` list in frontmatter) by syncing it against a GitHub label. Default label is `track/<slug>`; override per-track via `github.labels: [...]` in frontmatter. Read-only on GitHub. In an --all/--repo sweep it also detects MOVEs — an issue relabeled from one track to another in the same repo is moved (removed from the old track, added to the new). Add --draft to preview proposed ADDs/MOVEs/FLAGs without prompting or writing; add --yes to apply without prompting (non-interactive, e.g. from the VS Code extension; PUBLIC-repo move destinations are skipped under --yes). NOT for hand-curated tracks — see `refresh-md` if you only want to update issue state.",
      "WEEKLY hygiene on label-driven tracks — pulls labeled issues into their tracks, flags un-labeled ones. Use --repo=<key> to scope the sweep to one repo. Skip on hand-curated tracks (it'll propose dropping curated issues every run).",
      "/work-plan reconcile --repo=critforge --draft"),
     ("duplicates", "[--min-similarity=0.7] [--limit=20] [--state=open] [--timeout=N]",