@stylusnexus/work-plan 2026.6.11 → 2026.6.13-2

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

@@ -0,0 +1,131 @@
+"""push-track (#306): promote a private track to the shared tier + push.
+Real temp files for the move; git-worktree helpers + config mocked (offline)."""
+import io
+import json
+import sys
+import tempfile
+import unittest
+from contextlib import redirect_stdout, redirect_stderr
+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 commands import push_track
+from lib.frontmatter import parse_file
+from lib.write_guard import make_token
+
+
+class PushTrackTest(unittest.TestCase):
+    def _setup(self, d, tier="private", plan_branch="work-plan/plan"):
+        root = Path(d)
+        notes = root / "notes"; notes.mkdir()
+        priv = notes / "my-feature.md"
+        priv.write_text("---\ntrack: my-feature\n---\n# My Feature\n\nbody\n")
+        shared = root / "repo" / ".work-plan"; shared.mkdir(parents=True)
+        entry = {"github": "o/r", "local": str(root / "repo")}
+        if plan_branch:
+            entry["plan_branch"] = plan_branch
+        cfg = {"notes_root": str(notes), "repos": {"demo": entry}}
+        track = SimpleNamespace(
+            name="my-feature", tier=tier, folder="demo", repo="o/r",
+            path=priv, meta={"track": "my-feature"}, body="# My Feature\n\nbody\n",
+        )
+        return root, cfg, track, shared, priv
+
+    def _drive(self, cfg, track, shared, args, vis="PRIVATE",
+               commit_sha="abc123", push_rc=0):
+        push_proc = SimpleNamespace(returncode=push_rc, stderr="")
+        with mock.patch("commands.push_track.load_config", return_value=cfg), \
+             mock.patch("commands.push_track.discover_tracks", return_value=[track]), \
+             mock.patch("commands.push_track.find_track_by_name", return_value=track), \
+             mock.patch("lib.write_guard.repo_visibility", return_value=vis), \
+             mock.patch("commands.push_track.pw.shared_tier_dir", return_value=shared), \
+             mock.patch("commands.push_track.pw.commit_shared_tier", return_value=commit_sha), \
+             mock.patch("commands.push_track.pw.push_plan_branch", return_value=push_proc) as mpush:
+            out, err = io.StringIO(), io.StringIO()
+            with redirect_stdout(out), redirect_stderr(err):
+                rc = push_track.run(args)
+        return rc, out.getvalue(), err.getvalue(), mpush
+
+    def test_promotes_and_pushes_private_repo(self):
+        with tempfile.TemporaryDirectory() as d:
+            _, cfg, track, shared, priv = self._setup(d)
+            rc, out, err, mpush = self._drive(cfg, track, shared, ["my-feature"])
+            self.assertEqual(rc, 0)
+            dest = shared / "my-feature.md"
+            self.assertTrue(dest.is_file())             # written to shared tier
+            self.assertFalse(priv.exists())             # private copy removed
+            meta, _ = parse_file(dest)
+            self.assertEqual(meta["track"], "my-feature")  # frontmatter preserved
+            mpush.assert_called_once()                  # pushed
+
+    def test_no_push_keeps_local(self):
+        with tempfile.TemporaryDirectory() as d:
+            _, cfg, track, shared, priv = self._setup(d)
+            rc, out, err, mpush = self._drive(cfg, track, shared, ["my-feature", "--no-push"])
+            self.assertEqual(rc, 0)
+            self.assertTrue((shared / "my-feature.md").is_file())
+            mpush.assert_not_called()
+            self.assertIn("plan-branch push", out)
+
+    def test_public_repo_no_token_returns_needs_confirm_no_mutation(self):
+        with tempfile.TemporaryDirectory() as d:
+            _, cfg, track, shared, priv = self._setup(d)
+            rc, out, err, mpush = self._drive(cfg, track, shared, ["my-feature"], vis="PUBLIC")
+            self.assertEqual(rc, 0)
+            data = json.loads(out)
+            self.assertTrue(data["needs_confirm"])
+            self.assertEqual(data["token"], make_token("o/r", "my-feature"))
+            self.assertFalse((shared / "my-feature.md").exists())  # nothing moved
+            self.assertTrue(priv.exists())                          # private intact
+            mpush.assert_not_called()
+
+    def test_public_repo_with_valid_token_proceeds(self):
+        with tempfile.TemporaryDirectory() as d:
+            _, cfg, track, shared, priv = self._setup(d)
+            tok = make_token("o/r", "my-feature")
+            rc, out, err, mpush = self._drive(
+                cfg, track, shared, ["my-feature", f"--confirm={tok}"], vis="PUBLIC")
+            self.assertEqual(rc, 0)
+            self.assertTrue((shared / "my-feature.md").is_file())
+            mpush.assert_called_once()
+
+    def test_public_no_push_skips_gate(self):
+        # --no-push keeps it local, so no exposure gate even on a public repo.
+        with tempfile.TemporaryDirectory() as d:
+            _, cfg, track, shared, priv = self._setup(d)
+            rc, out, err, mpush = self._drive(
+                cfg, track, shared, ["my-feature", "--no-push"], vis="PUBLIC")
+            self.assertEqual(rc, 0)
+            self.assertTrue((shared / "my-feature.md").is_file())
+            mpush.assert_not_called()
+
+    def test_already_shared_aborts(self):
+        with tempfile.TemporaryDirectory() as d:
+            _, cfg, track, shared, priv = self._setup(d, tier="shared")
+            rc, out, err, mpush = self._drive(cfg, track, shared, ["my-feature"])
+            self.assertEqual(rc, 1)
+            self.assertIn("already in the shared tier", err)
+
+    def test_no_plan_branch_hints_init(self):
+        with tempfile.TemporaryDirectory() as d:
+            _, cfg, track, shared, priv = self._setup(d, plan_branch=None)
+            rc, out, err, mpush = self._drive(cfg, track, shared, ["my-feature"])
+            self.assertEqual(rc, 1)
+            self.assertIn("plan-branch init", err)
+
+    def test_dest_exists_aborts(self):
+        with tempfile.TemporaryDirectory() as d:
+            _, cfg, track, shared, priv = self._setup(d)
+            (shared / "my-feature.md").write_text("# already here\n")
+            rc, out, err, mpush = self._drive(cfg, track, shared, ["my-feature"])
+            self.assertEqual(rc, 1)
+            self.assertIn("already exists", err)
+            self.assertTrue(priv.exists())  # private not removed on abort
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,138 @@
+"""Cross-repo duplicate-slug isolation in reconcile (#255).
+
+Identical track slugs in DIFFERENT repos are explicitly supported. Reconcile's
+in-flight state must be keyed by a per-track identity (repo, path), not by slug
+— otherwise a later same-slug track's fetch overwrites the earlier one's, and
+under `--all --yes` issues from one repo get written into the same-named track
+in ANOTHER repo (membership corruption).
+
+All gh calls are mocked; tests run offline. The fake `gh` here is REPO-AWARE
+(unlike the shared move harness) so two same-slug tracks in different repos can
+return different labeled issues.
+"""
+import json
+import sys
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import reconcile
+
+
+def _track(*, slug, repo, issues=None):
+    # Path embeds the repo so two same-slug tracks have distinct file paths,
+    # mirroring how discover_tracks lays out per-repo note dirs.
+    safe_repo = repo.replace("/", "_")
+    return SimpleNamespace(
+        name=slug,
+        path=Path(f"/tmp/fake/{safe_repo}/{slug}.md"),
+        body="# fake",
+        meta={"track": slug, "status": "active",
+              "github": {"repo": repo, "issues": list(issues or [])}},
+        has_frontmatter=True,
+        repo=repo,
+    )
+
+
+class _RepoAwareHarness:
+    """Drives reconcile --all where labeled issues depend on BOTH repo and label.
+
+    `labeled` maps (repo, label) -> list of issue dicts that
+    `gh issue/pr list --repo <repo> --label <label>` should return.
+    """
+
+    def __init__(self, tracks, labeled):
+        self.tracks = tracks
+        self.labeled = labeled
+        self.writes = []  # (path_str, issues) per write_file call
+
+    def _fake_run(self, argv, *a, **kw):
+        out = []
+        if "--label" in argv and argv[1] == "issue":  # count issues once, not PRs
+            repo = argv[argv.index("--repo") + 1]
+            lab = argv[argv.index("--label") + 1]
+            out = self.labeled.get((repo, lab), [])
+        return MagicMock(returncode=0, stdout=json.dumps(out), stderr="")
+
+    def _fake_write(self, path, meta, body):
+        self.writes.append((str(path), list(meta.get("github", {}).get("issues") or [])))
+
+    def run(self, extra_args=None):
+        cfg = {"notes_root": "/tmp/n"}
+        with patch("commands.reconcile.subprocess.run", side_effect=self._fake_run), \
+             patch("commands.reconcile.load_config", return_value=cfg), \
+             patch("commands.reconcile.discover_tracks", return_value=self.tracks), \
+             patch("commands.reconcile.needs_confirm", return_value=False), \
+             patch("commands.reconcile.write_file", side_effect=self._fake_write), \
+             patch("commands.reconcile.prompt_input", return_value="y"):
+            rc = reconcile.run(["--all"] + (extra_args or []))
+        return rc
+
+
+class DupSlugCrossRepoTest(unittest.TestCase):
+    def test_adds_land_in_the_correct_repo_track(self):
+        """Two tracks share slug 'core' across repos o/a and o/b. Each repo
+        labels a DIFFERENT issue. Under --all --yes, each issue must land in
+        its OWN repo's track — never bleed into the same-named sibling."""
+        a = _track(slug="core", repo="o/a", issues=[])
+        b = _track(slug="core", repo="o/b", issues=[])
+        labeled = {
+            ("o/a", "track/core"): [{"number": 11, "title": "a-issue", "state": "OPEN"}],
+            ("o/b", "track/core"): [{"number": 22, "title": "b-issue", "state": "OPEN"}],
+        }
+        h = _RepoAwareHarness([a, b], labeled)
+        rc = h.run(extra_args=["--yes"])
+        self.assertEqual(rc, 0)
+        writes = dict(h.writes)
+        # Key off each track's real Path string (backslashes on Windows), not a
+        # hardcoded POSIX literal — the collision is the slug, not the path.
+        self.assertEqual(writes[str(a.path)], [11])
+        self.assertEqual(writes[str(b.path)], [22])
+
+    def test_failed_fetch_does_not_corrupt_same_slug_sibling(self):
+        """If repo o/a's fetch is intact but o/b's is independent, the second
+        track's results must not overwrite the first's. Here o/a adds #11 and
+        o/b adds #22; pre-fix, the shared 'core' key meant the second fetch
+        clobbered the first and #11 was lost / mis-routed."""
+        a = _track(slug="core", repo="o/a", issues=[11])  # already has #11
+        b = _track(slug="core", repo="o/b", issues=[])
+        labeled = {
+            # o/a still labels #11 (no change → no write expected for a)
+            ("o/a", "track/core"): [{"number": 11, "title": "a", "state": "OPEN"}],
+            # o/b newly labels #99
+            ("o/b", "track/core"): [{"number": 99, "title": "b", "state": "OPEN"}],
+        }
+        h = _RepoAwareHarness([a, b], labeled)
+        rc = h.run(extra_args=["--yes"])
+        self.assertEqual(rc, 0)
+        writes = dict(h.writes)
+        # o/a unchanged → not written. o/b gains #99 only — NOT #11.
+        self.assertNotIn(str(a.path), writes)
+        self.assertEqual(writes[str(b.path)], [99])
+
+    def test_no_cross_repo_move_between_same_slug_tracks(self):
+        """A move only fires within ONE repo. #50 sits in o/a's 'core'
+        frontmatter and is labeled for o/b's 'core' — different repos, so it
+        must stay a FLAG on o/a, not move across the repo boundary."""
+        a = _track(slug="core", repo="o/a", issues=[50])
+        b = _track(slug="core", repo="o/b", issues=[])
+        labeled = {
+            ("o/a", "track/core"): [],  # #50 lost its label in o/a
+            ("o/b", "track/core"): [{"number": 50, "title": "x", "state": "OPEN"}],
+        }
+        h = _RepoAwareHarness([a, b], labeled)
+        rc = h.run(extra_args=["--yes"])
+        self.assertEqual(rc, 0)
+        writes = dict(h.writes)
+        # o/a keeps #50 (no same-repo move target) → not rewritten.
+        self.assertNotIn(str(a.path), writes)
+        # o/b ADDs #50 because it now carries o/b's label — legitimate, in-repo.
+        self.assertEqual(writes.get(str(b.path)), [50])
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -160,6 +160,81 @@ class CanonicalRederiveTest(unittest.TestCase):
         self.assertIn("## Notes\n\nkeep me", mw.call_args[0][2])
 
 
