@stylusnexus/work-plan 2026.6.9

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

@@ -0,0 +1,46 @@
+"""Smoke test: importable + main() exists."""
+import io
+import unittest
+import sys
+from contextlib import redirect_stderr, redirect_stdout
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+import work_plan
+
+
+class SmokeTest(unittest.TestCase):
+    def test_main_exists(self):
+        self.assertTrue(callable(work_plan.main))
+
+    def test_main_no_args_returns_2(self):
+        self.assertEqual(work_plan.main(["work_plan.py"]), 2)
+
+    def test_version_loads_from_file(self):
+        # VERSION lives at the repo root in source mode and next to work_plan.py
+        # in installed mode. The loader walks upward; either layout must produce
+        # a non-empty string. Guards against future moves of the VERSION file.
+        v = work_plan._load_version()
+        self.assertTrue(v, "VERSION file unreachable from work_plan.py")
+        self.assertNotEqual(v, "unknown",
+                            "VERSION file present but resolved to 'unknown' fallback")
+
+    def test_version_flag_prints_and_exits_zero(self):
+        for flag in ("--version", "-v"):
+            with self.subTest(flag=flag):
+                out_buf = io.StringIO()
+                err_buf = io.StringIO()
+                with redirect_stdout(out_buf), redirect_stderr(err_buf):
+                    rc = work_plan.main(["work_plan.py", flag])
+                out = out_buf.getvalue().strip()
+                err = err_buf.getvalue()
+                self.assertEqual(rc, 0)
+                self.assertTrue(out, f"{flag} produced empty stdout")
+                self.assertIn(work_plan.VERSION, out)
+                self.assertEqual(err, "", f"{flag} wrote to stderr: {err!r}")
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,79 @@
+"""Tests for idempotent status-header stamping."""
+import unittest
+import sys
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.status_header import BEGIN, END, render_block, stamp
+
+ROW = {
+    "glyph": "✅", "verdict": "shipped",
+    "files_present": 9, "files_declared": 9,
+    "last_touched": "2026-04-02",
+}
+
+
+class RenderBlockTest(unittest.TestCase):
+    def test_block_is_delimited_and_evidence_only(self):
+        block = render_block(ROW)
+        self.assertTrue(block.startswith(BEGIN))
+        self.assertTrue(block.rstrip().endswith(END))
+        self.assertIn("shipped", block)
+        self.assertIn("9/9 files", block)
+        self.assertIn("2026-04-02", block)
+
+    def test_none_last_touched_renders_unknown(self):
+        row = dict(ROW, last_touched=None)
+        self.assertIn("unknown", render_block(row))
+
+
+class StampTest(unittest.TestCase):
+    DOC = "# My Plan\n\nSome body text.\n"
+
+    def test_inserts_after_h1(self):
+        out = stamp(self.DOC, ROW)
+        self.assertIn(BEGIN, out)
+        self.assertLess(out.index(BEGIN), out.index("Some body text."))
+        self.assertGreater(out.index(BEGIN), out.index("# My Plan"))
+
+    def test_idempotent_same_evidence_zero_diff(self):
+        once = stamp(self.DOC, ROW)
+        twice = stamp(once, ROW)
+        self.assertEqual(once, twice)
+
+    def test_rewrites_only_block_on_evidence_change(self):
+        once = stamp(self.DOC, ROW)
+        changed = stamp(once, dict(ROW, files_present=5, verdict="partial"))
+        self.assertNotEqual(once, changed)
+        self.assertEqual(changed.count(BEGIN), 1)
+        self.assertIn("partial", changed)
+        self.assertNotIn("shipped", changed)
+
+    def test_prepends_when_no_h1(self):
+        out = stamp("no heading here\n", ROW)
+        self.assertTrue(out.startswith(BEGIN))
+
+    def test_duplicate_blocks_collapse_to_one_fresh(self):
+        # Two stale blocks (e.g. from a bad merge) -> one fresh, no stale leftover.
+        block = render_block(dict(ROW, verdict="partial", files_present=1))
+        doc = f"# Plan\n\n{block}\n\nbody\n\n{block}\n"
+        out = stamp(doc, ROW)
+        self.assertEqual(out.count(BEGIN), 1)
+        self.assertEqual(out.count(END), 1)
+        self.assertIn("shipped", out)
+        self.assertNotIn("partial", out)
+        self.assertEqual(out, stamp(out, ROW))   # stable on re-run
+
+    def test_dangling_begin_does_not_duplicate(self):
+        # An orphan BEGIN (no END) must not cause a second block to be stacked.
+        doc = f"# Plan\n\n{BEGIN}\n> **Status:** truncated\n\nbody\n"
+        out = stamp(doc, ROW)
+        self.assertEqual(out.count(BEGIN), 1)
+        self.assertEqual(out.count(END), 1)
+        self.assertEqual(out, stamp(out, ROW))   # idempotent afterward
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,162 @@
+"""Tests for status_table parser/updater."""
+import unittest
+import sys
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.status_table import (
+    find_status_table, update_row_status, ISSUE_NUM_RE,
+    render_issue_row, append_rows, sync_missing_rows,
+    find_canonical_status_tables, CANONICAL_MARKER,
+)
+
+FIXTURES = Path(__file__).parent / "fixtures"
+
+
+def _canonical_body(rows):
+    """Build a body with a canonical issue table containing the given rows.
+
+    `rows` is a list of pre-rendered row strings (without leading/trailing
+    newline). A trailing narrative section is included to prove appends land
+    before it, not at end-of-body.
+    """
+    lines = [
+        "## Issues (canonical)",
+        "",
+        f"{CANONICAL_MARKER} — auto-managed. -->",
+        "",
+        "| # | Title | Assignee | Status |",
+        "|---|---|---|---|",
+    ]
+    lines.extend(rows)
+    lines.extend(["", "---", "", "## Notes", "", "Some narrative here."])
+    return "\n".join(lines)
+
+
+class FindStatusTableTest(unittest.TestCase):
+    def test_finds_table_with_status_col(self):
+        body = (FIXTURES / "with_status_table.md").read_text()
+        table = find_status_table(body)
+        self.assertIsNotNone(table)
+        self.assertEqual(table["status_col_index"], 2)
+        self.assertEqual(len(table["rows"]), 3)
+
+    def test_returns_none_when_no_status_table(self):
+        self.assertIsNone(find_status_table("# Just text"))
+
+
+class UpdateRowStatusTest(unittest.TestCase):
+    def test_updates_one_row(self):
+        body = (FIXTURES / "with_status_table.md").read_text()
+        new = update_row_status(body, 4254, "✅ Shipped (PR #9999)")
+        self.assertIn("✅ Shipped (PR #9999)", new)
+        self.assertIn("✅ Shipped ", new)
+
+
+class RenderIssueRowTest(unittest.TestCase):
+    def test_renders_canonical_row_shape(self):
+        row = render_issue_row(487, "fix the thing", "@alice", "🔲 Open")
+        self.assertEqual(row, "| #487 | fix the thing | @alice | 🔲 Open |")
+
+
+class AppendRowsTest(unittest.TestCase):
+    def test_inserts_after_last_row_before_narrative(self):
+        body = _canonical_body(["| #678 | a | — | 🔲 Open |"])
+        table = find_canonical_status_tables(body)[0]
+        new = append_rows(body, table, ["| #999 | b | — | 🔲 Open |"])
+        lines = new.split("\n")
+        # New row sits directly after the existing data row...
+        self.assertEqual(lines[7], "| #999 | b | — | 🔲 Open |")
+        # ...and the narrative section survives below it.
+        self.assertIn("## Notes", new)
+        self.assertLess(new.index("#999"), new.index("## Notes"))
+
+    def test_no_rows_is_noop(self):
+        body = _canonical_body(["| #678 | a | — | 🔲 Open |"])
+        table = find_canonical_status_tables(body)[0]
+        self.assertEqual(append_rows(body, table, []), body)
+
+
+class SyncMissingRowsTest(unittest.TestCase):
+    def test_appends_missing_in_frontmatter_order(self):
+        body = _canonical_body([
+            "| #678 | first | — | 🔲 Open |",
+            "| #925 | second | — | ✅ Shipped |",
+        ])
+        # Frontmatter lists three more than the table, deliberately out of
+        # numeric order to prove frontmatter order (not sort) is honored.
+        frontmatter_nums = [678, 925, 5195, 487, 2196]
+        issues_by_num = {
+            5195: {"number": 5195, "title": "newer", "state": "OPEN",
+                   "assignees": [{"login": "bob"}]},
+            487: {"number": 487, "title": "older", "state": "CLOSED", "assignees": []},
+            2196: {"number": 2196, "title": "mid", "state": "OPEN", "assignees": []},
+        }
+        new, added = sync_missing_rows(body, frontmatter_nums, issues_by_num)
+        self.assertEqual(added, 3)
+        table = find_canonical_status_tables(new)[0]
+        nums = [int(ISSUE_NUM_RE.search(r["cells"][0]).group(1)) for r in table["rows"]]
+        self.assertEqual(nums, [678, 925, 5195, 487, 2196])
+        self.assertIn("| #5195 | newer | @bob | 🔲 Open |", new)
+        self.assertIn("| #487 | older | — | ✅ Shipped |", new)
+
+    def test_slots_low_rank_row_above_existing(self):
+        # The #79 case: frontmatter lists #487 first, but it's missing from a
+        # table whose existing rows start at #678. Option A slots #487 to the
+        # top instead of tacking it onto the end.
+        body = _canonical_body([
+            "| #678 | first | — | 🔲 Open |",
+            "| #2528 | last | — | ✅ Shipped |",
+        ])
+        frontmatter_nums = [487, 678, 1556, 2528, 5195]
+        issues_by_num = {
+            487: {"number": 487, "title": "earliest", "state": "OPEN", "assignees": []},
+            1556: {"number": 1556, "title": "middle", "state": "OPEN", "assignees": []},
+            5195: {"number": 5195, "title": "newest", "state": "OPEN", "assignees": []},
+        }
+        new, added = sync_missing_rows(body, frontmatter_nums, issues_by_num)
+        self.assertEqual(added, 3)
+        table = find_canonical_status_tables(new)[0]
+        nums = [int(ISSUE_NUM_RE.search(r["cells"][0]).group(1)) for r in table["rows"]]
+        # Full table order now mirrors frontmatter: #487 at top, #1556 between
+        # #678 and #2528, #5195 at the end.
+        self.assertEqual(nums, frontmatter_nums)
+        # Existing rows are re-emitted verbatim (minimal diff).
+        self.assertIn("| #678 | first | — | 🔲 Open |", new)
+        self.assertIn("| #2528 | last | — | ✅ Shipped |", new)
+
+    def test_unranked_existing_row_imposes_no_constraint(self):
+        # A row whose issue isn't in frontmatter (manual addition) shouldn't
+        # block a missing row from slotting past it.
+        body = _canonical_body([
+            "| #9001 | manual | — | 🔲 Open |",
+            "| #678 | tracked | — | 🔲 Open |",
+        ])
+        new, added = sync_missing_rows(
+            body, [487, 678],
+            {487: {"number": 487, "title": "early", "state": "OPEN", "assignees": []}},
+        )
+        self.assertEqual(added, 1)
+        table = find_canonical_status_tables(new)[0]
+        nums = [int(ISSUE_NUM_RE.search(r["cells"][0]).group(1)) for r in table["rows"]]
+        # #487 slots immediately before #678 (its frontmatter successor),
+        # leaving the unranked #9001 put.
+        self.assertEqual(nums, [9001, 487, 678])
+
+    def test_no_drift_is_noop(self):
+        body = _canonical_body(["| #678 | first | — | 🔲 Open |"])
+        new, added = sync_missing_rows(body, [678], {678: {"number": 678}})
+        self.assertEqual(added, 0)
+        self.assertEqual(new, body)
+
+    def test_missing_issue_without_fetched_data_still_appends(self):
+        body = _canonical_body(["| #678 | first | — | 🔲 Open |"])
+        new, added = sync_missing_rows(body, [678, 999], {})
+        self.assertEqual(added, 1)
+        self.assertIn("#999", new)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,112 @@
+"""Tests for the `Suggested first action` line in handoff's fresh-session prompt.
+
+Issue #57: the resume hook surfaced `Pick up #4790 from the 'next_up' list.`
+even though #4790 was rendered as `(state: closed)` directly above. The fix
+filters next_up by state and picks the first non-closed entry; if every entry
+is closed, it emits a 'run handoff to rotate' hint instead.
+"""
+import sys
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import handoff
+
+
+class FirstActionableNextUpTest(unittest.TestCase):
+    def test_returns_first_open_when_leading_entry_closed(self):
+        issues_by_num = {
+            4790: {"number": 4790, "state": "CLOSED"},
+            4789: {"number": 4789, "state": "OPEN"},
+            4788: {"number": 4788, "state": "OPEN"},
+        }
+        result = handoff._first_actionable_next_up([4790, 4789, 4788], issues_by_num)
+        self.assertEqual(result, 4789)
+
+    def test_returns_first_when_already_open(self):
+        issues_by_num = {
+            4789: {"number": 4789, "state": "OPEN"},
+            4790: {"number": 4790, "state": "CLOSED"},
+        }
+        result = handoff._first_actionable_next_up([4789, 4790], issues_by_num)
+        self.assertEqual(result, 4789)
+
+    def test_returns_none_when_every_entry_closed(self):
+        issues_by_num = {
+            4790: {"number": 4790, "state": "CLOSED"},
+            4791: {"number": 4791, "state": "MERGED"},
+        }
+        result = handoff._first_actionable_next_up([4790, 4791], issues_by_num)
+        self.assertIsNone(result)
+
+    def test_unknown_issue_is_treated_as_actionable(self):
+        result = handoff._first_actionable_next_up([9999], {})
+        self.assertEqual(result, 9999)
+
+    def test_unknown_returned_before_closed(self):
+        issues_by_num = {4790: {"number": 4790, "state": "CLOSED"}}
+        result = handoff._first_actionable_next_up([4790, 9999], issues_by_num)
+        self.assertEqual(result, 9999)
+
+
+def _track_meta(next_up):
+    return SimpleNamespace(
+        meta={"track": "demo", "launch_priority": "P3", "milestone_alignment": "v1.0.0"},
+        repo="org/repo",
+        local_path=None,
+        path=Path("/tmp/demo.md"),
+        name="demo",
+    )
+
+
+class BuildFreshSessionPromptTest(unittest.TestCase):
+    def test_suggests_first_open_when_leading_next_up_closed(self):
+        track = _track_meta(None)
+        next_up = [4790, 4789]
+        issues_by_num = {
+            4790: {"number": 4790, "title": "shipped already", "state": "CLOSED"},
+            4789: {"number": 4789, "title": "still open", "state": "OPEN"},
+        }
+        prompt = handoff._build_fresh_session_prompt(
+            track, commits=[], uncommitted=[], last_session="",
+            open_items=[], open_source=None,
+            next_up=next_up, issues_by_num=issues_by_num,
+            repo_wide_commits=0,
+        )
+        self.assertIn("Pick up #4789 from the `next_up` list.", prompt)
+        self.assertNotIn("Pick up #4790 from the `next_up` list.", prompt)
+
+    def test_emits_rotate_hint_when_all_next_up_closed(self):
+        track = _track_meta(None)
+        next_up = [4790, 4791]
+        issues_by_num = {
+            4790: {"number": 4790, "title": "x", "state": "CLOSED"},
+            4791: {"number": 4791, "title": "y", "state": "MERGED"},
+        }
+        prompt = handoff._build_fresh_session_prompt(
+            track, commits=[], uncommitted=[], last_session="",
+            open_items=[], open_source=None,
+            next_up=next_up, issues_by_num=issues_by_num,
+            repo_wide_commits=0,
+        )
+        self.assertIn("All `next_up` items are closed", prompt)
+        self.assertIn("/work-plan handoff demo", prompt)
+        self.assertNotIn("Pick up #", prompt)
+
+    def test_uncommitted_takes_precedence_over_next_up(self):
+        track = _track_meta(None)
+        prompt = handoff._build_fresh_session_prompt(
+            track, commits=[], uncommitted=["src/foo.ts"], last_session="",
+            open_items=[], open_source=None,
+            next_up=[4790], issues_by_num={4790: {"state": "CLOSED"}},
+            repo_wide_commits=0,
+        )
+        self.assertIn("Resume the uncommitted work above.", prompt)
+        self.assertNotIn("Pick up #", prompt)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,56 @@
+"""Tests for track discovery."""
+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, discover_archived_tracks
+
+FIXTURES = Path(__file__).parent / "fixtures" / "notes_root"
+
+
+class DiscoverTracksTest(unittest.TestCase):
+    def setUp(self):
+        self.cfg = {
+            "notes_root": str(FIXTURES),
+            "repos": {"critforge": {"github": "stylusnexus/CritForge", "local": None}},
+        }
+
+    def test_active_track_discovered(self):
+        names = [t.name for t in discover_tracks(self.cfg) if t.has_frontmatter]
+        self.assertIn("example", names)
+
+    def test_repo_inferred_from_folder(self):
+        ex = next(t for t in discover_tracks(self.cfg) if t.name == "example")
+        self.assertEqual(ex.repo, "stylusnexus/CritForge")
+
+    def test_no_frontmatter_flagged_needs_init(self):
+        nf = next(t for t in discover_tracks(self.cfg) if t.path.name == "no_frontmatter.md")
+        self.assertTrue(nf.needs_init)
+
+    def test_loose_file_flagged_needs_filing(self):
+        loose = next(t for t in discover_tracks(self.cfg) if t.path.name == "loose_at_root.md")
+        self.assertTrue(loose.needs_filing)
+
+    def test_archived_excluded_from_discover_tracks(self):
+        names = [t.name for t in discover_tracks(self.cfg)]
+        self.assertNotIn("old", names)
+
+
+class DiscoverArchivedTracksTest(unittest.TestCase):
+    def setUp(self):
+        self.cfg = {
+            "notes_root": str(FIXTURES),
+            "repos": {"critforge": {"github": "stylusnexus/CritForge", "local": None}},
+        }
+
+    def test_finds_shipped_track_in_archive(self):
+        archived = discover_archived_tracks(self.cfg)
+        slugs = [a.meta.get("track") for a in archived]
+        self.assertIn("old", slugs)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,60 @@
+"""Tests for pure verdict classification."""
+import unittest
+import sys
+from datetime import date
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.manifest import ManifestScore
+from lib.verdict import classify, Verdict
+
+TODAY = date(2026, 5, 30)
+
+
+def _score(sat, tot):
+    return ManifestScore(total=tot, satisfied=sat,
+                         by_kind={"create": (sat, tot), "modify": (0, 0), "test": (0, 0)})
+
+
+class ClassifyTest(unittest.TestCase):
+    def test_shipped_when_all_files_present(self):
+        v = classify(_score(9, 9), checkbox_done=0, checkbox_total=24,
+                     last_touched=date(2026, 4, 1), today=TODAY)
+        self.assertEqual(v.label, "shipped")
+        self.assertEqual(v.glyph, "✅")
+        self.assertIn("boxes stale", v.rationale)  # 0/24 boxes -> stale note
+
+    def test_shipped_without_stale_note_when_boxes_checked(self):
+        v = classify(_score(9, 9), checkbox_done=20, checkbox_total=24,
+                     last_touched=date(2026, 4, 1), today=TODAY)
+        self.assertEqual(v.label, "shipped")
+        self.assertNotIn("boxes stale", v.rationale)
+
+    def test_partial_when_some_files(self):
+        v = classify(_score(3, 9), checkbox_done=0, checkbox_total=9,
+                     last_touched=date(2026, 5, 1), today=TODAY)
+        self.assertEqual(v.label, "partial")
+        self.assertEqual(v.glyph, "\U0001f7e1")
+
+    def test_dead_when_no_files_and_stale(self):
+        v = classify(_score(0, 9), checkbox_done=0, checkbox_total=9,
+                     last_touched=date(2026, 1, 1), today=TODAY, dead_days=60)
+        self.assertEqual(v.label, "dead")
+        self.assertEqual(v.glyph, "\U0001f480")
+
+    def test_early_not_dead_when_recent(self):
+        v = classify(_score(0, 9), checkbox_done=0, checkbox_total=9,
+                     last_touched=date(2026, 5, 20), today=TODAY, dead_days=60)
+        self.assertEqual(v.label, "partial")
+
+    def test_manifest_less_routes_to_llm(self):
+        v = classify(_score(0, 0), checkbox_done=0, checkbox_total=0,
+                     last_touched=None, today=TODAY)
+        self.assertEqual(v.label, "manifest-less")
+        self.assertEqual(v.glyph, "\U0001f47b")
+
+
+if __name__ == "__main__":
+    unittest.main()