@stylusnexus/work-plan 2026.6.11 → 2026.6.13-2

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

@@ -16,6 +16,8 @@ def _track(name, repo, issues, *, has_frontmatter=True, status="active"):
         name=name,
         repo=repo,
         tier="private",
+        path=Path(f"/tmp/notes/{name}.md"),
+        folder="myrepo",
         has_frontmatter=has_frontmatter,
         meta={
             "status": status,
@@ -71,6 +73,23 @@ class ExportRunJsonTest(unittest.TestCase):
         self.assertEqual(rc, 0)
         self.assertEqual(out["schema"], 1)
 
+    def test_track_file_path_is_emitted(self):
+        """The export carries each track's .md path end-to-end (#211)."""
+        tracks = [_track("alpha", _SHARED_REPO, [1])]
+        rc, out, _ = self._run_with_mocks(tracks, _EXPORT_MAP)
+        self.assertEqual(rc, 0)
+        # str(Path(...)) so the expected separator matches the platform (Windows
+        # backslashes). The path is whatever os.sep the fixture's Path produces.
+        self.assertEqual(out["tracks"][0]["path"], str(Path("/tmp/notes/alpha.md")))
+
+    def test_track_folder_key_is_emitted(self):
+        """The export carries each track's config folder key end-to-end for the
+        Plans view's `plan-status --repo=<key>` arg (#164)."""
+        tracks = [_track("alpha", _SHARED_REPO, [1])]
+        rc, out, _ = self._run_with_mocks(tracks, _EXPORT_MAP)
+        self.assertEqual(rc, 0)
+        self.assertEqual(out["tracks"][0]["folder"], "myrepo")
+
     def test_track_issues_assembled_in_declared_order(self):
         # Issues are milestone-sorted (#101): null-milestone group sorts by number.
         tracks = [_track("alpha", _SHARED_REPO, [2, 1])]
@@ -291,5 +310,81 @@ class ExportCommandGateTest(unittest.TestCase):
         self.assertEqual(export_cmd.run([]), 2)
 
 
+class ExportPlanBadgeTest(unittest.TestCase):
+    """`_plan_badge` resolves a track's declared plan link into an execution
+    badge using the same evaluator as plan-status (#285). Real temp repo so the
+    manifest/checkbox/frontmatter read is exercised; git date is mocked."""
+
+    import tempfile as _tempfile
+
+    def _repo_with_plan(self, d, plan_text):
+        root = Path(d)
+        (root / "docs/plans").mkdir(parents=True)
+        (root / "docs/plans/p.md").write_text(plan_text)
+        (root / "src").mkdir()
+        (root / "src/new.ts").write_text("export const x = 1")  # 1/1 declared present
+        return root
+
+    def _track_with_plan(self, rel="docs/plans/p.md", folder="demo"):
+        return SimpleNamespace(
+            name="alpha", repo="o/r", tier="private", folder=folder,
+            path=Path("/tmp/notes/alpha.md"), has_frontmatter=True,
+            meta={"status": "active", "plan": rel, "github": {"repo": "o/r", "issues": []}})
+
+    def _badge(self, track, root):
+        with patch("commands.export.resolve_local_path_for_folder", return_value=root), \
+             patch("commands.plan_status.git_state.path_last_commit_date", return_value=None):
+            from datetime import date
+            return export_cmd._plan_badge(track, {"notes_root": "/tmp"}, date(2026, 6, 13), 60, 14)
+
+    # A shipped-by-files plan with 0/2 boxes -> lie_gap unless overridden.
+    BODY = ("# P\n\n**Files:**\n- Create: `src/new.ts`\n- [ ] Step 1\n- [ ] Step 2\n")
+
+    def test_no_plan_returns_none(self):
+        t = self._track_with_plan()
+        t.meta.pop("plan")
+        self.assertIsNone(self._badge(t, Path("/tmp")))
+
+    def test_resolved_badge_with_lie_gap(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo_with_plan(d, self.BODY)
+            badge = self._badge(self._track_with_plan(), root)
+            self.assertTrue(badge["resolved"])
+            self.assertEqual(badge["verdict"], "shipped")
+            self.assertEqual(badge["files_present"], 1)
+            self.assertEqual(badge["files_declared"], 1)
+            self.assertTrue(badge["lie_gap"])
+            self.assertIsNone(badge["override"])
+
+    def test_override_silences_lie_gap_in_badge(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo_with_plan(d, f"---\nverdict_override: shipped\n---\n{self.BODY}")
+            badge = self._badge(self._track_with_plan(), root)
+            self.assertEqual(badge["override"], "shipped")
+            self.assertFalse(badge["lie_gap"])
+
+    def test_unresolved_when_no_local_clone(self):
+        t = self._track_with_plan()
+        with patch("commands.export.resolve_local_path_for_folder", return_value=None):
+            from datetime import date
+            badge = export_cmd._plan_badge(t, {"notes_root": "/tmp"}, date(2026, 6, 13), 60, 14)
+        self.assertEqual(badge, {"rel": "docs/plans/p.md", "resolved": False})
+
+    def test_unresolved_when_file_absent(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            root = Path(d)  # empty repo — declared plan file does not exist
+            badge = self._badge(self._track_with_plan(rel="docs/plans/missing.md"), root)
+            self.assertEqual(badge, {"rel": "docs/plans/missing.md", "resolved": False})
+
+    def test_no_folder_is_unresolved(self):
+        t = self._track_with_plan(folder=None)
+        from datetime import date
+        badge = export_cmd._plan_badge(t, {"notes_root": "/tmp"}, date(2026, 6, 13), 60, 14)
+        self.assertEqual(badge, {"rel": "docs/plans/p.md", "resolved": False})
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -136,12 +136,55 @@ class InitRepoNonInteractiveTest(unittest.TestCase):
     # ------------------------------------------------------------------
 
     def test_repo_already_exists_returns_rc1(self):
-        """Key already in config.repos → rc 1, yq NOT called."""
+        """Key already in config.repos (no --update) → rc 1, yq NOT called,
+        and the message points at --update."""
         existing = {"mykey": {"github": "org/myrepo", "local": None}}
         rc, msub, out = _drive(["mykey", "--github=org/myrepo"], existing_repos=existing)
         self.assertEqual(rc, 1)
         msub.assert_not_called()
         self.assertIn("already exists", out)
+        self.assertIn("--update", out)
+
+    # ------------------------------------------------------------------
+    # --update on an existing key → updates its local path
+    # ------------------------------------------------------------------
+
+    def test_update_existing_sets_local(self):
+        """Existing key + --update --local=/new/path → yq merges local into the
+        existing block; rc 0; no 'already exists' error."""
+        existing = {"mykey": {"github": "org/myrepo"}}
+        rc, msub, out = _drive(
+            ["mykey", "--github=org/myrepo", "--local=/new/path", "--update"],
+            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")
+        # Merge expression preserves other keys via `* env(...)`.
+        expr = yq_args[2]
+        self.assertIn(".repos.mykey", expr)
+        self.assertIn("env(WP_REPO_UPDATES)", expr)
+        updates = json.loads(msub.call_args.kwargs["env"]["WP_REPO_UPDATES"])
+        self.assertEqual(updates["local"], "/new/path")
+        self.assertIn("Updated", out)
+        self.assertNotIn("already exists", out)
+
+    def test_update_nonexistent_key_falls_back_to_add(self):
+        """--update on a key NOT in config → behaves as a plain add (creates the
+        block via the add path), rc 0."""
+        rc, msub, out = _drive(
+            ["mykey", "--github=org/myrepo", "--local=/some/path", "--update"],
+            existing_repos={},
+        )
+        self.assertEqual(rc, 0)
+        msub.assert_called_once()
+        expr = msub.call_args[0][0][2]
+        # Add path uses the assignment form, not the merge form.
+        self.assertEqual(expr, ".repos.mykey = env(WP_REPO_BLOCK)")
+        block = json.loads(msub.call_args.kwargs["env"]["WP_REPO_BLOCK"])
+        self.assertEqual(block["local"], "/some/path")
 
     # ------------------------------------------------------------------
     # No key → rc 2
@@ -153,6 +196,62 @@ class InitRepoNonInteractiveTest(unittest.TestCase):
         self.assertEqual(rc, 2)
         msub.assert_not_called()
 
+    # ------------------------------------------------------------------
+    # --clear-local: sets local to null on an existing key
+    # ------------------------------------------------------------------
+
+    def test_clear_local_sets_local_null(self):
+        """--update --clear-local on an existing key → yq merges {local: null};
+        rc 0; '✓ Cleared local path' printed."""
+        existing = {"mykey": {"github": "org/myrepo", "local": "/old/path"}}
+        rc, msub, out = _drive(
+            ["mykey", "--update", "--clear-local"],
+            existing_repos=existing,
+        )
+        self.assertEqual(rc, 0)
+        msub.assert_called_once()
+        expr = msub.call_args[0][0][2]
+        self.assertIn(".repos.mykey", expr)
+        self.assertIn("env(WP_REPO_UPDATES)", expr)
+        updates = json.loads(msub.call_args.kwargs["env"]["WP_REPO_UPDATES"])
+        self.assertIn("local", updates)
+        self.assertIsNone(updates["local"])
+        # github not passed → not in the merge (other fields preserved by yq).
+        self.assertNotIn("github", updates)
+        self.assertIn("Cleared local path", out)
+
+    def test_clear_local_with_local_is_mutually_exclusive(self):
+        """--clear-local + --local=<path> → rc 2, yq NOT called."""
+        existing = {"mykey": {"github": "org/myrepo", "local": "/old/path"}}
+        rc, msub, out = _drive(
+            ["mykey", "--update", "--clear-local", "--local=/new/path"],
+            existing_repos=existing,
+        )
+        self.assertEqual(rc, 2)
+        msub.assert_not_called()
+        self.assertIn("mutually exclusive", out)
+
+    def test_clear_local_without_update_returns_rc2(self):
+        """--clear-local without --update → rc 2, yq NOT called."""
+        existing = {"mykey": {"github": "org/myrepo", "local": "/old/path"}}
+        rc, msub, out = _drive(
+            ["mykey", "--clear-local"],
+            existing_repos=existing,
+        )
+        self.assertEqual(rc, 2)
+        msub.assert_not_called()
+        self.assertIn("requires --update", out)
+
+    def test_clear_local_nonexistent_key_returns_rc1(self):
+        """--update --clear-local on a key NOT in config → rc 1, yq NOT called."""
+        rc, msub, out = _drive(
+            ["mykey", "--update", "--clear-local"],
+            existing_repos={},
+        )
+        self.assertEqual(rc, 1)
+        msub.assert_not_called()
+        self.assertIn("not found", out)
+
     # ------------------------------------------------------------------
     # Invalid key format → rc 2
     # ------------------------------------------------------------------

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

@@ -0,0 +1,83 @@
+"""Tests for the list-open-issues subcommand (#282).
+
+Mocks fetch_open_issues — runs offline, never touches the network.
+"""
+import io
+import json
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest.mock import patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import list_open_issues
+
+
+def _row(number, title="t", state="OPEN", logins=(), milestone=None):
+    """A raw gh issue row as fetch_open_issues returns."""
+    d = {"number": number, "title": title, "state": state,
+         "assignees": [{"login": l} for l in logins]}
+    if milestone:
+        d["milestone"] = {"title": milestone}
+    return d
+
+
+def _run(args, rows):
+    with patch("commands.list_open_issues.fetch_open_issues", return_value=rows):
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = list_open_issues.run(args)
+    out = buf.getvalue()
+    try:
+        parsed = json.loads(out)
+    except json.JSONDecodeError:
+        parsed = None
+    return rc, parsed
+
+
+class ListOpenIssuesTest(unittest.TestCase):
+    def test_emits_repo_and_normalized_issues(self):
+        rows = [_row(91, "Rate-limit login", "OPEN", ["eve"], "v0.6"),
+                _row(87, "Fix auth", "OPEN")]
+        rc, out = _run(["--repo=o/r"], rows)
+        self.assertEqual(rc, 0)
+        self.assertEqual(out["repo"], "o/r")
+        # Same Issue shape as the export (number/title/state/assignee/milestone).
+        self.assertEqual(
+            out["issues"][0],
+            {"number": 91, "title": "Rate-limit login", "state": "open",
+             "assignee": "@eve", "milestone": "v0.6"},
+        )
+        self.assertEqual(out["issues"][1],
+                         {"number": 87, "title": "Fix auth", "state": "open",
+                          "assignee": "—", "milestone": None})
+
+    def test_exclude_filters_given_numbers(self):
+        rows = [_row(1), _row(2), _row(3)]
+        rc, out = _run(["--repo=o/r", "--exclude=1,3"], rows)
+        self.assertEqual(rc, 0)
+        self.assertEqual([i["number"] for i in out["issues"]], [2])
+
+    def test_exclude_tolerates_blanks_and_nonnumeric(self):
+        rows = [_row(1), _row(2)]
+        rc, out = _run(["--repo=o/r", "--exclude=1, ,x,"], rows)
+        self.assertEqual(rc, 0)
+        self.assertEqual([i["number"] for i in out["issues"]], [2])
+
+    def test_missing_repo_is_usage_error(self):
+        rc, out = _run([], [])
+        self.assertEqual(rc, 2)
+        self.assertIn("error", out)
+
+    def test_empty_fetch_yields_empty_issue_list(self):
+        # fetch_open_issues returns [] on a bad/unreachable repo — not an error.
+        rc, out = _run(["--repo=o/r"], [])
+        self.assertEqual(rc, 0)
+        self.assertEqual(out, {"repo": "o/r", "issues": []})
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -11,7 +11,7 @@ from lib.manifest import (
     DeclaredPath, strip_range, parse_declared_paths,
     count_checkboxes, plan_date_from_filename,
     ManifestScore, score_manifest,
-    is_in_tree, out_of_tree_ratio,
+    is_in_tree, out_of_tree_ratio, offtree_declared_paths,
 )
 
 
@@ -158,5 +158,34 @@ class ScoreManifestTest(unittest.TestCase):
         self.assertIsNone(score.pct)
 
 
+class OfftreeDeclaredPathsTest(unittest.TestCase):
+    ROOT = "/repo"
+
+    def _decls(self, *paths):
+        return [DeclaredPath(kind="create", path=p) for p in paths]
+
+    def test_in_tree_paths_are_not_flagged(self):
+        decls = self._decls("src/a.ts", "src/b.ts")
+        self.assertEqual(offtree_declared_paths(decls, self.ROOT), [])
+
+    def test_flags_absolute_tilde_and_escape(self):
+        decls = self._decls("src/ok.ts", "/etc/passwd", "~/secrets.txt", "../sibling/x.ts")
+        self.assertEqual(
+            offtree_declared_paths(decls, self.ROOT),
+            ["/etc/passwd", "~/secrets.txt", "../sibling/x.ts"],
+        )
+
+    def test_flags_junk_root_slash(self):
+        # The literal `/` #164's smoke caught — resolves to the filesystem root.
+        self.assertEqual(offtree_declared_paths(self._decls("/x/y"), self.ROOT), ["/x/y"])
+
+    def test_dedups_preserving_first_seen_order(self):
+        decls = self._decls("../x.ts", "src/ok.ts", "../x.ts")
+        self.assertEqual(offtree_declared_paths(decls, self.ROOT), ["../x.ts"])
+
+    def test_empty_decls(self):
+        self.assertEqual(offtree_declared_paths([], self.ROOT), [])
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -308,5 +308,82 @@ class DispatcherHookTest(unittest.TestCase):
             self.assertIsNone(work_plan._notes_precommit_state("slot"))
 
 
+class SharedDispatcherHookTest(unittest.TestCase):
+    """The shared-tier (#260) auto-commit hook mirrors the notes one: snapshot
+    each plan_branch repo's dirty .work-plan/ paths BEFORE the command, then
+    commit only that repo's delta — never another repo's pre-existing edits.
+    """
+
+    @staticmethod
+    def _cfg_two():
+        return {"notes_root": "/tmp/notes", "repos": {
+            "alpha": {"github": "o/alpha", "local": "/tmp/alpha", "plan_branch": "wp-plan"},
+            "beta":  {"github": "o/beta",  "local": "/tmp/beta",  "plan_branch": "wp-plan"},
+            "gamma": {"github": "o/gamma", "local": "/tmp/gamma"},  # legacy, no plan_branch
+        }}
+
+    def test_commits_only_the_touched_repo(self):
+        cfg = self._cfg_two()
+        # alpha gains a file; beta has a pre-existing dirty file that must NOT
+        # be committed; gamma has no plan_branch so it's never visited. Keyed by
+        # Path.name (not str) so the test is OS path-separator agnostic.
+        dirty = {
+            "alpha": [[], [".work-plan/x.md"]],   # before, after
+            "beta":  [[".work-plan/stale.md"], [".work-plan/stale.md"]],
+        }
+        def fake_ensure(local, branch):
+            return Path(local)  # use the repo's local path as the worktree handle
+        def fake_dirty(wt):
+            return dirty[Path(wt).name].pop(0)
+        commits = []
+        def fake_commit(wt, msg, paths):
+            commits.append((Path(wt).name, tuple(paths)))
+            return "deadbee"
+        with patch("lib.config.load_config", return_value=cfg), \
+             patch("lib.plan_worktree.ensure_worktree", side_effect=fake_ensure), \
+             patch("lib.plan_worktree.dirty_work_plan_paths", side_effect=fake_dirty), \
+             patch("lib.plan_worktree.commit_shared_tier", side_effect=fake_commit):
+            err = io.StringIO()
+            with redirect_stderr(err):
+                pre = work_plan._shared_precommit_state("slot")
+                work_plan._commit_shared_writes(pre, ["slot", "1", "x"])
+            out = err.getvalue()
+        # Only alpha committed, and only its new path.
+        self.assertEqual(commits, [("alpha", (".work-plan/x.md",))])
+        self.assertIn("alpha", out)
+        self.assertNotIn("beta", out)
+
+    def test_skips_read_only_command(self):
+        with patch("lib.config.load_config", return_value=self._cfg_two()) as mload:
+            self.assertIsNone(work_plan._shared_precommit_state("brief"))
+            mload.assert_not_called()
+
+    def test_none_when_no_plan_branch_repos(self):
+        cfg = {"notes_root": "/tmp/n", "repos": {
+            "gamma": {"github": "o/gamma", "local": "/tmp/gamma"}}}
+        with patch("lib.config.load_config", return_value=cfg):
+            self.assertIsNone(work_plan._shared_precommit_state("slot"))
+
+    def test_precommit_never_raises_on_failure(self):
+        with patch("lib.config.load_config", side_effect=RuntimeError("boom")):
+            self.assertIsNone(work_plan._shared_precommit_state("slot"))
+
+    def test_warns_when_changes_present_but_commit_refused(self):
+        cfg = {"notes_root": "/tmp/n", "repos": {
+            "alpha": {"github": "o/alpha", "local": "/tmp/alpha", "plan_branch": "wp"}}}
+        seq = {"alpha": [[], [".work-plan/x.md"]]}
+        with patch("lib.config.load_config", return_value=cfg), \
+             patch("lib.plan_worktree.ensure_worktree",
+                   side_effect=lambda l, b: Path(l)), \
+             patch("lib.plan_worktree.dirty_work_plan_paths",
+                   side_effect=lambda wt: seq[Path(wt).name].pop(0)), \
+             patch("lib.plan_worktree.commit_shared_tier", return_value=None):
+            err = io.StringIO()
+            with redirect_stderr(err):
+                pre = work_plan._shared_precommit_state("slot")
+                work_plan._commit_shared_writes(pre, ["slot", "1", "x"])
+            self.assertIn("NOT", err.getvalue())
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -0,0 +1,104 @@
+"""plan-ack (#286 slice 1): durable, frontmatter-only acknowledgment. Real temp
+repo so the write round-trips through real yq; config + visibility are mocked."""
+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_ack
+from lib import frontmatter
+from lib.write_guard import make_token
+
+REL = "docs/superpowers/plans/p.md"
+BODY = "# Plan\n\nbody the writer must never touch\n"
+
+
+class PlanAckTest(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_ack.config_mod.load_config", return_value=cfg), \
+             mock.patch("commands.plan_ack.config_mod.resolve_local_path_for_folder",
+                        return_value=root), \
+             mock.patch("commands.plan_ack.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_ack.run(args)
+        return rc, out.getvalue(), err.getvalue()
+
+    def test_writes_acknowledged_preserving_body(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out, err = self._drive(root, ["--repo=k", "--", REL])
+            self.assertEqual(rc, 0)
+            meta, body = frontmatter.parse_file(root / REL)
+            self.assertIs(meta["acknowledged"], True)
+            self.assertEqual(body, BODY)
+            self.assertIn("frontmatter only", out)
+
+    def test_clear_removes_acknowledged(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d, f"---\nacknowledged: true\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("acknowledged", meta)
+            self.assertEqual(body, BODY)
+
+    def test_clear_when_absent_is_noop(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out, err = self._drive(root, ["--repo=k", "--clear", "--", REL])
+            self.assertEqual(rc, 0)
+            self.assertIn("nothing to clear", out)
+
+    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", "--", 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))
+            meta, _ = frontmatter.parse_file(root / REL)
+            self.assertNotIn("acknowledged", meta)   # no write happened
+
+    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", f"--confirm={token}", "--", REL],
+                                       slug="org/pub", vis="PUBLIC")
+            self.assertEqual(rc, 0)
+            meta, _ = frontmatter.parse_file(root / REL)
+            self.assertIs(meta["acknowledged"], True)
+
+    def test_path_escape_rejected(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out, err = self._drive(root, ["--repo=k", "--", "../../etc/passwd"])
+            self.assertEqual(rc, 1)
+            self.assertIn("not a file inside", err)
+
+    def test_missing_repo_flag_rejected(self):
+        rc, out, err = self._drive(Path("/tmp"), ["--", REL])
+        self.assertEqual(rc, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,86 @@
+"""plan-baseline (#286 slice 2): stamp the computed verdict to frontmatter as a
+drift baseline. Real temp repo (real yq); config + git date mocked."""
+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_baseline
+from lib import frontmatter
+from lib.write_guard import make_token
+
+REL = "docs/superpowers/plans/p.md"
+# A plan whose one declared file exists → mechanical verdict "shipped".
+BODY = "# Plan\n\n**Files:**\n- Create: `src/new.ts`\n- [ ] Step 1\n"
+
+
+class PlanBaselineTest(unittest.TestCase):
+    def _repo(self, d, with_file=True, doc_text=BODY):
+        root = Path(d)
+        (root / "docs/superpowers/plans").mkdir(parents=True)
+        (root / REL).write_text(doc_text)
+        if with_file:
+            (root / "src").mkdir()
+            (root / "src/new.ts").write_text("export const x = 1")
+        return root
+
+    def _drive(self, root, args, slug=None, vis="PRIVATE"):
+        cfg = {"notes_root": str(root), "repos": {}}
+        with mock.patch("commands.plan_baseline.config_mod.load_config", return_value=cfg), \
+             mock.patch("commands.plan_baseline.config_mod.resolve_local_path_for_folder",
+                        return_value=root), \
+             mock.patch("commands.plan_baseline.config_mod.resolve_github_for_folder",
+                        return_value=slug), \
+             mock.patch("commands.plan_status.git_state.path_last_commit_date",
+                        return_value=None), \
+             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_baseline.run(args)
+        return rc, out.getvalue(), err.getvalue()
+
+    def test_stamps_computed_verdict(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)               # file present → shipped
+            rc, out, err = self._drive(root, ["--repo=k", "--", REL])
+            self.assertEqual(rc, 0)
+            meta, body = frontmatter.parse_file(root / REL)
+            self.assertEqual(meta["verdict_baseline"], "shipped")
+            self.assertIn("shipped", out)
+
+    def test_clear_removes_baseline(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d, doc_text=f"---\nverdict_baseline: shipped\n---\n{BODY}")
+            rc, out, err = self._drive(root, ["--repo=k", "--clear", "--", REL])
+            self.assertEqual(rc, 0)
+            meta, _ = frontmatter.parse_file(root / REL)
+            self.assertNotIn("verdict_baseline", meta)
+
+    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", "--", REL],
+                                       slug="org/pub", vis="PUBLIC")
+            self.assertEqual(rc, 0)
+            data = json.loads(out)
+            self.assertEqual(data["token"], make_token("org/pub", REL))
+            meta, _ = frontmatter.parse_file(root / REL)
+            self.assertNotIn("verdict_baseline", meta)
+
+    def test_path_escape_rejected(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out, err = self._drive(root, ["--repo=k", "--", "../../etc/passwd"])
+            self.assertEqual(rc, 1)
+            self.assertIn("not a file inside", err)
+
+
+if __name__ == "__main__":
+    unittest.main()