@stylusnexus/work-plan 2026.6.9-1

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

@@ -0,0 +1,348 @@
+"""Tests for group --apply tier-aware routing — Phase C."""
+import io
+import json
+import sys
+import tempfile
+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))
+
+from commands import group
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_cfg(*, notes_root, repo_entry=None):
+    if repo_entry is None:
+        repo_entry = {
+            "github": "org/myrepo",
+            "local": "/home/user/projects/myrepo",
+        }
+    return {
+        "notes_root": str(notes_root),
+        "repos": {"myrepo": repo_entry},
+    }
+
+
+def _make_batch(*, repo="org/myrepo", folder="myrepo", milestone="v1.0",
+                private=False, issues=None):
+    if issues is None:
+        issues = [
+            {"number": 1, "title": "Issue one", "milestone": None,
+             "labels": [], "assignees": [], "state": "OPEN"},
+            {"number": 2, "title": "Issue two", "milestone": None,
+             "labels": [], "assignees": [], "state": "OPEN"},
+        ]
+    return {
+        "repo": repo, "folder": folder, "milestone": milestone,
+        "private": private, "issues": issues,
+    }
+
+
+def _make_answers(slug="auth-flow", name="Auth Flow", summary="Auth stuff",
+                  issues=None):
+    if issues is None:
+        issues = [1, 2]
+    return [{"slug": slug, "name": name, "summary": summary, "issues": issues}]
+
+
+def _drive_apply(args, *, cfg, batch, answers, vis="PRIVATE"):
+    """Run group._apply with mocked filesystem and gh calls.
+
+    Uses real temp files for batch/answers (so Path.exists() on them works),
+    and patches Path.exists only for track paths (the per-cluster slug files).
+    """
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Write batch and answers to REAL temp files
+        batch_file = Path(tmpdir) / "groups.json"
+        answers_file = Path(tmpdir) / "groups.answers.json"
+        batch_file.write_text(json.dumps(batch), encoding="utf-8")
+        answers_file.write_text(json.dumps(answers), encoding="utf-8")
+
+        # Track the path that _apply will try to write slug.md files to
+        # For shared route: <local>/.work-plan/<slug>.md
+        # For private route: notes_root/folder/<slug>.md
+        # We need Path.exists() to return False for those track files but
+        # True for the batch/answers files that already exist on disk.
+        # Solution: only patch Path.exists for paths that don't actually exist.
+
+        with patch("commands.group._batch_path", return_value=batch_file), \
+             patch("commands.group._answers_path", return_value=answers_file), \
+             patch("commands.group.load_config", return_value=cfg), \
+             patch("lib.write_guard.repo_visibility", return_value=vis), \
+             patch("commands.group.is_valid_git_repo", return_value=True), \
+             patch("commands.group.write_file") as mw, \
+             patch("commands.group.parse_file", return_value=({}, "")), \
+             patch("commands.group.seed_readme") as mseed, \
+             patch("pathlib.Path.mkdir"):
+            # Patch Path.exists to return True for the batch/answers files,
+            # False for track files (slug.md paths that don't exist yet).
+            _real_exists = Path.exists
+
+            def _selective_exists(self):
+                # Real files on disk → use real check
+                if str(self) in (str(batch_file), str(answers_file)):
+                    return True
+                # Track directory for shared route: let it appear to exist
+                # so _apply doesn't error out trying to mkdir and fails
+                # Use Path.name (not endswith) so Windows backslash paths match too.
+                _name = Path(self).name
+                if _name == ".work-plan" or _name == "myrepo":
+                    return True
+                # Track .md files: pretend they don't exist (trigger create path)
+                if str(self).endswith(".md"):
+                    return False
+                # Everything else: real check
+                return _real_exists(self)
+
+            with patch("pathlib.Path.exists", _selective_exists):
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = group._apply(cfg, args)
+        return rc, mw, mseed, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+class GroupApplyTierRoutingTest(unittest.TestCase):
+
+    def test_apply_with_valid_clone_routes_to_work_plan_dir(self):
+        """group --apply with a valid clone routes track to .work-plan/<slug>.md."""
+        notes_root = "/tmp/fake-notes"
+        cfg = _make_cfg(notes_root=notes_root)
+        batch = _make_batch()
+        answers = _make_answers()
+
+        rc, mw, mseed, out = _drive_apply([], cfg=cfg, batch=batch,
+                                          answers=answers, vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        written_path = mw.call_args[0][0]
+        # Path should be under .work-plan/, not notes_root
+        self.assertIn(".work-plan", str(written_path))
+        self.assertNotIn("fake-notes", str(written_path))
+
+    def test_apply_private_flag_routes_to_notes_root(self):
+        """group --apply --private routes to notes_root/folder/<slug>.md."""
+        notes_root = "/tmp/fake-notes"
+        cfg = _make_cfg(notes_root=notes_root)
+        batch = _make_batch(private=False)  # Not private in batch
+        answers = _make_answers()
+
+        # But --private in args overrides
+        rc, mw, mseed, out = _drive_apply(["--apply", "--private"],
+                                          cfg=cfg, batch=batch,
+                                          answers=answers, vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        written_path = mw.call_args[0][0]
+        # Path should NOT be under .work-plan/
+        self.assertNotIn(".work-plan", str(written_path))
+
+    def test_apply_private_in_batch_routes_to_notes_root(self):
+        """group --apply with private=True stored in batch routes to notes_root."""
+        notes_root = "/tmp/fake-notes"
+        cfg = _make_cfg(notes_root=notes_root)
+        batch = _make_batch(private=True)  # Private stored in batch
+        answers = _make_answers()
+
+        # No --private in args, but batch says private
+        rc, mw, mseed, out = _drive_apply(["--apply"],
+                                          cfg=cfg, batch=batch,
+                                          answers=answers, vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        written_path = mw.call_args[0][0]
+        self.assertNotIn(".work-plan", str(written_path))
+
+    def test_apply_shared_route_seeds_readme_when_dir_is_new(self):
+        """group --apply seeds README only when .work-plan/ is newly created."""
+        notes_root = "/tmp/fake-notes"
+        cfg = _make_cfg(notes_root=notes_root)
+        batch = _make_batch()
+        answers = _make_answers()
+
+        # Make the .work-plan dir appear to NOT exist so the mkdir+seed path runs
+        with tempfile.TemporaryDirectory() as tmpdir:
+            batch_file = Path(tmpdir) / "groups.json"
+            answers_file = Path(tmpdir) / "groups.answers.json"
+            batch_file.write_text(json.dumps(batch), encoding="utf-8")
+            answers_file.write_text(json.dumps(answers), encoding="utf-8")
+
+            _real_exists = Path.exists
+
+            def _exists_dir_missing(self):
+                if str(self) in (str(batch_file), str(answers_file)):
+                    return True
+                if str(self).endswith(".work-plan"):
+                    return False  # dir not yet created → triggers mkdir+seed
+                if str(self).endswith(".md"):
+                    return False
+                return _real_exists(self)
+
+            with patch("commands.group._batch_path", return_value=batch_file), \
+                 patch("commands.group._answers_path", return_value=answers_file), \
+                 patch("commands.group.load_config", return_value=cfg), \
+                 patch("lib.write_guard.repo_visibility", return_value="PRIVATE"), \
+                 patch("commands.group.is_valid_git_repo", return_value=True), \
+                 patch("commands.group.write_file"), \
+                 patch("commands.group.parse_file", return_value=({}, "")), \
+                 patch("commands.group.seed_readme") as mseed, \
+                 patch("pathlib.Path.mkdir"), \
+                 patch("pathlib.Path.exists", _exists_dir_missing):
+                group._apply(cfg, [])
+
+            mseed.assert_called_once()
+            seeded_path = mseed.call_args[0][0]
+            self.assertIn(".work-plan", str(seeded_path))
+
+    def test_apply_shared_route_no_readme_resurrection(self):
+        """group --apply does NOT call seed_readme when .work-plan/ already exists."""
+        notes_root = "/tmp/fake-notes"
+        cfg = _make_cfg(notes_root=notes_root)
+        batch = _make_batch()
+        answers = _make_answers()
+
+        # Default _drive_apply mocks .work-plan as existing → seed_readme not called
+        rc, mw, mseed, out = _drive_apply([], cfg=cfg, batch=batch,
+                                          answers=answers, vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mseed.assert_not_called()
+
+    def test_apply_private_route_does_not_seed_readme(self):
+        """group --apply --private does NOT call seed_readme."""
+        notes_root = "/tmp/fake-notes"
+        cfg = _make_cfg(notes_root=notes_root)
+        batch = _make_batch()
+        answers = _make_answers()
+
+        rc, mw, mseed, out = _drive_apply(["--apply", "--private"],
+                                          cfg=cfg, batch=batch,
+                                          answers=answers, vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mseed.assert_not_called()
+
+    def test_apply_shared_route_public_repo_prints_headsup(self):
+        """group --apply on a public repo → heads-up printed, non-blocking."""
+        notes_root = "/tmp/fake-notes"
+        cfg = _make_cfg(notes_root=notes_root)
+        batch = _make_batch()
+        answers = _make_answers()
+
+        rc, mw, mseed, out = _drive_apply([], cfg=cfg, batch=batch,
+                                          answers=answers, vis="PUBLIC")
+        # Non-blocking: rc 0 and write_file still called
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertIn("HEADS-UP", out)
+        self.assertIn("PUBLIC", out)
+
+    def test_apply_shared_route_unknown_vis_prints_headsup(self):
+        """group --apply with unknown visibility → heads-up printed."""
+        notes_root = "/tmp/fake-notes"
+        cfg = _make_cfg(notes_root=notes_root)
+        batch = _make_batch()
+        answers = _make_answers()
+
+        rc, mw, mseed, out = _drive_apply([], cfg=cfg, batch=batch,
+                                          answers=answers, vis=None)
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertIn("HEADS-UP", out)
+
+    def test_apply_shared_route_new_track_prints_shared_hint(self):
+        """group --apply shared route → new track file gets commit+push hint."""
+        notes_root = "/tmp/fake-notes"
+        cfg = _make_cfg(notes_root=notes_root)
+        batch = _make_batch()
+        answers = _make_answers()
+
+        rc, mw, mseed, out = _drive_apply([], cfg=cfg, batch=batch,
+                                          answers=answers, vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        self.assertIn("shared", out)
+        self.assertIn("commit + push", out)
+
+    def test_apply_private_route_no_shared_hint(self):
+        """group --apply --private → no commit+push hint."""
+        notes_root = "/tmp/fake-notes"
+        cfg = _make_cfg(notes_root=notes_root)
+        batch = _make_batch()
+        answers = _make_answers()
+
+        rc, mw, mseed, out = _drive_apply(["--apply", "--private"],
+                                          cfg=cfg, batch=batch,
+                                          answers=answers, vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        # No shared hint on the private route
+        self.assertNotIn("commit + push", out)
+
+    def test_prepare_step_stores_private_flag_in_batch(self):
+        """group (prepare step) with --private stores 'private': True in batch JSON."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            notes_root = Path(tmpdir) / "notes"
+            notes_root.mkdir()
+            cfg = _make_cfg(notes_root=str(notes_root))
+            batch_file = Path(tmpdir) / "groups.json"
+
+            issues = [
+                {"number": 1, "title": "T1", "milestone": None,
+                 "labels": [], "assignees": [], "state": "OPEN"},
+            ]
+
+            with patch("commands.group.load_config", return_value=cfg), \
+                 patch("commands.group._batch_path", return_value=batch_file), \
+                 patch("commands.group._answers_path",
+                       return_value=Path(tmpdir) / "groups.answers.json"), \
+                 patch("subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(
+                    returncode=0, stdout=json.dumps(issues), stderr=""
+                )
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = group.run(["--repo=myrepo", "--private"])
+
+            self.assertEqual(rc, 0)
+            stored = json.loads(batch_file.read_text())
+            self.assertTrue(stored.get("private"))
+
+    def test_prepare_step_without_private_flag_stores_false(self):
+        """group (prepare) without --private stores 'private': False in batch."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            notes_root = Path(tmpdir) / "notes"
+            notes_root.mkdir()
+            cfg = _make_cfg(notes_root=str(notes_root))
+            batch_file = Path(tmpdir) / "groups.json"
+
+            issues = [
+                {"number": 1, "title": "T1", "milestone": None,
+                 "labels": [], "assignees": [], "state": "OPEN"},
+            ]
+
+            with patch("commands.group.load_config", return_value=cfg), \
+                 patch("commands.group._batch_path", return_value=batch_file), \
+                 patch("commands.group._answers_path",
+                       return_value=Path(tmpdir) / "groups.answers.json"), \
+                 patch("subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(
+                    returncode=0, stdout=json.dumps(issues), stderr=""
+                )
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = group.run(["--repo=myrepo"])
+
+            self.assertEqual(rc, 0)
+            stored = json.loads(batch_file.read_text())
+            self.assertFalse(stored.get("private"))
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,73 @@
+"""Tests that handoff self-heals canonical-table drift (issue #77).
+
+handoff updates existing rows' status via update_row_status but, before #77,
+never appended rows for frontmatter issues missing from the table. These tests
+drive the derived handoff path (git skipped via local_path=None + no prior
+handoff) and assert the missing rows are appended.
+"""
+import io
+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 handoff
+from lib.status_table import find_canonical_status_tables, ISSUE_NUM_RE
+
+CANON_HEADER = (
+    "## Issues (canonical)\n\n"
+    "<!-- canonical-issue-table — auto-managed. -->\n\n"
+    "| # | Title | Assignee | Status |\n"
+    "|---|---|---|---|\n"
+)
+
+
+def _track():
+    body = (CANON_HEADER
+            + "| #1 | first | — | 🔲 Open |\n"
+            + "| #2 | second | — | ✅ Shipped |\n"
+            + "\n---\n\n## Notes\n\nnarrative\n")
+    return SimpleNamespace(
+        name="platform-health",
+        path=Path("/tmp/fake/platform-health.md"),
+        body=body,
+        meta={"track": "platform-health", "status": "active",
+              "github": {"repo": "o/r", "issues": [1, 2, 30, 40]}},
+        has_frontmatter=True,
+        repo="o/r",
+        local_path=None,  # skips all git attribution paths
+    )
+
+
+def _issue(num, title, state="OPEN"):
+    return {"number": num, "title": title, "state": state, "assignees": []}
+
+
+class HandoffAppendTest(unittest.TestCase):
+    def test_derived_handoff_appends_missing_rows(self):
+        track = _track()
+        issues = [_issue(1, "first"), _issue(2, "second", "CLOSED"),
+                  _issue(30, "third"), _issue(40, "fourth", "CLOSED")]
+        with patch("commands.handoff.fetch_issues", return_value=issues), \
+             patch("commands.handoff.write_file") as mw:
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = handoff._derived_handoff(track)
+
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        new_body = mw.call_args[0][2]
+        table = find_canonical_status_tables(new_body)[0]
+        nums = [int(ISSUE_NUM_RE.search(r["cells"][0]).group(1)) for r in table["rows"]]
+        self.assertEqual(nums, [1, 2, 30, 40])
+        self.assertIn("| #30 | third | — | 🔲 Open |", new_body)
+        self.assertIn("| #40 | fourth | — | ✅ Shipped |", new_body)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,152 @@
+"""Tests for handoff commit-attribution helpers: path-glob attribution
+(`github.paths`) and the repo-wide commit counter that drives the soft
+'silence is expected' signal.
+"""
+import sys
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from datetime import datetime
+
+from commands import handoff
+
+
+def _track(meta_github, local_path="/tmp/repo"):
+    return SimpleNamespace(
+        meta={"github": meta_github},
+        local_path=local_path,
+    )
+
+
+def _proc(stdout="", returncode=0):
+    return SimpleNamespace(stdout=stdout, returncode=returncode, stderr="")
+
+
+SINCE = datetime(2026, 4, 29, 0, 0, 0)
+
+
+class RecentCommitsPathGlobsTest(unittest.TestCase):
+    def test_path_glob_attributes_commit_with_no_issue_ref(self):
+        """A commit whose subject doesn't mention any tracked issue but
+        whose changed paths match `github.paths` should be attributed."""
+        log_output = (
+            "---COMMIT---\nabc1234|fix(useToast): debounce stacking|2026-04-30T10:00:00+00:00\n"
+            "---BODY---\n\n---ENDBODY---\n"
+            "apps/web/src/hooks/useToast.tsx\napps/web/src/hooks/useToast.test.tsx\n\n"
+            "---COMMIT---\ndef5678|chore: bump deps|2026-04-30T09:00:00+00:00\n"
+            "---BODY---\n\n---ENDBODY---\n"
+            "package.json\n"
+        )
+        track = _track({
+            "issues": [4148, 4149],
+            "paths": ["apps/web/src/hooks/useToast*"],
+        })
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout=log_output)):
+            commits = handoff._recent_commits(track, SINCE)
+        self.assertEqual(len(commits), 1)
+        self.assertEqual(commits[0]["sha"], "abc1234")
+
+    def test_issue_ref_still_attributes_when_paths_set(self):
+        """Issue-ref attribution and path attribution are an OR, not AND."""
+        log_output = (
+            "---COMMIT---\nabc1234|fix #4148: tighten guardrails|2026-04-30T10:00:00+00:00\n"
+            "---BODY---\n\n---ENDBODY---\n"
+            "infra/iam/policy.tf\n"
+        )
+        track = _track({
+            "issues": [4148],
+            "paths": ["apps/web/src/hooks/useToast*"],
+        })
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout=log_output)):
+            commits = handoff._recent_commits(track, SINCE)
+        self.assertEqual(len(commits), 1)
+        self.assertEqual(commits[0]["sha"], "abc1234")
+
+    def test_body_issue_ref_attributes_squash_merge_commit(self):
+        """Squash-merged PRs use Conventional Commit subjects with the issue
+        ref in the body (e.g. 'Closes #4148'). Subject scanning alone misses
+        these; body scanning must catch them."""
+        log_output = (
+            "---COMMIT---\nabc1234|feat(adventure): cache regen prompts|2026-04-30T10:00:00+00:00\n"
+            "---BODY---\n"
+            "Reduce duplicate LLM calls when artifacts regenerate.\n"
+            "\n"
+            "Closes #4148\n"
+            "---ENDBODY---\n"
+        )
+        track = _track({"issues": [4148]})
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout=log_output)):
+            commits = handoff._recent_commits(track, SINCE)
+        self.assertEqual(len(commits), 1)
+        self.assertEqual(commits[0]["sha"], "abc1234")
+
+    def test_body_ref_to_untracked_issue_does_not_attribute(self):
+        """A body that references an issue NOT in github.issues must not
+        attribute — otherwise any commit citing any issue would get picked up."""
+        log_output = (
+            "---COMMIT---\nabc1234|chore: unrelated|2026-04-30T10:00:00+00:00\n"
+            "---BODY---\nCloses #9999\n---ENDBODY---\n"
+        )
+        track = _track({"issues": [4148]})
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout=log_output)):
+            commits = handoff._recent_commits(track, SINCE)
+        self.assertEqual(commits, [])
+
+    def test_no_paths_no_issues_returns_empty(self):
+        """A track with neither tracked issues nor path globs gets nothing."""
+        track = _track({"issues": [], "paths": []})
+        with mock.patch("commands.handoff.subprocess.run") as run:
+            commits = handoff._recent_commits(track, SINCE)
+            run.assert_not_called()
+        self.assertEqual(commits, [])
+
+    def test_explicit_branches_skip_path_globs(self):
+        """When `github.branches` is set, paths do not apply (explicit
+        branches are the contract)."""
+        log_output = "abc1234|merge: feature work|2026-04-30T10:00:00+00:00"
+        track = _track({
+            "issues": [4148],
+            "branches": ["feature/x"],
+            "paths": ["should-not-apply/**"],
+        })
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout=log_output)) as run:
+            commits = handoff._recent_commits(track, SINCE)
+            args = run.call_args.args[0]
+            self.assertIn("feature/x", args)
+            self.assertNotIn("--name-only", args)
+        self.assertEqual(len(commits), 1)
+
+
+class RepoCommitsSinceTest(unittest.TestCase):
+    def test_counts_lines_in_log_output(self):
+        out = "sha1\nsha2\nsha3\n"
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout=out)):
+            n = handoff._repo_commits_since(Path("/tmp/repo"), SINCE)
+        self.assertEqual(n, 3)
+
+    def test_returns_zero_on_empty(self):
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout="")):
+            n = handoff._repo_commits_since(Path("/tmp/repo"), SINCE)
+        self.assertEqual(n, 0)
+
+    def test_returns_zero_on_failure(self):
+        with mock.patch("commands.handoff.subprocess.run",
+                        return_value=_proc(stdout="", returncode=128)):
+            n = handoff._repo_commits_since(Path("/tmp/repo"), SINCE)
+        self.assertEqual(n, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()