@stylusnexus/work-plan 2026.6.9 → 2026.6.10

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

@@ -0,0 +1,351 @@
+"""Tests for the auto-triage subcommand."""
+import io
+import json
+import sys
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch, MagicMock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import auto_triage
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_cfg(folder="myrepo", github="org/myrepo"):
+    return {
+        "notes_root": "/tmp/notes",
+        "repos": {folder: {"github": github, "local": f"/tmp/{folder}"}},
+    }
+
+
+def _make_track(name, repo, issue_nums, status="active", slug=None):
+    return SimpleNamespace(
+        name=name,
+        repo=repo,
+        has_frontmatter=True,
+        path=Path(f"/tmp/notes/{name}.md"),
+        body="",
+        meta={
+            "track": slug or name,
+            "status": status,
+            "launch_priority": "P2",
+            "milestone_alignment": "v1",
+            "github": {"repo": repo, "issues": list(issue_nums)},
+        },
+    )
+
+
+def _open_issues(*numbers):
+    return [{"number": n, "title": f"Issue {n}", "state": "OPEN",
+             "milestone": None, "labels": []} for n in numbers]
+
+
+def _drive_prepare(args, *, cfg, tracks, open_issues):
+    buf = io.StringIO()
+    with patch("commands.auto_triage.load_config", return_value=cfg), \
+         patch("commands.auto_triage.discover_tracks", return_value=tracks), \
+         patch("commands.auto_triage.fetch_open_issues", return_value=open_issues), \
+         patch("commands.auto_triage._batch_path") as mbatch, \
+         patch("commands.auto_triage._answers_path"):
+        # Use a real temp file so write_text works
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            mbatch.return_value = Path(f.name)
+        with redirect_stdout(buf):
+            rc = auto_triage.run(args)
+    return rc, buf.getvalue(), mbatch.return_value
+
+
+def _drive_apply(*, cfg, tracks, batch, answers):
+    """Run auto_triage._apply with mocked filesystem and frontmatter calls."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        batch_file = Path(tmpdir) / "auto_triage.json"
+        answers_file = Path(tmpdir) / "auto_triage.answers.json"
+        batch_file.write_text(json.dumps(batch), encoding="utf-8")
+        answers_file.write_text(json.dumps(answers), encoding="utf-8")
+
+        with patch("commands.auto_triage._batch_path", return_value=batch_file), \
+             patch("commands.auto_triage._answers_path", return_value=answers_file), \
+             patch("commands.auto_triage.load_config", return_value=cfg), \
+             patch("commands.auto_triage.discover_tracks", return_value=tracks), \
+             patch("commands.auto_triage.parse_file",
+                   side_effect=lambda p: (tracks[0].meta.copy()
+                                         if tracks else {}, "")) as mparse, \
+             patch("commands.auto_triage.write_file") as mwrite:
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = auto_triage._apply(cfg)
+        return rc, mwrite, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# Prepare step tests
+# ---------------------------------------------------------------------------
+
+class AutoTriagePrepareTest(unittest.TestCase):
+
+    def test_prints_prompt_with_tracks_and_issues(self):
+        cfg = _make_cfg()
+        tracks = [_make_track("auth-flow", "org/myrepo", [1, 2])]
+        rc, out, _ = _drive_prepare([], cfg=cfg, tracks=tracks,
+                                    open_issues=_open_issues(1, 2, 3, 4))
+        self.assertEqual(rc, 0)
+        self.assertIn("auth-flow", out)
+        self.assertIn("Issue 3", out)
+        self.assertIn("Issue 4", out)
+        # tracked issues should NOT appear in untracked list
+        self.assertNotIn("Issue 1", out)
+        self.assertNotIn("Issue 2", out)
+
+    def test_no_untracked_issues_exits_clean(self):
+        cfg = _make_cfg()
+        tracks = [_make_track("auth-flow", "org/myrepo", [1, 2])]
+        rc, out, _ = _drive_prepare([], cfg=cfg, tracks=tracks,
+                                    open_issues=_open_issues(1, 2))
+        self.assertEqual(rc, 0)
+        self.assertIn("full coverage", out)
+
+    def test_no_active_tracks_exits_with_guidance(self):
+        cfg = _make_cfg()
+        parked = _make_track("old-track", "org/myrepo", [1], status="parked")
+        rc, out, _ = _drive_prepare([], cfg=cfg, tracks=[parked],
+                                    open_issues=_open_issues(1, 2))
+        self.assertEqual(rc, 0)
+        self.assertIn("group", out)
+
+    def test_multiple_repos_requires_repo_flag(self):
+        cfg = {"notes_root": "/tmp", "repos": {
+            "repoA": {"github": "org/repoA"},
+            "repoB": {"github": "org/repoB"},
+        }}
+        rc, out, _ = _drive_prepare([], cfg=cfg, tracks=[],
+                                    open_issues=[])
+        self.assertEqual(rc, 1)
+        self.assertIn("Specify with --repo", out)
+
+    def test_repo_flag_filters_to_one_repo(self):
+        cfg = {"notes_root": "/tmp", "repos": {
+            "repoA": {"github": "org/repoA"},
+            "repoB": {"github": "org/repoB"},
+        }}
+        tracks = [_make_track("t1", "org/repoA", [1])]
+        rc, out, _ = _drive_prepare(["--repo=repoA"], cfg=cfg, tracks=tracks,
+                                    open_issues=_open_issues(1, 2))
+        self.assertEqual(rc, 0)
+        self.assertIn("repoA", out)
+
+    def test_unknown_repo_flag_returns_error(self):
+        cfg = _make_cfg()
+        rc, out, _ = _drive_prepare(["--repo=nope"], cfg=cfg, tracks=[],
+                                    open_issues=[])
+        self.assertEqual(rc, 1)
+        self.assertIn("ERROR", out)
+
+    def test_batch_file_written_with_correct_fields(self):
+        cfg = _make_cfg()
+        tracks = [_make_track("auth-flow", "org/myrepo", [1])]
+        with tempfile.TemporaryDirectory() as tmpdir:
+            batch_file = Path(tmpdir) / "auto_triage.json"
+            buf = io.StringIO()
+            with patch("commands.auto_triage.load_config", return_value=cfg), \
+                 patch("commands.auto_triage.discover_tracks", return_value=tracks), \
+                 patch("commands.auto_triage.fetch_open_issues",
+                       return_value=_open_issues(1, 2, 3)), \
+                 patch("commands.auto_triage._batch_path", return_value=batch_file), \
+                 patch("commands.auto_triage._answers_path",
+                       return_value=Path(tmpdir) / "answers.json"), \
+                 redirect_stdout(buf):
+                auto_triage.run([])
+            stored = json.loads(batch_file.read_text())
+        self.assertEqual(stored["repo"], "org/myrepo")
+        self.assertEqual(stored["folder"], "myrepo")
+        self.assertEqual(len(stored["untracked"]), 2)  # 1 is tracked
+        self.assertEqual(len(stored["tracks"]), 1)
+        self.assertEqual(stored["tracks"][0]["slug"], "auth-flow")
+
+    def test_limit_truncates_with_more_issues(self):
+        """When untracked count exceeds --limit, show first N + truncation hint."""
+        cfg = _make_cfg()
+        tracks = [_make_track("auth-flow", "org/myrepo", [])]
+        issues = _open_issues(*range(1, 110))  # 109 untracked
+        rc, out, _ = _drive_prepare(["--limit=10"], cfg=cfg, tracks=tracks,
+                                    open_issues=issues)
+        self.assertEqual(rc, 0)
+        self.assertIn("Issue 1", out)
+        self.assertIn("Issue 10", out)
+        self.assertNotIn("Issue 11", out)
+        self.assertIn("and 99 more", out)
+        self.assertIn("--limit", out)
+
+    def test_limit_at_or_below_count_shows_all(self):
+        """When untracked count is within --limit, show all with no truncation."""
+        cfg = _make_cfg()
+        tracks = [_make_track("auth-flow", "org/myrepo", [])]
+        issues = _open_issues(1, 2, 3)
+        rc, out, _ = _drive_prepare([], cfg=cfg, tracks=tracks,
+                                    open_issues=issues)
+        self.assertEqual(rc, 0)
+        self.assertIn("Issue 1", out)
+        self.assertIn("Issue 2", out)
+        self.assertIn("Issue 3", out)
+        self.assertNotIn("more issues", out)
+
+
+# ---------------------------------------------------------------------------
+# Apply step tests
+# ---------------------------------------------------------------------------
+
+class AutoTriageApplyTest(unittest.TestCase):
+
+    def _simple_batch(self):
+        return {
+            "repo": "org/myrepo",
+            "folder": "myrepo",
+            "untracked": [{"number": 3, "title": "Issue 3"},
+                          {"number": 4, "title": "Issue 4"}],
+            "tracks": [{"slug": "auth-flow"}],
+        }
+
+    def test_apply_slots_issues_into_track(self):
+        cfg = _make_cfg()
+        track = _make_track("auth-flow", "org/myrepo", [1, 2])
+        answers = [{"track": "auth-flow", "issues": [3, 4]}]
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            batch_file = Path(tmpdir) / "auto_triage.json"
+            answers_file = Path(tmpdir) / "auto_triage.answers.json"
+            batch_file.write_text(json.dumps(self._simple_batch()))
+            answers_file.write_text(json.dumps(answers))
+
+            with patch("commands.auto_triage._batch_path", return_value=batch_file), \
+                 patch("commands.auto_triage._answers_path", return_value=answers_file), \
+                 patch("commands.auto_triage.load_config", return_value=cfg), \
+                 patch("commands.auto_triage.discover_tracks", return_value=[track]), \
+                 patch("commands.auto_triage.parse_file",
+                       return_value=(track.meta.copy(), "")) as mparse, \
+                 patch("commands.auto_triage.write_file") as mwrite:
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = auto_triage._apply(cfg)
+
+        self.assertEqual(rc, 0)
+        mwrite.assert_called_once()
+        written_meta = mwrite.call_args[0][1]
+        self.assertIn(3, written_meta["github"]["issues"])
+        self.assertIn(4, written_meta["github"]["issues"])
+
+    def test_apply_skips_already_tracked_issues(self):
+        cfg = _make_cfg()
+        track = _make_track("auth-flow", "org/myrepo", [1, 2, 3])  # 3 already there
+        answers = [{"track": "auth-flow", "issues": [3, 4]}]  # 3 dup, 4 new
+
+        batch = {
+            "repo": "org/myrepo", "folder": "myrepo",
+            "untracked": [{"number": 4, "title": "Issue 4"}],
+            "tracks": [{"slug": "auth-flow"}],
+        }
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            batch_file = Path(tmpdir) / "b.json"
+            answers_file = Path(tmpdir) / "a.json"
+            batch_file.write_text(json.dumps(batch))
+            answers_file.write_text(json.dumps(answers))
+
+            with patch("commands.auto_triage._batch_path", return_value=batch_file), \
+                 patch("commands.auto_triage._answers_path", return_value=answers_file), \
+                 patch("commands.auto_triage.load_config", return_value=cfg), \
+                 patch("commands.auto_triage.discover_tracks", return_value=[track]), \
+                 patch("commands.auto_triage.parse_file",
+                       return_value=(track.meta.copy(), "")), \
+                 patch("commands.auto_triage.write_file") as mwrite:
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = auto_triage._apply(cfg)
+
+        self.assertEqual(rc, 0)
+        # write_file called once for issue 4 (issue 3 not in batch untracked → no write)
+        # Actually 4 is new, so write_file should be called
+        mwrite.assert_called_once()
+        out = buf.getvalue()
+        self.assertIn("already present", out)  # note about #3
+
+    def test_apply_unknown_track_in_answers_warns_and_skips(self):
+        cfg = _make_cfg()
+        track = _make_track("auth-flow", "org/myrepo", [1])
+        answers = [{"track": "nonexistent-track", "issues": [3]}]
+
+        batch = {
+            "repo": "org/myrepo", "folder": "myrepo",
+            "untracked": [{"number": 3, "title": "Issue 3"}],
+            "tracks": [],
+        }
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            batch_file = Path(tmpdir) / "b.json"
+            answers_file = Path(tmpdir) / "a.json"
+            batch_file.write_text(json.dumps(batch))
+            answers_file.write_text(json.dumps(answers))
+
+            with patch("commands.auto_triage._batch_path", return_value=batch_file), \
+                 patch("commands.auto_triage._answers_path", return_value=answers_file), \
+                 patch("commands.auto_triage.load_config", return_value=cfg), \
+                 patch("commands.auto_triage.discover_tracks", return_value=[track]), \
+                 patch("commands.auto_triage.parse_file", return_value=({}, "")), \
+                 patch("commands.auto_triage.write_file") as mwrite:
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = auto_triage._apply(cfg)
+
+        self.assertEqual(rc, 0)
+        mwrite.assert_not_called()
+        self.assertIn("WARN", buf.getvalue())
+
+    def test_apply_missing_answers_file_returns_error(self):
+        cfg = _make_cfg()
+        with patch("commands.auto_triage._answers_path",
+                   return_value=Path("/nonexistent/answers.json")), \
+             patch("commands.auto_triage._batch_path",
+                   return_value=Path("/nonexistent/batch.json")):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = auto_triage._apply(cfg)
+        self.assertEqual(rc, 1)
+        self.assertIn("ERROR", buf.getvalue())
+
+    def test_apply_empty_answers_does_nothing(self):
+        cfg = _make_cfg()
+        track = _make_track("auth-flow", "org/myrepo", [1])
+        batch = {
+            "repo": "org/myrepo", "folder": "myrepo",
+            "untracked": [{"number": 3, "title": "Issue 3"}],
+            "tracks": [{"slug": "auth-flow"}],
+        }
+        with tempfile.TemporaryDirectory() as tmpdir:
+            batch_file = Path(tmpdir) / "b.json"
+            answers_file = Path(tmpdir) / "a.json"
+            batch_file.write_text(json.dumps(batch))
+            answers_file.write_text(json.dumps([]))
+
+            with patch("commands.auto_triage._batch_path", return_value=batch_file), \
+                 patch("commands.auto_triage._answers_path", return_value=answers_file), \
+                 patch("commands.auto_triage.load_config", return_value=cfg), \
+                 patch("commands.auto_triage.discover_tracks", return_value=[track]), \
+                 patch("commands.auto_triage.write_file") as mwrite:
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = auto_triage._apply(cfg)
+
+        self.assertEqual(rc, 0)
+        mwrite.assert_not_called()
+        self.assertIn("0 issue(s) assigned", buf.getvalue())
+
+
+if __name__ == "__main__":
+    unittest.main()

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()