@stylusnexus/work-plan 2026.6.9-1

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

@@ -0,0 +1,324 @@
+"""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")
+
+
+# ---------------------------------------------------------------------------
+# 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_close.py

@@ -0,0 +1,273 @@
+"""Tests for the non-interactive close command (issue #87, Phase 3a).
+
+Covers:
+- close <track> --state=parked on a PRIVATE repo → status set to parked,
+  write_file called, shutil.move NOT called (stays in place), rc 0.
+- --state=shipped on a private repo → status shipped, write_file called,
+  shutil.move called to archive/shipped/, rc 0.
+- --state=abandoned → moves to archive/abandoned/.
+- Missing --state → rc 2, no write.
+- Invalid --state=bogus → rc 2, no write.
+- --note="wrapped up" → the body passed to write_file contains the ## Wrap-up
+  section with the note.
+- Public repo, no token → prints needs_confirm JSON, no write/move, rc 0;
+  token equals make_token(repo, track.name).
+- Public repo with valid --confirm=<token> → performs the close (write/move
+  happen), rc 0.
+- No input()/prompt_input is reached on the flagged path (patch them to raise).
+"""
+import io
+import json
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import close
+from lib.write_guard import make_token
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _track(*, name="alpha", repo="ok/repo", status="active"):
+    return SimpleNamespace(
+        name=name,
+        path=Path(f"/tmp/fake/{name}.md"),
+        body="# fake body",
+        meta={
+            "track": name,
+            "status": status,
+            "github": {"repo": repo},
+        },
+        has_frontmatter=True,
+        repo=repo,
+    )
+
+
+def _drive(args, track=None, vis="PRIVATE"):
+    """Run close.run(args) with all external I/O mocked.
+
+    vis controls what repo_visibility returns (used by needs_confirm).
+    track defaults to a single private-repo track named 'alpha'.
+    """
+    if track is None:
+        track = _track()
+    # notes_root must be a parent of the track path so relative_to() works
+    cfg = {"notes_root": "/tmp/fake", "repos": {"ok": {"github": "ok/repo"}}}
+
+    with patch("commands.close.load_config", return_value=cfg), \
+         patch("commands.close.discover_tracks", return_value=[track]), \
+         patch("commands.close.find_track_by_name", return_value=track), \
+         patch("lib.write_guard.repo_visibility", return_value=vis), \
+         patch("commands.close.write_file") as mw, \
+         patch("commands.close.shutil") as ms, \
+         patch("pathlib.Path.mkdir"):
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = close.run(args)
+    return rc, mw, ms, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# Test cases
+# ---------------------------------------------------------------------------
+
+class CloseNonInteractiveTest(unittest.TestCase):
+
+    # ------------------------------------------------------------------
+    # State: parked (stays in place)
+    # ------------------------------------------------------------------
+
+    def test_parked_private_write_no_move(self):
+        """close <track> --state=parked on PRIVATE repo → write_file called,
+        shutil.move NOT called, rc 0."""
+        rc, mw, ms, out = _drive(["alpha", "--state=parked"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        # status updated to parked
+        written_meta = mw.call_args[0][1]
+        self.assertEqual(written_meta["status"], "parked")
+        # move must NOT be called for parked
+        ms.move.assert_not_called()
+        self.assertIn("parked", out)
+
+    # ------------------------------------------------------------------
+    # State: shipped (moves to archive/shipped/)
+    # ------------------------------------------------------------------
+
+    def test_shipped_private_write_and_move(self):
+        """--state=shipped on private repo → write_file called, shutil.move
+        called to archive/shipped/, rc 0."""
+        rc, mw, ms, out = _drive(["alpha", "--state=shipped"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        written_meta = mw.call_args[0][1]
+        self.assertEqual(written_meta["status"], "shipped")
+        ms.move.assert_called_once()
+        # Destination path should contain archive/shipped
+        dest_arg = ms.move.call_args[0][1]
+        self.assertIn("archive", dest_arg)
+        self.assertIn("shipped", dest_arg)
+
+    # ------------------------------------------------------------------
+    # State: abandoned (moves to archive/abandoned/)
+    # ------------------------------------------------------------------
+
+    def test_abandoned_private_write_and_move(self):
+        """--state=abandoned → moves to archive/abandoned/."""
+        rc, mw, ms, out = _drive(["alpha", "--state=abandoned"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        written_meta = mw.call_args[0][1]
+        self.assertEqual(written_meta["status"], "abandoned")
+        ms.move.assert_called_once()
+        dest_arg = ms.move.call_args[0][1]
+        self.assertIn("archive", dest_arg)
+        self.assertIn("abandoned", dest_arg)
+
+    # ------------------------------------------------------------------
+    # Missing / invalid --state
+    # ------------------------------------------------------------------
+
+    def test_missing_state_returns_rc2(self):
+        """Missing --state → rc 2, no write."""
+        rc, mw, ms, out = _drive(["alpha"])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+        ms.move.assert_not_called()
+
+    def test_invalid_state_returns_rc2(self):
+        """Invalid --state=bogus → rc 2, no write."""
+        rc, mw, ms, out = _drive(["alpha", "--state=bogus"])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+        ms.move.assert_not_called()
+
+    def test_missing_track_name_returns_rc2(self):
+        """No positional args at all → rc 2 (usage error)."""
+        rc, mw, ms, out = _drive([])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+
+    # ------------------------------------------------------------------
+    # --note flag
+    # ------------------------------------------------------------------
+
+    def test_note_appended_to_body(self):
+        """--note='wrapped up' → body passed to write_file contains
+        ## Wrap-up section with the note."""
+        rc, mw, ms, out = _drive(["alpha", "--state=parked", "--note=wrapped up"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        written_body = mw.call_args[0][2]
+        self.assertIn("## Wrap-up", written_body)
+        self.assertIn("wrapped up", written_body)
+
+    def test_no_note_no_wrap_up_section(self):
+        """No --note flag → body does NOT contain ## Wrap-up section."""
+        rc, mw, ms, out = _drive(["alpha", "--state=parked"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        written_body = mw.call_args[0][2]
+        self.assertNotIn("## Wrap-up", written_body)
+
+    # ------------------------------------------------------------------
+    # Confirm-token gate (public repo)
+    # ------------------------------------------------------------------
+
+    def test_public_repo_no_token_returns_needs_confirm_json(self):
+        """Public repo, no token → prints needs_confirm JSON, no write/move,
+        rc 0; token equals make_token(repo, track.name)."""
+        track = _track(name="alpha", repo="ok/repo")
+        rc, mw, ms, out = _drive(["alpha", "--state=shipped"], track=track, vis="PUBLIC")
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        ms.move.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_unknown_visibility_returns_needs_confirm(self):
+        """Unknown visibility (None) → also requires confirm."""
+        track = _track(name="alpha", repo="ok/repo")
+        rc, mw, ms, out = _drive(["alpha", "--state=parked"], track=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_close(self):
+        """Public repo with valid --confirm=<token> → performs the close
+        (write_file called), rc 0."""
+        track = _track(name="alpha", repo="ok/repo")
+        tok = make_token("ok/repo", "alpha")
+        rc, mw, ms, out = _drive(
+            ["alpha", "--state=parked", f"--confirm={tok}"],
+            track=track, vis="PUBLIC"
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+
+    def test_public_repo_with_valid_confirm_shipped_moves(self):
+        """Public repo with valid --confirm=<token> + --state=shipped →
+        write_file AND shutil.move both called, rc 0."""
+        track = _track(name="alpha", repo="ok/repo")
+        tok = make_token("ok/repo", "alpha")
+        rc, mw, ms, out = _drive(
+            ["alpha", "--state=shipped", f"--confirm={tok}"],
+            track=track, vis="PUBLIC"
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        ms.move.assert_called_once()
+
+    def test_public_repo_wrong_token_blocks_write(self):
+        """Public repo with wrong confirm token → blocked, no write, rc 0."""
+        track = _track(name="alpha", repo="ok/repo")
+        rc, mw, ms, out = _drive(
+            ["alpha", "--state=shipped", "--confirm=wrongtoken"],
+            track=track, vis="PUBLIC"
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        data = json.loads(out.strip())
+        self.assertTrue(data["needs_confirm"])
+
+    # ------------------------------------------------------------------
+    # No input() on non-interactive path
+    # ------------------------------------------------------------------
+
+    def test_no_input_called_on_flagged_path(self):
+        """Flagged paths never call input() or prompt_input, even when
+        --state/--note are provided and the repo is private."""
+        track = _track(name="alpha", repo="ok/repo")
+
+        def _raise(*a, **kw):
+            raise AssertionError("input() must not be called on non-interactive path")
+
+        cfg = {"notes_root": "/tmp/fake-notes", "repos": {"ok": {"github": "ok/repo"}}}
+
+        with patch("builtins.input", side_effect=_raise), \
+             patch("lib.prompts.prompt_input", side_effect=_raise):
+            with patch("commands.close.load_config", return_value=cfg), \
+                 patch("commands.close.discover_tracks", return_value=[track]), \
+                 patch("commands.close.find_track_by_name", return_value=track), \
+                 patch("lib.write_guard.repo_visibility", return_value="PRIVATE"), \
+                 patch("commands.close.write_file"), \
+                 patch("commands.close.shutil"), \
+                 patch("pathlib.Path.mkdir"):
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = close.run(["alpha", "--state=parked", "--note=done"])
+        self.assertEqual(rc, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()