@stylusnexus/work-plan 2026.6.9-1

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

@@ -0,0 +1,52 @@
+"""Tests for the --repo=<key> filter shared by brief / refresh-md / reconcile / hygiene."""
+import unittest
+import sys
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.tracks import discover_tracks, filter_tracks_by_repo
+
+FIXTURES = Path(__file__).parent / "fixtures" / "notes_root"
+
+
+class FilterTracksByRepoTest(unittest.TestCase):
+    def setUp(self):
+        self.cfg = {
+            "notes_root": str(FIXTURES),
+            "repos": {"critforge": {"github": "stylusnexus/CritForge", "local": None}},
+        }
+        self.tracks = discover_tracks(self.cfg)
+
+    def test_matches_folder_key(self):
+        scoped = filter_tracks_by_repo(self.tracks, "critforge")
+        names = {t.name for t in scoped}
+        self.assertIn("example", names)
+        self.assertNotIn("loose_at_root", names)
+
+    def test_matches_github_slug(self):
+        scoped = filter_tracks_by_repo(self.tracks, "stylusnexus/CritForge")
+        names = {t.name for t in scoped}
+        self.assertIn("example", names)
+
+    def test_case_insensitive(self):
+        scoped = filter_tracks_by_repo(self.tracks, "CRITFORGE")
+        names = {t.name for t in scoped}
+        self.assertIn("example", names)
+
+    def test_unknown_key_returns_empty(self):
+        self.assertEqual(filter_tracks_by_repo(self.tracks, "nonexistent"), [])
+
+    def test_excludes_loose_filing_track(self):
+        scoped = filter_tracks_by_repo(self.tracks, "critforge")
+        for t in scoped:
+            self.assertFalse(t.needs_filing)
+
+    def test_track_folder_field_populated(self):
+        ex = next(t for t in self.tracks if t.name == "example")
+        self.assertEqual(ex.folder, "critforge")
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,117 @@
+"""Regression tests for the /tmp planting hardening (#18).
+
+Covers:
+- lib.scratch.cache_dir() creates ~/.claude/work-plan/cache/ with mode 0700.
+- commands.group._apply() rejects a batch whose `folder` is not in cfg.
+- commands.suggest_priorities._apply() rejects a batch whose `repo` is not in cfg.
+"""
+import json
+import os
+import stat
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib import scratch
+from commands import group, suggest_priorities
+
+
+# POSIX file mode bits aren't honored on Windows NTFS — os.chmod(0o700) is a
+# no-op for directories there and stat.S_IMODE reports 0o777 regardless. The
+# /tmp planting hardening these tests cover is itself a POSIX concern.
+_POSIX_MODE_ONLY = unittest.skipIf(
+    sys.platform == "win32", "POSIX file mode bits not honored on Windows"
+)
+
+
+class CacheDirTest(unittest.TestCase):
+    @_POSIX_MODE_ONLY
+    def test_creates_with_mode_0700(self):
+        with tempfile.TemporaryDirectory() as td:
+            with mock.patch.object(scratch.Path, "home", return_value=Path(td)):
+                p = scratch.cache_dir()
+            self.assertTrue(p.is_dir())
+            self.assertEqual(p, Path(td) / ".claude" / "work-plan" / "cache")
+            mode = stat.S_IMODE(os.stat(p).st_mode)
+            self.assertEqual(mode, 0o700)
+
+    @_POSIX_MODE_ONLY
+    def test_tightens_existing_loose_perms(self):
+        with tempfile.TemporaryDirectory() as td:
+            existing = Path(td) / ".claude" / "work-plan" / "cache"
+            existing.mkdir(parents=True, mode=0o755)
+            self.assertEqual(stat.S_IMODE(os.stat(existing).st_mode), 0o755)
+            with mock.patch.object(scratch.Path, "home", return_value=Path(td)):
+                scratch.cache_dir()
+            self.assertEqual(stat.S_IMODE(os.stat(existing).st_mode), 0o700)
+
+
+class GroupApplyValidationTest(unittest.TestCase):
+    def test_rejects_folder_not_in_cfg(self):
+        with tempfile.TemporaryDirectory() as td:
+            cache = Path(td) / "cache"
+            cache.mkdir()
+            (cache / "groups.json").write_text(json.dumps({
+                "repo": "x/y", "folder": "../../etc",
+                "milestone": "v1", "issues": [],
+            }))
+            (cache / "groups.answers.json").write_text("[]")
+            with mock.patch.object(group, "_batch_path", return_value=cache / "groups.json"), \
+                 mock.patch.object(group, "_answers_path", return_value=cache / "groups.answers.json"):
+                cfg = {"notes_root": td, "repos": {"legitrepo": {"github": "ok/ok"}}}
+                rc = group._apply(cfg)
+            self.assertEqual(rc, 1)
+
+    def test_accepts_folder_in_cfg(self):
+        with tempfile.TemporaryDirectory() as td:
+            cache = Path(td) / "cache"
+            cache.mkdir()
+            notes = Path(td) / "notes"
+            (notes / "legitrepo").mkdir(parents=True)
+            (cache / "groups.json").write_text(json.dumps({
+                "repo": "ok/ok", "folder": "legitrepo",
+                "milestone": "v1", "issues": [],
+            }))
+            (cache / "groups.answers.json").write_text("[]")
+            with mock.patch.object(group, "_batch_path", return_value=cache / "groups.json"), \
+                 mock.patch.object(group, "_answers_path", return_value=cache / "groups.answers.json"):
+                cfg = {"notes_root": str(notes), "repos": {"legitrepo": {"github": "ok/ok"}}}
+                rc = group._apply(cfg)
+            self.assertEqual(rc, 0)
+
+
+class SuggestPrioritiesApplyValidationTest(unittest.TestCase):
+    def test_rejects_repo_not_in_cfg(self):
+        with tempfile.TemporaryDirectory() as td:
+            cache = Path(td) / "cache"
+            cache.mkdir()
+            (cache / "priorities.json").write_text(json.dumps({
+                "repo": "attacker/target", "issues": [],
+            }))
+            (cache / "priorities.answers.json").write_text("[]")
+            with mock.patch.object(suggest_priorities, "_batch_path", return_value=cache / "priorities.json"):
+                cfg = {"repos": {"legitrepo": {"github": "ok/ok"}}}
+                rc = suggest_priorities._apply(cfg)
+            self.assertEqual(rc, 1)
+
+    def test_accepts_repo_in_cfg(self):
+        with tempfile.TemporaryDirectory() as td:
+            cache = Path(td) / "cache"
+            cache.mkdir()
+            (cache / "priorities.json").write_text(json.dumps({
+                "repo": "ok/ok", "issues": [],
+            }))
+            (cache / "priorities.answers.json").write_text("[]")
+            with mock.patch.object(suggest_priorities, "_batch_path", return_value=cache / "priorities.json"):
+                cfg = {"repos": {"legitrepo": {"github": "ok/ok"}}}
+                rc = suggest_priorities._apply(cfg)
+            self.assertEqual(rc, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,39 @@
+"""Tests for session_log."""
+import unittest
+import sys
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.session_log import append_session_log, SESSION_LOG_HEADER
+
+
+class AppendSessionLogTest(unittest.TestCase):
+    def test_appends_under_existing_section(self):
+        body = (
+            "# Track\n\nProse.\n\n"
+            f"{SESSION_LOG_HEADER}\n\n"
+            "### Session — 2026-04-23 22:14\n\n- Touched: prior\n"
+        )
+        new = append_session_log(
+            body, timestamp="2026-04-28 18:30",
+            touched=["#4254 polls"], next_up=["#925 wmsr"], blockers=[],
+        )
+        self.assertIn("### Session — 2026-04-28 18:30", new)
+        self.assertIn("### Session — 2026-04-23 22:14", new)
+        self.assertIn("- Touched: #4254 polls", new)
+
+    def test_creates_section_when_missing(self):
+        body = "# Track\n\nProse.\n"
+        new = append_session_log(
+            body, timestamp="2026-04-28 18:30",
+            touched=["#1 foo"], next_up=["#2 bar"],
+            blockers=[{"number": 3, "reason": "waiting"}],
+        )
+        self.assertIn(SESSION_LOG_HEADER, new)
+        self.assertIn("- Blocker: #3 — waiting", new)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,77 @@
+# tests/test_set_field.py
+import io, sys, 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 set_field
+from lib.write_guard import make_token
+
+def _t(name="ph", repo="o/r"):
+    return SimpleNamespace(name=name, repo=repo, path=Path(f"/tmp/{name}.md"),
+        has_frontmatter=True, meta={"status":"active","github":{"repo":repo}}, body="# b")
+
+def _drive(args, vis="PRIVATE", cfg=None):
+    base_cfg = {"notes_root": "/tmp"}
+    if cfg is not None:
+        base_cfg.update(cfg)
+    with patch("commands.set_field.load_config", return_value=base_cfg), \
+         patch("commands.set_field.discover_tracks", return_value=[_t()]), \
+         patch("lib.write_guard.repo_visibility", return_value=vis), \
+         patch("commands.set_field.write_file") as mw:
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = set_field.run(args)
+    return rc, mw, buf.getvalue()
+
+class SetFieldTest(unittest.TestCase):
+    def test_sets_status_private(self):
+        rc, mw, out = _drive(["ph", "status=parked"])
+        self.assertEqual(rc, 0); mw.assert_called_once()
+        self.assertEqual(mw.call_args[0][1]["status"], "parked")
+    def test_public_blocks_without_confirm(self):
+        rc, mw, out = _drive(["ph", "status=parked"], vis="PUBLIC")
+        self.assertEqual(rc, 0); mw.assert_not_called()
+        self.assertIn("needs_confirm", out)
+    def test_public_with_valid_confirm_writes(self):
+        tok = make_token("o/r", "ph")
+        rc, mw, out = _drive(["ph", "status=parked", f"--confirm={tok}"], vis="PUBLIC")
+        self.assertEqual(rc, 0); mw.assert_called_once()
+        self.assertEqual(mw.call_args[0][1]["status"], "parked")
+    def test_rejects_unknown_field(self):
+        rc, mw, out = _drive(["ph", "bogus=x"])
+        self.assertEqual(rc, 2); mw.assert_not_called()
+    def test_rejects_invalid_status(self):
+        rc, mw, out = _drive(["ph", "status=nonsense"])
+        self.assertEqual(rc, 2); mw.assert_not_called()
+    def test_rejects_non_integer_blockers(self):
+        rc, mw, out = _drive(["ph", "blockers=abc"])
+        self.assertEqual(rc, 2); mw.assert_not_called()
+    def test_repoless_track_writes_without_confirm(self):
+        with patch("commands.set_field.load_config", return_value={"notes_root":"/tmp"}), \
+             patch("commands.set_field.discover_tracks", return_value=[_t(repo=None)]), \
+             patch("commands.set_field.write_file") as mw:
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = set_field.run(["ph", "status=parked"])
+        self.assertEqual(rc, 0); mw.assert_called_once()
+
+    # --- assume_private_when_unknown: caller-level integration ---
+    def test_unknown_vis_with_flag_writes(self):
+        """Unknown visibility + assume_private_when_unknown=True → write proceeds."""
+        rc, mw, out = _drive(
+            ["ph", "status=parked"],
+            vis=None,
+            cfg={"assume_private_when_unknown": True},
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertNotIn("needs_confirm", out)
+
+    def test_unknown_vis_without_flag_emits_needs_confirm(self):
+        """Unknown visibility + no flag → still emits needs_confirm JSON."""
+        rc, mw, out = _drive(["ph", "status=parked"], vis=None)
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        self.assertIn("needs_confirm", out)

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