boost-skill-cli 1.0.147__tar.gz → 1.0.148__tar.gz

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.147
+Version: 1.0.148
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.147'
-__version_tuple__ = version_tuple = (1, 0, 147)
+__version__ = version = '1.0.148'
+__version_tuple__ = version_tuple = (1, 0, 148)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/boost_cli/commands/pkg.py

@@ -118,7 +118,9 @@ def _warn_secrets(res: store.InstallResult) -> None:
 def _report_result(res: store.InstallResult) -> None:
     """The canonical three-line install report."""
     if res.kind in ("rule", "workflow"):
-        out.ok("materialized → %s" % (" · ".join(res.linked) or "(no enabled agents)"))
+        where = " (this repo)" if res.scope == "project" else ""
+        out.ok("materialized%s → %s"
+               % (where, " · ".join(res.linked) or "(no enabled agents)"))
         out.ok("lock updated (.skill-lock.json)")
         _warn_injection(res)
         _warn_secrets(res)
@@ -166,6 +168,9 @@ def cmd_install(argv: List[str]) -> int:
                     help="reinstall even if already installed or pinned")
     ap.add_argument("--agent", action="append", metavar="A",
                     help="link only into this agent (repeatable)")
+    ap.add_argument("--scope", choices=("user", "project"), default="user",
+                    help="rules/workflows: install into your user config (default) "
+                         "or the current repo (project)")
     ap.add_argument("--dry-run", action="store_true",
                     help="show what would happen without changing anything")
     args = ap.parse_args(argv)
@@ -191,8 +196,10 @@ def cmd_install(argv: List[str]) -> int:
                 seen = (lockfile.get_rule if k == "rule"
                         else lockfile.get_workflow)(e["name"])
                 verb = "reinstall" if seen else "install"
-                out.info("would %s %s %s v%s from %s" % (verb, k, e["name"],
-                                                         e["version"], e["tap"]))
+                where = "into this repo" if args.scope == "project" else "user config"
+                out.info("would %s %s %s v%s from %s (%s)" % (verb, k, e["name"],
+                                                              e["version"], e["tap"],
+                                                              where))
                 out.info("  materialize → %s" % (" · ".join(targets)
                                                  or "(no enabled agents)"))
                 continue
@@ -210,7 +217,7 @@ def cmd_install(argv: List[str]) -> int:
         if multi:
             out.heading("%s v%s (%s)" % (e["name"], e["version"], e["tap"]))
         try:
-            res = store.install(e, force=args.force, only_agents=only)
+            res = store.install(e, force=args.force, only_agents=only, scope=args.scope)
         except BoostError as err:
             if not multi:
                 raise
@@ -414,7 +421,9 @@ def _update_materialized(kind: str, installed: Dict[str, dict], results) -> int:
         if not changed:
             continue
         try:
-            store.install(entry, force=True)
+            # keep the item where it was installed (user vs a specific repo).
+            store.install(entry, force=True,
+                          scope=lk.get("scope", "user"), base=lk.get("base"))
         except BoostError as err:
             out.warn("%s: %s" % (name, err.message))
             continue

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/boost_cli/core/rules.py

@@ -15,7 +15,7 @@ the filesystem writes and the lock record so uninstall can reverse them.
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Tuple
+from typing import Optional, Tuple
 
 # Name-scoped managed-block markers for CLAUDE.md. Stable + per-rule so install
 # is idempotent (a re-install replaces the block) and uninstall strips exactly
@@ -40,17 +40,27 @@ def markers(name: str) -> Tuple[str, str]:
     return BLOCK_START % name, BLOCK_END % name
 
 
-def rule_target(agent: str, skills_dir: Path, name: str) -> Tuple[str, Path]:
-    """Where rule ``name`` materializes for ``agent``, given its skills dir.
+def rule_target(agent: str, skills_dir: Path, name: str,
+                base: "Optional[Path]" = None) -> Tuple[str, Path]:
+    """Where rule ``name`` materializes for ``agent``.
 
