@stylusnexus/work-plan 2026.6.11 → 2026.6.13

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

@@ -0,0 +1,219 @@
+"""Tests for the plan-status staleness clock (#164).
+
+The clock keys off a plan's DECLARED manifest files (which get committed) — not
+the plan doc's own git date, which is null because plan docs are gitignored.
+All git is mocked; these run offline.
+"""
+import sys
+import unittest
+from datetime import date, datetime
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from lib import git_state
+from lib import manifest
+from lib import verdict as verdict_mod
+from commands import plan_status
+
+
+class TestPathsLastCommitDate(unittest.TestCase):
+    def test_returns_max_date_over_paths(self):
+        proc = mock.Mock(returncode=0, stdout="2026-06-10T12:00:00+00:00")
+        with mock.patch.object(Path, "exists", return_value=True), \
+                mock.patch.object(git_state, "_git", return_value=proc):
+            got = git_state.paths_last_commit_date(
+                ["a.py", "b.py"], Path("/repo"))
+        self.assertEqual(got, datetime(2026, 6, 10, 12, 0, 0))
+
+    def test_empty_paths_is_none(self):
+        with mock.patch.object(Path, "exists", return_value=True), \
+                mock.patch.object(git_state, "_git") as g:
+            self.assertIsNone(git_state.paths_last_commit_date([], Path("/repo")))
+            g.assert_not_called()
+
+    def test_empty_stdout_is_none(self):
+        proc = mock.Mock(returncode=0, stdout="")
+        with mock.patch.object(Path, "exists", return_value=True), \
+                mock.patch.object(git_state, "_git", return_value=proc):
+            self.assertIsNone(
+                git_state.paths_last_commit_date(["a.py"], Path("/repo")))
+
+
+class TestStallDaysConstant(unittest.TestCase):
+    def test_default_is_14(self):
+        self.assertEqual(verdict_mod.STALL_DAYS, 14)
+
+
+class TestUncheckedCheckboxLabels(unittest.TestCase):
+    def test_captures_unticked_labels_in_order(self):
+        text = (
+            "- [x] Phase 1 — git helper\n"
+            "- [x] Phase 2 — manifest\n"
+            "- [ ] Phase 4 — tests\n"
+            "- [ ] Phase 5 — docs\n"
+        )
+        self.assertEqual(
+            manifest.unchecked_checkbox_labels(text),
+            ["Phase 4 — tests", "Phase 5 — docs"],
+        )
+
+    def test_cap_limits_results(self):
+        text = "\n".join(f"- [ ] item {i}" for i in range(20))
+        got = manifest.unchecked_checkbox_labels(text)
+        self.assertEqual(len(got), 10)
+        self.assertEqual(got[0], "item 0")
+
+
+class _FakePath:
+    def __init__(self, name):
+        self.name = name
+
+
+class _Doc:
+    @classmethod
+    def make(cls, rel="plans/p.md", kind="plan", name="2026-05-01-p.md"):
+        d = cls.__new__(cls)
+        d.rel = rel
+        d.kind = kind
+        d.path = _FakePath(name)
+        return d
+
+
+def _decl(path):
+    return manifest.DeclaredPath(kind="create", path=path)
+
+
+class TestEvaluateStaleness(unittest.TestCase):
+    """The staleness ladder fires only for partial verdicts and keys off the
+    manifest files' commit date, not the plan doc's own (gitignored) date."""
+
+    def setUp(self):
+        self.today = date(2026, 6, 12)
+        self.partial = verdict_mod.Verdict("partial", "\U0001f7e1", "files")
+        self.decls = [_decl("src/a.py"), _decl("src/b.py")]
+
+    def _evaluate(self, manifest_date, on_disk, verdict=None, text="body"):
+        """Run _evaluate with manifest.* / git_state.* / classify mocked.
+
+        manifest_date: what paths_last_commit_date returns.
+        on_disk: which declared paths _declared_paths_on_disk reports present.
+        """
+        v = verdict or self.partial
+        doc = _Doc.make()
+        with mock.patch.object(plan_status, "_read", return_value=text), \
+                mock.patch.object(manifest, "parse_declared_paths", return_value=self.decls), \
+                mock.patch.object(manifest, "plan_date_from_filename", return_value=None), \
+                mock.patch.object(manifest, "score_manifest",
+                                  return_value=manifest.ManifestScore(2, 1, {})), \
+                mock.patch.object(manifest, "count_checkboxes", return_value=(1, 4)), \
+                mock.patch.object(manifest, "out_of_tree_ratio", return_value=0.0), \
+                mock.patch.object(manifest, "unchecked_checkbox_labels",
+                                  return_value=["do x"]), \
+                mock.patch.object(plan_status, "_declared_paths_on_disk",
+                                  return_value=on_disk), \
+                mock.patch.object(git_state, "path_last_commit_date", return_value=None), \
+                mock.patch.object(git_state, "paths_last_commit_date",
+                                  return_value=manifest_date), \
+                mock.patch.object(verdict_mod, "classify", return_value=v):
+            return plan_status._evaluate(doc, Path("/repo"), self.today, 60, 14)
+
+    def test_partial_cold_is_stalled(self):
+        cold = datetime(2026, 5, 1, 12, 0, 0)  # 42 days before today
+        row = self._evaluate(cold, ["src/a.py", "src/b.py"])
+        self.assertTrue(row["stalled"])
+        self.assertEqual(row["manifest_last_touched"], "2026-05-01")
+
+    def test_partial_warm_is_not_stalled(self):
+        warm = datetime(2026, 6, 10, 12, 0, 0)  # 2 days before today
+        row = self._evaluate(warm, ["src/a.py"])
+        self.assertFalse(row["stalled"])
+
+    def test_partial_no_files_on_disk_is_not_stalled(self):
+        row = self._evaluate(None, [])
+        self.assertFalse(row["stalled"])
+        self.assertIsNone(row["manifest_last_touched"])
+
+    def test_doc_uncommitted_but_manifest_committed_is_stalled(self):
+        # path_last_commit_date (doc) is None, but manifest committed 42d ago.
+        cold = datetime(2026, 5, 1, 12, 0, 0)
+        row = self._evaluate(cold, ["src/a.py"])
+        self.assertTrue(row["stalled"])
+        self.assertIsNone(row["last_touched"])  # doc date stays None
+
+    def test_present_but_never_committed_is_stalled(self):
+        # files exist on disk but manifest date is None -> never committed
+        row = self._evaluate(None, ["src/a.py"])
+        self.assertTrue(row["stalled"])
+
+    def test_emits_unchecked_items_and_stall_days(self):
+        row = self._evaluate(datetime(2026, 6, 10), ["src/a.py"])
+        self.assertEqual(row["unchecked_items"], ["do x"])
+        self.assertEqual(row["stall_days"], 14)
+
+    def test_non_partial_is_never_stalled(self):
+        shipped = verdict_mod.Verdict("shipped", "✅", "files")
+        row = self._evaluate(None, [], verdict=shipped)
+        self.assertFalse(row["stalled"])
+
+
+class TestResolveStallDays(unittest.TestCase):
+    def test_known_flag_set_includes_stall_days(self):
+        self.assertIn("--stall-days", plan_status.KNOWN)
+
+    def test_flag_beats_config_beats_default(self):
+        with mock.patch.object(plan_status.config_mod, "load_config",
+                               return_value={"stall_days": 30}):
+            self.assertEqual(
+                plan_status._resolve_stall_days({"--stall-days": "45"}), 45)
+
+    def test_config_beats_default(self):
+        with mock.patch.object(plan_status.config_mod, "load_config",
+                               return_value={"stall_days": 30}):
+            self.assertEqual(plan_status._resolve_stall_days({}), 30)
+
+    def test_default_when_unset(self):
+        with mock.patch.object(plan_status.config_mod, "load_config",
+                               return_value={}):
+            self.assertEqual(plan_status._resolve_stall_days({}), 14)
+
+    def test_non_integer_flag_falls_through(self):
+        with mock.patch.object(plan_status.config_mod, "load_config",
+                               return_value={}):
+            self.assertEqual(
+                plan_status._resolve_stall_days({"--stall-days": "abc"}), 14)
+
+
+class TestDeclaredPathsOnDiskGuards(unittest.TestCase):
+    """A junk declared path ('/'), a directory, or an out-of-tree '../x' must be
+    excluded — otherwise they poison `git log -- <paths>` and falsely stall an
+    actively-built plan (regression from the smoke test for #164)."""
+
+    def test_excludes_root_slash_dirs_and_escapes_keeps_real_files(self):
+        import tempfile, os
+        from lib.manifest import DeclaredPath
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            (root / "src").mkdir()
+            real = "src/a.py"
+            (root / real).write_text("x")
+            # a sibling file outside the repo root
+            outside = Path(td).parent / "escape_probe_164.py"
+            try:
+                outside.write_text("x")
+                decls = [
+                    DeclaredPath(kind="create", path=real),       # real file -> kept
+                    DeclaredPath(kind="create", path="/"),        # resolves to FS root dir -> dropped
+                    DeclaredPath(kind="create", path="src"),      # a directory -> dropped
+                    DeclaredPath(kind="modify", path=f"../{outside.name}"),  # out-of-tree -> dropped
+                ]
+                got = plan_status._declared_paths_on_disk(decls, root)
+                self.assertEqual(got, [real])
+            finally:
+                if outside.exists():
+                    outside.unlink()
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,378 @@
+"""Tests for lib/plan_worktree — shared-tier path resolution + plan-branch
+worktree (#260). git is mocked (offline); never shells out.
+"""
+import sys
+import tempfile
+import unittest
+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 lib import plan_worktree as pw
+
+
+def _ok(stdout=""):
+    return MagicMock(returncode=0, stdout=stdout, stderr="")
+
+
+def _fail():
+    return MagicMock(returncode=1, stdout="", stderr="boom")
+
+
+class _FakeGit:
+    """Stand-in for plan_worktree._git.
+
+    branch_exists: whether `rev-parse --verify` succeeds for the branch refs.
+    add_ok:        whether `worktree add` succeeds.
+    missing:       if True, every call returns None (git absent / timeout).
+    staged:        whether the staged-paths diff reports changes.
+    on_branch:     the branch the worktree reports for `rev-parse --abbrev-ref
+                   HEAD` (cached-worktree reuse verifies this matches).
+    porcelain:     stdout for `status --porcelain -- .work-plan` (dirty paths).
+    """
+    def __init__(self, *, branch_exists=True, add_ok=True, missing=False,
+                 staged=False, head="abc1234", on_branch="plan", porcelain="",
+                 orphan_ok=True, rm_ok=True, fetch_ok=True, push_ok=True,
+                 oneline=""):
+        self.branch_exists = branch_exists
+        self.add_ok = add_ok
+        self.missing = missing
+        self.staged = staged   # whether the scoped diff reports staged changes
+        self.head = head
+        self.on_branch = on_branch
+        self.porcelain = porcelain
+        self.orphan_ok = orphan_ok
+        self.rm_ok = rm_ok
+        self.fetch_ok = fetch_ok
+        self.push_ok = push_ok
+        self.oneline = oneline   # stdout for `log --oneline`
+        self.calls = []
+
+    def __call__(self, cwd, *args, timeout=None):
+        self.calls.append(args)
+        if self.missing:
+            return None
+        sub = args[0] if args else ""
+        if sub == "rev-parse" and "--short" in args:
+            return _ok(self.head + "\n")
+        if sub == "rev-parse" and "--abbrev-ref" in args:
+            return _ok(self.on_branch + "\n")
+        if sub == "rev-parse":  # --verify --quiet <ref>
+            return _ok("deadbee\n") if self.branch_exists else _fail()
+        if sub == "worktree" and len(args) > 1 and args[1] == "add":
+            return _ok() if self.add_ok else _fail()
+        if sub == "-c" and "status" in args:  # -c core.quotepath=false status -z …
+            return _ok(self.porcelain)
+        if sub == "worktree" and len(args) > 1 and args[1] == "remove":
+            return _ok()
+        if sub == "checkout" and "--orphan" in args:
+            return _ok() if self.orphan_ok else _fail()
+        if sub == "rm":
+            return _ok() if self.rm_ok else _fail()
+        if sub == "fetch":
+            return _ok() if self.fetch_ok else _fail()
+        if sub == "push":
+            return MagicMock(returncode=0 if self.push_ok else 1,
+                             stdout="", stderr="" if self.push_ok else "denied")
+        if sub == "log" and "--oneline" in args:
+            return _ok(self.oneline)
+        if sub == "diff" and "--cached" in args:
+            return MagicMock(returncode=1 if self.staged else 0, stdout="", stderr="")
+        if sub == "commit":
+            self.staged = False
+            return _ok()
+        return _ok()  # add, etc.
+
+
+class SharedTierDirTest(unittest.TestCase):
+    def test_no_local_returns_none(self):
+        self.assertIsNone(pw.shared_tier_dir({"github": "o/r"}))
+        self.assertIsNone(pw.shared_tier_dir({}))
+
+    def test_no_plan_branch_uses_working_tree(self):
+        # Legacy behaviour: <local>/.work-plan, no git involved.
+        with tempfile.TemporaryDirectory() as d:
+            got = pw.shared_tier_dir({"local": d})
+            self.assertEqual(got, Path(d).expanduser() / ".work-plan")
+
+    def test_plan_branch_uses_worktree_when_present(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = Path(d) / "wt"
+            dest.mkdir()
+            (dest / ".git").write_text("gitdir: ...\n")  # a worktree gitdir pointer
+            with patch.object(pw, "_worktree_dir", return_value=dest), \
+                 patch.object(pw, "_git", _FakeGit()):
+                got = pw.shared_tier_dir({"local": d, "plan_branch": "plan"})
+            self.assertEqual(got, dest / ".work-plan")
+
+    def test_plan_branch_none_when_branch_missing(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = Path(d) / "wt"  # no .git → must be created, but branch missing
+            with patch.object(pw, "_worktree_dir", return_value=dest), \
+                 patch.object(pw, "_git", _FakeGit(branch_exists=False)):
+                got = pw.shared_tier_dir({"local": d, "plan_branch": "plan"})
+            self.assertIsNone(got)
+
+
+class EnsureWorktreeTest(unittest.TestCase):
+    def test_empty_branch_returns_none(self):
+        with tempfile.TemporaryDirectory() as d:
+            self.assertIsNone(pw.ensure_worktree(Path(d), ""))
+
+    def test_returns_existing_worktree_without_adding(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = Path(d) / "wt"
+            dest.mkdir()
+            (dest / ".git").write_text("gitdir: ...\n")
+            fake = _FakeGit()
+            with patch.object(pw, "_worktree_dir", return_value=dest), \
+                 patch.object(pw, "_git", fake):
+                got = pw.ensure_worktree(Path(d), "plan")
+            self.assertEqual(got, dest)
+            self.assertNotIn(("worktree", "add"), [tuple(c[:2]) for c in fake.calls])
+
+    def test_creates_worktree_when_branch_exists(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = Path(d) / "cache" / "wt"  # parent created by ensure_worktree
+            fake = _FakeGit(branch_exists=True, add_ok=True)
+            with patch.object(pw, "_worktree_dir", return_value=dest), \
+                 patch.object(pw, "_git", fake):
+                got = pw.ensure_worktree(Path(d), "plan")
+            self.assertEqual(got, dest)
+            self.assertIn(("worktree", "add"),
+                          [(c[0], c[1]) for c in fake.calls if len(c) > 1])
+
+    def test_none_when_branch_missing(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = Path(d) / "wt"
+            with patch.object(pw, "_worktree_dir", return_value=dest), \
+                 patch.object(pw, "_git", _FakeGit(branch_exists=False)):
+                self.assertIsNone(pw.ensure_worktree(Path(d), "plan"))
+
+    def test_none_when_add_fails(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = Path(d) / "cache" / "wt"
+            with patch.object(pw, "_worktree_dir", return_value=dest), \
+                 patch.object(pw, "_git", _FakeGit(branch_exists=True, add_ok=False)):
+                self.assertIsNone(pw.ensure_worktree(Path(d), "plan"))
+
+    def test_none_when_git_missing(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = Path(d) / "wt"
+            with patch.object(pw, "_worktree_dir", return_value=dest), \
+                 patch.object(pw, "_git", _FakeGit(missing=True)):
+                self.assertIsNone(pw.ensure_worktree(Path(d), "plan"))
+
+
+class ReuseBranchVerifyTest(unittest.TestCase):
+    """A cached worktree is reused ONLY when still on `plan_branch` (#260)."""
+    def test_refuses_cached_worktree_on_wrong_branch(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = Path(d) / "wt"
+            dest.mkdir()
+            (dest / ".git").write_text("gitdir: ...\n")
+            # Worktree was manually checked out to 'main' — must refuse, not
+            # commit plan churn on the wrong branch.
+            fake = _FakeGit(on_branch="main")
+            with patch.object(pw, "_worktree_dir", return_value=dest), \
+                 patch.object(pw, "_git", fake):
+                self.assertIsNone(pw.ensure_worktree(Path(d), "plan"))
+            self.assertNotIn(("worktree", "add"),
+                             [tuple(c[:2]) for c in fake.calls])
+
+
+class DirtyWorkPlanPathsTest(unittest.TestCase):
+    # Fixtures are NUL-delimited porcelain (`status --porcelain -z`).
+    def test_parses_porcelain_paths(self):
+        with tempfile.TemporaryDirectory() as d:
+            fake = _FakeGit(porcelain=" M .work-plan/a.md\0?? .work-plan/b.md\0")
+            with patch.object(pw, "_git", fake):
+                got = pw.dirty_work_plan_paths(Path(d))
+            self.assertEqual(got, [".work-plan/a.md", ".work-plan/b.md"])
+
+    def test_spaced_and_unicode_paths_roundtrip_verbatim(self):
+        # -z never quote-wraps: a space / non-ASCII path comes through clean.
+        with tempfile.TemporaryDirectory() as d:
+            fake = _FakeGit(porcelain="?? .work-plan/new café.md\0 M .work-plan/a b.md\0")
+            with patch.object(pw, "_git", fake):
+                got = pw.dirty_work_plan_paths(Path(d))
+            self.assertEqual(got, [".work-plan/new café.md", ".work-plan/a b.md"])
+
+    def test_rename_captures_both_dest_and_source(self):
+        # Staged rename: "R  <dest>\0<source>" — both committed so it lands atomically.
+        with tempfile.TemporaryDirectory() as d:
+            fake = _FakeGit(porcelain="R  .work-plan/new.md\0.work-plan/old.md\0?? .work-plan/c.md\0")
+            with patch.object(pw, "_git", fake):
+                got = pw.dirty_work_plan_paths(Path(d))
+            self.assertEqual(got, [".work-plan/new.md", ".work-plan/old.md", ".work-plan/c.md"])
+
+    def test_empty_on_clean_or_failure(self):
+        with tempfile.TemporaryDirectory() as d:
+            with patch.object(pw, "_git", _FakeGit(porcelain="")):
+                self.assertEqual(pw.dirty_work_plan_paths(Path(d)), [])
+            with patch.object(pw, "_git", _FakeGit(missing=True)):
+                self.assertEqual(pw.dirty_work_plan_paths(Path(d)), [])
+
+
+class CommitSharedTierTest(unittest.TestCase):
+    @staticmethod
+    def _wt(d):
+        wt = Path(d)
+        (wt / ".work-plan").mkdir(parents=True, exist_ok=True)
+        return wt
+
+    def test_commits_only_given_paths_when_dirty(self):
+        with tempfile.TemporaryDirectory() as d:
+            wt = self._wt(d)
+            fake = _FakeGit(staged=True, head="sh4r3d1")
+            paths = [".work-plan/feature.md"]
+            with patch.object(pw, "_git", fake):
+                self.assertEqual(
+                    pw.commit_shared_tier(wt, "work-plan slot 1 t", paths), "sh4r3d1")
+            # Scoped add/commit of the explicit path only — never a blanket
+            # `.work-plan` add that would sweep in unrelated dirty files.
+            self.assertIn(("add", "--", ".work-plan/feature.md"), fake.calls)
+            self.assertIn(("commit", "-m", "work-plan slot 1 t", "--",
+                           ".work-plan/feature.md"), fake.calls)
+            self.assertNotIn(("add", "--", ".work-plan"), fake.calls)
+
+    def test_noop_when_paths_empty(self):
+        with tempfile.TemporaryDirectory() as d:
+            wt = self._wt(d)
+            fake = _FakeGit(staged=True)
+            with patch.object(pw, "_git", fake):
+                self.assertIsNone(pw.commit_shared_tier(wt, "msg", []))
+            self.assertNotIn(("commit", "-m", "msg"), fake.calls)
+
+    def test_noop_when_nothing_staged(self):
+        with tempfile.TemporaryDirectory() as d:
+            wt = self._wt(d)
+            fake = _FakeGit(staged=False)
+            with patch.object(pw, "_git", fake):
+                self.assertIsNone(pw.commit_shared_tier(wt, "msg", [".work-plan/x.md"]))
+            self.assertNotIn(("commit", "-m", "msg", "--", ".work-plan/x.md"), fake.calls)
+
+    def test_noop_when_no_work_plan_dir(self):
+        with tempfile.TemporaryDirectory() as d:
+            with patch.object(pw, "_git", _FakeGit(staged=True)):
+                self.assertIsNone(
+                    pw.commit_shared_tier(Path(d), "msg", [".work-plan/x.md"]))
+
+    def test_none_when_git_missing(self):
+        with tempfile.TemporaryDirectory() as d:
+            wt = self._wt(d)
+            with patch.object(pw, "_git", _FakeGit(missing=True)):
+                self.assertIsNone(
+                    pw.commit_shared_tier(wt, "msg", [".work-plan/x.md"]))
+
+
+class BranchExistsHelpersTest(unittest.TestCase):
+    def test_local_and_remote_split(self):
+        with tempfile.TemporaryDirectory() as d:
+            with patch.object(pw, "_git", _FakeGit(branch_exists=True)):
+                self.assertTrue(pw.local_branch_exists(Path(d), "b"))
+                self.assertTrue(pw.remote_branch_exists(Path(d), "b"))
+                self.assertTrue(pw.is_published(Path(d), "b"))
+            with patch.object(pw, "_git", _FakeGit(branch_exists=False)):
+                self.assertFalse(pw.local_branch_exists(Path(d), "b"))
+                self.assertFalse(pw.is_published(Path(d), "b"))
+
+
+class FetchBranchTest(unittest.TestCase):
+    def test_true_on_success_false_on_failure(self):
+        with tempfile.TemporaryDirectory() as d:
+            with patch.object(pw, "_git", _FakeGit(fetch_ok=True)):
+                self.assertTrue(pw.fetch_branch(Path(d), "b"))
+            with patch.object(pw, "_git", _FakeGit(fetch_ok=False)):
+                self.assertFalse(pw.fetch_branch(Path(d), "b"))
+            with patch.object(pw, "_git", _FakeGit(missing=True)):
+                self.assertFalse(pw.fetch_branch(Path(d), "b"))
+
+
+class CreateOrphanWorktreeTest(unittest.TestCase):
+    def test_creates_worktree_and_work_plan_dir(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = Path(d) / "cache" / "wt"
+            with patch.object(pw, "_worktree_dir", return_value=dest), \
+                 patch.object(pw, "_git", _FakeGit()):
+                got = pw.create_orphan_worktree(Path(d), "work-plan/plan")
+            self.assertEqual(got, dest)
+            self.assertTrue((dest / ".work-plan").is_dir())
+
+    def test_none_when_worktree_already_cached(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = Path(d) / "wt"
+            dest.mkdir()
+            (dest / ".git").write_text("gitdir: ...\n")
+            with patch.object(pw, "_worktree_dir", return_value=dest), \
+                 patch.object(pw, "_git", _FakeGit()):
+                self.assertIsNone(pw.create_orphan_worktree(Path(d), "b"))
+
+    def test_none_and_rollback_when_orphan_checkout_fails(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = Path(d) / "cache" / "wt"
+            fake = _FakeGit(orphan_ok=False)
+            with patch.object(pw, "_worktree_dir", return_value=dest), \
+                 patch.object(pw, "_git", fake):
+                self.assertIsNone(pw.create_orphan_worktree(Path(d), "b"))
+            self.assertIn(("worktree", "remove"),
+                          [(c[0], c[1]) for c in fake.calls if len(c) > 1])
+
+    def test_none_when_git_missing(self):
+        with tempfile.TemporaryDirectory() as d:
+            dest = Path(d) / "cache" / "wt"
+            with patch.object(pw, "_worktree_dir", return_value=dest), \
+                 patch.object(pw, "_git", _FakeGit(missing=True)):
+                self.assertIsNone(pw.create_orphan_worktree(Path(d), "b"))
+
+
+class UnpushedOnelineTest(unittest.TestCase):
+    def test_uses_range_when_published(self):
+        with tempfile.TemporaryDirectory() as d:
+            fake = _FakeGit(branch_exists=True, oneline="a1 one\nb2 two\n")
+            with patch.object(pw, "_git", fake):
+                got = pw.unpushed_oneline(Path(d), "work-plan/plan")
+            self.assertEqual(got, ["a1 one", "b2 two"])
+            # range form origin/<branch>..<branch> when remote ref exists
+            logcall = [c for c in fake.calls if c and c[0] == "log"][0]
+            self.assertIn("origin/work-plan/plan..work-plan/plan", logcall)
+
+    def test_all_commits_when_unpublished(self):
+        with tempfile.TemporaryDirectory() as d:
+            fake = _FakeGit(branch_exists=False, oneline="a1 only\n")
+            with patch.object(pw, "_git", fake):
+                got = pw.unpushed_oneline(Path(d), "wp")
+            self.assertEqual(got, ["a1 only"])
+            logcall = [c for c in fake.calls if c and c[0] == "log"][0]
+            self.assertIn("wp", logcall)
+            self.assertNotIn("origin/wp..wp", logcall)
+
+    def test_empty_on_failure(self):
+        with tempfile.TemporaryDirectory() as d:
+            with patch.object(pw, "_git", _FakeGit(missing=True)):
+                self.assertEqual(pw.unpushed_oneline(Path(d), "b"), [])
+
+
+class PushPlanBranchTest(unittest.TestCase):
+    def test_returns_completed_process(self):
+        with tempfile.TemporaryDirectory() as d:
+            with patch.object(pw, "_git", _FakeGit(push_ok=True)):
+                proc = pw.push_plan_branch(Path(d), "b")
+            self.assertEqual(proc.returncode, 0)
+
+    def test_surfaces_failure(self):
+        with tempfile.TemporaryDirectory() as d:
+            with patch.object(pw, "_git", _FakeGit(push_ok=False)):
+                proc = pw.push_plan_branch(Path(d), "b")
+            self.assertEqual(proc.returncode, 1)
+
+    def test_none_when_git_missing(self):
+        with tempfile.TemporaryDirectory() as d:
+            with patch.object(pw, "_git", _FakeGit(missing=True)):
+                self.assertIsNone(pw.push_plan_branch(Path(d), "b"))
+
+
+if __name__ == "__main__":
+    unittest.main()