@stylusnexus/work-plan 2026.6.15-4 → 2026.6.16

package/README.md

@@ -48,11 +48,11 @@ The five essentials you'll use 80% of the time are:
 
 | Command | When |
 |---|---|
-| `/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 brief` | Morning. Multi-track snapshot — what's on your plate across every active track. Run from inside a configured repo's checkout and it **auto-scopes to that repo** (one-line banner; `--repo=all` shows everything). Add `--repo=<key>` to scope to a specific 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] [--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. |
+| `/work-plan hygiene [--repo=<key>]` | **Weekly all-in-one cleanup.** Runs four steps: ① `refresh-md --all` (pull live GitHub state into every active track's status table), ② `reconcile --all` (sync frontmatter membership against GitHub labels), ③ `dedupe-tiers` (report shared/private duplicate tracks, no deletes), ④ `duplicates` (flag likely-duplicate issues). `--repo=<key>` scopes steps ①–③ to one repo; step ④ is skipped in scoped mode. |
 | `/work-plan in-progress <n> [--clear]` | Starting or stopping active work on an issue. Adds (or removes with `--clear`) the `work-plan:in-progress` label on GitHub. Repo-resolved from the issue number, or pass `--repo=<key\|slug>` to disambiguate. `brief`/`orient`/the VS Code viewer also detect in-progress automatically from a hot `feat/<n>-`/`fix/<n>-` branch. |
 
 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:
@@ -109,7 +109,7 @@ flowchart TB
   - 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.
+- **Weekly** → `hygiene` runs `refresh-md --all` + `reconcile --all` + `dedupe-tiers` (report-only) + `duplicates` in sequence to keep status icons, GitHub labels, tier dedup, and issue-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.
 
@@ -510,13 +510,15 @@ See `docs/usage-examples.md` for end-to-end scenarios (morning brief, mid-work h
 
 | Subcommand | What it does |
 |---|---|
-| `brief [--repo=<key>]` | Multi-track snapshot of all active tracks across configured repos. `--repo=<key>` filters to one project (matches the folder name under `notes_root` or the `org/repo` GitHub slug; archived-reopen callouts are also scoped). |
+| `brief [--repo=<key> \| --repo=all]` | Multi-track snapshot of all active tracks across configured repos. When `--repo` is omitted and you're inside a configured repo's checkout, `brief` **auto-scopes to that repo** (resolved by clone path, then git remote) and prints a one-line banner; `--repo=all` forces the full cross-repo view. `--repo=<key>` filters to one project explicitly (matches the folder name under `notes_root` or the `org/repo` GitHub slug). In all cases the archived-reopen callouts are scoped to the same repo. Disable cwd auto-scope with `brief_auto_scope: false` in `config.yml`. |
+| `which-repo [--json]` | Resolve the current directory to one configured repo — by local clone path first, then the git `origin` remote. Prints the matched config key + GitHub slug, or reports no match. Read-only; it's the shared resolver behind `brief`'s cwd auto-scope and the VS Code viewer's repo auto-focus. |
 | `handoff <track> [--auto-next \| --set-next 1,2,3]` | Wrap up a work block. Writes a `### Session — <ts>` entry. `--auto-next` suggests a priority-sorted top-3 from open issues (interactive: apply / edit / skip). `--set-next 1,2,3` is the explicit form — note it writes the session entry too; for a field-only `next_up` change with no session log, use `set next_up=…`. Without either flag, just captures the session summary and reads any pre-existing `next_up`. |
 | `orient [track]` (alias: `where-was-i`) | Read-only paste block. With a track name: ~15-line track summary (priority, last session, next pick, git state). With no track: cwd snapshot (branch, recent commits, modified files) for non-track work. Add `--pick` for the interactive track picker. |
 | `slot <issue-num> [track]` | A new GitHub issue should belong to a track — adds it to the track's `github.issues` list. Non-interactive flags: `--move`/`--no-move` (relocate the issue off its prior track, or leave it; default no-move), `--confirm=<token>` (public-repo gate, see below). |
 | `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>` | Sync issue STATE (open/closed, status labels) from GitHub into the track body's status table. Does NOT change track membership — this is the right tool for "refresh the work I just completed." For a **canonical** table it re-derives the whole block from live data, milestone-ordered (active milestone first; see `canonicalize`), so the table self-heals and stays grouped instead of decaying; narrative (non-canonical) tables are updated conservatively in place. If the live fetch comes back incomplete (GitHub timeout/permission error, or a frontmatter issue that no longer resolves), that track is **skipped and left untouched** rather than rewriting valid rows as `(not fetched)`, and the command exits nonzero so sweeps can flag the degraded run. `--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. |
+| `hygiene [--repo=<key>]` | Weekly all-in-one: `refresh-md` + `reconcile` + `dedupe-tiers` (report-only) + `duplicates`. With `--repo=<key>`, steps 1–3 scope to that repo and the global `duplicates` step is skipped. |
+| `dedupe-tiers [--repo=<key>] [--apply]` | Remove private track copies that a shared twin in a repo's `.work-plan/` supersedes (#359). When a track is promoted to the shared tier, its private original under `notes_root` is sometimes left behind (bulk/manual promotion, or a failed unlink during `push-track`) — `discover_tracks` then warns `exists in both shared and private` on every run with no cleanup path. This removes the safe orphans and **refuses** any whose private copy references issue numbers the shared one lacks (no silent data loss; the invariant is `issue_refs(private) ⊆ issue_refs(shared)`). Covers active and archived tiers. Default is a **dry-run report**; `--apply` deletes (auto-committed to `notes_root`, so undoable via `notes-vcs undo`). `--repo=<key>` scopes to one repo. |
 | `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>] [--update [--clear-local]]` | Bootstrap a new repo: create `<notes_root>/<key>/archive/{shipped,abandoned}/` and add the repo block to your config. `--github` is required for an add; `--local` is optional. `--update` on an existing key changes its local/github; `--update --clear-local` forgets the saved local path (keeps github + other fields). `--clear-local` and `--local` are mutually exclusive. |

package/VERSION

@@ -1 +1 @@
-2026.06.15+488753b
+2026.06.16+ebd6045

package/package.json

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

@@ -1,8 +1,10 @@
 """brief subcommand — fully featured."""
+import os
 from datetime import datetime
 from pathlib import Path
 
 from lib.config import load_config, ConfigError
+from lib.cwd_repo import resolve_repo_for_dir
 from lib.tracks import (
     discover_tracks, discover_archived_tracks, filter_tracks_by_repo,
     priority_rank, recency_sort_key,
@@ -24,9 +26,9 @@ from lib.render import time_aware_framing, render_track_row, render_archived_reo
 
 def run(args: list[str]) -> int:
     flags, _ = parse_flags(args, {"--repo"})
-    repo_key = flags.get("--repo")
-    if repo_key is True:
-        print("usage: work_plan.py brief [--repo=<key>]")
+    repo_arg = flags.get("--repo")
+    if repo_arg is True:
+        print("usage: work_plan.py brief [--repo=<key> | --repo=all]")
         return 2
 
     try:
@@ -36,15 +38,39 @@ def run(args: list[str]) -> int:
         return 1
 
     tracks = discover_tracks(cfg)
+
+    # Resolve the effective scope key ONCE, then thread it through both the track
+    # filter and the archived-reopen pass so the two can never diverge (#358):
+    #   explicit --repo=<key> → scope to it (unchanged behavior, no banner)
+    #   explicit --repo=all   → force the full view (no scope, no auto-detect)
+    #   --repo omitted        → auto-detect from cwd (unless opted out); banner on hit
+    auto_scoped = False
+    if isinstance(repo_arg, str):
+        repo_key = None if repo_arg.lower() == "all" else repo_arg
+    else:
+        repo_key = None
+        if cfg.get("brief_auto_scope", True):
+            match = resolve_repo_for_dir(cfg, os.getcwd())
+            # Only auto-scope when the detected repo actually has tracks — a
+            # convenience must never hide tracks you'd otherwise see.
+            if match and filter_tracks_by_repo(tracks, match["key"]):
+                repo_key = match["key"]
+                auto_scoped = True
+
     if repo_key:
         scoped = filter_tracks_by_repo(tracks, repo_key)
         if not scoped:
+            # Reachable only via an explicit --repo (the auto path above already
+            # guaranteed a non-empty match).
             print(f"No tracks found for repo '{repo_key}'.")
             available = sorted((cfg.get("repos") or {}).keys())
             if available:
                 print(f"Configured repo keys: {', '.join(available)}")
             return 0
         tracks = scoped
+        if auto_scoped:
+            print(f"Scoped to repo '{repo_key}' (cwd). Use --repo=all to see everything.")
+            print()
     active = [t for t in tracks if t.has_frontmatter
               and t.meta.get("status") in ("active", "in-progress", "blocked")]
 

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

@@ -0,0 +1,104 @@
+"""dedupe-tiers — remove private track copies shadowed by a shared twin (#359).
+
+When a track is promoted to the shared tier (a repo's `.work-plan/`), the private
+original under `notes_root` is normally moved out by `push-track`. But bulk or
+manual promotion — or a failed unlink mid-promote — leaves the private copy
+behind. `discover_tracks` then resolves the collision ("using shared") but warns
+on EVERY invocation, with no built-in way to clean up.
+
+This verb removes the orphaned private copies that their shared twin supersedes,
+and REFUSES to touch any whose private copy still references issue numbers the
+shared one lacks — so no tracked work is ever silently dropped. The no-data-loss
+invariant is `issue_refs(private) ⊆ issue_refs(shared)`.
+
+Default is a dry-run report. Pass `--apply` to delete the safe orphans; the
+deletion lands in notes_root and the dispatcher's auto-commit makes it undoable.
+
+Usage:
+    work_plan.py dedupe-tiers [--repo=<key>] [--apply]
+"""
+import sys
+from pathlib import Path
+
+from lib.config import load_config, ConfigError
+from lib.tracks import find_tier_duplicates, issue_refs
+from lib.prompts import parse_flags
+
+KNOWN = {"--repo", "--apply"}
+
+
+def run(args: list) -> int:
+    flags, _ = parse_flags(args, KNOWN)
+    repo_key = flags.get("--repo")
+    if repo_key is True:
+        print("usage: work_plan.py dedupe-tiers [--repo=<key>] [--apply]",
+              file=sys.stderr)
+        return 2
+    apply = bool(flags.get("--apply"))
+
+    try:
+        cfg = load_config()
+    except ConfigError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        return 1
+
+    pairs = find_tier_duplicates(cfg)
+    if repo_key:
+        k = repo_key.lower()
+        pairs = [(s, p) for (s, p) in pairs
+                 if (s.folder and s.folder.lower() == k)
+                 or (s.repo and s.repo.lower() == k)]
+
+    if not pairs:
+        scope = f" for repo '{repo_key}'" if repo_key else ""
+        print(f"No shared/private duplicate tracks found{scope}. Nothing to dedupe.")
+        return 0
+
+    safe: list = []      # (shared, private) — private issue refs ⊆ shared
+    diverged: list = []  # (shared, private, extra_refs) — private has unique refs
+    for s, p in pairs:
+        extra = issue_refs(p) - issue_refs(s)
+        if extra:
+            diverged.append((s, p, extra))
+        else:
+            safe.append((s, p))
+
+    print(f"Found {len(pairs)} shared/private duplicate track(s):")
+    print(f"  {len(safe)} safe to remove (private issue refs ⊆ shared)")
+    print(f"  {len(diverged)} diverged — kept for manual review")
+    print()
+
+    for s, p in safe:
+        print(f"  ✓ {p.name}  (repo {s.repo or s.folder}) — private superseded by shared")
+        print(f"      private: {p.path}")
+    for s, p, extra in diverged:
+        refs = ", ".join(f"#{n}" for n in sorted(extra))
+        print(f"  ⚠ {p.name}  (repo {s.repo or s.folder}) — private has issue refs "
+              f"not in shared: {refs}")
+        print(f"      KEPT: {p.path} — reconcile by hand")
+
+    if not apply:
+        print()
+        if safe:
+            print(f"Dry run. Re-run with --apply to remove {len(safe)} private orphan(s).")
+        else:
+            print("Dry run. Nothing safe to remove automatically.")
+        return 0
+
+    if not safe:
+        print()
+        print("Nothing removed — every duplicate diverged and needs manual review.")
+        return 0
+
+    removed = 0
+    for s, p in safe:
+        try:
+            Path(p.path).unlink()
+            removed += 1
+        except OSError as e:
+            print(f"WARN: could not remove {p.path}: {e}", file=sys.stderr)
+
+    print()
+    print(f"Removed {removed} private orphan(s). "
+          f"{len(diverged)} diverged track(s) left for manual review.")
+    return 0

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

@@ -2,7 +2,7 @@
 import json
 from datetime import datetime, date
 from lib.config import load_config, ConfigError, resolve_local_path_for_folder
-from lib.tracks import discover_tracks
+from lib.tracks import discover_tracks, find_tier_duplicates, issue_refs
 from lib.github_state import fetch_export_issues, fetch_open_issues, repo_visibility
 from lib.git_state import hot_issue_numbers
 from lib.export_model import build_export
@@ -148,6 +148,22 @@ def run(args: list[str]) -> int:
             if nums:
                 hot_by_track[(t.repo, t.name)] = nums
 
+    # Shared/private tier duplicates (#361): the viewer is otherwise blind to
+    # them — discover_tracks drops the private copy with a stderr-only WARN. We
+    # surface them as a read-only health signal; `safe` mirrors dedupe-tiers'
+    # no-data-loss invariant (private issue refs ⊆ shared), so the viewer can
+    # tell auto-removable orphans from diverged ones needing manual review.
+    tier_duplicates = []
+    for shared_t, private_t in find_tier_duplicates(cfg):
+        tier_duplicates.append({
+            "repo": shared_t.repo,
+            "folder": shared_t.folder,
+            "name": shared_t.name,
+            "shared_path": str(shared_t.path),
+            "private_path": str(private_t.path),
+            "safe": issue_refs(private_t) <= issue_refs(shared_t),
+        })
+
     next_up_default = cfg.get("next_up_default")
     now = datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
     print(json.dumps(
@@ -156,7 +172,8 @@ def run(args: list[str]) -> int:
                      config_repos=config_repos,
                      plan_by_track=plan_by_track,
                      hot_by_track=hot_by_track,
-                     next_up_default=next_up_default),
+                     next_up_default=next_up_default,
+                     tier_duplicates=tier_duplicates),
         indent=2,
     ))
     return 0

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

@@ -3,11 +3,15 @@
 Runs in sequence:
   1. refresh-md --all --yes  (drift in body status tables)
   2. reconcile --all          (sync track/<slug> labels ↔ frontmatter)
-  3. duplicates               (find consolidation candidates)
+  3. dedupe-tiers             (report shared/private duplicate tracks)
+  4. duplicates               (find consolidation candidates)
 
 One command for the standard weekly maintenance pass.
 
-Pass --repo=<key> to scope steps 1 and 2 to a single repo. Step 3 (duplicates)
+Step 3 (dedupe-tiers) is report-only here — it never deletes during hygiene.
+Run `/work-plan dedupe-tiers --apply` directly to remove the safe orphans.
+
+Pass --repo=<key> to scope steps 1 and 2 to a single repo. Step 4 (duplicates)
 is per-repo, so:
   - when --repo is set, it's scoped to that repo;
   - when --repo is absent and config has exactly one repo, it runs against
@@ -18,7 +22,7 @@ is per-repo, so:
 Pass --timeout=N to set the gh subprocess timeout for the duplicates step
 (default 30s).
 """
-from commands import refresh_md, reconcile, duplicates
+from commands import refresh_md, reconcile, duplicates, dedupe_tiers
 from lib.config import load_config, ConfigError
 from lib.prompts import parse_flags
 import time
@@ -62,7 +66,7 @@ def run(args: list[str]) -> int:
 
     t0 = time.time()
     print("=" * 60)
-    print(f"WEEKLY HYGIENE — step 1 of 3: refresh-md{scope_label}")
+    print(f"WEEKLY HYGIENE — step 1 of 4: refresh-md{scope_label}")
     print("=" * 60)
     refresh_args = [f"--repo={repo_key}"] if repo_key else ["--all"]
     if yes:
@@ -70,12 +74,12 @@ def run(args: list[str]) -> int:
     rc = refresh_md.run(refresh_args)
     if rc != 0:
         print(f"\n⚠ refresh-md exited with code {rc}; continuing.")
-    print(f"  (step 1/3 done in {time.time() - t0:.1f}s)")
+    print(f"  (step 1/4 done in {time.time() - t0:.1f}s)")
 
     t1 = time.time()
     print()
     print("=" * 60)
-    print(f"WEEKLY HYGIENE — step 2 of 3: reconcile{scope_label}")
+    print(f"WEEKLY HYGIENE — step 2 of 4: reconcile{scope_label}")
     print("=" * 60)
     reconcile_args = [f"--repo={repo_key}"] if repo_key else ["--all"]
     if yes:
@@ -83,7 +87,18 @@ def run(args: list[str]) -> int:
     rc = reconcile.run(reconcile_args)
     if rc != 0:
         print(f"\n⚠ reconcile exited with code {rc}; continuing.")
-    print(f"  (step 2/3 done in {time.time() - t1:.1f}s)")
+    print(f"  (step 2/4 done in {time.time() - t1:.1f}s)")
+
+    t_dt = time.time()
+    print()
+    print("=" * 60)
+    print(f"WEEKLY HYGIENE — step 3 of 4: dedupe-tiers{scope_label} (report-only)")
+    print("=" * 60)
+    dedupe_args = [f"--repo={repo_key}"] if repo_key else []
+    rc = dedupe_tiers.run(dedupe_args)
+    if rc != 0:
+        print(f"\n⚠ dedupe-tiers exited with code {rc}; continuing.")
+    print(f"  (step 3/4 done in {time.time() - t_dt:.1f}s)")
 
     if skip_dups:
         print()
@@ -93,7 +108,7 @@ def run(args: list[str]) -> int:
     t2 = time.time()
     print()
     print("=" * 60)
-    print("WEEKLY HYGIENE — step 3 of 3: duplicates")
+    print("WEEKLY HYGIENE — step 4 of 4: duplicates")
     print("=" * 60)
 
     try:
@@ -122,7 +137,7 @@ def run(args: list[str]) -> int:
     rc = duplicates.run(dupes_args)
     if rc != 0:
         print(f"\n⚠ duplicates exited with code {rc}.")
-    print(f"  (step 3/3 done in {time.time() - t2:.1f}s)")
+    print(f"  (step 4/4 done in {time.time() - t2:.1f}s)")
 
     print()
     print(f"✓ Weekly hygiene complete ({time.time() - t0:.1f}s total). Review the duplicate candidates above and "

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

@@ -0,0 +1,52 @@
+"""which-repo — resolve the current directory to a configured repo.
+
+Prints the matched repo's config key + GitHub slug, or reports no match. The
+VS Code viewer spawns this with cwd set to the workspace folder to auto-focus its
+repo lens (#357); `brief` calls the underlying resolver directly for cwd
+auto-scope (#358). Read-only — never mutates anything.
+
+Exit codes (human form): 0 on a match, 1 on no match — so a shell caller can
+gate on it. The `--json` form always exits 0 and prints a `{"key": ...}` payload
+(key is null on no match) for the viewer to parse.
+"""
+import json
+import os
+
+from lib.config import load_config, ConfigError
+from lib.cwd_repo import resolve_repo_for_dir
+from lib.prompts import parse_flags
+
+
+def run(args: list) -> int:
+    flags, _ = parse_flags(args, {"--json"})
+    want_json = bool(flags.get("--json"))
+
+    try:
+        cfg = load_config()
+    except ConfigError as e:
+        if want_json:
+            print(json.dumps({"key": None}))
+            return 0
+        print(f"ERROR: {e}")
+        return 1
+
+    match = resolve_repo_for_dir(cfg, os.getcwd())
+
+    if want_json:
+        if match:
+            print(json.dumps({
+                "key": match["key"],
+                "github": match.get("github"),
+                "matched_by": match["matched_by"],
+            }))
+        else:
+            print(json.dumps({"key": None}))
+        return 0
+
+    if match:
+        how = "local clone path" if match["matched_by"] == "local" else "git remote"
+        print(f"Resolved to repo '{match['key']}' (matched by {how}).")
+        return 0
+
+    print("No configured repo matches the current directory.")
+    return 1

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

@@ -0,0 +1,133 @@
+"""Resolve a directory to a configured repo (config key + GitHub slug).
+
+Shared substrate for two sibling features: `brief` cwd auto-scope (#358) and the
+VS Code viewer auto-focus (#357). Both need the same "which configured repo is
+this directory?" answer, so it lives here once — exposed to the viewer through
+the `which-repo` command and called directly by `brief`.
+
+Resolution order: the local clone path is the primary signal (it's the most
+explicit thing the user configured); the git `origin` remote is the fallback for
+repos registered with `local: null`. If both resolve but to different keys (which
+shouldn't happen in practice), the local-path key wins.
+
+Read-only and never raises — every git call goes through the bounded `_git`
+wrapper, which returns None on failure, and a no-match returns None so callers
+fall back to their current all-repos behavior unchanged.
+"""
+import re
+from pathlib import Path
+from typing import Optional
+
+from lib.git_state import _git
+
+
+def _normalize_remote_url(url: str) -> Optional[str]:
+    """Normalize a git remote URL to a lowercased `org/repo` slug, or None.
+
+    Handles the forms git emits for GitHub remotes:
+      git@github.com:org/repo.git        -> org/repo   (scp-like)
+      ssh://git@github.com/org/repo.git  -> org/repo
+      https://github.com/org/repo.git    -> org/repo
+      https://github.com/org/repo        -> org/repo
+
+    A trailing `.git`, surrounding whitespace, and trailing slashes are stripped.
+    Returns None for anything it can't parse into a host-path.
+    """
+    if not url:
+        return None
+    u = url.strip()
+
+    # scp-like syntax: [user@]host:path  (no scheme, single colon before path)
+    m = re.match(r"^[\w.+-]+@[\w.-]+:(.+)$", u)
+    if m:
+        path = m.group(1)
+    else:
+        # url syntax: scheme://[user@]host[:port]/path
+        m = re.match(r"^[\w.+-]+://(?:[^/@]+@)?[^/]+/(.+)$", u)
+        if not m:
+            return None
+        path = m.group(1)
+
+    path = path.strip().strip("/")
+    if path.endswith(".git"):
+        path = path[:-len(".git")]
+    path = path.strip("/")
+    return path.lower() or None
+
+
+def _toplevel(start_dir) -> Optional[Path]:
+    """The git work-tree root containing `start_dir`, resolved absolute, or None.
+
+    Uses `rev-parse --show-toplevel` (not the raw dir) so resolution works from
+    any nested subdirectory and a configured `local` that merely *contains* the
+    cwd can't false-match.
+    """
+    proc = _git(start_dir, "rev-parse", "--show-toplevel")
+    if proc is None or proc.returncode != 0:
+        return None
+    out = proc.stdout.strip()
+    if not out:
+        return None
+    try:
+        return Path(out).resolve()
+    except OSError:
+        return None
+
+
+def _origin_slug(start_dir) -> Optional[str]:
+    """The `org/repo` slug of `start_dir`'s `origin` remote, or None."""
+    proc = _git(start_dir, "remote", "get-url", "origin")
+    if proc is None or proc.returncode != 0:
+        return None
+    return _normalize_remote_url(proc.stdout.strip())
+
+
+def resolve_repo_for_dir(cfg: dict, start_dir) -> Optional[dict]:
+    """Resolve `start_dir` to a single configured repo.
+
+    Returns `{"key", "github", "matched_by"}` (matched_by is "local" or
+    "remote") when exactly one repo matches, else None. None covers: no repos
+    configured, dir isn't a git repo, no match, or an ambiguous (>1) match —
+    callers treat all of these as "don't auto-scope."
+    """
+    repos = cfg.get("repos") or {}
+    if not repos:
+        return None
+
+    # --- local clone path (primary) ---
+    top = _toplevel(start_dir)
+    if top is not None:
+        local_keys = []
+        for key, entry in repos.items():
+            local_raw = (entry or {}).get("local")
+            if not local_raw:
+                continue
+            try:
+                cfg_root = Path(local_raw).expanduser().resolve()
+            except OSError:
+                continue
+            if cfg_root == top:
+                local_keys.append(key)
+        if len(local_keys) == 1:
+            key = local_keys[0]
+            return {"key": key,
+                    "github": (repos[key] or {}).get("github"),
+                    "matched_by": "local"}
+        if len(local_keys) > 1:
+            # Ambiguous local config — refuse to guess.
+            return None
+
+    # --- git origin remote (fallback) ---
+    slug = _origin_slug(start_dir)
+    if slug:
+        remote_keys = [
+            key for key, entry in repos.items()
+            if entry and entry.get("github") and entry["github"].lower() == slug
+        ]
+        if len(remote_keys) == 1:
+            key = remote_keys[0]
+            return {"key": key,
+                    "github": repos[key].get("github"),
+                    "matched_by": "remote"}
+
+    return None

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

@@ -23,8 +23,13 @@ def detect_drift(body: str, github_issues: list[dict]) -> list[dict]:
                 continue
             gh_state = state_by_num[num]
             looks_closed = any(k in body_status for k in ("✅", "shipped", "merged", "closed"))
-            looks_open = "🔲" in body_status or "open" in body_status
 
+            # Asymmetric by design: CLOSED is terminal, so a closed issue whose
+            # row doesn't explicitly read closed (open marker, ambiguous, or empty)
+            # is drift. OPEN is not terminal — an open issue legitimately sits in
+            # many states (in-progress, blocked, todo), so only an explicit closed
+            # marker contradicts it. A broad open-side check (`not looks_open`)
+            # would false-positive every in-progress row, which is why we don't.
             if gh_state == "CLOSED" and not looks_closed:
                 drift.append({"issue": num, "body_status": body_status, "github_state": "CLOSED"})
             elif gh_state == "OPEN" and looks_closed:

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

@@ -86,7 +86,7 @@ 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,
-                 next_up_default=None) -> dict:
+                 next_up_default=None, tier_duplicates=None) -> dict:
     plan_by_track = plan_by_track or {}
     hot_by_track = hot_by_track or {}
     out = {"schema": SCHEMA, "generated_at": now, "tracks": []}
@@ -169,4 +169,9 @@ def build_export(tracks, issues_by_track, visibility, now: str,
     # the starting point for adding fresh tracks. Each entry:
     # {folder, repo(slug), local, has_local, visibility}.
     out["repos"] = list(config_repos or [])
+    # Shared/private tier duplicates (#361, additive): tracks that exist in both
+    # a repo's shared .work-plan/ and the private notes_root tier. Read-only
+    # health signal for the viewer; resolved with the `dedupe-tiers` CLI verb.
+    # Each entry: {repo, folder, name, shared_path, private_path, safe}.
+    out["tier_duplicates"] = list(tier_duplicates or [])
     return out

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

@@ -1,4 +1,5 @@
 """Discover tracks under notes_root and shared .work-plan/ dirs."""
+import re
 import sys
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -74,9 +75,11 @@ def discover_tracks(cfg: dict) -> list[Track]:
     for t in private:
         key = (t.repo, t.name)
         if key in shared_keys:
+            hint = f" --repo={t.folder}" if t.folder else ""
             print(
                 f"WARN: track {t.name!r} (repo={t.repo!r}) exists in both shared"
-                f" ({shared_keys[key].path}) and private ({t.path}); using shared.",
+                f" ({shared_keys[key].path}) and private ({t.path}); using shared."
+                f" → resolve with `/work-plan dedupe-tiers{hint}`.",
                 file=sys.stderr,
             )
         else:
@@ -85,6 +88,63 @@ def discover_tracks(cfg: dict) -> list[Track]:
     return merged
 
 
+def issue_refs(track: "Track") -> set:
+    """All GitHub issue numbers a track references: the union of its frontmatter
+    `github.issues` list and every `#NNNN` token in its body. Used by
+    dedupe-tiers as the no-data-loss invariant — a private copy is only safe to
+    drop when its issue refs are a subset of the shared twin's.
+    """
+    refs: set = set()
+    fm_issues = (track.meta.get("github") or {}).get("issues") or []
+    for n in fm_issues:
+        try:
+            refs.add(int(n))
+        except (TypeError, ValueError):
+            continue
+    for m in re.finditer(r"#(\d+)", track.body or ""):
+        refs.add(int(m.group(1)))
+    return refs
+
+
+def find_tier_duplicates(cfg: dict) -> list:
+    """Return (shared, private) Track pairs that collide on (repo, name) across
+    BOTH the active and archived tiers. Unlike discover_tracks, this does NOT
+    print a warning and does NOT drop the private side — it hands both copies to
+    the caller (dedupe-tiers) so the orphan can be inspected and removed.
+    """
+    pairs: list = []
+
+    # A duplicate requires a PRIVATE copy, which lives under notes_root. With no
+    # notes_root configured there can be no private tier and thus no duplicates —
+    # return early (also keeps the helper safe to call with a bare cfg).
+    if not cfg.get("notes_root"):
+        return pairs
+
+    shared_active = {(t.repo, t.name): t
+                     for t in _discover_shared_tracks(cfg, include_archive=False)}
+    for t in _discover_private_tracks(cfg, include_archive=False):
+        s = shared_active.get((t.repo, t.name))
+        if s is not None:
+            pairs.append((s, t))
+
+    shared_arch = {(t.repo, t.name): t
+                   for t in _discover_shared_tracks(cfg, include_archive=True,
+                                                    archive_only=True)}
+    notes_root = Path(cfg["notes_root"]).expanduser()
+    if notes_root.exists():
+        for md_path in sorted(notes_root.rglob("*.md")):
+            if "archive" not in md_path.parts:
+                continue
+            if md_path.name.startswith((".", "_", "-")):
+                continue
+            t = _build_track(md_path, notes_root, cfg)
+            s = shared_arch.get((t.repo, t.name))
+            if s is not None:
+                pairs.append((s, t))
+
+    return pairs
+
+
 def filter_tracks_by_repo(tracks: list[Track], key: str) -> list[Track]:
     """Filter tracks by repo. Matches the config-key folder name OR the
     `org/repo` GitHub slug, so users can pass either. Case-insensitive."""
@@ -176,10 +236,12 @@ def discover_archived_tracks(cfg: dict) -> list[Track]:
     for t in private_archived:
         key = (t.repo, t.name)
         if key in shared_keys:
+            hint = f" --repo={t.folder}" if t.folder else ""
             print(
                 f"WARN: archived track {t.name!r} (repo={t.repo!r}) exists in"
                 f" both shared ({shared_keys[key].path}) and private"
-                f" ({t.path}); using shared.",
+                f" ({t.path}); using shared."
+                f" → resolve with `/work-plan dedupe-tiers{hint}`.",
                 file=sys.stderr,
             )
         else:

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

@@ -0,0 +1,126 @@
+"""brief cwd auto-scope (#358 Phase 2).
+
+Exercises brief.run()'s scope resolution with the resolver, config loader,
+track discovery, and the archived-reopen pass all mocked — so no network/git.
+Tracks are inactive (status 'shipped') so the render loop stays trivial; we
+assert behavior through the banner text and the `repo_key` threaded into
+`_surface_archived_reopens` (which is exactly the value used to scope both the
+track list and the archived callouts).
+"""
+import io
+import sys
+import types
+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 commands import brief
+
+
+def _track(folder, repo):
+    return types.SimpleNamespace(
+        has_frontmatter=True,
+        meta={"status": "shipped"},   # inactive → no per-track render
+        needs_init=False,
+        needs_filing=False,
+        folder=folder,
+        repo=repo,
+        path=Path(f"/notes/{folder}/{folder}.md"),
+    )
+
+
+CFG = {"repos": {
+    "work-plan-toolkit": {"local": "/code/wpt", "github": "stylusnexus/work-plan-toolkit"},
+    "defect-scan": {"local": "/code/ds", "github": "stylusnexus/defect-scan"},
+}}
+
+TRACKS = [
+    _track("work-plan-toolkit", "stylusnexus/work-plan-toolkit"),
+    _track("defect-scan", "stylusnexus/defect-scan"),
+]
+
+BANNER = "Scoped to repo"
+
+
+def _run(args, cfg=None, resolve_return=mock.DEFAULT):
+    """Run brief.run(args) with collaborators mocked. Returns (stdout, archived_mock, resolve_mock)."""
+    cfg = CFG if cfg is None else cfg
+    buf = io.StringIO()
+    with mock.patch.object(brief, "load_config", return_value=cfg), \
+         mock.patch.object(brief, "discover_tracks", return_value=list(TRACKS)), \
+         mock.patch.object(brief, "_surface_archived_reopens") as archived, \
+         mock.patch.object(brief, "resolve_repo_for_dir") as resolve:
+        if resolve_return is not mock.DEFAULT:
+            resolve.return_value = resolve_return
+        with redirect_stdout(buf):
+            brief.run(args)
+    return buf.getvalue(), archived, resolve
+
+
+def _archived_repo_key(archived):
+    self_call = archived.call_args
+    return self_call.kwargs.get("repo_key")
+
+
+class BriefAutoScopeTest(unittest.TestCase):
+    # --- auto-detect on (default) -------------------------------------------
+
+    def test_autoscope_prints_banner_and_scopes(self):
+        out, archived, _ = _run(
+            [], resolve_return={"key": "work-plan-toolkit",
+                                "github": "stylusnexus/work-plan-toolkit",
+                                "matched_by": "local"})
+        self.assertIn(BANNER, out)
+        self.assertIn("work-plan-toolkit", out)
+        # archived-reopen pass scoped to the same detected key
+        self.assertEqual(_archived_repo_key(archived), "work-plan-toolkit")
+
+    def test_archived_reopens_scoped_to_detected_repo(self):
+        _, archived, _ = _run(
+            [], resolve_return={"key": "defect-scan",
+                                "github": "stylusnexus/defect-scan",
+                                "matched_by": "local"})
+        self.assertEqual(_archived_repo_key(archived), "defect-scan")
+
+    def test_banner_printed_exactly_once(self):
+        out, _, _ = _run(
+            [], resolve_return={"key": "work-plan-toolkit",
+                                "github": "stylusnexus/work-plan-toolkit",
+                                "matched_by": "local"})
+        self.assertEqual(out.count(BANNER), 1)
+
+    def test_no_match_shows_all_no_banner(self):
+        out, archived, _ = _run([], resolve_return=None)
+        self.assertNotIn(BANNER, out)
+        self.assertIsNone(_archived_repo_key(archived))
+
+    # --- explicit --repo / escape hatch -------------------------------------
+
+    def test_repo_all_shows_everything_no_banner_no_autodetect(self):
+        out, archived, resolve = _run(["--repo=all"])
+        self.assertNotIn(BANNER, out)
+        self.assertIsNone(_archived_repo_key(archived))
+        resolve.assert_not_called()   # --repo=all must short-circuit auto-detect
+
+    def test_explicit_repo_scopes_without_banner_or_autodetect(self):
+        out, archived, resolve = _run(["--repo=defect-scan"])
+        self.assertNotIn(BANNER, out)
+        self.assertEqual(_archived_repo_key(archived), "defect-scan")
+        resolve.assert_not_called()
+
+    # --- opt-out -------------------------------------------------------------
+
+    def test_optout_disables_autoscope(self):
+        cfg = {"repos": CFG["repos"], "brief_auto_scope": False}
+        out, archived, resolve = _run([], cfg=cfg)
+        self.assertNotIn(BANNER, out)
+        self.assertIsNone(_archived_repo_key(archived))
+        resolve.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,164 @@
+"""cwd → configured-repo resolution (#358/#357 Phase 1).
+
+All git calls are mocked, so these run offline. The resolver shells `git` via
+`lib.git_state._git`, imported into `lib.cwd_repo`'s namespace — so we patch
+`lib.cwd_repo._git`.
+"""
+import sys
+import types
+import unittest
+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 cwd_repo
+from lib.cwd_repo import resolve_repo_for_dir, _normalize_remote_url
+
+
+def _proc(stdout="", returncode=0):
+    """A stand-in for subprocess.CompletedProcess as `_git` returns it."""
+    return types.SimpleNamespace(stdout=stdout, returncode=returncode)
+
+
+def _fake_git(toplevel=None, origin=None):
+    """Build a `_git` replacement keyed on the git subcommand.
+
+    `toplevel` / `origin` are raw stdout strings (or None → non-zero exit, i.e.
+    git failed / not a repo / no remote).
+    """
+    def _g(repo_path, *args, **kwargs):
+        if args[:2] == ("rev-parse", "--show-toplevel"):
+            return _proc(toplevel, 0) if toplevel is not None else _proc("", 128)
+        if args[:2] == ("remote", "get-url"):
+            return _proc(origin, 0) if origin is not None else _proc("", 2)
+        return _proc("", 0)
+    return _g
+
+
+# Absolute, non-symlinked paths so .resolve() is a no-op-equal on both sides.
+CFG = {
+    "repos": {
+        "work-plan-toolkit": {
+            "local": "/code/work-plan-toolkit",
+            "github": "stylusnexus/work-plan-toolkit",
+        },
+        "defect-scan": {
+            "local": "/code/defect-scan",
+            "github": "stylusnexus/defect-scan",
+        },
+        # A repo with no local clone — only a remote can match it.
+        "remote-only": {
+            "local": None,
+            "github": "stylusnexus/remote-only",
+        },
+    }
+}
+
+
+class NormalizeRemoteUrlTest(unittest.TestCase):
+    def test_scp_form(self):
+        self.assertEqual(
+            _normalize_remote_url("git@github.com:Org/Repo.git"), "org/repo")
+
+    def test_https_with_git_suffix(self):
+        self.assertEqual(
+            _normalize_remote_url("https://github.com/org/repo.git"), "org/repo")
+
+    def test_https_without_suffix(self):
+        self.assertEqual(
+            _normalize_remote_url("https://github.com/org/repo"), "org/repo")
+
+    def test_ssh_url_form(self):
+        self.assertEqual(
+            _normalize_remote_url("ssh://git@github.com/org/repo.git"), "org/repo")
+
+    def test_all_forms_land_on_same_slug(self):
+        forms = [
+            "git@github.com:org/repo.git",
+            "https://github.com/org/repo.git",
+            "https://github.com/org/repo",
+            "ssh://git@github.com/org/repo.git",
+        ]
+        slugs = {_normalize_remote_url(f) for f in forms}
+        self.assertEqual(slugs, {"org/repo"})
+
+    def test_garbage_returns_none(self):
+        self.assertIsNone(_normalize_remote_url(""))
+        self.assertIsNone(_normalize_remote_url("not-a-url"))
+
+
+class ResolveRepoForDirTest(unittest.TestCase):
+    def test_local_match_at_clone_root(self):
+        with mock.patch.object(cwd_repo, "_git",
+                               _fake_git(toplevel="/code/work-plan-toolkit")):
+            got = resolve_repo_for_dir(CFG, "/code/work-plan-toolkit")
+        self.assertEqual(got, {
+            "key": "work-plan-toolkit",
+            "github": "stylusnexus/work-plan-toolkit",
+            "matched_by": "local",
+        })
+
+    def test_local_match_from_nested_subdir(self):
+        # cwd is deep inside the clone; toplevel still resolves to the root.
+        with mock.patch.object(cwd_repo, "_git",
+                               _fake_git(toplevel="/code/work-plan-toolkit")):
+            got = resolve_repo_for_dir(
+                CFG, "/code/work-plan-toolkit/skills/work-plan/lib")
+        self.assertIsNotNone(got)
+        self.assertEqual(got["key"], "work-plan-toolkit")
+        self.assertEqual(got["matched_by"], "local")
+
+    def test_remote_match_when_local_is_null(self):
+        # Not a configured local path, but origin matches the remote-only repo.
+        with mock.patch.object(cwd_repo, "_git",
+                               _fake_git(toplevel="/somewhere/else",
+                                         origin="git@github.com:stylusnexus/remote-only.git")):
+            got = resolve_repo_for_dir(CFG, "/somewhere/else")
+        self.assertEqual(got, {
+            "key": "remote-only",
+            "github": "stylusnexus/remote-only",
+            "matched_by": "remote",
+        })
+
+    def test_local_wins_over_remote_when_they_disagree(self):
+        # toplevel == defect-scan's clone, but origin points at work-plan-toolkit.
+        # The local-path key must win.
+        with mock.patch.object(cwd_repo, "_git",
+                               _fake_git(toplevel="/code/defect-scan",
+                                         origin="git@github.com:stylusnexus/work-plan-toolkit.git")):
+            got = resolve_repo_for_dir(CFG, "/code/defect-scan")
+        self.assertEqual(got["key"], "defect-scan")
+        self.assertEqual(got["matched_by"], "local")
+
+    def test_no_match_inside_unconfigured_repo(self):
+        with mock.patch.object(cwd_repo, "_git",
+                               _fake_git(toplevel="/code/unknown",
+                                         origin="git@github.com:someone/unknown.git")):
+            self.assertIsNone(resolve_repo_for_dir(CFG, "/code/unknown"))
+
+    def test_no_match_when_not_a_git_repo(self):
+        # git rev-parse fails AND no remote — resolver returns None, no raise.
+        with mock.patch.object(cwd_repo, "_git",
+                               _fake_git(toplevel=None, origin=None)):
+            self.assertIsNone(resolve_repo_for_dir(CFG, "/tmp/plain-dir"))
+
+    def test_none_when_two_repos_share_a_local_path(self):
+        # Pathological config: two keys point at the same clone. Refuse to guess.
+        cfg = {"repos": {
+            "a": {"local": "/code/dup", "github": "org/a"},
+            "b": {"local": "/code/dup", "github": "org/b"},
+        }}
+        with mock.patch.object(cwd_repo, "_git",
+                               _fake_git(toplevel="/code/dup")):
+            self.assertIsNone(resolve_repo_for_dir(cfg, "/code/dup"))
+
+    def test_none_when_no_repos_configured(self):
+        with mock.patch.object(cwd_repo, "_git",
+                               _fake_git(toplevel="/code/x")):
+            self.assertIsNone(resolve_repo_for_dir({"repos": {}}, "/code/x"))
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,147 @@
+"""Tests for the dedupe-tiers command and its tracks.py helpers (#359)."""
+import io
+import sys
+import tempfile
+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 dedupe_tiers
+from lib import tracks
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _track(*, name, repo="org/repo", folder="repo", issues=None, body="", path=None,
+           tier="private"):
+    meta = {"track": name, "github": {"repo": repo}}
+    if issues is not None:
+        meta["github"]["issues"] = issues
+    return SimpleNamespace(
+        name=name,
+        path=Path(path) if path else Path(f"/tmp/notes/{folder}/{name}.md"),
+        repo=repo,
+        folder=folder,
+        meta=meta,
+        body=body,
+        tier=tier,
+    )
+
+
+def _drive(args, pairs, *, notes_root="/tmp/notes"):
+    cfg = {"notes_root": notes_root, "repos": {"repo": {"github": "org/repo"}}}
+    buf = io.StringIO()
+    with patch("commands.dedupe_tiers.load_config", return_value=cfg), \
+         patch("commands.dedupe_tiers.find_tier_duplicates", return_value=pairs), \
+         redirect_stdout(buf):
+        rc = dedupe_tiers.run(args)
+    return rc, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# issue_refs
+# ---------------------------------------------------------------------------
+
+class TestIssueRefs(unittest.TestCase):
+    def test_unions_frontmatter_and_body(self):
+        t = _track(name="a", issues=[10, 20], body="see #20 and #30 here")
+        self.assertEqual(tracks.issue_refs(t), {10, 20, 30})
+
+    def test_empty_when_no_refs(self):
+        t = _track(name="a", issues=None, body="no refs at all")
+        self.assertEqual(tracks.issue_refs(t), set())
+
+    def test_ignores_non_int_frontmatter(self):
+        t = _track(name="a", issues=[1, "oops", None], body="")
+        self.assertEqual(tracks.issue_refs(t), {1})
+
+
+# ---------------------------------------------------------------------------
+# find_tier_duplicates pairing (helpers patched)
+# ---------------------------------------------------------------------------
+
+class TestFindTierDuplicates(unittest.TestCase):
+    def test_pairs_only_colliding_active_tracks(self):
+        shared = [_track(name="dup", tier="shared"), _track(name="only-shared", tier="shared")]
+        private = [_track(name="dup"), _track(name="only-private")]
+        cfg = {"notes_root": "/tmp/does-not-exist-xyz", "repos": {}}
+        with patch.object(tracks, "_discover_shared_tracks") as ds, \
+             patch.object(tracks, "_discover_private_tracks", return_value=private):
+            # active call returns `shared`; archive-only call returns []
+            ds.side_effect = lambda cfg, include_archive=False, archive_only=False: (
+                [] if archive_only else shared)
+            pairs = tracks.find_tier_duplicates(cfg)
+        names = [(s.name, p.name) for (s, p) in pairs]
+        self.assertEqual(names, [("dup", "dup")])
+
+
+# ---------------------------------------------------------------------------
+# command: report / apply / safety
+# ---------------------------------------------------------------------------
+
+class TestDedupeCommand(unittest.TestCase):
+    def test_no_pairs_reports_nothing(self):
+        rc, out = _drive([], [])
+        self.assertEqual(rc, 0)
+        self.assertIn("Nothing to dedupe", out)
+
+    def test_dry_run_removes_nothing(self):
+        with tempfile.TemporaryDirectory() as d:
+            pf = Path(d) / "dup.md"
+            pf.write_text("# dup\n")
+            shared = _track(name="dup", issues=[1, 2], tier="shared")
+            private = _track(name="dup", issues=[1], path=str(pf))
+            rc, out = _drive([], [(shared, private)])
+            self.assertTrue(pf.exists(), "dry run must not delete")
+        self.assertEqual(rc, 0)
+        self.assertIn("Dry run", out)
+        self.assertIn("--apply", out)
+
+    def test_apply_removes_subset_orphan(self):
+        with tempfile.TemporaryDirectory() as d:
+            pf = Path(d) / "dup.md"
+            pf.write_text("# dup\n")
+            shared = _track(name="dup", issues=[1, 2, 3], tier="shared")
+            private = _track(name="dup", issues=[1, 3], path=str(pf))
+            rc, out = _drive(["--apply"], [(shared, private)])
+            self.assertEqual(rc, 0)
+            self.assertFalse(pf.exists(), "subset orphan must be removed on --apply")
+        self.assertIn("Removed 1 private orphan", out)
+
+    def test_apply_keeps_diverged_orphan(self):
+        with tempfile.TemporaryDirectory() as d:
+            pf = Path(d) / "dup.md"
+            pf.write_text("# dup\n")
+            # private references #99 which the shared twin lacks → must be kept
+            shared = _track(name="dup", issues=[1, 2], tier="shared")
+            private = _track(name="dup", issues=[1], body="leftover #99", path=str(pf))
+            rc, out = _drive(["--apply"], [(shared, private)])
+            self.assertEqual(rc, 0)
+            self.assertTrue(pf.exists(), "diverged orphan must NOT be removed")
+        self.assertIn("#99", out)
+        self.assertIn("manual review", out)
+
+    def test_repo_filter_scopes_pairs(self):
+        a_shared = _track(name="a", repo="org/a", folder="a", issues=[1], tier="shared")
+        a_priv = _track(name="a", repo="org/a", folder="a", issues=[1])
+        b_shared = _track(name="b", repo="org/b", folder="b", issues=[1], tier="shared")
+        b_priv = _track(name="b", repo="org/b", folder="b", issues=[1])
+        rc, out = _drive(["--repo=a"], [(a_shared, a_priv), (b_shared, b_priv)])
+        self.assertEqual(rc, 0)
+        self.assertIn("a  (repo org/a)", out)
+        self.assertNotIn("org/b", out)
+
+    def test_repo_flag_without_value_is_usage_error(self):
+        rc, _ = _drive(["--repo"], [])
+        self.assertEqual(rc, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -33,6 +33,38 @@ class DetectDriftTest(unittest.TestCase):
     def test_no_table_returns_empty(self):
         self.assertEqual(detect_drift("# No table\n", [{"number": 1, "state": "CLOSED"}]), [])
 
+    # --- OPEN-side + ambiguous-body cases: pin the *intentional asymmetry* ----
+    # CLOSED is terminal → broad check (anything not-closed drifts). OPEN is not
+    # terminal → narrow check (only an explicit closed marker drifts). These
+    # guard against someone "restoring symmetry" with a `not looks_open` open-side
+    # check, which would false-positive every in-progress row.
+
+    def _body(self, status: str) -> str:
+        return ("| # | Title | Status |\n"
+                "|---|---|---|\n"
+                f"| #1 | foo | {status} |\n")
+
+    def test_drift_when_closed_in_md_open_in_github(self):
+        # OPEN-side condition (was untested): body says shipped, GitHub reopened it.
+        drift = detect_drift(self._body("✅ Shipped"), [{"number": 1, "state": "OPEN"}])
+        self.assertEqual(len(drift), 1)
+        self.assertEqual(drift[0]["github_state"], "OPEN")
+
+    def test_no_drift_when_open_in_md_open_in_github(self):
+        self.assertEqual(detect_drift(self._body("🔲 Open"), [{"number": 1, "state": "OPEN"}]), [])
+
+    def test_open_with_ambiguous_status_is_NOT_drift(self):
+        # The deliberate narrow OPEN-side: an in-progress row must not be flagged.
+        self.assertEqual(
+            detect_drift(self._body("🚧 In progress"), [{"number": 1, "state": "OPEN"}]), [])
+
+    def test_closed_with_ambiguous_status_IS_drift(self):
+        # The deliberate broad CLOSED-side: a closed issue whose row doesn't read
+        # closed (here: ambiguous) is drift.
+        drift = detect_drift(self._body("🚧 In progress"), [{"number": 1, "state": "CLOSED"}])
+        self.assertEqual(len(drift), 1)
+        self.assertEqual(drift[0]["github_state"], "CLOSED")
+
 
 if __name__ == "__main__":
     unittest.main()

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

@@ -151,6 +151,49 @@ class ExportRunJsonTest(unittest.TestCase):
         self.assertEqual(rc, 0)
         self.assertEqual(out["tracks"][0]["issues"], [])
 
+    # --- tier_duplicates (#361) -------------------------------------------
+
+    def _dup_track(self, *, issues, body="", path):
+        return SimpleNamespace(
+            repo=_SHARED_REPO, folder="myrepo", name="dup", path=Path(path),
+            meta={"github": {"repo": _SHARED_REPO, "issues": issues}}, body=body,
+        )
+
+    def test_tier_duplicates_empty_when_none(self):
+        """With no notes_root in cfg (mock returns {}), the field is an empty
+        list — present but quiet, so the viewer can rely on its shape."""
+        tracks = [_track("alpha", _SHARED_REPO, [1])]
+        rc, out, _ = self._run_with_mocks(tracks, _EXPORT_MAP)
+        self.assertEqual(rc, 0)
+        self.assertEqual(out["tier_duplicates"], [])
+
+    def test_tier_duplicate_subset_is_safe(self):
+        shared = self._dup_track(issues=[1, 2, 3], path="/repo/.work-plan/dup.md")
+        private = self._dup_track(issues=[1, 3], path="/notes/myrepo/dup.md")
+        with patch("commands.export.find_tier_duplicates",
+                   return_value=[(shared, private)]):
+            rc, out, _ = self._run_with_mocks([_track("a", _SHARED_REPO, [1])], _EXPORT_MAP)
+        self.assertEqual(rc, 0)
+        td = out["tier_duplicates"]
+        self.assertEqual(len(td), 1)
+        self.assertEqual(td[0]["name"], "dup")
+        self.assertEqual(td[0]["repo"], _SHARED_REPO)
+        self.assertEqual(td[0]["folder"], "myrepo")
+        self.assertTrue(td[0]["safe"])
+        self.assertEqual(td[0]["shared_path"], str(Path("/repo/.work-plan/dup.md")))
+        self.assertEqual(td[0]["private_path"], str(Path("/notes/myrepo/dup.md")))
+
+    def test_tier_duplicate_diverged_is_unsafe(self):
+        # private references #99, which the shared twin lacks → not safe to remove
+        shared = self._dup_track(issues=[1, 2], path="/repo/.work-plan/dup.md")
+        private = self._dup_track(issues=[1], body="leftover #99",
+                                  path="/notes/myrepo/dup.md")
+        with patch("commands.export.find_tier_duplicates",
+                   return_value=[(shared, private)]):
+            rc, out, _ = self._run_with_mocks([_track("a", _SHARED_REPO, [1])], _EXPORT_MAP)
+        self.assertEqual(rc, 0)
+        self.assertFalse(out["tier_duplicates"][0]["safe"])
+
     def test_visibility_included_in_output(self):
         tracks = [_track("alpha", _SHARED_REPO, [1])]
         rc, out, _ = self._run_with_mocks(tracks, _EXPORT_MAP, vis={_SHARED_REPO: "PUBLIC"})

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

@@ -0,0 +1,22 @@
+"""which-repo is dispatchable + documented (#358/#357 Phase 1)."""
+import sys
+import unittest
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+import work_plan
+
+
+class RegisterWhichRepoTest(unittest.TestCase):
+    def test_in_subcommands(self):
+        self.assertEqual(work_plan.SUBCOMMANDS["which-repo"], "commands.which_repo")
+
+    def test_in_descriptions(self):
+        names = {row[0] for row in work_plan.DESCRIPTIONS}
+        self.assertIn("which-repo", names)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/work_plan.py

@@ -47,6 +47,7 @@ SUBCOMMANDS = {
     "duplicates": "commands.duplicates",
     "coverage": "commands.coverage",
     "canonicalize": "commands.canonicalize",
+    "dedupe-tiers": "commands.dedupe_tiers",
     "hygiene": "commands.hygiene",
     "--hygiene": "commands.hygiene",      # flag-style alias
     "plan-status": "commands.plan_status",
@@ -57,6 +58,7 @@ SUBCOMMANDS = {
     "close-issue": "commands.close_issue",
     "in-progress": "commands.in_progress",
     "export": "commands.export",
+    "which-repo": "commands.which_repo",
     "auth-status": "commands.auth_status",
     "list-open-issues": "commands.list_open_issues",
     "set": "commands.set_field",
@@ -147,8 +149,12 @@ DESCRIPTIONS = [
      "Insert a canonical master issue table at the top of a track. The table has a Milestone column and is ordered active-milestone-first (the track's milestone_alignment milestone, then other milestones grouped with a blank divider row, then no-milestone last) so near-term work sits above someday work (#101). Refresh-md then targets ONLY this table, re-deriving it (so the order self-heals) and leaving narrative tables alone. Use --repo=<key> or track@repo to disambiguate; with --all, --repo=<key> scopes to one repo.",
      "ONE-TIME for hand-written tracks with multiple narrative tables, OR after restructuring a track.",
      "/work-plan canonicalize ux-redesign"),
+    ("dedupe-tiers", "[--repo=<key>] [--apply]",
+     "Remove private track copies that a shared twin in a repo's .work-plan/ supersedes (#359). When a track is promoted to the shared tier, the private original under notes_root is sometimes left behind (bulk/manual promotion, or a failed unlink) — discover_tracks then warns 'exists in both shared and private' on every run with no cleanup path. This removes the safe orphans and REFUSES any whose private copy references issue numbers the shared one lacks (no silent data loss; the invariant is issue_refs(private) ⊆ issue_refs(shared)). Covers active and archived tiers. Default is a dry-run report; --apply deletes (auto-committed to notes_root, so undoable).",
+     "When `exists in both shared and private` warnings appear, or after a bulk promote that left private originals behind.",
+     "/work-plan dedupe-tiers --repo=critforge --apply"),
     ("hygiene", "[--yes] [--no-duplicates] [--repo=<key>] [--timeout=N]",
-     "Weekly cleanup wrapper: refresh-md + reconcile + duplicates. With --repo=<key>, steps 1 and 2 scope to that repo; the duplicates step (a global similarity scan) is skipped. --timeout=N sets the gh subprocess timeout for the duplicates step (default 30s).",
+     "Weekly cleanup wrapper: refresh-md + reconcile + dedupe-tiers (report-only) + duplicates. With --repo=<key>, steps 1–3 scope to that repo; the duplicates step (a global similarity scan) is skipped. --timeout=N sets the gh subprocess timeout for the duplicates step (default 30s).",
      "WEEKLY — runs all three hygiene commands in sequence so you don't have to remember each. Use --repo=<key> to clean up one project without touching the others.",
      "/work-plan hygiene --repo=myproject"),
     ("export", "--json",
@@ -219,6 +225,10 @@ DESCRIPTIONS = [
      "Promote a PRIVATE track (local-only, in notes_root) to the repo's SHARED tier and publish it (#306). Moves the track's `.md` 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` (keeps it local). The tier is derived from location, so this is a file move, not a frontmatter edit. Requires the repo to have a local clone + a `plan_branch` (else hints `plan-branch init`). Pushing to a PUBLIC repo makes the track world-visible, so the push is confirm-token gated (prints `needs_confirm` + token; re-run with `--confirm=<token>`).",
      "When a private track is ready to share with teammates — promote it to the shared plan branch in one step instead of hand-moving the file.",
      "/work-plan push-track my-feature --repo=myproject"),
+    ("which-repo", "[--json]",
+     "Resolve the current directory to one configured repo — by local clone path first, then the git `origin` remote. Prints the matched config key + GitHub slug, or reports no match. Read-only. Underlies `brief` cwd auto-scope and the VS Code viewer's repo auto-focus.",
+     "Rarely run by hand — it's the shared resolver the viewer and `brief` call. Useful to confirm which repo a checkout maps to.",
+     "/work-plan which-repo --json"),
 ]