-    Returns ``(mode, path)``: ``MODE_CLAUDE`` writes/merges the CLAUDE.md at the
-    agent root; ``MODE_FILE`` drops a file into the agent's ``rules/`` dir. The
-    agent root is the parent of its configured skills dir (``~/.cursor/skills``
-    -> ``~/.cursor``), so no extra config is needed.
+    Returns ``(mode, path)``: ``MODE_CLAUDE`` writes/merges a CLAUDE.md;
+    ``MODE_FILE`` drops a file into the agent's ``rules/`` dir.
+
+    ``base`` selects the scope:
+      * ``None`` (user scope) — the agent's user config: the parent of its
+        configured skills dir (``~/.cursor/skills`` -> ``~/.cursor``), and
+        ``~/.claude/CLAUDE.md`` for Claude.
+      * a directory (project scope) — that repo: ``<base>/.cursor/rules/…`` and,
+        since Claude reads per-repo memory from the root, ``<base>/CLAUDE.local.md``
+        (the personal, git-ignored file) for Claude.
     """
-    root = Path(skills_dir).parent
+    dotdir = Path(skills_dir).parent.name          # ".claude" / ".cursor" / …
     if agent in CLAUDE_MD_AGENTS:
-        return MODE_CLAUDE, root / "CLAUDE.md"
+        if base is not None:
+            return MODE_CLAUDE, Path(base) / "CLAUDE.local.md"
+        return MODE_CLAUDE, Path(skills_dir).parent / "CLAUDE.md"
+    root = (Path(base) / dotdir) if base is not None else Path(skills_dir).parent
     ext = RULE_DIR_EXT.get(agent, DEFAULT_RULE_EXT)
     return MODE_FILE, root / "rules" / (name + ext)
 

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/boost_cli/core/store.py

@@ -26,6 +26,7 @@ class InstallResult:
     score: int = 0
     upgraded: bool = False
     kind: str = "skill"
+    scope: str = "user"   # "user" or "project" — where a rule/workflow landed
     # For rules/workflows the installed content is a single file (or a merged
     # CLAUDE.md block), not a SKILL.md tree — carry the raw source so the caller
     # scans exactly what it installed instead of a non-existent SKILL.md.
@@ -117,14 +118,32 @@ def _copy_skill(src: Path, dest: Path) -> None:
         shutil.rmtree(backup, ignore_errors=True)
 
 
+def _resolve_base(scope: str, base) -> Optional[Path]:
+    """Directory a project-scoped install materializes under (the repo), or None
+    for user scope. An explicit ``base`` (e.g. from a lock record on update/sync)
+    wins so a re-materialization lands where the original install did, not in
+    whatever the current working directory happens to be."""
+    if base:
+        return Path(base)
+    return Path.cwd() if scope == "project" else None
+
+
 def install(entry: dict, force: bool = False,
-            only_agents: Optional[List[str]] = None) -> InstallResult:
-    """Install a catalog entry. Raises BoostError on policy block or conflict."""
+            only_agents: Optional[List[str]] = None,
+            scope: str = "user", base=None) -> InstallResult:
+    """Install a catalog entry. Raises BoostError on policy block or conflict.
+
+    ``scope`` is ``"user"`` (default — the agent's user config dirs) or
+    ``"project"`` (the current repo). Skills ignore scope (they always live in
+    the canonical store); rules/workflows honor it.
+    """
     kind = entry.get("kind", "skill")
     if kind == "rule":
-        return _install_rule(entry, force=force, only_agents=only_agents)
+        return _install_rule(entry, force=force, only_agents=only_agents,
+                             scope=scope, base=base)
     if kind == "workflow":
-        return _install_workflow(entry, force=force, only_agents=only_agents)
+        return _install_workflow(entry, force=force, only_agents=only_agents,
+                                 scope=scope, base=base)
     if kind != "skill":
         raise BoostError(
             "%s is a %s, which boost does not know how to install" % (entry["name"], kind),
@@ -172,14 +191,16 @@ def install(entry: dict, force: bool = False,
 
 
 def _install_rule(entry: dict, force: bool = False,
-                  only_agents: Optional[List[str]] = None) -> InstallResult:
+                  only_agents: Optional[List[str]] = None,
+                  scope: str = "user", base=None) -> InstallResult:
     """Materialize a rule into each enabled agent's native format.
 
     Cursor/Windsurf/Cline get a verbatim file drop in their ``rules/`` dir
     (frontmatter preserved — it is native rule metadata); Claude Code has no
     rules folder, so the rule merges into ``CLAUDE.md`` as an idempotent managed
-    block. Every materialization is recorded so ``uninstall`` reverses exactly
-    what was written.
+    block. With ``scope="project"`` these land under the repo (and Claude uses
+    ``CLAUDE.local.md``). Every materialization is recorded so ``uninstall``
+    reverses exactly what was written.
     """
     import hashlib
 
@@ -204,13 +225,14 @@ def _install_rule(entry: dict, force: bool = False,
     meta, body = frontmatter.parse(raw)
     claude_body = rules.render_claude_body(str(meta.get("name") or name), body)
 
+    resolved_base = _resolve_base(scope, base)
     paths.ensure_dirs()
     materializations: List[dict] = []
     linked: List[str] = []
     for agent, skills_dir in agents.enabled_agents().items():
         if only_agents and agent not in only_agents:
             continue
-        mode, path = rules.rule_target(agent, skills_dir, name)
+        mode, path = rules.rule_target(agent, skills_dir, name, base=resolved_base)
         path.parent.mkdir(parents=True, exist_ok=True)
         if mode == rules.MODE_CLAUDE:
             current = path.read_text(encoding="utf-8") if path.exists() else ""
@@ -228,6 +250,8 @@ def _install_rule(entry: dict, force: bool = False,
         "source_file": entry.get("skill_md", ""),
         "commit": gitutil.head_commit(tap.path),
         "sha256": hashlib.sha256(raw.encode("utf-8")).hexdigest(),
+        "scope": scope,
+        "base": str(resolved_base) if resolved_base is not None else None,
         "installed_at": (existing or {}).get("installed_at", now),
         "updated_at": now,
         "materializations": materializations,
@@ -240,6 +264,7 @@ def _install_rule(entry: dict, force: bool = False,
         kind="rule", scan_text=raw)
     res.linked = linked
     res.upgraded = existing is not None
+    res.scope = scope
     return res
 
 
@@ -266,12 +291,14 @@ def _uninstall_rule(name: str, rule: dict) -> dict:
 
 
 def _install_workflow(entry: dict, force: bool = False,
-                      only_agents: Optional[List[str]] = None) -> InstallResult:
+                      only_agents: Optional[List[str]] = None,
+                      scope: str = "user", base=None) -> InstallResult:
     """Materialize a workflow (slash command / subagent) into each enabled agent.
 
     A verbatim Markdown drop into the agent's ``commands/`` or ``agents/`` dir —
-    the slot derived from the source path — with no transformation. Every drop is
-    recorded so ``uninstall`` removes exactly the files it wrote.
+    the slot derived from the source path — with no transformation. With
+    ``scope="project"`` the drop lands under the repo (``<repo>/.claude/…``).
+    Every drop is recorded so ``uninstall`` removes exactly the files it wrote.
     """
     import hashlib
 
@@ -296,13 +323,14 @@ def _install_workflow(entry: dict, force: bool = False,
     raw = src.read_text(encoding="utf-8", errors="replace")
     slot = workflows.detect_slot(source_rel)
 
+    resolved_base = _resolve_base(scope, base)
     paths.ensure_dirs()
     materializations: List[dict] = []
     linked: List[str] = []
     for agent, skills_dir in agents.enabled_agents().items():
         if only_agents and agent not in only_agents:
             continue
-        path = workflows.workflow_target(skills_dir, slot, name)
+        path = workflows.workflow_target(skills_dir, slot, name, base=resolved_base)
         path.parent.mkdir(parents=True, exist_ok=True)
         util.atomic_write_text(path, raw)
         materializations.append({"agent": agent, "slot": slot, "path": str(path)})
@@ -317,6 +345,8 @@ def _install_workflow(entry: dict, force: bool = False,
         "source_file": source_rel,
         "commit": gitutil.head_commit(tap.path),
         "sha256": hashlib.sha256(raw.encode("utf-8")).hexdigest(),
+        "scope": scope,
+        "base": str(resolved_base) if resolved_base is not None else None,
         "installed_at": (existing or {}).get("installed_at", now),
         "updated_at": now,
         "materializations": materializations,
@@ -329,6 +359,7 @@ def _install_workflow(entry: dict, force: bool = False,
         kind="workflow", scan_text=raw)
     res.linked = linked
     res.upgraded = existing is not None
+    res.scope = scope
     return res
 
 
@@ -506,7 +537,10 @@ def sync_apply(plan: Dict[str, list]) -> List[str]:
                 matches = [e for e in catalog.find(name)
                            if e["tap"] == tap_name and e.get("kind", "skill") == kind]
                 if matches:
-                    install(matches[0], force=True)
+                    # preserve the original scope/base so a project rule repairs
+                    # into its repo, not wherever sync happens to run.
+                    install(matches[0], force=True,
+                            scope=entry.get("scope", "user"), base=entry.get("base"))
                     actions.append("re-materialized %s %s from %s"
                                    % (kind, name, tap_name))
                     continue

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/boost_cli/core/workflows.py

@@ -14,6 +14,7 @@ the filesystem writes and the lock record so uninstall can reverse them.
 from __future__ import annotations
 
 from pathlib import Path
+from typing import Optional
 
 SLOT_COMMANDS = "commands"
 SLOT_AGENTS = "agents"
@@ -36,11 +37,16 @@ def detect_slot(source_rel: str) -> str:
     return SLOT_AGENTS if parts & AGENT_DIRS else SLOT_COMMANDS
 
 
-def workflow_target(skills_dir: Path, slot: str, name: str) -> Path:
+def workflow_target(skills_dir: Path, slot: str, name: str,
+                    base: Optional[Path] = None) -> Path:
     """Where workflow ``name`` (in ``slot``) materializes for an agent.
 
-    The agent root is the parent of its configured skills dir
-    (``~/.claude/skills`` -> ``~/.claude``), so the file lands at
-    ``<root>/<slot>/<name>.md`` with no extra config.
+    ``base`` selects the scope:
+      * ``None`` (user scope) — the parent of the agent's configured skills dir
+        (``~/.claude/skills`` -> ``~/.claude/<slot>/<name>.md``).
+      * a directory (project scope) — that repo's per-agent dotdir
+        (``<base>/.claude/<slot>/<name>.md``).
     """
-    return Path(skills_dir).parent / slot / (name + ".md")
+    root = (Path(base) / Path(skills_dir).parent.name) if base is not None \
+        else Path(skills_dir).parent
+    return root / slot / (name + ".md")

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/boost_skill_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.147
+Version: 1.0.148
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/boost_skill_cli.egg-info/SOURCES.txt

@@ -141,6 +141,7 @@ docs/roadmap/items/github-pages-deploy-is-broken-every-push.md
 docs/roadmap/items/golden-set-statistical-power.md
 docs/roadmap/items/hash-pinned-reproducible-toolchain-uv-lock.md
 docs/roadmap/items/html-validation-html-validate.md
+docs/roadmap/items/install-scope-user-or-project.md
 docs/roadmap/items/integrity-verification-boost-verify.md
 docs/roadmap/items/invocation-pid-logging-for-crash-correlation.md
 docs/roadmap/items/layering-guard-import-linter.md

boost_skill_cli-1.0.148/docs/roadmap/items/install-scope-user-or-project.md

@@ -0,0 +1,27 @@
+---
+id: install-scope-user-or-project
+board: code
+section: internals
+status: shipped
+category: Install engine · UX
+complexity: M
+impact: High
+wow: 3
+note: rules/workflows were user-global only
+order: 27
+owner: loop/install-scope
+pr: 169
+title: <code>boost install --scope user|project</code> for rules/workflows
+---
+Rule and workflow install always materialized into user-global agent config
+           (<code>~/.claude/CLAUDE.md</code>, <code>~/.cursor/rules</code>, …), so a
+           rule meant for one repo leaked into every session. Add
+           <code>--scope project</code>: materialize into the current repo instead —
+           <code>&lt;repo&gt;/.cursor/rules/</code>, <code>&lt;repo&gt;/.claude/commands|agents/</code>,
+           and, since Claude reads per-repo memory from the root and has no rules
+           folder, <code>&lt;repo&gt;/CLAUDE.local.md</code> (the personal, git-ignored
+           file). The chosen scope + base dir are recorded in the lock so
+           <code>update</code>/<code>sync</code> re-materialize back into the same
+           repo rather than wherever they happen to run. Default stays
+           <code>--scope user</code> (unchanged behavior). Uninstall already reverses
+           by recorded path, so it works for either scope.

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/docs/roadmap.html

@@ -118,7 +118,7 @@
       <div class="stat"><b>16</b><span>Shipped</span></div>
       <div class="stat"><b>1</b><span>Next up</span></div>
       <div class="stat"><b>4</b><span>Planned</span></div>
-      <div class="stat"><b>107</b><span>Loop finds</span></div>
+      <div class="stat"><b>108</b><span>Loop finds</span></div>
       <!-- /ROADMAP:stats -->
     </div>
   </section>
@@ -840,6 +840,29 @@ chunks instead cost ~70%.</p>
           <span class="m">close the last skill-only gaps for rules/workflows</span>
         </div>
       </article>
+
+      <article class="cap rcard">
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Install engine · UX</span></div>
+        <h3><code>boost install --scope user|project</code> for rules/workflows</h3>
+        <p>Rule and workflow install always materialized into user-global agent config
+           (<code>~/.claude/CLAUDE.md</code>, <code>~/.cursor/rules</code>, …), so a
+           rule meant for one repo leaked into every session. Add
+           <code>--scope project</code>: materialize into the current repo instead —
+           <code>&lt;repo&gt;/.cursor/rules/</code>, <code>&lt;repo&gt;/.claude/commands|agents/</code>,
+           and, since Claude reads per-repo memory from the root and has no rules
+           folder, <code>&lt;repo&gt;/CLAUDE.local.md</code> (the personal, git-ignored
+           file). The chosen scope + base dir are recorded in the lock so
+           <code>update</code>/<code>sync</code> re-materialize back into the same
+           repo rather than wherever they happen to run. Default stays
+           <code>--scope user</code> (unchanged behavior). Uninstall already reverses
+           by recorded path, so it works for either scope.</p>
+        <div class="meta">
+          <span class="m">Complexity <b>M</b></span>
+          <span class="m hi">Impact <b>High</b></span>
+          <span class="m">Wow <b class="wow">★★★</b></span>
+          <span class="m">rules/workflows were user-global only</span>
+        </div>
+      </article>
       <!-- /ROADMAP:cards -->
 
     </div>

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/tests/functional/test_cli_pkg.py

@@ -68,6 +68,22 @@ class TestInstall:
         assert "suspicious pattern" in r.out
         assert "in rule content" in r.out              # not "in SKILL.md"
 
+    def test_rule_scope_project_lands_in_repo_not_global(self, boost,
+                                                         fixture_tap_src,
+                                                         tmp_path, monkeypatch):
+        tap_dir = _copy_tap(fixture_tap_src, tmp_path / "sp-tap")
+        _add_and_commit(tap_dir, "rules/team.mdc",
+                        "---\nname: team-rules\n---\n\nAlways TDD.\n", "add rule")
+        boost("tap", tap_dir)
+        repo = tmp_path / "proj"
+        repo.mkdir()
+        monkeypatch.chdir(repo)                         # project scope == cwd
+        r = boost("install", "team-rules", "--scope", "project")
+        assert "materialized (this repo)" in r.out
+        assert (repo / "CLAUDE.local.md").is_file()     # Claude -> personal repo file
+        assert (repo / ".cursor" / "rules" / "team-rules.mdc").is_file()
+        assert not (paths.home() / ".claude" / "CLAUDE.md").exists()  # not global
+
     def test_exact_report_lines(self, boost, tapped):
         r = boost("install", "brainstorming")
         assert "copied to ~/.agents/skills/brainstorming" in r.out

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/tests/unit/test_rules.py

@@ -43,6 +43,24 @@ class TestRuleTarget:
         assert mode == rules.MODE_FILE
         assert path == Path("/h/.zed/rules/r.md")
 
+    # --- project scope (base=<repo>) ---
+    def test_project_claude_uses_claude_local_md_at_repo_root(self):
+        mode, path = rules.rule_target("claude-code", Path("/h/.claude/skills"),
+                                       "r", base=Path("/repo"))
+        assert mode == rules.MODE_CLAUDE
+        assert path == Path("/repo/CLAUDE.local.md")   # personal, not ~/.claude
+
+    def test_project_cursor_uses_repo_dotcursor_rules(self):
+        mode, path = rules.rule_target("cursor", Path("/h/.cursor/skills"),
+                                       "r", base=Path("/repo"))
+        assert mode == rules.MODE_FILE
+        assert path == Path("/repo/.cursor/rules/r.mdc")
+
+    def test_project_windsurf_uses_repo_dotwindsurf(self):
+        _mode, path = rules.rule_target("windsurf", Path("/h/.windsurf/skills"),
+                                        "r", base=Path("/repo"))
+        assert path == Path("/repo/.windsurf/rules/r.md")
+
 
 class TestRenderClaudeBody:
     def test_title_header_then_body(self):

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/tests/unit/test_store.py

@@ -700,3 +700,51 @@ class TestSyncMaterializations:
         res = store.install(_workflow_entry(tap))
         assert res.scan_text is not None
         assert "Run the release." in res.scan_text
+
+
+class TestInstallScope:
+    def test_resolve_base(self):
+        from pathlib import Path as P
+        assert store._resolve_base("user", None) is None
+        assert store._resolve_base("project", None) == P.cwd()
+        assert store._resolve_base("project", "/x") == P("/x")
+
+    def test_rule_project_scope_materializes_under_base(self, tap, tmp_path):
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        res = store.install(_rule_entry(tap), scope="project", base=str(repo))
+        assert res.scope == "project"
+        # Claude -> personal repo file, not ~/.claude/CLAUDE.md
+        cm = repo / "CLAUDE.local.md"
+        assert cm.is_file()
+        assert "boost:rule:team-conventions start" in cm.read_text()
+        assert (repo / ".cursor" / "rules" / "team-conventions.mdc").is_file()
+        assert (repo / ".windsurf" / "rules" / "team-conventions.md").is_file()
+        assert not (paths.home() / ".claude" / "CLAUDE.md").exists()  # not global
+        rec = lockfile.get_rule("team-conventions")
+        assert rec["scope"] == "project"
+        assert rec["base"] == str(repo)
+
+    def test_workflow_project_scope_under_base(self, tap, tmp_path):
+        repo = tmp_path / "repo2"
+        repo.mkdir()
+        store.install(_workflow_entry(tap), scope="project", base=str(repo))
+        assert (repo / ".claude" / "commands" / "ship-it.md").is_file()
+        assert not (paths.home() / ".claude" / "commands" / "ship-it.md").exists()
+        assert lockfile.get_workflow("ship-it")["base"] == str(repo)
+
+    def test_user_scope_is_default_and_global(self, tap):
+        res = store.install(_rule_entry(tap))
+        assert res.scope == "user"
+        assert (paths.home() / ".claude" / "CLAUDE.md").is_file()
+        rec = lockfile.get_rule("team-conventions")
+        assert rec["scope"] == "user" and rec["base"] is None
+
+    def test_project_uninstall_reverses_repo_files(self, tap, tmp_path):
+        repo = tmp_path / "repo3"
+        repo.mkdir()
+        store.install(_rule_entry(tap), scope="project", base=str(repo))
+        store.uninstall("team-conventions")
+        assert not (repo / ".cursor" / "rules" / "team-conventions.mdc").exists()
+        assert not (repo / "CLAUDE.local.md").exists()  # held only our block
+        assert lockfile.get_rule("team-conventions") is None

{boost_skill_cli-1.0.147 → boost_skill_cli-1.0.148}/tests/unit/test_workflows.py

@@ -47,3 +47,13 @@ class TestWorkflowTarget:
     def test_uses_configured_skills_dir_parent(self):
         p = workflows.workflow_target(Path("/opt/cursor/skills"), "commands", "x")
         assert p == Path("/opt/cursor/commands/x.md")
+
+    def test_project_scope_lands_under_repo_dotdir(self):
+        p = workflows.workflow_target(Path("/h/.claude/skills"), "commands",
+                                      "ship", base=Path("/repo"))
+        assert p == Path("/repo/.claude/commands/ship.md")
+
+    def test_project_scope_subagent_under_repo(self):
+        p = workflows.workflow_target(Path("/h/.claude/skills"), "agents",
+                                      "rev", base=Path("/repo"))
+        assert p == Path("/repo/.claude/agents/rev.md")