@stylusnexus/work-plan 2026.6.9

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

@@ -0,0 +1,61 @@
+"""--archive: previews under --draft; gated by confirmation otherwise (offline)."""
+import io
+import unittest
+import sys
+import tempfile
+from datetime import datetime
+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
+
+DEAD_PLAN = "# Dead Plan\n\n- Create: `src/never.ts`\n"
+
+
+class ArchiveTest(unittest.TestCase):
+    def _repo(self, d):
+        root = Path(d)
+        (root / "docs/superpowers/plans").mkdir(parents=True)
+        self.rel = "docs/superpowers/plans/2026-01-01-dead.md"
+        (root / self.rel).write_text(DEAD_PLAN)
+        return root
+
+    def _run(self, root, args, mv_ok=True):
+        # stale last-commit (well beyond DEAD_DAYS) so the absent-file plan is dead
+        with mock.patch("commands.plan_status.git_state.path_last_commit_date",
+                        return_value=datetime(2026, 1, 1)), \
+             mock.patch("commands.plan_status.Path.cwd", return_value=root), \
+             mock.patch("commands.plan_status.git_state.git_mv",
+                        return_value=mv_ok) as mv, \
+             mock.patch("commands.plan_status.prompt_yes_no", return_value=True):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = plan_status.run(args)
+        return rc, buf.getvalue(), mv
+
+    def test_draft_previews_without_moving(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out, mv = self._run(root, ["--archive", "--draft"])
+            self.assertEqual(rc, 0)
+            self.assertIn("archive", out.lower())
+            mv.assert_not_called()
+
+    def test_apply_moves_after_confirm(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out, mv = self._run(root, ["--archive"])
+            self.assertEqual(rc, 0)
+            mv.assert_called_once()
+            args = mv.call_args[0]
+            self.assertEqual(args[0], self.rel)
+            self.assertEqual(args[1],
+                             "docs/superpowers/plans/archive/abandoned/2026-01-01-dead.md")
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,55 @@
+"""A plan whose declared files live outside the repo -> foreign verdict."""
+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
+
+# All declared paths are ~/-rooted -> outside this repo.
+FOREIGN_PLAN = (
+    "# Daily Work Planner\n\n"
+    "- Create: `~/.claude/skills/work-plan/work_plan.py`\n"
+    "- Create: `~/.claude/skills/work-plan/SKILL.md`\n"
+)
+# Declares in-repo src/ paths -> a real (partial) plan, NOT foreign.
+LOCAL_PLAN = "# Real\n\n- Create: `src/here.ts`\n- Create: `src/gone.ts`\n"
+
+
+class ForeignTest(unittest.TestCase):
+    def _repo(self, d):
+        root = Path(d)
+        (root / "docs/superpowers/plans").mkdir(parents=True)
+        (root / "docs/superpowers/plans/2026-04-28-daily-work-planner.md").write_text(FOREIGN_PLAN)
+        (root / "docs/superpowers/plans/2026-05-01-real.md").write_text(LOCAL_PLAN)
+        (root / "src").mkdir()
+        (root / "src/here.ts").write_text("x")
+        return root
+
+    def _json(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):
+                plan_status.run(["--json"])
+        return {r["rel"].split("/")[-1]: r for r in json.loads(buf.getvalue())["docs"]}
+
+    def test_out_of_tree_plan_is_foreign_local_is_not(self):
+        with tempfile.TemporaryDirectory() as d:
+            rows = self._json(self._repo(d))
+            self.assertEqual(rows["2026-04-28-daily-work-planner.md"]["verdict"], "foreign")
+            self.assertEqual(rows["2026-04-28-daily-work-planner.md"]["glyph"], "🧳")
+            # the in-repo plan is partial (1/2), not foreign
+            self.assertEqual(rows["2026-05-01-real.md"]["verdict"], "partial")
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,61 @@
+"""--issues: previews under --draft; opens gh issues after confirm (offline)."""
+import io
+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
+
+# 1 of 2 files present -> partial.
+PARTIAL_PLAN = "# Partial\n\n- Create: `src/here.ts`\n- Create: `src/gone.ts`\n"
+
+
+class IssuesTest(unittest.TestCase):
+    def _repo(self, d):
+        root = Path(d)
+        (root / "docs/superpowers/plans").mkdir(parents=True)
+        (root / "docs/superpowers/plans/2026-05-01-partial.md").write_text(PARTIAL_PLAN)
+        (root / "src").mkdir()
+        (root / "src/here.ts").write_text("x")   # gone.ts absent -> partial
+        return root
+
+    def _run(self, root, args, create_ret="https://github.com/o/r/issues/9"):
+        with mock.patch("commands.plan_status.git_state.path_last_commit_date",
+                        return_value=None), \
+             mock.patch("commands.plan_status._resolve_repo_root", return_value=root), \
+             mock.patch("commands.plan_status._repo_slug", return_value="o/r"), \
+             mock.patch("commands.plan_status.github_state.create_issue",
+                        return_value=create_ret) as ci, \
+             mock.patch("commands.plan_status.prompt_yes_no", return_value=True):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = plan_status.run(args)
+        return rc, buf.getvalue(), ci
+
+    def test_draft_previews_without_creating(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out, ci = self._run(root, ["--issues", "--draft", "--repo=critforge"])
+            self.assertEqual(rc, 0)
+            self.assertIn("gone.ts", out)       # unsatisfied path shown in preview
+            ci.assert_not_called()
+
+    def test_apply_creates_issue_after_confirm(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out, ci = self._run(root, ["--issues", "--repo=critforge"])
+            self.assertEqual(rc, 0)
+            ci.assert_called_once()
+            title, body = ci.call_args[0][1], ci.call_args[0][2]
+            self.assertIn("partial", body.lower())
+            self.assertIn("src/gone.ts", body)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,71 @@
+"""--llm --apply: validates provenance, merges verdicts, optionally stamps."""
+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
+
+PROSE = "# Design Doc\n\nProse only.\n"
+
+
+class LlmApplyTest(unittest.TestCase):
+    def _setup(self, d, cache, answers):
+        root = Path(d)
+        (root / "docs/superpowers/specs").mkdir(parents=True)
+        rel = "docs/superpowers/specs/2026-03-16-x-design.md"
+        (root / rel).write_text(PROSE)
+        batch = {"repo_root": str(root), "docs": [{"rel": rel}]}
+        (Path(cache) / "plan_status.json").write_text(json.dumps(batch))
+        (Path(cache) / "plan_status.answers.json").write_text(json.dumps(answers))
+        return root, rel
+
+    def _run(self, root, cache, args):
+        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), \
+             mock.patch("commands.plan_status.cache_dir", return_value=Path(cache)):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = plan_status.run(args)
+        return rc, buf.getvalue()
+
+    def test_merges_verdict_into_report(self):
+        with tempfile.TemporaryDirectory() as d, tempfile.TemporaryDirectory() as cache:
+            rel = "docs/superpowers/specs/2026-03-16-x-design.md"
+            root, _ = self._setup(d, cache, [
+                {"rel": rel, "verdict": "shipped", "confidence": 0.9, "rationale": "done"}
+            ])
+            rc, out = self._run(root, cache, ["--llm", "--apply"])
+            self.assertEqual(rc, 0)
+            self.assertIn("shipped", out)
+            self.assertIn("done", out)
+
+    def test_rejects_rel_not_in_batch(self):
+        with tempfile.TemporaryDirectory() as d, tempfile.TemporaryDirectory() as cache:
+            root, rel = self._setup(d, cache, [
+                {"rel": "../evil.md", "verdict": "shipped", "confidence": 1, "rationale": "x"}
+            ])
+            rc, out = self._run(root, cache, ["--llm", "--apply"])
+            self.assertIn("skip", out.lower())
+
+    def test_rejects_repo_root_mismatch(self):
+        with tempfile.TemporaryDirectory() as d, tempfile.TemporaryDirectory() as cache:
+            root, rel = self._setup(d, cache, [])
+            bp = Path(cache) / "plan_status.json"
+            b = json.loads(bp.read_text()); b["repo_root"] = "/somewhere/else"
+            bp.write_text(json.dumps(b))
+            rc, out = self._run(root, cache, ["--llm", "--apply"])
+            self.assertEqual(rc, 1)
+            self.assertIn("repo_root", out.lower())
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,66 @@
+"""--llm step 1: writes a batch of candidate docs + prints a prompt."""
+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
+
+PROSE = "# Design Doc\n\nProse only, no file manifest here.\n"
+
+
+class LlmPrepareTest(unittest.TestCase):
+    def _repo(self, d):
+        root = Path(d)
+        (root / "docs/superpowers/specs").mkdir(parents=True)
+        (root / "docs/superpowers/specs/2026-03-16-x-design.md").write_text(PROSE)
+        return root
+
+    def test_prepare_writes_batch_of_candidates(self):
+        with tempfile.TemporaryDirectory() as d, tempfile.TemporaryDirectory() as cache:
+            root = self._repo(d)
+            cache_file = Path(cache) / "plan_status.json"
+            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), \
+                 mock.patch("commands.plan_status.cache_dir", return_value=Path(cache)):
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = plan_status.run(["--llm"])
+            self.assertEqual(rc, 0)
+            self.assertTrue(cache_file.exists())
+            batch = json.loads(cache_file.read_text())
+            self.assertEqual(batch["repo_root"], str(root))
+            rels = [d["rel"] for d in batch["docs"]]
+            self.assertIn("docs/superpowers/specs/2026-03-16-x-design.md", rels)
+            out = buf.getvalue()
+            self.assertIn("plan_status.answers.json", out)
+
+    def test_prepare_reports_when_no_candidates(self):
+        with tempfile.TemporaryDirectory() as d, tempfile.TemporaryDirectory() as cache:
+            root = Path(d)
+            (root / "docs/superpowers/plans").mkdir(parents=True)
+            (root / "docs/superpowers/plans/2026-01-01-done.md").write_text(
+                "# Done\n- Create: `src/a.py`\n")
+            (root / "src").mkdir()
+            (root / "src/a.py").write_text("x")
+            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), \
+                 mock.patch("commands.plan_status.cache_dir", return_value=Path(cache)):
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = plan_status.run(["--llm"])
+            self.assertEqual(rc, 0)
+            self.assertIn("no docs need an llm verdict", buf.getvalue().lower())
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,70 @@
+"""Stamp / draft behaviour for plan-status (offline)."""
+import io
+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
+from lib.status_header import BEGIN
+
+PLAN = (
+    "# Idea Mode Implementation Plan\n\n"
+    "**Files:**\n"
+    "- Create: `src/new.ts`\n"
+    "- Create: `src/missing.ts`\n"
+    "- [ ] Step 1\n"
+)
+
+
+class StampBehaviourTest(unittest.TestCase):
+    def _repo(self, d):
+        root = Path(d)
+        (root / "docs/superpowers/plans").mkdir(parents=True)
+        self.plan_path = root / "docs/superpowers/plans/2026-03-16-idea-mode-ui.md"
+        self.plan_path.write_text(PLAN)
+        (root / "src").mkdir()
+        (root / "src/new.ts").write_text("x")
+        return root
+
+    def _run(self, root, args):
+        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(args)
+        return rc, buf.getvalue()
+
+    def test_draft_does_not_write(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out = self._run(root, ["--stamp", "--draft"])
+            self.assertEqual(rc, 0)
+            self.assertIn("would stamp", out)
+            self.assertNotIn(BEGIN, self.plan_path.read_text())
+
+    def test_stamp_writes_block(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out = self._run(root, ["--stamp"])
+            self.assertEqual(rc, 0)
+            self.assertIn("stamped", out)
+            self.assertIn(BEGIN, self.plan_path.read_text())
+
+    def test_stamp_is_idempotent_on_disk(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            self._run(root, ["--stamp"])
+            first = self.plan_path.read_text()
+            self._run(root, ["--stamp"])
+            self.assertEqual(first, self.plan_path.read_text())
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,38 @@
+"""Plugin manifest(s) parse, carry required fields, and match VERSION (CalVer).
+
+Offline. The Codex manifest (.codex-plugin/plugin.json) lands in Phase 2; this
+test tolerates its absence and only asserts equality when it exists.
+"""
+import json
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+
+
+def _load(rel):
+    return json.loads((REPO_ROOT / rel).read_text(encoding="utf-8"))
+
+
+class ClaudeManifestTest(unittest.TestCase):
+    def test_required_fields(self):
+        m = _load(".claude-plugin/plugin.json")
+        self.assertEqual(m["name"], "work-plan")
+        self.assertTrue(m["description"])
+        self.assertEqual(m["license"], "MIT")
+
+    def test_version_matches_VERSION(self):
+        m = _load(".claude-plugin/plugin.json")
+        ver = (REPO_ROOT / "VERSION").read_text(encoding="utf-8").strip()
+        self.assertEqual(m["version"], ver)   # CalVer string, not semver
+
+    def test_codex_manifest_agrees_when_present(self):
+        codex = REPO_ROOT / ".codex-plugin" / "plugin.json"
+        if not codex.exists():
+            self.skipTest("Codex manifest is Phase 2")
+        self.assertEqual(_load(".codex-plugin/plugin.json")["version"],
+                         _load(".claude-plugin/plugin.json")["version"])
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,60 @@
+"""Tests for reconcile action selection + target/body construction + unsatisfied paths."""
+import unittest
+import sys
+from datetime import date
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.manifest import DeclaredPath, unsatisfied_paths
+from lib.reconcile_actions import dead_rows, partial_rows, archive_dest, issue_for
+
+
+def _row(rel, verdict, present=0, declared=0):
+    return {"rel": rel, "verdict": verdict, "files_present": present,
+            "files_declared": declared, "glyph": "?", "rationale": ""}
+
+
+class SelectionTest(unittest.TestCase):
+    def test_dead_and_partial_filters(self):
+        rows = [_row("a.md", "dead"), _row("b.md", "partial", 3, 9),
+                _row("c.md", "shipped", 9, 9)]
+        self.assertEqual([r["rel"] for r in dead_rows(rows)], ["a.md"])
+        self.assertEqual([r["rel"] for r in partial_rows(rows)], ["b.md"])
+
+
+class ArchiveDestTest(unittest.TestCase):
+    def test_dest_under_archive_abandoned(self):
+        self.assertEqual(
+            archive_dest("docs/superpowers/plans/2026-01-01-x.md"),
+            "docs/superpowers/plans/archive/abandoned/2026-01-01-x.md")
+
+
+class UnsatisfiedPathsTest(unittest.TestCase):
+    def test_returns_only_missing(self):
+        decls = [DeclaredPath("create", "src/here.ts"),
+                 DeclaredPath("create", "src/gone.ts"),
+                 DeclaredPath("modify", "src/old.ts")]
+        missing = unsatisfied_paths(
+            decls, Path("/repo"), date(2026, 3, 1),
+            exists=lambda rel: rel == "src/here.ts",
+            committed_since=lambda rel: False)
+        self.assertEqual({d.path for d in missing}, {"src/gone.ts", "src/old.ts"})
+
+
+class IssueForTest(unittest.TestCase):
+    def test_title_and_body(self):
+        class Doc:
+            rel = "docs/superpowers/plans/2026-01-01-feature-x.md"
+        row = _row(Doc.rel, "partial", 2, 5)
+        missing = [DeclaredPath("create", "src/a.ts"), DeclaredPath("modify", "src/b.ts")]
+        title, body = issue_for(Doc(), row, missing)
+        self.assertIn("2026-01-01-feature-x", title)
+        self.assertIn("2/5", body)
+        self.assertIn("`src/a.ts`", body)
+        self.assertIn("`src/b.ts`", body)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,166 @@
+"""Read-only GitHub contract test for the reconcile subcommand.
+
+The docstring at the top of commands/reconcile.py declares:
+  "reconcile only READS GitHub via `gh issue list`. It NEVER writes labels,
+   edits issues, or modifies remote state."
+
+This test enforces that contract. Without it, the docstring is aspirational —
+a future refactor could silently introduce a `gh issue edit` (or close, or
+label, or comment) call and the existing test suite would still pass.
+
+The test mocks subprocess.run, drives reconcile against a fake track, and
+asserts every captured `gh` invocation matches an allowlist of read-only
+verbs. It exercises both the default-label path (no `github.labels`
+override) and the new override path from #32.
+"""
+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
+
+# Allowlist of `gh` subcommand pairs considered read-only.
+# `gh api` is intentionally excluded — it can be GET or write depending on -X.
+# If reconcile ever needs it, add a more specific check (require -X GET, etc.).
+READ_ONLY_GH_VERBS = {
+    ("issue", "list"),
+    ("issue", "view"),
+    ("pr", "list"),
+    ("pr", "view"),
+}
+
+
+def _fake_track(*, slug, repo, labels=None, issues=None):
+    meta = {
+        "track": slug,
+        "status": "active",
+        "github": {"repo": repo, "issues": issues or []},
+    }
+    if labels is not None:
+        meta["github"]["labels"] = labels
+    return SimpleNamespace(
+        name=slug,
+        path=Path(f"/tmp/fake/{slug}.md"),
+        body="# fake",
+        meta=meta,
+        has_frontmatter=True,
+        repo=repo,
+    )
+
+
+class ReadOnlyContractTest(unittest.TestCase):
+    def _drive(self, *, track, gh_response, user_choice, extra_args=None):
+        """Run reconcile.run against mocks; return (exit_code, captured_argvs, write_mock, prompt_mock)."""
+        captured = []
+
+        def fake_run(argv, *args, **kwargs):
+            captured.append(list(argv))
+            return MagicMock(returncode=0, stdout=json.dumps(gh_response), stderr="")
+
+        cfg = {"notes_root": "/tmp/fake-notes", "repos": {"ok": {"github": "ok/ok"}}}
+        # NOTE: find_track_by_name is intentionally NOT mocked. We let the real
+        # resolver run against the in-memory [track] list so a regression that
+        # broke the active-status filter (or the name-matching logic) would
+        # surface here — not just be silently bypassed by the mock.
+        with patch("commands.reconcile.subprocess.run", side_effect=fake_run), \
+             patch("commands.reconcile.load_config", return_value=cfg), \
+             patch("commands.reconcile.discover_tracks", return_value=[track]), \
+             patch("commands.reconcile.prompt_input", return_value=user_choice) as mock_prompt, \
+             patch("commands.reconcile.write_file") as mock_write:
+            args = [track.meta["track"]] + (extra_args or [])
+            rc = reconcile.run(args)
+        return rc, captured, mock_write, mock_prompt
+
+    def _assert_read_only(self, captured):
+        gh_calls = [a for a in captured if a and a[0] == "gh"]
+        self.assertGreater(len(gh_calls), 0,
+                           "reconcile should have made at least one gh call")
+        for argv in gh_calls:
+            verb_pair = tuple(argv[1:3])
+            self.assertIn(
+                verb_pair, READ_ONLY_GH_VERBS,
+                f"reconcile invoked a non-read-only gh command: {' '.join(argv)}\n"
+                f"This violates the READ-ONLY GITHUB CONTRACT documented at the top "
+                f"of commands/reconcile.py. Writes must go through the local "
+                f"frontmatter file, never through gh.",
+            )
+
+    def test_default_label_path_is_read_only(self):
+        # Track without `github.labels` falls back to default `track/<slug>`.
+        track = _fake_track(slug="alpha", repo="ok/ok", labels=None, issues=[1, 2, 3])
+        gh_response = [
+            {"number": 1, "title": "one", "state": "OPEN"},
+            {"number": 4, "title": "four", "state": "OPEN"},
+        ]
+        rc, captured, mock_write, _ = self._drive(
+            track=track, gh_response=gh_response, user_choice="n",
+        )
+        self.assertEqual(rc, 0)
+        self._assert_read_only(captured)
+        mock_write.assert_not_called()
+
+    def test_label_override_path_is_read_only(self):
+        # Track WITH `github.labels` override (the new feature from #32).
+        # Each label produces a `gh issue list` AND a `gh pr list` — all must
+        # be read-only. PRs are queried so frontmatter entries pointing at
+        # labeled PRs aren't spuriously FLAGged.
+        track = _fake_track(slug="beta", repo="ok/ok",
+                            labels=["storytelling", "campaigns"], issues=[10])
+        gh_response = [{"number": 10, "title": "x", "state": "OPEN"}]
+        rc, captured, mock_write, _ = self._drive(
+            track=track, gh_response=gh_response, user_choice="n",
+        )
+        self.assertEqual(rc, 0)
+        self._assert_read_only(captured)
+        # Two configured labels × two kinds (issue + pr) → four gh invocations
+        gh_calls = [a for a in captured if a and a[0] == "gh"]
+        self.assertEqual(len(gh_calls), 4,
+                         f"expected one gh issue + one gh pr call per label, got {len(gh_calls)}")
+        kinds = sorted(c[1] for c in gh_calls)
+        self.assertEqual(kinds, ["issue", "issue", "pr", "pr"],
+                         f"expected two issue + two pr calls, got {kinds}")
+
+    def test_user_accept_writes_local_file_only_not_gh(self):
+        # Even when the user accepts the proposed ADDs, the only write should
+        # be to the local frontmatter file via write_file — never via gh.
+        track = _fake_track(slug="gamma", repo="ok/ok", issues=[5])
+        gh_response = [
+            {"number": 5, "title": "x", "state": "OPEN"},
+            {"number": 99, "title": "new", "state": "OPEN"},
+        ]
+        rc, captured, mock_write, _ = self._drive(
+            track=track, gh_response=gh_response, user_choice="y",
+        )
+        self.assertEqual(rc, 0)
+        self._assert_read_only(captured)
+        mock_write.assert_called_once()
+
+    def test_draft_skips_user_prompt_and_write(self):
+        # --draft prints the analysis but never prompts and never writes.
+        # Even with proposed ADDs (so the report path is exercised), the user
+        # should not be interrupted and the local file should remain untouched.
+        # user_choice="y" would normally trigger a write — proves --draft
+        # short-circuits before the prompt is reached.
+        track = _fake_track(slug="delta", repo="ok/ok", issues=[5])
+        gh_response = [
+            {"number": 5, "title": "x", "state": "OPEN"},
+            {"number": 99, "title": "new", "state": "OPEN"},
+        ]
+        rc, captured, mock_write, mock_prompt = self._drive(
+            track=track, gh_response=gh_response,
+            user_choice="y", extra_args=["--draft"],
+        )
+        self.assertEqual(rc, 0)
+        self._assert_read_only(captured)
+        mock_prompt.assert_not_called()
+        mock_write.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()