@stylusnexus/work-plan 2026.6.11 → 2026.6.13-2

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

@@ -0,0 +1,279 @@
+"""Tests for the plan-branch command (#260 Phase 3). All git + config writes
+are mocked — offline, no real repo or yq touched.
+"""
+import io
+import json
+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 plan_branch as pb
+
+
+def _cfg(plan_branch=None, local="/tmp/repo", github="o/r", visibility=None):
+    entry = {"github": github}
+    if local is not None:
+        entry["local"] = local
+    if plan_branch is not None:
+        entry["plan_branch"] = plan_branch
+    return {"notes_root": "/tmp/notes", "repos": {"myrepo": entry}}
+
+
+def _run(args, *, cfg, pw=None, needs=False, valid=True, repo_ok=True,
+         set_ok=True):
+    """Drive plan_branch.run with the lib + guards mocked. `pw` is a dict of
+    plan_worktree function-name → MagicMock/return overrides."""
+    pwmod = MagicMock()
+    # sensible defaults
+    pwmod._branch_exists.return_value = False
+    pwmod.local_branch_exists.return_value = True
+    pwmod.is_published.return_value = False
+    pwmod.unpushed_oneline.return_value = []
+    pwmod.fetch_branch.return_value = True
+    pwmod.ensure_worktree.return_value = Path("/wt")
+    pwmod.create_orphan_worktree.return_value = Path("/wt")
+    pwmod.dirty_work_plan_paths.return_value = [".work-plan/README.md"]
+    pwmod.commit_shared_tier.return_value = "abc1234"
+    pwmod.push_plan_branch.return_value = MagicMock(returncode=0, stderr="")
+    # Overrides set each function's return_value (the function stays a MagicMock
+    # so call-count assertions still work).
+    for k, v in (pw or {}).items():
+        getattr(pwmod, k).return_value = v
+    with patch("commands.plan_branch.load_config", return_value=cfg), \
+         patch("commands.plan_branch.is_valid_git_repo", return_value=repo_ok), \
+         patch("commands.plan_branch.seed_readme", return_value=True), \
+         patch("commands.plan_branch.needs_confirm", return_value=needs), \
+         patch("commands.plan_branch.valid_token", return_value=valid), \
+         patch("commands.plan_branch.make_token", return_value="tok123"), \
+         patch("commands.plan_branch._set_plan_branch", return_value=set_ok), \
+         patch("commands.plan_branch.pw", pwmod):
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = pb.run(args)
+    return rc, buf.getvalue(), pwmod
+
+
+class UsageTest(unittest.TestCase):
+    def test_bad_action_rc2(self):
+        rc, out, _ = _run(["frobnicate", "myrepo"], cfg=_cfg())
+        self.assertEqual(rc, 2)
+        self.assertIn("usage", out)
+
+    def test_no_action_rc2(self):
+        rc, out, _ = _run([], cfg=_cfg())
+        self.assertEqual(rc, 2)
+
+
+class ResolveRepoTest(unittest.TestCase):
+    def test_unconfigured_repo_errs(self):
+        rc, out, _ = _run(["status", "nope"], cfg=_cfg())
+        self.assertEqual(rc, 1)
+        self.assertIn("not a configured repo", out)
+
+    def test_missing_local_path_errs(self):
+        rc, out, _ = _run(["status", "myrepo"], cfg=_cfg(local=None))
+        self.assertEqual(rc, 1)
+        self.assertIn("no local clone path", out)
+
+    def test_not_a_git_repo_errs(self):
+        rc, out, _ = _run(["status", "myrepo"], cfg=_cfg(), repo_ok=False)
+        self.assertEqual(rc, 1)
+        self.assertIn("not a git repository", out)
+
+    def test_single_repo_inferred_when_arg_omitted(self):
+        rc, out, _ = _run(["status"], cfg=_cfg(plan_branch="work-plan/plan"))
+        self.assertEqual(rc, 0)
+
+    def test_ambiguous_repo_requires_arg(self):
+        cfg = _cfg(plan_branch="x")
+        cfg["repos"]["other"] = {"github": "o/o", "local": "/tmp/o"}
+        rc, out, _ = _run(["status"], cfg=cfg)
+        self.assertEqual(rc, 1)
+        self.assertIn("specify which repo", out)
+
+
+class InitTest(unittest.TestCase):
+    def test_create_orphan_when_branch_absent(self):
+        rc, out, pwmod = _run(["init", "myrepo"], cfg=_cfg(),
+                              pw={"_branch_exists": False})
+        self.assertEqual(rc, 0)
+        pwmod.create_orphan_worktree.assert_called_once()
+        pwmod.commit_shared_tier.assert_called_once()
+        pwmod.ensure_worktree.assert_not_called()
+        self.assertIn("Created orphan branch 'work-plan/plan'", out)
+        self.assertIn("Recorded plan_branch", out)
+
+    def test_connect_when_branch_exists(self):
+        rc, out, pwmod = _run(["init", "myrepo"], cfg=_cfg(),
+                              pw={"_branch_exists": True})
+        self.assertEqual(rc, 0)
+        pwmod.ensure_worktree.assert_called_once()
+        pwmod.create_orphan_worktree.assert_not_called()
+        self.assertIn("Connected", out)
+
+    def test_custom_branch_name(self):
+        rc, out, pwmod = _run(["init", "myrepo", "--branch=wp/custom"],
+                              cfg=_cfg(), pw={"_branch_exists": False})
+        self.assertEqual(rc, 0)
+        self.assertIn("wp/custom", out)
+
+    def test_invalid_branch_rc2(self):
+        for bad in ["--branch=-evil", "--branch=a..b", "--branch=/lead",
+                    "--branch=trail/", "--branch=a//b"]:
+            rc, out, _ = _run(["init", "myrepo", bad], cfg=_cfg())
+            self.assertEqual(rc, 2, bad)
+            self.assertIn("not a valid branch", out)
+
+    def test_refuses_switching_existing_plan_branch(self):
+        rc, out, _ = _run(["init", "myrepo", "--branch=work-plan/other"],
+                          cfg=_cfg(plan_branch="work-plan/plan"))
+        self.assertEqual(rc, 1)
+        self.assertIn("already has plan_branch", out)
+
+    def test_commit_failure_errs(self):
+        rc, out, _ = _run(["init", "myrepo"], cfg=_cfg(),
+                          pw={"_branch_exists": False, "commit_shared_tier": None})
+        self.assertEqual(rc, 1)
+        self.assertIn("initial commit failed", out)
+
+    def test_orphan_creation_failure_errs(self):
+        rc, out, _ = _run(["init", "myrepo"], cfg=_cfg(),
+                          pw={"_branch_exists": False,
+                              "create_orphan_worktree": None})
+        self.assertEqual(rc, 1)
+        self.assertIn("could not create the plan worktree", out)
+
+    def test_public_repo_push_warning_shown(self):
+        rc, out, _ = _run(["init", "myrepo"], cfg=_cfg(),
+                          pw={"_branch_exists": False}, needs=True)
+        self.assertEqual(rc, 0)
+        self.assertIn("public", out.lower())
+
+
+class StatusTest(unittest.TestCase):
+    def test_no_plan_branch(self):
+        rc, out, _ = _run(["status", "myrepo"], cfg=_cfg())
+        self.assertEqual(rc, 0)
+        self.assertIn("no plan_branch configured", out)
+
+    def test_no_plan_branch_json(self):
+        rc, out, _ = _run(["status", "myrepo", "--json"], cfg=_cfg())
+        self.assertEqual(rc, 0)
+        self.assertEqual(json.loads(out)["configured"], False)
+
+    def test_published_with_unpushed(self):
+        rc, out, _ = _run(["status", "myrepo"], cfg=_cfg(plan_branch="work-plan/plan"),
+                          pw={"is_published": True,
+                              "unpushed_oneline": ["a1 one", "b2 two"]})
+        self.assertEqual(rc, 0)
+        self.assertIn("on origin", out)
+        self.assertIn("2 commit(s)", out)
+
+    def test_local_only_json_shape(self):
+        rc, out, _ = _run(["status", "myrepo", "--json"],
+                          cfg=_cfg(plan_branch="work-plan/plan"),
+                          pw={"is_published": False, "local_branch_exists": True,
+                              "unpushed_oneline": ["a1 x"]})
+        d = json.loads(out)
+        self.assertEqual(d["plan_branch"], "work-plan/plan")
+        self.assertTrue(d["configured"])
+        self.assertFalse(d["published"])
+        self.assertEqual(d["unpushed_count"], 1)
+
+
+class PushTest(unittest.TestCase):
+    def test_no_plan_branch_errs(self):
+        rc, out, _ = _run(["push", "myrepo"], cfg=_cfg())
+        self.assertEqual(rc, 1)
+        self.assertIn("no plan_branch", out)
+
+    def test_local_branch_missing_errs(self):
+        rc, out, _ = _run(["push", "myrepo"], cfg=_cfg(plan_branch="work-plan/plan"),
+                          pw={"local_branch_exists": False})
+        self.assertEqual(rc, 1)
+        self.assertIn("doesn't exist locally", out)
+
+    def test_nothing_to_push(self):
+        rc, out, pwmod = _run(["push", "myrepo"],
+                             cfg=_cfg(plan_branch="work-plan/plan"),
+                             pw={"unpushed_oneline": []})
+        self.assertEqual(rc, 0)
+        self.assertIn("Nothing to push", out)
+        pwmod.push_plan_branch.assert_not_called()
+
+    def test_dry_run_lists_without_pushing(self):
+        rc, out, pwmod = _run(["push", "myrepo", "--dry-run"],
+                             cfg=_cfg(plan_branch="work-plan/plan"),
+                             pw={"unpushed_oneline": ["a1 one", "b2 two"]})
+        self.assertEqual(rc, 0)
+        self.assertIn("Would push 2 commit(s)", out)
+        pwmod.push_plan_branch.assert_not_called()
+
+    def test_public_repo_blocks_without_confirm(self):
+        rc, out, pwmod = _run(["push", "myrepo"],
+                             cfg=_cfg(plan_branch="work-plan/plan"),
+                             pw={"unpushed_oneline": ["a1 x"]},
+                             needs=True, valid=False)
+        self.assertEqual(rc, 0)
+        d = json.loads(out)
+        self.assertTrue(d["needs_confirm"])
+        self.assertEqual(d["token"], "tok123")
+        self.assertIn("visible to anyone on the internet", d["reason"])
+        pwmod.push_plan_branch.assert_not_called()
+
+    def test_public_repo_pushes_with_valid_confirm(self):
+        rc, out, pwmod = _run(["push", "myrepo", "--confirm=tok123"],
+                             cfg=_cfg(plan_branch="work-plan/plan"),
+                             pw={"unpushed_oneline": ["a1 x"]},
+                             needs=True, valid=True)
+        self.assertEqual(rc, 0)
+        pwmod.push_plan_branch.assert_called_once()
+        self.assertIn("Pushed", out)
+
+    def test_empty_github_still_gated(self):
+        # Regression: a config entry with an empty/unknown github must NOT skip
+        # the gate. needs_confirm fails CLOSED on unknown visibility; the old
+        # `github and needs_confirm(...)` short-circuit defeated that and pushed
+        # unguarded. With the guard removed the gate fires.
+        rc, out, pwmod = _run(["push", "myrepo"],
+                             cfg=_cfg(plan_branch="work-plan/plan", github=""),
+                             pw={"unpushed_oneline": ["a1 x"]},
+                             needs=True, valid=False)
+        self.assertEqual(rc, 0)
+        self.assertIn("needs_confirm", out)
+        pwmod.push_plan_branch.assert_not_called()
+
+    def test_private_repo_pushes_without_gate(self):
+        rc, out, pwmod = _run(["push", "myrepo"],
+                             cfg=_cfg(plan_branch="work-plan/plan"),
+                             pw={"unpushed_oneline": ["a1 x"]}, needs=False)
+        self.assertEqual(rc, 0)
+        pwmod.push_plan_branch.assert_called_once()
+
+    def test_protected_branch_failure_actionable(self):
+        proc = MagicMock(returncode=1, stderr="remote: protected branch hook declined")
+        rc, out, _ = _run(["push", "myrepo"],
+                          cfg=_cfg(plan_branch="work-plan/plan"),
+                          pw={"unpushed_oneline": ["a1 x"],
+                              "push_plan_branch": proc}, needs=False)
+        self.assertEqual(rc, 1)
+        self.assertIn("protected", out.lower())
+        self.assertIn("work-plan/**", out)
+
+    def test_generic_push_failure(self):
+        proc = MagicMock(returncode=1, stderr="fatal: unable to access")
+        rc, out, _ = _run(["push", "myrepo"],
+                          cfg=_cfg(plan_branch="work-plan/plan"),
+                          pw={"unpushed_oneline": ["a1 x"],
+                              "push_plan_branch": proc}, needs=False)
+        self.assertEqual(rc, 1)
+        self.assertIn("push failed", out)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,109 @@
+"""plan-confirm (#286): frontmatter-only verdict_override writes, with the
+public-repo confirm-token gate. Uses a real temp repo so the frontmatter write
+round-trips through real yq; config + visibility are mocked (offline)."""
+import io
+import json
+import unittest
+import sys
+import tempfile
+from contextlib import redirect_stdout, redirect_stderr
+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_confirm
+from lib import frontmatter
+from lib.write_guard import make_token
+
+REL = "docs/superpowers/plans/p.md"
+BODY = "# Idea Mode UI\n\nbody text the writer must never touch\n"
+
+
+class PlanConfirmTest(unittest.TestCase):
+    def _repo(self, d, doc_text=BODY):
+        root = Path(d)
+        (root / "docs/superpowers/plans").mkdir(parents=True)
+        (root / REL).write_text(doc_text)
+        return root
+
+    def _drive(self, root, args, slug=None, vis="PRIVATE"):
+        cfg = {"notes_root": str(root), "repos": {}}
+        with mock.patch("commands.plan_confirm.config_mod.load_config", return_value=cfg), \
+             mock.patch("commands.plan_confirm.config_mod.resolve_local_path_for_folder",
+                        return_value=root), \
+             mock.patch("commands.plan_confirm.config_mod.resolve_github_for_folder",
+                        return_value=slug), \
+             mock.patch("lib.write_guard.repo_visibility", return_value=vis):
+            out, err = io.StringIO(), io.StringIO()
+            with redirect_stdout(out), redirect_stderr(err):
+                rc = plan_confirm.run(args)
+        # stdout carries the machine surfaces (needs_confirm JSON, success line);
+        # stderr carries usage/validation errors. Tests assert on either.
+        return rc, out.getvalue(), err.getvalue()
+
+    def test_writes_override_to_frontmatter_preserving_body(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out, err = self._drive(root, ["--repo=k", "--verdict=shipped", "--", REL])
+            self.assertEqual(rc, 0)
+            meta, body = frontmatter.parse_file(root / REL)
+            self.assertEqual(meta["verdict_override"], "shipped")
+            self.assertEqual(body, BODY)        # body byte-preserved
+            self.assertIn("frontmatter only", out)
+
+    def test_clear_removes_override(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d, f"---\nverdict_override: shipped\n---\n{BODY}")
+            rc, out, err = self._drive(root, ["--repo=k", "--clear", "--", REL])
+            self.assertEqual(rc, 0)
+            meta, body = frontmatter.parse_file(root / REL)
+            self.assertNotIn("verdict_override", meta)
+            self.assertEqual(body, BODY)
+
+    def test_public_repo_no_token_returns_needs_confirm(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out, err = self._drive(root, ["--repo=k", "--verdict=shipped", "--", REL],
+                                  slug="org/pub", vis="PUBLIC")
+            self.assertEqual(rc, 0)
+            data = json.loads(out)
+            self.assertTrue(data["needs_confirm"])
+            self.assertEqual(data["token"], make_token("org/pub", REL))
+            # NO write happened.
+            meta, _ = frontmatter.parse_file(root / REL)
+            self.assertNotIn("verdict_override", meta)
+
+    def test_public_repo_with_valid_token_writes(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            token = make_token("org/pub", REL)
+            rc, out, err = self._drive(
+                root, ["--repo=k", "--verdict=shipped", f"--confirm={token}", "--", REL],
+                slug="org/pub", vis="PUBLIC")
+            self.assertEqual(rc, 0)
+            meta, _ = frontmatter.parse_file(root / REL)
+            self.assertEqual(meta["verdict_override"], "shipped")
+
+    def test_path_escape_rejected(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out, err = self._drive(root, ["--repo=k", "--verdict=shipped", "--",
+                                         "../../etc/passwd"])
+            self.assertEqual(rc, 1)
+            self.assertIn("not a file inside", err)
+
+    def test_invalid_verdict_rejected(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out, err = self._drive(root, ["--repo=k", "--verdict=done", "--", REL])
+            self.assertEqual(rc, 2)
+
+    def test_missing_repo_flag_rejected(self):
+        rc, out, err = self._drive(Path("/tmp"), ["--verdict=shipped", "--", REL])
+        self.assertEqual(rc, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,145 @@
+"""verdict_override (#286): a frontmatter override pins the verdict and silences
+the lie-gap on plan-status. Offline — frontmatter parse shells to real yq."""
+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
+
+# A plan whose ONE declared file exists (→ mechanical "shipped", file score 100%)
+# but whose two phase checkboxes are unticked → the classic lie-gap shape.
+BODY = (
+    "# Idea Mode UI\n\n"
+    "**Files:**\n"
+    "- Create: `src/new.ts`\n"
+    "- [ ] Step 1: do the thing\n"
+    "- [ ] Step 2: do the other thing\n"
+)
+
+
+def _frontmattered(override: str) -> str:
+    return f"---\nverdict_override: {override}\n---\n{BODY}"
+
+
+def _frontmattered_kv(key: str, value: str) -> str:
+    return f"---\n{key}: {value}\n---\n{BODY}"
+
+
+class OverrideTest(unittest.TestCase):
+    def _row(self, root):
+        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)
+        return json.loads(buf.getvalue())["docs"][0]
+
+    def _repo(self, d, doc_text):
+        root = Path(d)
+        (root / "docs/superpowers/plans").mkdir(parents=True)
+        (root / "docs/superpowers/plans/p.md").write_text(doc_text)
+        (root / "src").mkdir()
+        (root / "src/new.ts").write_text("export const x = 1")  # 1/1 declared present
+        return root
+
+    def test_baseline_lie_gap_without_override(self):
+        with tempfile.TemporaryDirectory() as d:
+            row = self._row(self._repo(d, BODY))
+            self.assertEqual(row["verdict"], "shipped")
+            self.assertTrue(row["lie_gap"])      # 0/2 boxes -> lie-gap fires
+            self.assertIsNone(row["override"])
+
+    def test_override_shipped_silences_lie_gap(self):
+        with tempfile.TemporaryDirectory() as d:
+            row = self._row(self._repo(d, _frontmattered("shipped")))
+            self.assertEqual(row["verdict"], "shipped")
+            self.assertEqual(row["override"], "shipped")
+            self.assertFalse(row["lie_gap"])     # human-confirmed -> no longer a lie
+            self.assertIn("human-confirmed", row["rationale"])
+
+    def test_override_pins_verdict_over_mechanical(self):
+        # Declared file MISSING -> mechanical would be partial; override pins dead.
+        with tempfile.TemporaryDirectory() as d:
+            root = Path(d)
+            (root / "docs/superpowers/plans").mkdir(parents=True)
+            (root / "docs/superpowers/plans/p.md").write_text(_frontmattered("dead"))
+            # no src/new.ts -> 0/1 files
+            row = self._row(root)
+            self.assertEqual(row["verdict"], "dead")
+            self.assertEqual(row["override"], "dead")
+            self.assertEqual(row["glyph"], "💀")
+
+    def test_invalid_override_value_ignored(self):
+        with tempfile.TemporaryDirectory() as d:
+            row = self._row(self._repo(d, _frontmattered("done")))  # not a valid verdict
+            self.assertIsNone(row["override"])
+            self.assertTrue(row["lie_gap"])      # falls back to mechanical
+
+    def test_acknowledged_frontmatter_emitted(self):
+        with tempfile.TemporaryDirectory() as d:
+            row = self._row(self._repo(d, f"---\nacknowledged: true\n---\n{BODY}"))
+            self.assertTrue(row["acknowledged"])
+
+    def test_acknowledged_false_without_frontmatter(self):
+        with tempfile.TemporaryDirectory() as d:
+            row = self._row(self._repo(d, BODY))
+            self.assertFalse(row["acknowledged"])
+
+    def test_baseline_matching_live_verdict_no_drift(self):
+        # File present → live "shipped"; baseline shipped → no drift.
+        with tempfile.TemporaryDirectory() as d:
+            row = self._row(self._repo(d, _frontmattered_kv("verdict_baseline", "shipped")))
+            self.assertEqual(row["verdict_baseline"], "shipped")
+            self.assertFalse(row["verdict_drift"])
+
+    def test_baseline_diverged_flags_drift(self):
+        # File MISSING → live "partial"; baseline shipped → drift (regressed).
+        with tempfile.TemporaryDirectory() as d:
+            root = Path(d)
+            (root / "docs/superpowers/plans").mkdir(parents=True)
+            (root / "docs/superpowers/plans/p.md").write_text(
+                f"---\nverdict_baseline: shipped\n---\n{BODY}")  # no src/new.ts
+            row = self._row(root)
+            self.assertEqual(row["verdict"], "partial")
+            self.assertTrue(row["verdict_drift"])
+
+    def test_override_suppresses_drift(self):
+        # baseline partial, but a human override pins shipped → drift suppressed.
+        with tempfile.TemporaryDirectory() as d:
+            row = self._row(self._repo(
+                d, "---\nverdict_baseline: partial\nverdict_override: shipped\n---\n" + BODY))
+            self.assertEqual(row["verdict"], "shipped")
+            self.assertFalse(row["verdict_drift"])
+
+    def test_no_baseline_no_drift(self):
+        with tempfile.TemporaryDirectory() as d:
+            row = self._row(self._repo(d, BODY))
+            self.assertIsNone(row["verdict_baseline"])
+            self.assertFalse(row["verdict_drift"])
+
+    def test_offtree_paths_flagged(self):
+        # A plan declaring an out-of-tree path surfaces it read-only (#286 slice 3).
+        body = ("# P\n\n**Files:**\n- Create: `src/new.ts`\n"
+                "- Create: `../sibling/escape.ts`\n- [ ] Step 1\n")
+        with tempfile.TemporaryDirectory() as d:
+            row = self._row(self._repo(d, body))
+            self.assertEqual(row["offtree_paths"], ["../sibling/escape.ts"])
+
+    def test_offtree_paths_empty_for_clean_manifest(self):
+        with tempfile.TemporaryDirectory() as d:
+            row = self._row(self._repo(d, BODY))
+            self.assertEqual(row["offtree_paths"], [])
+
+
+if __name__ == "__main__":
+    unittest.main()