@stylusnexus/work-plan 2026.6.9

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

@@ -0,0 +1,445 @@
+"""Tests for the non-interactive new-track command (issue #87, Phase 3a).
+
+Covers:
+- Creates a track for a config-key repo on a PRIVATE repo → write_file called
+  with the right meta (github.repo = key's github value; status active;
+  priority/milestone defaults), rc 0.
+- Creates a track for a bare org/repo slug → folder = name part after '/',
+  github = full slug, rc 0.
+- Public repo, no token → needs_confirm JSON, write_file NOT called, rc 0;
+  token == make_token(github, slug).
+- Public repo, valid --confirm=<token> → creates (write_file called), rc 0.
+- Existing path → rc 2, no write.
+- Unknown repo (not a config key, no slash) → rc 1, no write.
+- Invalid slug → rc 2.
+- --priority=P1 --milestone=v2 reflected in meta; defaults applied when absent.
+- --private accepted without error, creates normally, rc 0.
+- "new-track" in SUBCOMMANDS and appears in DESCRIPTIONS.
+"""
+import io
+import json
+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))
+
+from commands import new_track
+from lib.write_guard import make_token
+import work_plan
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+NOTES_ROOT = "/tmp/fake-notes"
+
+def _make_cfg(*, repos=None):
+    if repos is None:
+        repos = {
+            "myrepo": {"github": "org/myrepo", "local": None},
+            "critforge": {"github": "stylusnexus/critforge", "local": None},
+        }
+    return {"notes_root": NOTES_ROOT, "repos": repos}
+
+
+def _drive(args, *, vis="PRIVATE", notes_root_exists=True, target_path_exists=False):
+    """Run new_track.run(args) with all external I/O mocked.
+
+    vis: what repo_visibility returns for needs_confirm.
+    notes_root_exists: whether notes_root directory exists.
+    target_path_exists: whether the target .md path already exists.
+    """
+    cfg = _make_cfg()
+
+    def _path_exists(self):
+        # notes_root itself → notes_root_exists; target path → target_path_exists.
+        # Compare with Path equality (not str ==): on Windows str(Path("/tmp/x"))
+        # uses backslashes, so an exact "/tmp/fake-notes" string match never fires
+        # and the notes_root-missing case can't be simulated.
+        if self == Path(NOTES_ROOT):
+            return notes_root_exists
+        if self.suffix == ".md":
+            return target_path_exists
+        # archive dirs and parent dirs default to True
+        return True
+
+    with patch("commands.new_track.load_config", return_value=cfg), \
+         patch("commands.new_track.write_file") as mw, \
+         patch("lib.write_guard.repo_visibility", return_value=vis), \
+         patch("pathlib.Path.exists", _path_exists), \
+         patch("pathlib.Path.mkdir"):
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = new_track.run(args)
+    return rc, mw, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# Test cases
+# ---------------------------------------------------------------------------
+
+class NewTrackCommandTest(unittest.TestCase):
+
+    # ------------------------------------------------------------------
+    # Registry checks
+    # ------------------------------------------------------------------
+
+    def test_subcommand_registered_in_subcommands(self):
+        """'new-track' must be in work_plan.SUBCOMMANDS."""
+        self.assertIn("new-track", work_plan.SUBCOMMANDS)
+
+    def test_subcommand_appears_in_descriptions(self):
+        """'new-track' must appear in work_plan.DESCRIPTIONS."""
+        names = [entry[0] for entry in work_plan.DESCRIPTIONS]
+        self.assertIn("new-track", names)
+
+    # ------------------------------------------------------------------
+    # Config-key repo (PRIVATE)
+    # ------------------------------------------------------------------
+
+    def test_config_key_private_creates_track(self):
+        """Config-key repo 'myrepo' (PRIVATE) → write_file called with
+        github.repo = 'org/myrepo', status = 'active', rc 0."""
+        rc, mw, out = _drive(["myrepo", "my-feature"], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        meta = mw.call_args[0][1]
+        self.assertEqual(meta["github"]["repo"], "org/myrepo")
+        self.assertEqual(meta["status"], "active")
+
+    def test_config_key_folder_resolves_correctly(self):
+        """Config-key 'critforge' → folder = 'critforge',
+        github.repo = 'stylusnexus/critforge'."""
+        rc, mw, out = _drive(["critforge", "encounter-builder"], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        meta = mw.call_args[0][1]
+        self.assertEqual(meta["github"]["repo"], "stylusnexus/critforge")
+        # Track name from slug
+        self.assertEqual(meta["track"], "encounter-builder")
+        # Path passed to write_file should be under critforge folder
+        path_arg = mw.call_args[0][0]
+        self.assertIn("critforge", str(path_arg))
+
+    # ------------------------------------------------------------------
+    # Bare org/repo slug
+    # ------------------------------------------------------------------
+
+    def test_bare_org_repo_slug_uses_name_as_folder(self):
+        """'stylusnexus/work-plan-toolkit' → folder = 'work-plan-toolkit',
+        github.repo = 'stylusnexus/work-plan-toolkit', rc 0."""
+        rc, mw, out = _drive(
+            ["stylusnexus/work-plan-toolkit", "my-feature"], vis="PRIVATE"
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        meta = mw.call_args[0][1]
+        self.assertEqual(meta["github"]["repo"], "stylusnexus/work-plan-toolkit")
+        path_arg = mw.call_args[0][0]
+        self.assertIn("work-plan-toolkit", str(path_arg))
+
+    # ------------------------------------------------------------------
+    # Public repo — confirm gate
+    # ------------------------------------------------------------------
+
+    def test_public_repo_no_token_returns_needs_confirm_json(self):
+        """Public repo, no token → prints needs_confirm JSON, write_file
+        NOT called, rc 0; token == make_token(github, slug)."""
+        rc, mw, out = _drive(["myrepo", "my-feature"], vis="PUBLIC")
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        data = json.loads(out.strip())
+        self.assertTrue(data["needs_confirm"])
+        self.assertEqual(data["token"], make_token("org/myrepo", "my-feature"))
+        self.assertIn("PUBLIC", data["reason"])
+
+    def test_public_repo_unknown_vis_returns_needs_confirm_json(self):
+        """Unknown visibility (None) also requires confirm."""
+        rc, mw, out = _drive(["myrepo", "my-feature"], vis=None)
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        data = json.loads(out.strip())
+        self.assertTrue(data["needs_confirm"])
+
+    def test_public_repo_wrong_token_blocked(self):
+        """Wrong --confirm token → blocked, no write, rc 0."""
+        rc, mw, out = _drive(
+            ["myrepo", "my-feature", "--confirm=wrongtoken"], vis="PUBLIC"
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        data = json.loads(out.strip())
+        self.assertTrue(data["needs_confirm"])
+
+    def test_public_repo_valid_token_writes(self):
+        """Valid --confirm=<token> on a public repo → creates track, rc 0."""
+        tok = make_token("org/myrepo", "my-feature")
+        rc, mw, out = _drive(
+            ["myrepo", "my-feature", f"--confirm={tok}"], vis="PUBLIC"
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+
+    def test_bare_slug_public_token_uses_full_github(self):
+        """Public bare slug: token is make_token(full-github, slug)."""
+        tok = make_token("org/other-repo", "new-slug")
+        rc, mw, out = _drive(
+            ["org/other-repo", "new-slug", f"--confirm={tok}"], vis="PUBLIC"
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+
+    # ------------------------------------------------------------------
+    # Existing path → rc 2
+    # ------------------------------------------------------------------
+
+    def test_existing_path_returns_rc2_no_write(self):
+        """Target .md already exists → rc 2, no write."""
+        rc, mw, out = _drive(
+            ["myrepo", "existing-track"], vis="PRIVATE", target_path_exists=True
+        )
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+
+    # ------------------------------------------------------------------
+    # Unknown repo → rc 1
+    # ------------------------------------------------------------------
+
+    def test_unknown_repo_not_key_no_slash_returns_rc1(self):
+        """Repo not a config key and no slash → rc 1, no write."""
+        rc, mw, out = _drive(["unknown-repo", "my-feature"])
+        self.assertEqual(rc, 1)
+        mw.assert_not_called()
+        self.assertIn("unknown repo", out.lower())
+
+    # ------------------------------------------------------------------
+    # Invalid slug → rc 2
+    # ------------------------------------------------------------------
+
+    def test_invalid_slug_uppercase_returns_rc2(self):
+        """Slug with uppercase letters → rc 2."""
+        rc, mw, out = _drive(["myrepo", "MyFeature"])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+
+    def test_invalid_slug_spaces_returns_rc2(self):
+        """Slug with spaces → rc 2."""
+        rc, mw, out = _drive(["myrepo", "my feature"])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+
+    def test_invalid_slug_special_chars_returns_rc2(self):
+        """Slug with special chars (underscore) → rc 2."""
+        rc, mw, out = _drive(["myrepo", "my_feature"])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+
+    # ------------------------------------------------------------------
+    # Missing positionals → rc 2
+    # ------------------------------------------------------------------
+
+    def test_no_args_returns_rc2(self):
+        """No positional args at all → rc 2 (usage error)."""
+        rc, mw, out = _drive([])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+
+    def test_only_one_positional_returns_rc2(self):
+        """Only repo, no slug → rc 2 (usage error)."""
+        rc, mw, out = _drive(["myrepo"])
+        self.assertEqual(rc, 2)
+        mw.assert_not_called()
+
+    # ------------------------------------------------------------------
+    # Priority and milestone flags
+    # ------------------------------------------------------------------
+
+    def test_explicit_priority_and_milestone_in_meta(self):
+        """--priority=P1 --milestone=v2 → reflected in meta."""
+        rc, mw, out = _drive(
+            ["myrepo", "my-feature", "--priority=P1", "--milestone=v2"],
+            vis="PRIVATE"
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        meta = mw.call_args[0][1]
+        self.assertEqual(meta["launch_priority"], "P1")
+        self.assertEqual(meta["milestone_alignment"], "v2")
+
+    def test_defaults_p2_and_v100_when_absent(self):
+        """No flags → launch_priority=P2, milestone_alignment=v1.0.0."""
+        rc, mw, out = _drive(["myrepo", "my-feature"], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        meta = mw.call_args[0][1]
+        self.assertEqual(meta["launch_priority"], "P2")
+        self.assertEqual(meta["milestone_alignment"], "v1.0.0")
+
+    def test_invalid_priority_falls_back_to_p2(self):
+        """Invalid --priority=P9 → silently falls back to P2."""
+        rc, mw, out = _drive(
+            ["myrepo", "my-feature", "--priority=P9"], vis="PRIVATE"
+        )
+        self.assertEqual(rc, 0)
+        meta = mw.call_args[0][1]
+        self.assertEqual(meta["launch_priority"], "P2")
+
+    def test_priority_uppercased(self):
+        """--priority=p1 (lowercase) → P1 after uppercasing."""
+        rc, mw, out = _drive(
+            ["myrepo", "my-feature", "--priority=p1"], vis="PRIVATE"
+        )
+        self.assertEqual(rc, 0)
+        meta = mw.call_args[0][1]
+        self.assertEqual(meta["launch_priority"], "P1")
+
+    # ------------------------------------------------------------------
+    # Frontmatter structure
+    # ------------------------------------------------------------------
+
+    def test_meta_has_expected_keys(self):
+        """Written meta contains all required frontmatter keys."""
+        rc, mw, out = _drive(["myrepo", "my-feature"], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        meta = mw.call_args[0][1]
+        for key in ("track", "status", "launch_priority", "milestone_alignment",
+                    "github", "related_tracks", "last_touched", "last_handoff",
+                    "next_up", "blockers"):
+            self.assertIn(key, meta, f"meta missing key: {key}")
+
+    def test_meta_github_issues_and_branches_empty(self):
+        """New track starts with github.issues=[] and github.branches=[]."""
+        rc, mw, out = _drive(["myrepo", "my-feature"], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        meta = mw.call_args[0][1]
+        self.assertEqual(meta["github"]["issues"], [])
+        self.assertEqual(meta["github"]["branches"], [])
+
+    def test_meta_related_tracks_next_up_blockers_empty(self):
+        """New track starts with empty related_tracks, next_up, blockers."""
+        rc, mw, out = _drive(["myrepo", "my-feature"], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        meta = mw.call_args[0][1]
+        self.assertEqual(meta["related_tracks"], [])
+        self.assertEqual(meta["next_up"], [])
+        self.assertEqual(meta["blockers"], [])
+
+    def test_body_contains_slug_heading(self):
+        """Body passed to write_file contains a heading with the slug."""
+        rc, mw, out = _drive(["myrepo", "my-feature"], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        body = mw.call_args[0][2]
+        self.assertIn("my-feature", body)
+
+    # ------------------------------------------------------------------
+    # --private flag (no-op, accepted without error)
+    # ------------------------------------------------------------------
+
+    def test_private_flag_accepted_no_error(self):
+        """--private accepted without error, creates normally, rc 0."""
+        rc, mw, out = _drive(
+            ["myrepo", "my-feature", "--private"], vis="PRIVATE"
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+
+    def test_private_flag_on_public_repo_still_gated(self):
+        """--private on a public repo: confirm gate still fires (gate is by
+        visibility, not --private flag)."""
+        rc, mw, out = _drive(
+            ["myrepo", "my-feature", "--private"], vis="PUBLIC"
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        data = json.loads(out.strip())
+        self.assertTrue(data["needs_confirm"])
+
+    # ------------------------------------------------------------------
+    # notes_root missing → rc 1
+    # ------------------------------------------------------------------
+
+    def test_missing_notes_root_returns_rc1(self):
+        """notes_root directory does not exist → rc 1, no write."""
+        rc, mw, out = _drive(
+            ["myrepo", "my-feature"], vis="PRIVATE", notes_root_exists=False
+        )
+        self.assertEqual(rc, 1)
+        mw.assert_not_called()
+
+    # ------------------------------------------------------------------
+    # Success output
+    # ------------------------------------------------------------------
+
+    def test_success_prints_created_line(self):
+        """On success, output contains 'Created track' and the slug."""
+        rc, mw, out = _drive(["myrepo", "my-feature"], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        self.assertIn("my-feature", out)
+
+    # ------------------------------------------------------------------
+    # Gate fires BEFORE any FS write
+    # ------------------------------------------------------------------
+
+    def test_gate_before_mkdir_on_public(self):
+        """On a public repo without a token, mkdir is NOT called
+        (gate fires before any filesystem operation)."""
+        cfg = _make_cfg()
+
+        def _path_exists(self):
+            if self == Path(NOTES_ROOT):
+                return True
+            if self.suffix == ".md":
+                return False
+            return True
+
+        with patch("commands.new_track.load_config", return_value=cfg), \
+             patch("commands.new_track.write_file") as mw, \
+             patch("lib.write_guard.repo_visibility", return_value="PUBLIC"), \
+             patch("pathlib.Path.exists", _path_exists), \
+             patch("pathlib.Path.mkdir") as mmkdir:
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = new_track.run(["myrepo", "my-feature"])
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        mmkdir.assert_not_called()
+
+    # ------------------------------------------------------------------
+    # No input() on non-interactive paths
+    # ------------------------------------------------------------------
+
+    def test_no_input_called_on_private_repo(self):
+        """Private repo with valid flags never calls input() or prompt_input —
+        proving no prompt is hit on the non-interactive code path."""
+        cfg = _make_cfg()
+
+        def _raise(*a, **kw):
+            raise AssertionError("input() must not be called — command must be non-interactive")
+
+        def _path_exists(self):
+            if self == Path(NOTES_ROOT):
+                return True
+            if self.suffix == ".md":
+                return False
+            return True
+
+        with patch("builtins.input", side_effect=_raise), \
+             patch("lib.prompts.prompt_input", side_effect=_raise):
+            with patch("commands.new_track.load_config", return_value=cfg), \
+                 patch("commands.new_track.write_file") as mw, \
+                 patch("lib.write_guard.repo_visibility", return_value="PRIVATE"), \
+                 patch("pathlib.Path.exists", _path_exists), \
+                 patch("pathlib.Path.mkdir"):
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = new_track.run(["myrepo", "my-feature"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,149 @@
+"""Tests for the next_up suggestion algorithm.
+
+Covers the priority + recency sort, blocker exclusion, closed-issue filter,
+top-N capping, and the `updatedAt`-missing fallback. The algorithm has one
+home (lib/next_up.py) shared by handoff's --auto-next flag and brief's
+next_up_auto: true frontmatter knob — so a regression here would surface
+in both commands.
+"""
+import sys
+import unittest
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.next_up import suggest_next_up
+
+
+def _issue(num, *, state="OPEN", priority=None, updated="2026-01-01T00:00:00Z",
+           title="", milestone=None):
+    """Build a minimal issue dict matching gh's --json output."""
+    labels = [{"name": f"priority/{priority}"}] if priority else []
+    ms_obj = {"title": milestone} if milestone else None
+    return {
+        "number": num, "state": state, "labels": labels,
+        "updatedAt": updated, "title": title or f"issue #{num}",
+        "milestone": ms_obj,
+    }
+
+
+class SuggestNextUpTest(unittest.TestCase):
+    def test_empty_input_returns_empty(self):
+        self.assertEqual(suggest_next_up([], []), [])
+
+    def test_only_closed_returns_empty(self):
+        issues = [_issue(1, state="CLOSED", priority="P0"),
+                  _issue(2, state="CLOSED", priority="P1")]
+        self.assertEqual(suggest_next_up(issues, []), [])
+
+    def test_priority_order(self):
+        # Same updatedAt across all — pure priority ranking. P0 < P1 < P2 < P3.
+        issues = [
+            _issue(3, priority="P3"),
+            _issue(0, priority="P0"),
+            _issue(2, priority="P2"),
+            _issue(1, priority="P1"),
+        ]
+        self.assertEqual(suggest_next_up(issues, []), [0, 1, 2])  # default n=3
+
+    def test_recency_within_priority_bucket(self):
+        # All P1 — most recently updated wins.
+        issues = [
+            _issue(10, priority="P1", updated="2026-01-01T00:00:00Z"),
+            _issue(20, priority="P1", updated="2026-04-30T00:00:00Z"),  # newest
+            _issue(30, priority="P1", updated="2026-02-15T00:00:00Z"),
+        ]
+        self.assertEqual(suggest_next_up(issues, []), [20, 30, 10])
+
+    def test_priority_dominates_recency(self):
+        # P0 is older than P3 but still comes first.
+        issues = [
+            _issue(99, priority="P3", updated="2026-04-30T00:00:00Z"),
+            _issue(1, priority="P0", updated="2024-01-01T00:00:00Z"),
+        ]
+        self.assertEqual(suggest_next_up(issues, []), [1, 99])
+
+    def test_no_priority_label_defaults_to_p3(self):
+        # Unlabeled issues sort with P3, behind P0/P1/P2.
+        issues = [
+            _issue(50, priority=None, updated="2026-04-30T00:00:00Z"),
+            _issue(51, priority="P3", updated="2026-04-30T00:00:00Z"),
+            _issue(2, priority="P2"),
+        ]
+        result = suggest_next_up(issues, [])
+        # P2 first; the two P3 (one labeled, one defaulting) follow.
+        self.assertEqual(result[0], 2)
+        self.assertIn(50, result[1:])
+        self.assertIn(51, result[1:])
+
+    def test_blockers_excluded(self):
+        issues = [
+            _issue(1, priority="P0"),
+            _issue(2, priority="P1"),
+            _issue(3, priority="P2"),
+        ]
+        # #1 is blocked — should NOT appear, even though it's P0.
+        self.assertEqual(suggest_next_up(issues, [1]), [2, 3])
+
+    def test_top_n_caps_result(self):
+        issues = [_issue(i, priority="P0") for i in range(10)]
+        self.assertEqual(len(suggest_next_up(issues, [], n=2)), 2)
+        self.assertEqual(len(suggest_next_up(issues, [], n=5)), 5)
+
+    def test_default_n_is_3(self):
+        issues = [_issue(i, priority="P0") for i in range(10)]
+        self.assertEqual(len(suggest_next_up(issues, [])), 3)
+
+    def test_missing_updatedAt_treated_as_oldest(self):
+        # Within same priority, an issue without updatedAt should sort LAST.
+        issues = [
+            _issue(1, priority="P1", updated="2026-01-01T00:00:00Z"),
+            _issue(2, priority="P1", updated=""),  # missing
+            _issue(3, priority="P1", updated="2026-04-30T00:00:00Z"),
+        ]
+        result = suggest_next_up(issues, [])
+        self.assertEqual(result[0], 3)  # newest first
+        self.assertEqual(result[-1], 2)  # missing-updated last
+
+    def test_track_milestone_aligned_outranks_other_milestone(self):
+        # Track is gated by v0.4.0. A P0 on v2.0.0 must sort BEHIND a P3 on v0.4.0
+        # because milestone alignment dominates priority — keeps post-launch
+        # work from polluting a launch-window auto-next.
+        issues = [
+            _issue(1, priority="P0", milestone="v2.0.0 — Post-Launch",
+                   updated="2026-04-30T00:00:00Z"),
+            _issue(2, priority="P3", milestone="v0.4.0 — MVP",
+                   updated="2026-01-01T00:00:00Z"),
+        ]
+        self.assertEqual(suggest_next_up(issues, [], track_milestone="v0.4.0"), [2, 1])
+
+    def test_track_milestone_unmilestoned_sorts_last(self):
+        # Items with no milestone fall behind any milestoned item.
+        issues = [
+            _issue(1, priority="P0", milestone=None),
+            _issue(2, priority="P3", milestone="v2.0.0"),
+        ]
+        self.assertEqual(suggest_next_up(issues, [], track_milestone="v0.4.0"), [2, 1])
+
+    def test_no_track_milestone_preserves_priority_order(self):
+        # Without a track milestone, behavior matches the legacy priority+recency sort:
+        # all milestone buckets collapse to "OTHER" so they tie, leaving priority to decide.
+        issues = [
+            _issue(1, priority="P0", milestone="v2.0.0"),
+            _issue(2, priority="P3", milestone="v0.4.0"),
+        ]
+        self.assertEqual(suggest_next_up(issues, []), [1, 2])
+
+    def test_unparsable_updatedAt_falls_back_gracefully(self):
+        # A garbage timestamp string should be treated like missing — not crash.
+        issues = [
+            _issue(1, priority="P0", updated="not-a-date"),
+            _issue(2, priority="P0", updated="2026-04-30T00:00:00Z"),
+        ]
+        result = suggest_next_up(issues, [])
+        self.assertEqual(result, [2, 1])  # parsable+newer wins; garbage trails
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,68 @@
+"""Smoke + behavior test for the plan-status command (offline)."""
+import io
+import json
+import unittest
+import sys
+import tempfile
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest import mock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import plan_status
+
+PLAN_BODY = (
+    "# Idea Mode Implementation Plan\n\n"
+    "**Files:**\n"
+    "- Create: `src/new.ts`\n"
+    "- Create: `src/missing.ts`\n"
+    "- [ ] Step 1: do the thing\n"
+    "- [ ] Step 2: do the other thing\n"
+)
+
+
+class PlanStatusRunTest(unittest.TestCase):
+    def _repo(self, d):
+        root = Path(d)
+        (root / "docs/superpowers/plans").mkdir(parents=True)
+        (root / "docs/superpowers/plans/2026-03-16-idea-mode-ui.md").write_text(PLAN_BODY)
+        (root / "src").mkdir()
+        (root / "src/new.ts").write_text("export const x = 1")  # 1 of 2 created
+        return root
+
+    def test_json_report_classifies_partial(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            with mock.patch("commands.plan_status.git_state.path_last_commit_date",
+                            return_value=None), \
+                 mock.patch("commands.plan_status.Path.cwd", return_value=root):
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = plan_status.run(["--json"])
+            self.assertEqual(rc, 0)
+            data = json.loads(buf.getvalue())
+            self.assertEqual(len(data["docs"]), 1)
+            row = data["docs"][0]
+            self.assertEqual(row["files_present"], 1)
+            self.assertEqual(row["files_declared"], 2)
+            self.assertEqual(row["verdict"], "partial")  # 50% -> partial
+
+    def test_human_report_runs(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            with mock.patch("commands.plan_status.git_state.path_last_commit_date",
+                            return_value=None), \
+                 mock.patch("commands.plan_status.Path.cwd", return_value=root):
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = plan_status.run([])
+            self.assertEqual(rc, 0)
+            out = buf.getvalue()
+            self.assertIn("plan-status", out)
+            self.assertIn("partial", out)
+
+
+if __name__ == "__main__":
+    unittest.main()