+class PartialFetchTest(unittest.TestCase):
+    """A degraded GitHub fetch must never overwrite valid rows with
+    '(not fetched)'. The track is skipped, left untouched, and the run exits
+    nonzero so --yes / hygiene callers see the degradation (#256)."""
+
+    def test_partial_fetch_skips_track_and_preserves_rows(self):
+        """One of several frontmatter issues missing → no write, rc=1, the
+        existing table is left exactly as it was."""
+        existing = [_gh(1, "first"), _gh(2, "second")]
+        track = _track(name="t", repo="o/r", issues=[1, 2, 3],
+                       body=_canon_body(existing + [_gh(3, "third")]))
+        original_body = track.body
+        # #3 fails to come back from the fetch.
+        rc, mw, out = _drive(track, existing, ["t", "--yes"])
+        self.assertEqual(rc, 1)
+        mw.assert_not_called()
+        self.assertEqual(track.body, original_body)
+        self.assertNotIn("(not fetched)", out)
+        self.assertIn("#3", out)
+        self.assertNotIn("All tracks in sync.", out)
+
+    def test_total_fetch_failure_skips_track(self):
+        """Fetch returns nothing (GitHub unreachable) → track skipped, rc=1,
+        no write, table untouched."""
+        existing = [_gh(1, "first"), _gh(2, "second")]
+        track = _track(name="t", repo="o/r", issues=[1, 2],
+                       body=_canon_body(existing))
+        rc, mw, out = _drive(track, [], ["t", "--yes"])
+        self.assertEqual(rc, 1)
+        mw.assert_not_called()
+        self.assertIn("no issues", out)
+
+    def test_healthy_track_still_refreshes_alongside_degraded(self):
+        """In an --all batch, a complete-fetch track writes normally while a
+        degraded track is skipped; the run still exits nonzero overall."""
+        good_existing = [_gh(1, "first", "OPEN")]
+        good = _track(name="good", repo="o/r", issues=[1],
+                      body=_canon_body(good_existing))
+        bad = _track(name="bad", repo="o/r", issues=[5, 6],
+                     body=_canon_body([_gh(5, "fifth"), _gh(6, "sixth")]))
+
+        # good: #1 fetched (and flipped to CLOSED so there's a write); bad: #6 missing.
+        fetched = [_gh(1, "first", "CLOSED"), _gh(5, "fifth")]
+        cfg = {"notes_root": "/tmp/fake"}
+        with patch("commands.refresh_md.load_config", return_value=cfg), \
+             patch("commands.refresh_md.discover_tracks", return_value=[good, bad]), \
+             patch("commands.refresh_md.fetch_issues", return_value=fetched), \
+             patch("commands.refresh_md.write_file") as mw:
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = refresh_md.run(["--all", "--yes"])
+        out = buf.getvalue()
+        self.assertEqual(rc, 1)
+        # Only the healthy track is written.
+        self.assertEqual(mw.call_count, 1)
+        written_path = mw.call_args[0][0]
+        self.assertEqual(written_path.name, "good.md")
+        self.assertIn("#6", out)  # degraded track's missing issue is reported
+
+    def test_table_only_number_absent_from_frontmatter_does_not_gate(self):
+        """A number that appears in the body table but NOT in frontmatter
+        doesn't feed the rebuild, so a fetch miss on it is harmless — the track
+        still refreshes (rc=0)."""
+        # Frontmatter membership is [1, 2]; the body also references #99, which
+        # is not in frontmatter. #99 is not fetched, but must not block.
+        existing = [_gh(1, "first", "OPEN"), _gh(2, "second")]
+        body = _canon_body(existing) + "\nSee also #99 for context.\n"
+        track = _track(name="t", repo="o/r", issues=[1, 2], body=body)
+        rc, mw, out = _drive(track, [_gh(1, "first", "CLOSED"), _gh(2, "second")],
+                             ["t", "--yes"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertNotIn("(not fetched)", mw.call_args[0][2])
+
+
 class NarrativeTableTest(unittest.TestCase):
     """Tracks with NO canonical marker keep the conservative in-place behavior."""
 

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

@@ -0,0 +1,77 @@
+"""Tests for the non-interactive remove-repo command (#290).
+
+Covers:
+- Removing an existing key → yq called with del(.repos.<key>); rc 0.
+- Missing key (not in config) → rc 1, yq NOT called.
+- Invalid key format → rc 2, yq NOT called.
+- No positional key → rc 2.
+"""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import remove_repo
+
+
+def _make_cfg(*, notes_root="/tmp/fake-notes", repos=None):
+    return {"notes_root": notes_root, "repos": repos or {}}
+
+
+def _drive(args, *, existing_repos=None):
+    cfg = _make_cfg(repos=existing_repos or {})
+    mock_proc = MagicMock(returncode=0, stdout="", stderr="")
+    with patch("commands.remove_repo.load_config", return_value=cfg), \
+         patch("commands.remove_repo.subprocess.run", return_value=mock_proc) as msub, \
+         patch("pathlib.Path.exists", return_value=False):
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = remove_repo.run(args)
+    return rc, msub, buf.getvalue()
+
+
+class RemoveRepoTest(unittest.TestCase):
+
+    def test_removes_existing_key(self):
+        """Existing key → yq del(.repos.<key>) called; rc 0; '✓ Removed' printed."""
+        existing = {"mykey": {"github": "org/myrepo", "local": "/some/path"}}
+        rc, msub, out = _drive(["mykey"], existing_repos=existing)
+        self.assertEqual(rc, 0)
+        msub.assert_called_once()
+        yq_args = msub.call_args[0][0]
+        self.assertEqual(yq_args[0], "yq")
+        self.assertEqual(yq_args[1], "-i")
+        self.assertEqual(yq_args[2], "del(.repos.mykey)")
+        self.assertIn("✓ Removed", out)
+        # Config-only note surfaces the untouched local clone.
+        self.assertIn("config-only", out)
+
+    def test_missing_key_returns_rc1(self):
+        """Key not in config.repos → rc 1, yq NOT called."""
+        existing = {"otherkey": {"github": "org/other"}}
+        rc, msub, out = _drive(["mykey"], existing_repos=existing)
+        self.assertEqual(rc, 1)
+        msub.assert_not_called()
+        self.assertIn("not found", out)
+
+    def test_invalid_key_format_returns_rc2(self):
+        """Uppercase key → rc 2, yq NOT called (validated before load)."""
+        rc, msub, out = _drive(["MyKey"], existing_repos={"MyKey": {}})
+        self.assertEqual(rc, 2)
+        msub.assert_not_called()
+        self.assertIn("not a valid key", out)
+
+    def test_no_key_returns_rc2(self):
+        """No positional key → rc 2, yq NOT called."""
+        rc, msub, out = _drive([], existing_repos={})
+        self.assertEqual(rc, 2)
+        msub.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -75,3 +75,63 @@ class SetFieldTest(unittest.TestCase):
         self.assertEqual(rc, 0)
         mw.assert_not_called()
         self.assertIn("needs_confirm", out)
+
+
+class SetFieldPlanTest(unittest.TestCase):
+    """`set <track> plan=<rel>` — the #285 track↔plan frontmatter link."""
+
+    def _track(self, folder="demo", meta=None):
+        return SimpleNamespace(
+            name="ph", repo="o/r", folder=folder, path=Path("/tmp/ph.md"),
+            has_frontmatter=True, meta=meta if meta is not None else {"status": "active"},
+            body="# b")
+
+    def _drive_plan(self, args, track, cfg=None):
+        base_cfg = {"notes_root": "/tmp"}
+        if cfg:
+            base_cfg.update(cfg)
+        with patch("commands.set_field.load_config", return_value=base_cfg), \
+             patch("commands.set_field.discover_tracks", return_value=[track]), \
+             patch("lib.write_guard.repo_visibility", return_value="PRIVATE"), \
+             patch("commands.set_field.resolve_local_path_for_folder", return_value=None), \
+             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()
+
+    def test_sets_plan_path(self):
+        t = self._track()
+        rc, mw, out = self._drive_plan(["ph", "plan=docs/plans/p.md"], t)
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertEqual(mw.call_args[0][1]["plan"], "docs/plans/p.md")
+
+    def test_empty_plan_clears_link(self):
+        t = self._track(meta={"status": "active", "plan": "docs/plans/old.md"})
+        rc, mw, out = self._drive_plan(["ph", "plan="], t)
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertNotIn("plan", mw.call_args[0][1])  # key removed, not written as ""
+        self.assertIn("cleared", out)
+
+    def test_unresolved_plan_path_warns_but_saves(self):
+        # local path exists but the file doesn't -> WARN on stderr, still writes.
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            t = self._track()
+            with patch("commands.set_field.load_config", return_value={"notes_root": "/tmp"}), \
+                 patch("commands.set_field.discover_tracks", return_value=[t]), \
+                 patch("lib.write_guard.repo_visibility", return_value="PRIVATE"), \
+                 patch("commands.set_field.resolve_local_path_for_folder",
+                       return_value=Path(d)), \
+                 patch("commands.set_field.write_file") as mw:
+                err = io.StringIO()
+                from contextlib import redirect_stderr
+                buf = io.StringIO()
+                with redirect_stdout(buf), redirect_stderr(err):
+                    rc = set_field.run(["ph", "plan=docs/plans/missing.md"])
+            self.assertEqual(rc, 0)
+            mw.assert_called_once()
+            self.assertEqual(mw.call_args[0][1]["plan"], "docs/plans/missing.md")
+            self.assertIn("does not resolve", err.getvalue())