@stylusnexus/work-plan 2026.6.9-1 → 2026.6.9-2

package/VERSION

@@ -1 +1 @@
-2026.06.09+f7e5ff5
+2026.06.09+530f7e8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stylusnexus/work-plan",
-  "version": "2026.6.9-1",
+  "version": "2026.6.9-2",
   "description": "Track-aware daily work planning over GitHub issues. Shared tracks (git-synced .work-plan/ in each repo), AI clustering (group/auto-triage), VS Code viewer, Claude Code + Codex plugins. Pure Python stdlib.",
   "bin": {
     "work-plan": "bin/work-plan"

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

@@ -0,0 +1,184 @@
+"""batch-slot subcommand — slot multiple issues into a track at once."""
+import json
+import subprocess
+
+from lib.config import load_config, ConfigError
+from lib.tracks import discover_tracks, find_track_by_name, parse_track_repo_arg, AmbiguousTrackError
+from lib.frontmatter import write_file
+from lib.write_guard import needs_confirm, make_token, valid_token
+from lib.prompts import parse_flags
+
+
+def _find_prior_owners(issue_num: int, repo: str, target_name: str, tracks):
+    """Active tracks in `repo` (excluding `target_name`) whose frontmatter
+    already lists `issue_num`. Shared with slot.py."""
+    owners = []
+    for t in tracks:
+        if not t.has_frontmatter or t.name == target_name or t.repo != repo:
+            continue
+        if t.meta.get("status") not in ("active", "in-progress", "blocked"):
+            continue
+        if issue_num in (t.meta.get("github", {}).get("issues") or []):
+            owners.append(t)
+    return owners
+
+
+def run(args: list[str]) -> int:
+    flags, positional = parse_flags(
+        args, {"--confirm", "--move", "--no-move", "--repo"}
+    )
+
+    if len(positional) < 2:
+        print(
+            "usage: work_plan.py batch-slot <issue-num>... <track | track@repo>"
+            " [--repo=<key>]"
+        )
+        return 2
+
+    # Last positional is the track; everything before is an issue number.
+    *issue_strs, target_arg = positional
+
+    issue_nums: list[int] = []
+    for s in issue_strs:
+        try:
+            issue_nums.append(int(s))
+        except ValueError:
+            print(f"ERROR: '{s}' is not an issue number.")
+            return 2
+
+    repo_flag = flags.get("--repo") if flags.get("--repo") is not True else None
+
+    target_name = target_arg
+    repo_qualifier = repo_flag
+    if target_arg:
+        name_from_arg, repo_from_arg = parse_track_repo_arg(target_arg)
+        target_name = name_from_arg
+        if repo_from_arg:
+            repo_qualifier = repo_from_arg
+
+    if "--move" in flags and "--no-move" in flags:
+        print("ERROR: --move and --no-move are mutually exclusive.")
+        return 2
+
+    try:
+        cfg = load_config()
+    except ConfigError as e:
+        print(f"ERROR: {e}")
+        return 1
+
+    tracks = discover_tracks(cfg)
+
+    try:
+        target = find_track_by_name(
+            target_name, tracks, active_only=True, repo=repo_qualifier
+        )
+    except AmbiguousTrackError as e:
+        print(str(e))
+        return 1
+    if not target:
+        print(f"No active track matching '{target_name}'.")
+        return 1
+
+    # Confirm gate — fire once for the whole batch.
+    confirm = flags.get("--confirm")
+    if target.repo and needs_confirm(target.repo, cfg) and not (
+        isinstance(confirm, str) and valid_token(confirm, target.repo, target.name)
+    ):
+        print(
+            json.dumps(
+                {
+                    "needs_confirm": True,
+                    "reason": (
+                        f"{target.repo} is PUBLIC (or visibility unknown); "
+                        f"batch-slotting {len(issue_nums)} issue(s) will be"
+                        f" written there."
+                    ),
+                    "token": make_token(target.repo, target.name),
+                }
+            )
+        )
+        return 0
+
+    do_move = "--move" in flags
+
+    # Collect source tracks that need issue removal (consolidated per source).
+    source_removals: dict[str, tuple] = {}  # source_name -> (source_track, set[issue_num])
+
+    issues = list(target.meta.get("github", {}).get("issues") or [])
+    skipped: list[int] = []
+    slotted: list[int] = []
+
+    for issue_num in issue_nums:
+        if issue_num in issues:
+            skipped.append(issue_num)
+            continue
+
+        # Milestone mismatch check (non-blocking warning).
+        proc = subprocess.run(
+            ["gh", "issue", "view", str(issue_num),
+             "--repo", target.repo, "--json", "milestone"],
+            capture_output=True, text=True,
+        )
+        if proc.returncode == 0:
+            info = json.loads(proc.stdout)
+            m = info.get("milestone", {})
+            if (
+                m and m.get("title")
+                and m["title"] != target.meta.get("milestone_alignment")
+            ):
+                print(
+                    f"⚠  #{issue_num} is on milestone '{m['title']}', "
+                    f"track '{target.name}' aligned to"
+                    f" '{target.meta.get('milestone_alignment')}'."
+                )
+
+        # Prior-owner detection.
+        sources = _find_prior_owners(
+            issue_num, target.repo, target.name, tracks
+        )
+
+        issues.append(issue_num)
+        slotted.append(issue_num)
+
+        if sources and do_move:
+            for src in sources:
+                if src.name not in source_removals:
+                    source_removals[src.name] = (src, set())
+                source_removals[src.name][1].add(issue_num)
+        elif sources and not do_move:
+            names = ", ".join(f"'{t.name}'" for t in sources)
+            print(
+                f"ℹ #{issue_num} still listed in {names}"
+                f" — re-run with --move to relocate."
+            )
+
+    if not slotted:
+        if skipped:
+            print(
+                f"All {len(skipped)} issue(s) already in track"
+                f" '{target.name}'."
+            )
+        return 0
+
+    # Write source tracks (consolidated removals).
+    if do_move:
+        for src_name, (src, removals) in source_removals.items():
+            src_issues = [
+                n for n in (src.meta.get("github", {}).get("issues") or [])
+                if n not in removals
+            ]
+            src.meta.setdefault("github", {})["issues"] = src_issues
+            write_file(src.path, src.meta, src.body)
+            removed_str = ", ".join(f"#{n}" for n in sorted(removals))
+            print(f"  ✓ Removed {removed_str} from '{src_name}'.")
+
+    # Write target track once.
+    target.meta.setdefault("github", {})["issues"] = sorted(issues)
+    write_file(target.path, target.meta, target.body)
+
+    slotted_str = ", ".join(f"#{n}" for n in slotted)
+    print(f"✓ Slotted {slotted_str} into '{target.name}'.")
+    if skipped:
+        skipped_str = ", ".join(f"#{n}" for n in skipped)
+        print(f"ℹ Skipped (already in track): {skipped_str}.")
+    return 0

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

@@ -117,21 +117,45 @@ def find_track_by_name(
 
 def discover_archived_tracks(cfg: dict) -> list[Track]:
     """Walk notes_root for archived .md files, and also scan each repo's
-    .work-plan/archive/ for shared archived tracks."""
+    .work-plan/archive/ for shared archived tracks.
+
+    Deduplicates by (repo, name): shared wins over private, same as
+    discover_tracks for active tracks.
+    """
     notes_root = Path(cfg["notes_root"]).expanduser()
-    out = []
+    private_archived: list[Track] = []
     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
-            out.append(_build_track(md_path, notes_root, cfg))
+            private_archived.append(_build_track(md_path, notes_root, cfg))
 
-    # Also scan shared repos' .work-plan/archive/
-    out.extend(_discover_shared_tracks(cfg, include_archive=True,
-                                        archive_only=True))
-    return out
+    shared_archived = _discover_shared_tracks(cfg, include_archive=True,
+                                              archive_only=True)
+
+    # Build lookup for shared tracks keyed by (repo, name)
+    shared_keys: dict = {}
+    for t in shared_archived:
+        key = (t.repo, t.name)
+        shared_keys[key] = t
+
+    # Merge: shared wins on collision
+    merged = list(shared_archived)
+    for t in private_archived:
+        key = (t.repo, t.name)
+        if key in shared_keys:
+            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.",
+                file=sys.stderr,
+            )
+        else:
+            merged.append(t)
+
+    return merged
 
 
 # ---------------------------------------------------------------------------

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

@@ -0,0 +1,291 @@
+"""Tests for the non-interactive batch-slot command (issue #140).
+
+Covers:
+- Slots multiple new issues into a private-repo track → write_file called once, rc 0.
+- Some issues already present → skipped with note, others slotted.
+- All issues already present → no write, prints skip message.
+- Public repo, no token → prints needs_confirm JSON, write_file NOT called, rc 0.
+- Public repo with valid --confirm=<token> → write_file called, rc 0.
+- --move with prior owners → removes issues from sources (consolidated writes).
+- Default / --no-move with prior owners → prior owners NOT modified, note printed.
+- Bad issue number / < 2 positionals → rc 2.
+- Mutually exclusive --move + --no-move → 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 MagicMock, patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import batch_slot
+from lib.write_guard import make_token
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _track(*, name, repo="ok/repo", issues=None, status="active"):
+    return SimpleNamespace(
+        name=name,
+        path=Path(f"/tmp/fake/{name}.md"),
+        body="# fake",
+        meta={
+            "track": name,
+            "status": status,
+            "github": {"repo": repo, "issues": list(issues or [])},
+        },
+        has_frontmatter=True,
+        repo=repo,
+    )
+
+
+def _drive(args, tracks=None, vis="PRIVATE"):
+    """Run batch_slot.run(args) with all external I/O mocked."""
+    if tracks is None:
+        tracks = [_track(name="alpha", repo="ok/repo", issues=[])]
+    cfg = {"notes_root": "/tmp/fake-notes", "repos": {"ok": {"github": "ok/repo"}}}
+    gh_proc = MagicMock(returncode=0, stdout="{}", stderr="")
+
+    with patch("commands.batch_slot.load_config", return_value=cfg), \
+         patch("commands.batch_slot.discover_tracks", return_value=tracks), \
+         patch("commands.batch_slot.subprocess.run", return_value=gh_proc), \
+         patch("lib.write_guard.repo_visibility", return_value=vis), \
+         patch("commands.batch_slot.write_file") as mw:
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = batch_slot.run(args)
+    return rc, mw, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# Test cases
+# ---------------------------------------------------------------------------
+
+class BatchSlotTest(unittest.TestCase):
+
+    # ------------------------------------------------------------------
+    # Basic batch slot (private repo)
+    # ------------------------------------------------------------------
+
+    def test_slots_multiple_new_issues(self):
+        """Slots multiple new issues into a private-repo track → write_file called, rc 0."""
+        track = _track(name="alpha", repo="ok/repo", issues=[10])
+        rc, mw, out = _drive(["30", "40", "alpha"], tracks=[track], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()  # target written once
+        written_meta = mw.call_args[0][1]
+        self.assertIn(10, written_meta["github"]["issues"])
+        self.assertIn(30, written_meta["github"]["issues"])
+        self.assertIn(40, written_meta["github"]["issues"])
+        self.assertEqual(sorted(written_meta["github"]["issues"]),
+                         written_meta["github"]["issues"])
+
+    def test_skips_already_present_issues(self):
+        """Some issues already present → skipped with note, others slotted."""
+        track = _track(name="alpha", repo="ok/repo", issues=[42])
+        rc, mw, out = _drive(["42", "99", "alpha"], tracks=[track], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        written_meta = mw.call_args[0][1]
+        self.assertIn(42, written_meta["github"]["issues"])
+        self.assertIn(99, written_meta["github"]["issues"])
+        self.assertIn("Skipped", out)
+        self.assertIn("42", out)
+        self.assertIn("Slotted", out)
+        self.assertIn("99", out)
+
+    def test_all_already_present_no_write(self):
+        """All issues already present → no write, prints skip message."""
+        track = _track(name="alpha", repo="ok/repo", issues=[42, 99])
+        rc, mw, out = _drive(["42", "99", "alpha"], tracks=[track], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        self.assertIn("already in track", out)
+
+    # ------------------------------------------------------------------
+    # Confirm-token gate (public repo)
+    # ------------------------------------------------------------------
+
+    def test_public_repo_no_token_returns_needs_confirm_json(self):
+        """Public repo, no token → prints needs_confirm JSON, write_file NOT called."""
+        import json
+        track = _track(name="alpha", repo="ok/repo", issues=[])
+        rc, mw, out = _drive(["99", "100", "alpha"], tracks=[track], vis="PUBLIC")
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        data = json.loads(out.strip())
+        self.assertTrue(data["needs_confirm"])
+        self.assertEqual(data["token"], make_token("ok/repo", "alpha"))
+
+    def test_public_repo_with_valid_confirm_performs_write(self):
+        """Public repo with valid --confirm=<token> → write_file called."""
+        track = _track(name="alpha", repo="ok/repo", issues=[])
+        tok = make_token("ok/repo", "alpha")
+        rc, mw, out = _drive(
+            ["99", "100", "alpha", f"--confirm={tok}"],
+            tracks=[track], vis="PUBLIC",
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+
+    def test_public_repo_with_wrong_token_blocks_write(self):
+        """Public repo with wrong confirm token → blocked, no write."""
+        import json
+        track = _track(name="alpha", repo="ok/repo", issues=[])
+        rc, mw, out = _drive(
+            ["99", "alpha", "--confirm=badtoken"],
+            tracks=[track], vis="PUBLIC",
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        data = json.loads(out.strip())
+        self.assertTrue(data["needs_confirm"])
+
+    # ------------------------------------------------------------------
+    # --move / --no-move flags
+    # ------------------------------------------------------------------
+
+    def test_move_removes_issues_from_prior_owners(self):
+        """--move with prior owners → removes issues from sources, writes all."""
+        source = _track(name="alpha", repo="ok/repo", issues=[42, 77])
+        target = _track(name="beta", repo="ok/repo", issues=[])
+        rc, mw, out = _drive(
+            ["42", "77", "beta", "--move"],
+            tracks=[source, target], vis="PRIVATE",
+        )
+        self.assertEqual(rc, 0)
+        # source + target both written
+        self.assertEqual(2, mw.call_count)
+        self.assertEqual([], source.meta["github"]["issues"])
+        self.assertIn(42, target.meta["github"]["issues"])
+        self.assertIn(77, target.meta["github"]["issues"])
+
+    def test_move_consolidates_multi_source_removals(self):
+        """Multiple issues from same prior owner → source written once."""
+        source = _track(name="alpha", repo="ok/repo", issues=[42, 77])
+        target = _track(name="beta", repo="ok/repo", issues=[])
+        rc, mw, out = _drive(
+            ["42", "77", "beta", "--move"],
+            tracks=[source, target], vis="PRIVATE",
+        )
+        self.assertEqual(rc, 0)
+        self.assertEqual(2, mw.call_count)  # source + target, NOT 3
+        # Issues sorted are maintained
+        self.assertEqual(sorted(source.meta["github"]["issues"]),
+                         source.meta["github"]["issues"])
+        self.assertEqual(sorted(target.meta["github"]["issues"]),
+                         target.meta["github"]["issues"])
+
+    def test_default_no_move_preserves_prior_owners(self):
+        """Default (no --move) → prior owners NOT modified; note printed."""
+        source = _track(name="alpha", repo="ok/repo", issues=[42])
+        target = _track(name="beta", repo="ok/repo", issues=[])
+        rc, mw, out = _drive(
+            ["42", "beta"], tracks=[source, target], vis="PRIVATE",
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()  # only target written
+        self.assertIn(42, source.meta["github"]["issues"])
+        self.assertIn(42, target.meta["github"]["issues"])
+        self.assertIn("--move", out)
+
+    def test_explicit_no_move_preserves_prior_owners(self):
+        """Explicit --no-move behaves same as default."""
+        source = _track(name="alpha", repo="ok/repo", issues=[42])
+        target = _track(name="beta", repo="ok/repo", issues=[])
+        rc, mw, out = _drive(
+            ["42", "beta", "--no-move"],
+            tracks=[source, target], vis="PRIVATE",
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertIn(42, source.meta["github"]["issues"])
+        self.assertIn("--move", out)
+
+    # ------------------------------------------------------------------
+    # Error cases
+    # ------------------------------------------------------------------
+
+    def test_less_than_two_positionals_returns_rc2(self):
+        """Fewer than 2 positional args (need at least 1 issue + 1 track) → rc 2."""
+        rc, mw, out = _drive(["42"])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+
+    def test_no_args_returns_rc2(self):
+        """No positional arguments → rc 2."""
+        rc, mw, out = _drive([])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+
+    def test_bad_issue_number_returns_rc2(self):
+        """Non-integer in issue position → rc 2."""
+        rc, mw, out = _drive(["notanumber", "alpha"])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+
+    def test_move_and_no_move_together_returns_rc2(self):
+        """Both --move and --no-move → rc 2."""
+        track = _track(name="alpha", repo="ok/repo", issues=[])
+        rc, mw, out = _drive(
+            ["42", "alpha", "--move", "--no-move"],
+            tracks=[track], vis="PRIVATE",
+        )
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+        self.assertIn("mutually exclusive", out)
+
+    def test_unknown_track_returns_rc1(self):
+        """Track not found → rc 1."""
+        rc, mw, out = _drive(["42", "nonexistent"])
+        self.assertEqual(rc, 1)
+        mw.assert_not_called()
+
+    # ------------------------------------------------------------------
+    # Single issue (degenerate case)
+    # ------------------------------------------------------------------
+
+    def test_single_issue_works_like_slot(self):
+        """A single issue in batch-slot behaves like regular slot."""
+        track = _track(name="alpha", repo="ok/repo", issues=[10])
+        rc, mw, out = _drive(["42", "alpha"], tracks=[track], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        written_meta = mw.call_args[0][1]
+        self.assertIn(42, written_meta["github"]["issues"])
+
+    # ------------------------------------------------------------------
+    # No input() on non-interactive paths
+    # ------------------------------------------------------------------
+
+    def test_no_input_called_on_flagged_paths(self):
+        """Flagged paths (issue + track given) never call input()."""
+        source = _track(name="alpha", repo="ok/repo", issues=[42])
+        target = _track(name="beta", repo="ok/repo", issues=[])
+
+        def _raise(*a, **kw):
+            raise AssertionError("input() must not be called on non-interactive path")
+
+        with patch("builtins.input", side_effect=_raise), \
+             patch("lib.prompts.prompt_input", side_effect=_raise):
+            cfg = {"notes_root": "/tmp/fake-notes", "repos": {"ok": {"github": "ok/repo"}}}
+            gh_proc = MagicMock(returncode=0, stdout="{}", stderr="")
+            with patch("commands.batch_slot.load_config", return_value=cfg), \
+                 patch("commands.batch_slot.discover_tracks", return_value=[source, target]), \
+                 patch("commands.batch_slot.subprocess.run", return_value=gh_proc), \
+                 patch("lib.write_guard.repo_visibility", return_value="PRIVATE"), \
+                 patch("commands.batch_slot.write_file"):
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = batch_slot.run(["42", "beta", "--move"])
+        self.assertEqual(rc, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -380,6 +380,71 @@ class DiscoverArchivedSharedTest(unittest.TestCase):
         slugs = [a.meta.get("track") for a in archived]
         self.assertIn("old", slugs)
 
+    def test_archived_collision_shared_wins(self):
+        """When (repo, name) collides in archived tracks, shared wins + warns."""
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            # Shared archived track
+            _write_track_md(
+                clone / ".work-plan" / "archive" / "shipped.md",
+                "shipped", "org/repo", status="shipped",
+            )
+            # Private archived track with SAME name in notes_root
+            notes = base / "notes"
+            _write_track_md(
+                notes / "repo" / "archive" / "shipped.md",
+                "shipped", "org/repo", status="shipped",
+            )
+            cfg = {
+                "notes_root": str(notes),
+                "repos": {
+                    "repo": {"github": "org/repo", "local": str(clone)},
+                },
+            }
+
+            stderr_buf = io.StringIO()
+            with patch("sys.stderr", stderr_buf):
+                archived = discover_archived_tracks(cfg)
+
+            # Exactly one entry for "shipped"
+            shipped = [t for t in archived if t.name == "shipped"]
+            self.assertEqual(len(shipped), 1)
+            self.assertEqual(shipped[0].tier, "shared")
+            # Warning was emitted
+            self.assertIn("WARN:", stderr_buf.getvalue())
+            self.assertIn("shipped", stderr_buf.getvalue())
+
+    def test_archived_no_collision_no_warning(self):
+        """Different names in shared/private archives → no warning, both returned."""
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            _write_track_md(
+                clone / ".work-plan" / "archive" / "shared-archived.md",
+                "shared-archived", "org/repo", status="shipped",
+            )
+            notes = base / "notes"
+            _write_track_md(
+                notes / "repo" / "archive" / "private-archived.md",
+                "private-archived", "org/repo", status="shipped",
+            )
+            cfg = {
+                "notes_root": str(notes),
+                "repos": {
+                    "repo": {"github": "org/repo", "local": str(clone)},
+                },
+            }
+
+            stderr_buf = io.StringIO()
+            with patch("sys.stderr", stderr_buf):
+                archived = discover_archived_tracks(cfg)
+
+            names = [t.name for t in archived]
+            self.assertIn("shared-archived", names)
+            self.assertIn("private-archived", names)
+            self.assertNotIn("WARN:", stderr_buf.getvalue())
+
 
 if __name__ == "__main__":
     unittest.main()

package/skills/work-plan/work_plan.py

@@ -31,6 +31,7 @@ SUBCOMMANDS = {
     "orient": "commands.where_was_i",
     "--orient": "commands.where_was_i",   # flag-style alias
     "slot": "commands.slot",
+    "batch-slot": "commands.batch_slot",
     "close": "commands.close",
     "refresh-md": "commands.refresh_md",
     "list": "commands.list_cmd",
@@ -72,6 +73,10 @@ DESCRIPTIONS = [
      "Add a GitHub issue to a track's frontmatter. If the issue is already in another active track in the same repo, prompts to move it (remove from source) rather than duplicate. Use --repo=<key> or track@repo to disambiguate when the same track slug exists in multiple repos.",
      "When a new GitHub issue is filed and you want it associated with a track — or when an existing issue was relabeled and needs to move tracks.",
      "/work-plan slot 4234 tabletop"),
+    ("batch-slot", "<issue-num>... <track | track@repo> [--repo=<key>] [--move|--no-move]",
+     "Slot multiple GitHub issues into a track at once. The last positional argument is the track; everything before it is an issue number. Skips issues already in the track. Use --move to remove issues from any prior owning tracks.",
+     "After bulk-triage with auto-triage or group — when several issues need the same track assignment.",
+     "/work-plan batch-slot 100 101 102 tabletop --move"),
     ("close", "<track | track@repo> [--repo=<key>]",
      "Retire a track: shipped / parked / abandoned. Moves to archive/. Use --repo=<key> or track@repo to disambiguate when the same track slug exists in multiple repos.",
      "When a track is done, paused, or won't ship — frees mental space.",