@stylusnexus/work-plan 2026.6.9

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

@@ -0,0 +1,292 @@
+"""Tests for the non-interactive set-notes-root command (issue #87, Phase 3a).
+
+Covers:
+- set-notes-root /some/new/path → yq called with correct expression, mkdir
+  called, rc 0.
+- Missing positional path → rc 2, no yq call.
+- Orphan warning: current notes_root differs and discover_tracks returns ≥1
+  track → WARN line printed but rc 0 and yq still called.
+- No warning when new path equals current notes_root.
+- No warning when discover_tracks returns no tracks.
+- yq failure (CalledProcessError) → rc 1.
+- Subcommand registered in SUBCOMMANDS and DESCRIPTIONS.
+- Non-interactive guard: input()/prompt_input patched to raise, must not fire.
+"""
+import io
+import subprocess
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest.mock import patch, MagicMock, call
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+import work_plan
+from commands import set_notes_root
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_cfg(*, notes_root="/tmp/old-notes"):
+    return {"notes_root": notes_root, "repos": {}}
+
+
+def _fake_track():
+    """Return a minimal Track-like object (just needs to be truthy in a list)."""
+    t = MagicMock()
+    t.has_frontmatter = True
+    return t
+
+
+def _drive(args, *, cfg_notes_root="/tmp/old-notes", tracks=None, yq_raises=False):
+    """Run set_notes_root.run(args) with all external I/O mocked.
+
+    cfg_notes_root: the current notes_root recorded in config.
+    tracks: list returned by discover_tracks (default []).
+    yq_raises: if True, subprocess.run raises CalledProcessError.
+    """
+    cfg = _make_cfg(notes_root=cfg_notes_root)
+    if tracks is None:
+        tracks = []
+
+    mock_proc = MagicMock(returncode=0, stdout="", stderr="")
+
+    if yq_raises:
+        err = subprocess.CalledProcessError(1, ["yq"], stderr="yq error")
+        sub_side = err
+    else:
+        sub_side = None
+
+    with patch("commands.set_notes_root.load_config", return_value=cfg), \
+         patch("commands.set_notes_root.discover_tracks", return_value=tracks), \
+         patch("commands.set_notes_root.subprocess.run",
+               return_value=mock_proc,
+               side_effect=sub_side) as msub, \
+         patch("pathlib.Path.mkdir") as mmkdir:
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = set_notes_root.run(args)
+    return rc, msub, mmkdir, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# Test cases
+# ---------------------------------------------------------------------------
+
+class SetNotesRootTest(unittest.TestCase):
+
+    # ------------------------------------------------------------------
+    # Happy path: updates config and creates dir
+    # ------------------------------------------------------------------
+
+    def test_happy_path_calls_yq_and_mkdir(self):
+        """set-notes-root /some/new/path → yq -i called with the absolute path
+        expression, mkdir called, rc 0."""
+        rc, msub, mmkdir, out = _drive(
+            ["/some/new/path"],
+            cfg_notes_root="/tmp/old-notes",
+        )
+        self.assertEqual(rc, 0)
+
+        # yq must have been called
+        msub.assert_called_once()
+        yq_args = msub.call_args[0][0]
+        self.assertEqual(yq_args[0], "yq")
+        self.assertEqual(yq_args[1], "-i")
+        # Expression must set .notes_root to the absolute path. The command
+        # resolves the input to an absolute path, which on Windows uses a drive
+        # letter + backslashes — so compare against the same resolution, not the
+        # raw POSIX input string.
+        expected = str(Path("/some/new/path").expanduser().resolve())
+        expr = yq_args[2]
+        self.assertIn(".notes_root", expr)
+        self.assertIn(expected, expr)
+
+        # mkdir must have been called (creates the dir)
+        mmkdir.assert_called_once()
+
+        # Success confirmation in output
+        self.assertIn("✓", out)
+        self.assertIn(expected, out)
+
+    def test_yq_receives_config_path_as_last_arg(self):
+        """yq -i call passes DEFAULT_CONFIG_PATH as the file argument."""
+        from lib.config import DEFAULT_CONFIG_PATH
+        rc, msub, mmkdir, out = _drive(["/new/path"])
+        self.assertEqual(rc, 0)
+        yq_args = msub.call_args[0][0]
+        self.assertEqual(yq_args[-1], str(DEFAULT_CONFIG_PATH))
+
+    # ------------------------------------------------------------------
+    # Missing positional → rc 2
+    # ------------------------------------------------------------------
+
+    def test_missing_path_returns_rc2(self):
+        """No positional argument → rc 2, yq NOT called."""
+        rc, msub, mmkdir, out = _drive([])
+        self.assertEqual(rc, 2)
+        msub.assert_not_called()
+        self.assertIn("usage", out.lower())
+
+    # ------------------------------------------------------------------
+    # Orphan warning: tracks exist at old root
+    # ------------------------------------------------------------------
+
+    def test_orphan_warning_when_tracks_exist_and_root_differs(self):
+        """New path differs from current, discover_tracks returns 1 track →
+        WARN line printed, rc 0, yq still called."""
+        tracks = [_fake_track()]
+        rc, msub, mmkdir, out = _drive(
+            ["/some/new/path"],
+            cfg_notes_root="/tmp/old-notes",
+            tracks=tracks,
+        )
+        self.assertEqual(rc, 0)
+        msub.assert_called_once()
+        self.assertIn("WARN", out)
+
+    def test_orphan_warning_names_count(self):
+        """Orphan warning mentions the track count."""
+        tracks = [_fake_track(), _fake_track(), _fake_track()]
+        rc, msub, mmkdir, out = _drive(
+            ["/brand/new/path"],
+            cfg_notes_root="/tmp/old-notes",
+            tracks=tracks,
+        )
+        self.assertEqual(rc, 0)
+        self.assertIn("3", out)
+
+    def test_orphan_warning_mentions_not_moved(self):
+        """Orphan warning states tracks will NOT be moved."""
+        tracks = [_fake_track()]
+        rc, msub, mmkdir, out = _drive(
+            ["/brand/new/path"],
+            cfg_notes_root="/tmp/old-notes",
+            tracks=tracks,
+        )
+        self.assertIn("WARN", out)
+        # The warning should communicate non-movement
+        out_lower = out.lower()
+        self.assertTrue(
+            "not" in out_lower or "won't" in out_lower or "manual" in out_lower,
+            f"Expected move-warning language in: {out!r}",
+        )
+
+    # ------------------------------------------------------------------
+    # No warning when new path equals current notes_root
+    # ------------------------------------------------------------------
+
+    def test_no_warning_when_path_unchanged(self):
+        """New path resolves to same location as current → no WARN, rc 0."""
+        tracks = [_fake_track()]
+        rc, msub, mmkdir, out = _drive(
+            ["/tmp/old-notes"],
+            cfg_notes_root="/tmp/old-notes",
+            tracks=tracks,
+        )
+        self.assertEqual(rc, 0)
+        self.assertNotIn("WARN", out)
+
+    # ------------------------------------------------------------------
+    # No warning when there are no tracks
+    # ------------------------------------------------------------------
+
+    def test_no_warning_when_no_tracks(self):
+        """Paths differ but no tracks → no WARN, rc 0."""
+        rc, msub, mmkdir, out = _drive(
+            ["/some/new/path"],
+            cfg_notes_root="/tmp/old-notes",
+            tracks=[],
+        )
+        self.assertEqual(rc, 0)
+        self.assertNotIn("WARN", out)
+
+    # ------------------------------------------------------------------
+    # yq failure → rc 1
+    # ------------------------------------------------------------------
+
+    def test_yq_failure_returns_rc1(self):
+        """CalledProcessError from yq → error message printed, rc 1."""
+        rc, msub, mmkdir, out = _drive(
+            ["/some/new/path"],
+            yq_raises=True,
+        )
+        self.assertEqual(rc, 1)
+        self.assertIn("ERROR", out)
+
+    # ------------------------------------------------------------------
+    # Subcommand registration
+    # ------------------------------------------------------------------
+
+    def test_subcommand_registered_in_subcommands(self):
+        """'set-notes-root' appears in work_plan.SUBCOMMANDS."""
+        self.assertIn("set-notes-root", work_plan.SUBCOMMANDS)
+
+    def test_subcommand_registered_in_descriptions(self):
+        """'set-notes-root' appears in work_plan.DESCRIPTIONS."""
+        names = [entry[0] for entry in work_plan.DESCRIPTIONS]
+        self.assertIn("set-notes-root", names)
+
+    def test_subcommand_module_path(self):
+        """SUBCOMMANDS['set-notes-root'] points to commands.set_notes_root."""
+        self.assertEqual(
+            work_plan.SUBCOMMANDS["set-notes-root"],
+            "commands.set_notes_root",
+        )
+
+    # ------------------------------------------------------------------
+    # Non-interactive guard
+    # ------------------------------------------------------------------
+
+    def test_no_input_called_happy_path(self):
+        """Happy path must not call input() or prompt_input."""
+        cfg = _make_cfg(notes_root="/tmp/old-notes")
+        mock_proc = MagicMock(returncode=0, stdout="", stderr="")
+
+        def _raise(*a, **kw):
+            raise AssertionError(
+                "input() must not be called — command must be non-interactive"
+            )
+
+        with patch("builtins.input", side_effect=_raise), \
+             patch("lib.prompts.prompt_input", side_effect=_raise), \
+             patch("lib.prompts.prompt_yes_no", side_effect=_raise), \
+             patch("commands.set_notes_root.load_config", return_value=cfg), \
+             patch("commands.set_notes_root.discover_tracks", return_value=[]), \
+             patch("commands.set_notes_root.subprocess.run", return_value=mock_proc), \
+             patch("pathlib.Path.mkdir"):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = set_notes_root.run(["/some/path"])
+        self.assertEqual(rc, 0)
+
+    def test_no_input_called_with_tracks(self):
+        """Orphan warning path must also not call input()."""
+        cfg = _make_cfg(notes_root="/tmp/old-notes")
+        mock_proc = MagicMock(returncode=0, stdout="", stderr="")
+        tracks = [_fake_track()]
+
+        def _raise(*a, **kw):
+            raise AssertionError(
+                "input() must not be called — command must be non-interactive"
+            )
+
+        with patch("builtins.input", side_effect=_raise), \
+             patch("lib.prompts.prompt_input", side_effect=_raise), \
+             patch("lib.prompts.prompt_yes_no", side_effect=_raise), \
+             patch("commands.set_notes_root.load_config", return_value=cfg), \
+             patch("commands.set_notes_root.discover_tracks", return_value=tracks), \
+             patch("commands.set_notes_root.subprocess.run", return_value=mock_proc), \
+             patch("pathlib.Path.mkdir"):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = set_notes_root.run(["/some/new/path"])
+        self.assertEqual(rc, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,243 @@
+"""Tests for the non-interactive slot command (issue #87, Phase 3a).
+
+Covers:
+- Slots a new issue into a private-repo track → write_file called, rc 0.
+- Issue already present → no write, rc 0, prints "already in".
+- 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 a prior owner → removes issue from prior owner (two writes).
+- Default / --no-move with a prior owner → prior owner NOT modified (one write)
+  and "still listed … --move" note is printed.
+- Bad issue number / no positional → rc 2.
+- No input() is reached on the non-interactive flagged paths.
+"""
+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 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 slot.run(args) with all external I/O mocked.
+
+    vis controls what repo_visibility returns (used by needs_confirm).
+    tracks defaults to a single empty private-repo track named 'alpha'.
+    """
+    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.slot.load_config", return_value=cfg), \
+         patch("commands.slot.discover_tracks", return_value=tracks), \
+         patch("commands.slot.subprocess.run", return_value=gh_proc), \
+         patch("lib.write_guard.repo_visibility", return_value=vis), \
+         patch("commands.slot.write_file") as mw:
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = slot.run(args)
+    return rc, mw, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# Test cases
+# ---------------------------------------------------------------------------
+
+class SlotNonInteractiveTest(unittest.TestCase):
+
+    # ------------------------------------------------------------------
+    # Basic slot (private repo)
+    # ------------------------------------------------------------------
+
+    def test_slots_new_issue_into_private_track(self):
+        """Slots a new issue into a private-repo track → write_file called, rc 0."""
+        track = _track(name="alpha", repo="ok/repo", issues=[10, 20])
+        rc, mw, out = _drive(["30", "alpha"], tracks=[track], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        written_meta = mw.call_args[0][1]
+        self.assertIn(30, written_meta["github"]["issues"])
+        # Issues are sorted
+        self.assertEqual(sorted(written_meta["github"]["issues"]),
+                         written_meta["github"]["issues"])
+
+    def test_already_present_no_write(self):
+        """Issue already present → no write, rc 0, prints 'already in'."""
+        track = _track(name="alpha", repo="ok/repo", issues=[42])
+        rc, mw, out = _drive(["42", "alpha"], tracks=[track], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        self.assertIn("already in", 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, rc 0."""
+        import json
+        track = _track(name="alpha", repo="ok/repo", issues=[])
+        rc, mw, out = _drive(["99", "alpha"], tracks=[track], vis="PUBLIC")
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        # Output should be parseable JSON with needs_confirm key
+        data = json.loads(out.strip())
+        self.assertTrue(data["needs_confirm"])
+        self.assertEqual(data["token"], make_token("ok/repo", "alpha"))
+
+    def test_public_repo_unknown_visibility_returns_needs_confirm_json(self):
+        """Unknown visibility (None) → also requires confirm."""
+        import json
+        track = _track(name="alpha", repo="ok/repo", issues=[])
+        rc, mw, out = _drive(["99", "alpha"], tracks=[track], vis=None)
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        data = json.loads(out.strip())
+        self.assertTrue(data["needs_confirm"])
+
+    def test_public_repo_with_valid_confirm_performs_write(self):
+        """Public repo with valid --confirm=<token> → write_file called, rc 0."""
+        track = _track(name="alpha", repo="ok/repo", issues=[])
+        tok = make_token("ok/repo", "alpha")
+        rc, mw, out = _drive(["99", "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_flag_removes_issue_from_prior_owner(self):
+        """--move with a prior owner → removes issue from source, writes both."""
+        source = _track(name="alpha", repo="ok/repo", issues=[42])
+        target = _track(name="beta", repo="ok/repo", issues=[])
+        rc, mw, out = _drive(["42", "beta", "--move"],
+                              tracks=[source, target], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        self.assertEqual(2, mw.call_count,
+                         "source + target should both be written with --move")
+        self.assertNotIn(42, source.meta["github"]["issues"])
+        self.assertIn(42, target.meta["github"]["issues"])
+
+    def test_default_no_move_preserves_prior_owner(self):
+        """Default (no flags) with a prior owner → prior owner 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
+        # Source is untouched
+        self.assertIn(42, source.meta["github"]["issues"])
+        self.assertIn(42, target.meta["github"]["issues"])
+        # Note about --move must be printed
+        self.assertIn("--move", out)
+        self.assertIn("alpha", out)
+
+    def test_explicit_no_move_preserves_prior_owner(self):
+        """Explicit --no-move behaves same as default: prior owner NOT modified."""
+        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(42, target.meta["github"]["issues"])
+        self.assertIn("--move", out)
+
+    # ------------------------------------------------------------------
+    # Error cases
+    # ------------------------------------------------------------------
+
+    def test_no_positional_args_returns_rc2(self):
+        """No positional arguments → rc 2 (usage error)."""
+        rc, mw, out = _drive([])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+
+    def test_bad_issue_number_returns_rc2(self):
+        """Non-integer issue number → 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):
+        """Passing both --move and --no-move → rc 2, write_file NOT called."""
+        track = _track(name="alpha", repo="ok/repo", issues=[42])
+        rc, mw, out = _drive(["42", "alpha", "--move", "--no-move"], tracks=[track], vis="PRIVATE")
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+        self.assertIn("ERROR", out)
+        self.assertIn("mutually exclusive", out)
+
+    # ------------------------------------------------------------------
+    # No input() on non-interactive paths
+    # ------------------------------------------------------------------
+
+    def test_no_input_called_on_flagged_paths(self):
+        """Flagged paths (issue + track given) never call input() even if
+        prior owners exist or a public repo is detected."""
+        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.slot.load_config", return_value=cfg), \
+                 patch("commands.slot.discover_tracks", return_value=[source, target]), \
+                 patch("commands.slot.subprocess.run", return_value=gh_proc), \
+                 patch("lib.write_guard.repo_visibility", return_value="PRIVATE"), \
+                 patch("commands.slot.write_file"):
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    # --move (prior owner path) + private repo (no confirm gate)
+                    rc = slot.run(["42", "beta", "--move"])
+        self.assertEqual(rc, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,128 @@
+"""Tests for slot's prior-ownership detection (issue #62).
+
+Before #62, `slot` was add-only — running `slot 4562 chat-nlu` while #4562 was
+already listed in `ai-generators.md` frontmatter would leave the issue in BOTH
+tracks. The only fix was hand-editing YAML, which SKILL.md explicitly warns
+against. These tests pin the non-interactive behavior introduced in #87:
+detect prior ownership, and move only on explicit --move so non-interactive
+runs preserve add-only semantics by default.
+"""
+import sys
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import slot
+
+
+def _track(*, name, repo, issues, 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)},
+        },
+        has_frontmatter=True,
+        repo=repo,
+    )
+
+
+class SlotMoveTest(unittest.TestCase):
+    def _drive(self, *, tracks, args):
+        cfg = {"notes_root": "/tmp/fake-notes",
+               "repos": {"ok": {"github": "ok/ok"}}}
+        gh_proc = MagicMock(returncode=0, stdout="{}", stderr="")
+        with patch("commands.slot.subprocess.run", return_value=gh_proc), \
+             patch("commands.slot.load_config", return_value=cfg), \
+             patch("commands.slot.discover_tracks", return_value=tracks), \
+             patch("lib.write_guard.repo_visibility", return_value="PRIVATE"), \
+             patch("commands.slot.write_file") as mw:
+            rc = slot.run(args)
+        return rc, mw
+
+    def test_no_prior_ownership_writes_only_target(self):
+        target = _track(name="alpha", repo="ok/ok", issues=[])
+        rc, mw = self._drive(tracks=[target], args=["100", "alpha"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertEqual(100, target.meta["github"]["issues"][0])
+
+    def test_prior_ownership_with_move_flag_removes_from_source(self):
+        source = _track(name="alpha", repo="ok/ok", issues=[42])
+        target = _track(name="beta", repo="ok/ok", issues=[])
+        rc, mw = self._drive(
+            tracks=[source, target], args=["42", "beta", "--move"],
+        )
+        self.assertEqual(rc, 0)
+        self.assertEqual(2, mw.call_count, "source + target should both be written")
+        self.assertEqual([], source.meta["github"]["issues"])
+        self.assertEqual([42], target.meta["github"]["issues"])
+
+    def test_prior_ownership_without_move_flag_preserves_add_only(self):
+        # Default (no --move flag) → pre-#62 behavior: target gets the issue,
+        # source is untouched (duplicated state that reconcile can later FLAG).
+        source = _track(name="alpha", repo="ok/ok", issues=[42])
+        target = _track(name="beta", repo="ok/ok", issues=[])
+        rc, mw = self._drive(
+            tracks=[source, target], args=["42", "beta"],
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertEqual([42], source.meta["github"]["issues"])
+        self.assertEqual([42], target.meta["github"]["issues"])
+
+    def test_explicit_no_move_flag_preserves_add_only(self):
+        # --no-move behaves identically to the default.
+        source = _track(name="alpha", repo="ok/ok", issues=[42])
+        target = _track(name="beta", repo="ok/ok", issues=[])
+        rc, mw = self._drive(
+            tracks=[source, target], args=["42", "beta", "--no-move"],
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertEqual([42], source.meta["github"]["issues"])
+
+    def test_already_in_target_short_circuits(self):
+        # Issue already listed in target → no write.
+        source = _track(name="alpha", repo="ok/ok", issues=[42])
+        target = _track(name="beta", repo="ok/ok", issues=[42])
+        rc, mw = self._drive(
+            tracks=[source, target], args=["42", "beta"],
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+
+    def test_cross_repo_issue_not_detected_as_prior_owner(self):
+        # Same number in a different repo is a different issue. The prior-
+        # owner sweep MUST filter by track.repo or it will spuriously offer
+        # to move unrelated issues across repos.
+        other_repo = _track(name="alpha", repo="other/repo", issues=[42])
+        target = _track(name="beta", repo="ok/ok", issues=[])
+        rc, mw = self._drive(
+            tracks=[other_repo, target], args=["42", "beta"],
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertEqual([42], other_repo.meta["github"]["issues"])
+
+    def test_inactive_source_not_detected_as_prior_owner(self):
+        # Archived/parked tracks shouldn't be candidates — moving FROM a
+        # closed track is the wrong mental model; that's a reopen, not a slot.
+        parked = _track(name="alpha", repo="ok/ok", issues=[42], status="parked")
+        target = _track(name="beta", repo="ok/ok", issues=[])
+        rc, mw = self._drive(
+            tracks=[parked, target], args=["42", "beta"],
+        )
+        self.assertEqual(rc, 0)
+        self.assertEqual([42], parked.meta["github"]["issues"])
+
+
+if __name__ == "__main__":
+    unittest.main()