boost-skill-cli 1.2.200__tar.gz → 1.2.202__tar.gz

{boost_skill_cli-1.2.200 → boost_skill_cli-1.2.202}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.200
+Version: 1.2.202
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.200 → boost_skill_cli-1.2.202}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.200'
-__version_tuple__ = version_tuple = (1, 2, 200)
+__version__ = version = '1.2.202'
+__version_tuple__ = version_tuple = (1, 2, 202)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.200 → boost_skill_cli-1.2.202}/boost_cli/commands/bmad.py

@@ -163,9 +163,26 @@ def _on_off(value) -> str:
     return "on" if value else "off"
 
 
+def _project_root() -> Path:
+    """The directory project-scope personas, hooks and state all belong to.
+
+    The same root ``cs.settings_path("project")`` writes hooks under: the
+    enclosing repo when there is one. Personas and state used to follow the
+    raw cwd while hooks followed the repo root, so ``bmad on --scope project``
+    from ``src/deep`` split one install across two directories and ``doctor``
+    at the root and in the subdirectory disagreed about it. The cwd fallback
+    only answers in ``$HOME``, where a project write refuses anyway.
+
+    BMAD's skills and ``_bmad/`` are not routed here: ``npx bmad-method
+    install`` lays them out under the cwd it is given, and ``_skills_dir``
+    has to look where the installer put them.
+    """
+    return cs.project_base() or Path.cwd()
+
+
 def _agents_dir(scope) -> Path:
     """Where Claude Code reads subagent definitions for a scope."""
-    base = paths.home() if scope == "global" else Path.cwd()
+    base = paths.home() if scope == "global" else _project_root()
     return base / ".claude" / "agents"
 
 
@@ -219,6 +236,12 @@ def _hook_hosts(scope: str, requested=None, force: bool = False) -> list[str]:
     `on` installs two hooks, and a host list that decided itself twice said
     "skipping Codex CLI" twice for one decision.
     """
+    # A path computation that refuses project scope with no project, asked
+    # for Claude because every branch below writes somewhere: the other hosts
+    # are only probed when they are candidates, and an explicit `--host`
+    # never probed at all, so `on --scope project` from $HOME wrote personas
+    # into ~/.claude/agents before `add_hook` refused.
+    cs.settings_path(scope, host=hookhost.CLAUDE)
     if requested not in (None, "auto"):
         cs.refuse_escape(scope, str(requested), force=force)
         return [str(requested)]
@@ -845,7 +868,7 @@ def _doctor() -> int:
                % (_on_off(live), personas, _where(router_hosts), briefing))
         out.kv("  workflows", "skills=%d  installed=%s"
                % (_count_skills(_skills_dir(scope)), _on_off(st.get("installed"))))
-    out.dim("  project = %s" % Path.cwd())
+    out.dim("  project = %s" % _project_root())
     if not any(_get_scope_state(s).get("autopilot") for s in ("global", "project")):
         out.dim("  turn it on with `boost bmad on`", wrap=True)
     return 0
@@ -969,7 +992,7 @@ def _sessions_write(sessions: dict) -> None:
 
 
 def _proj_key(project=None) -> str:
-    return str(Path(project or Path.cwd()).resolve())
+    return str(Path(project or _project_root()).resolve())
 
 
 def _get_scope_state(scope, project=None) -> dict:

{boost_skill_cli-1.2.200 → boost_skill_cli-1.2.202}/boost_cli/commands/configuration.py

@@ -13,8 +13,8 @@ import shutil
 import subprocess
 import sys
 import time
+from collections.abc import Callable
 from datetime import datetime, timedelta
-from itertools import chain
 from pathlib import Path
 
 from .. import __version__, cliparse
@@ -1474,7 +1474,9 @@ def _tool_search(args: dict):
     # and re-parses the file on every call, so the obvious `find_any(name)`
     # inside this comprehension is ten reads of the same bytes. The union of
     # the three sections is that same predicate, once.
-    installed_names = set(chain.from_iterable(lockfile.all_installed().values()))
+    # A skill installed `--local` into this repo is installed too: leaving the
+    # project lock out told an agent its active project skill was missing.
+    installed_names = integrity.installed_names()
     marks = [e.get("name", "") in installed_names for e in entries]
     lines = [mcp.hit_line(e, installed=m)
              for e, m in zip(entries, marks, strict=True)]
@@ -1487,15 +1489,19 @@ def _tool_search(args: dict):
 
 def _tool_list(args: dict):
     # All three lock sections: "no skills installed" while `boost list` shows
-    # a rule is the exact disagreement this surface must not have.
+    # a rule is the exact disagreement this surface must not have. The same
+    # goes for the project lock `boost list` reads alongside the user's.
     everything = lockfile.all_installed()
+    pbase, project = integrity.project_skills()
     # The footer reads the lock file and the tap list and nothing else — no
     # catalog scan — so boost_list stays the instant, threshold-free tool that
     # INSTRUCTIONS and its own description both promise. It lands in the empty
     # state too: a machine with nothing installed is exactly where "what do I
-    # have" is least useful on its own.
-    footer = mcp.coverage_line(everything, tapped=builtin.configured_tap_count())
-    if not any(everything.values()):
+    # have" is least useful on its own. A name installed in both scopes is
+    # two installs, so the skill count takes both.
+    counted = everything | {"skill": [*everything["skill"], *project]}
+    footer = mcp.coverage_line(counted, tapped=builtin.configured_tap_count())
+    if not any(everything.values()) and not project:
         return "nothing installed\n" + footer, False
     lines = []
     for kind, section in everything.items():
@@ -1504,18 +1510,36 @@ def _tool_list(args: dict):
                          % (n, e.get("version", "?"), e.get("tap", "?"),
                             "" if kind == "skill" else " [%s]" % kind,
                             " [pinned]" if e.get("pinned") else ""))
+    if project:
+        lines.append("project skills (%s):" % _tilde(pbase))
+        lines.extend("%s v%s (%s) [project]%s"
+                     % (n, e.get("version", "?"), e.get("tap", "?"),
+                        " [pinned]" if e.get("pinned") else "")
+                     for n, e in sorted(project.items()))
     lines.append(footer)
     return "\n".join(lines), False
 
 
 def _tool_info(args: dict):
     name = str(args.get("name", ""))
-    found = lockfile.find_any(name)
-    kind, entry = found if found is not None else ("skill", None)
-    matches = catalog.find(name)
-    if not entry and not matches:
+    # The resolver `boost info` uses: split a `tap:name`, hold the qualifier
+    # against the installed record, and ask the project lock too. The unsplit
+    # name never matched the bare-keyed lock, so `fix2:x` read "installed: no"
+    # right after boost_install had installed it.
+    found = integrity.find_installed(name)
+    kind, entry, pbase = found if found is not None else ("skill", None, None)
+    if entry:
+        # The installed copy's own catalog row, never another tap's: version
+        # and tap came from the lock while the description came from
+        # whichever tap sorted first, one reply describing two items.
+        src = next((e for e in catalog.find(name)
+                    if e["tap"] == entry.get("tap")), {})
+    elif not catalog.find(name):
         return "no skill named %r (installed or in any tap)" % name, True
-    src = matches[0] if matches else {}
+    else:
+        # Raises the same "exists in multiple taps" error boost_read and
+        # boost_install give, rather than silently describing the first.
+        src = catalog.resolve_one(name)
     kind_label = kind if entry else src.get("kind", "skill")
     lines = ["name: " + name]
     if kind_label != "skill":
@@ -1531,6 +1555,8 @@ def _tool_info(args: dict):
             integrity.written_agent_names(kind, entry)) or "none"
         lines.extend(("installed: yes (%s)" % entry.get("installed_at", "?"),
                       "agents: %s" % agents_s))
+        if pbase is not None:
+            lines.append("scope: project (%s)" % _tilde(pbase))
         if entry.get("pinned"):
             lines.append("pinned: yes")
         if entry.get("quarantined"):
@@ -1684,10 +1710,17 @@ def _tool_doctor(args: dict):
                 "`boost replay` restores the lock that knows whose they are"
                 % (n, "" if n == 1 else "s", ", ".join(names))]
 
-    worded = {
-        "adoptable_store": lambda names: [
-            "%s was added outside boost — `boost sync` records it as a local "
-            "skill and links it" % n for n in names],
+    # Right after `boost replay rollback` over a corrupt lock, an unrecorded
+    # store dir may be what the lock's last change installed, so `boost sync`
+    # adopting it as `local` is the wrong fix (lockfile.unrestored_corrupt).
+    backup = (lockfile.unrestored_corrupt() if plan.get("adoptable_store")
+              else None)
+    worded: dict[str, Callable[[list], list[str]]] = {
+        "adoptable_store": lambda names: (
+            [lockfile.unrestored_line(len(names), ", ".join(names), backup)]
+            if backup else
+            ["%s was added outside boost — `boost sync` records it as a local "
+             "skill and links it" % n for n in names]),
         "unreadable_store": lambda rows: [store.unreadable_line(rows)],
         "foreign_store": store.foreign_store_lines,
         "plugin_duplicates": lambda rows: (store.plugin_duplicate_lines(rows)
@@ -1695,6 +1728,8 @@ def _tool_doctor(args: dict):
         "older_copies": store.older_copy_lines,
         "not_skill_store": lambda names: [store.not_skill_line(names)],
         "misnamed_store": lambda names: [store.misnamed_line(names)],
+        "workflow_copies": store.workflow_copy_lines,
+        "rule_blocks": store.rule_block_lines,
         "blocked_links": lambda rows: [
             "%s not linked for %s: %s is in the way and is not boost's — ask "
             "the user to move or delete it, then run `boost sync`"
@@ -1741,12 +1776,20 @@ def _tool_doctor(args: dict):
                 else integrity.materialized_status(n, e, kind))
         in _MAT_ISSUE_LABEL]
     lines.extend(mat_issues)
+    # Skills too, by the test CLI `boost doctor` asks: without it a skill
+    # edited in place left this reply "healthy" while the CLI flagged it.
+    skill_drift = [
+        "skill %s: modified since install (run `boost verify`)" % n
+        for n, e in sorted(everything["skill"].items())
+        if integrity.skill_modified(n, e)]
+    lines.extend(skill_drift)
     agent_lines = ["agents.%s.dir: %s — ask the user to fix it with `boost "
                    "config set agents.%s.dir <dir>`; link and materialization "
                    "checks were skipped" % (n, e.message, n)
                    for n, e in agent_errs]
     lines.extend(agent_lines)
-    total = issues + len(mat_issues) + len(agent_lines) + lock_bad
+    total = (issues + len(mat_issues) + len(skill_drift) + len(agent_lines)
+             + lock_bad)
     # A machine with no taps has nothing to disagree about, so every check
     # above passes and the old reply called it "healthy" — directly under the
     # line saying `taps: 0 (0 items available)`. That is the one state where
@@ -1776,16 +1819,17 @@ def _tool_doctor(args: dict):
     if total == 0:
         if tapped:
             lines.append("healthy — no issues found")
-    elif mat_issues or cfg_err or agent_lines:
+    elif mat_issues or skill_drift or cfg_err or agent_lines:
         # Not `boost sync`: an unresolvable agent dir makes sync refuse too.
         lines.append("%d issue(s) — run `boost doctor` for details" % total)
     else:
-        lines.append(_doctor_verdict(plan, total, lock_bad, lost))
+        lines.append(_doctor_verdict(plan, total, lock_bad, lost,
+                                     unrestored=backup is not None))
     return "\n".join(lines), total > 0
 
 
 def _doctor_verdict(plan: dict[str, list], total: int, lock_bad: bool,
-                    lost: bool) -> str:
+                    lost: bool, *, unrestored: bool = False) -> str:
     """The MCP doctor's last line: which issues `boost sync` fixes.
 
     It said "run `boost sync` to fix" over a lock only `boost replay` restores
@@ -1793,12 +1837,17 @@ def _doctor_verdict(plan: dict[str, list], total: int, lock_bad: bool,
     saw nothing change, and was told the same again. Three kinds, and the
     line names each one present: what sync fixes, what only `--prune` does
     (the user's call, since it deletes or unlinks), and what is the user's
-    to change.
+    to change. ``unrestored`` moves the skills added outside boost into the
+    user's share: the lock was just rolled back, and the record of what they
+    are is in the ``.corrupt`` backup, which sync cannot read.
     """
     repos = sum(1 for r in plan.get("foreign_store", ()) if store.is_repo_copy(r))
     user = (lock_bad + len(plan.get("blocked_links", ()))
             + len(plan.get("unreadable_store", ())) + repos
-            + (0 if lost else len(plan.get("unrecorded_store", ()))))
+            + len(plan.get("workflow_copies", ()))
+            + len(plan.get("rule_blocks", ()))
+            + (0 if lost else len(plan.get("unrecorded_store", ())))
+            + (len(plan.get("adoptable_store", ())) if unrestored else 0))
     prune = (len(plan.get("foreign_store", ())) - repos
              + len(plan.get("out_of_scope_links", ()))
              + sum(1 for r in plan.get("plugin_duplicates", ())

{boost_skill_cli-1.2.200 → boost_skill_cli-1.2.202}/boost_cli/commands/hooks.py

@@ -66,6 +66,10 @@ def cmd_hooks(argv) -> int:
     p.add_argument("--force", action="store_true",
                    help="write even when $CODEX_HOME points outside this $HOME")
     args = p.parse_args(argv)
+    # Trimmed once, here, so the name this command echoes back is the one
+    # stored and compared (`cs.clean_name` trims again as the core backstop);
+    # an all-whitespace name then meets the "needs --name" refusal below.
+    args.name = (args.name or "").strip()
 
     if args.action == "list":
         return _list(args.scope, args.host, args.event, args.as_json)

{boost_skill_cli-1.2.200 → boost_skill_cli-1.2.202}/boost_cli/commands/info.py

@@ -14,7 +14,6 @@ import shlex
 import subprocess
 import sys
 import webbrowser
-from itertools import chain
 from pathlib import Path
 
 from .. import cliparse
@@ -35,6 +34,7 @@ from ..core import (
     logs,
     mcpdecl,
     paths,
+    prereq,
     projectlock,
     registry,
     rules,
@@ -58,18 +58,8 @@ def _read(p: Path) -> str:
         raise BoostError("cannot read %s: %s" % (_tilde(p), e)) from e
 
 
-def _for_tap(entry, qualifier):
-    """``entry`` unless a ``tap:`` qualifier was given that it does not satisfy.
-
-    A qualifier has to be honored against the *installed* record, not only the
-    catalog: with one skill installed from tap A and asked about via
-    ``tap-b:skill``, tap A's lock entry is the wrong answer, and reporting it
-    would describe another tap's install as this one's.
-    """
-    if entry and qualifier and not catalog.tap_matches(
-            str(entry.get("tap") or ""), qualifier):
-        return None
-    return entry
+# Moved to core so the MCP tools resolve a `tap:name` exactly as these do.
+_for_tap = catalog.for_tap
 
 
 def _resolve_skill_md(name: str):
@@ -190,16 +180,24 @@ def _resolve_text(name: str):
 
 def _as_list(v) -> list:
     """Normalize a frontmatter value to a list of non-empty strings."""
-    if v in (None, "", False):
+    if v in (None, "", False) or isinstance(v, dict):
         return []
     if isinstance(v, list):
         return [str(x).strip() for x in v if str(x).strip()]
     return [s.strip() for s in str(v).split(",") if s.strip()]
 
 
-def _skill_meta(name: str):
-    """Frontmatter for a named skill — installed store preferred, else tap."""
+def _skill_meta(name: str, project: dict | None = None, pbase=None):
+    """Frontmatter for a named skill — installed copy preferred, else tap.
+
+    ``project``/``pbase`` are the current repo's lock and base: a project-only
+    skill has no store dir, so its copy in the repo is the installed one.
+    """
     p = store.skill_store_dir(name) / "SKILL.md"
+    if not p.exists() and project and name in project:
+        pdir = integrity.project_skill_dir(project[name], pbase)
+        if pdir is not None:
+            p = pdir / "SKILL.md"
     if not p.exists():
         matches = catalog.find(name)
         if not matches:
@@ -534,8 +532,13 @@ def cmd_info(argv):
     if lock:
         matches = catalog.find(args.name)
         same_tap = [e for e in matches if e["tap"] == lock.get("tap")]
-        candidates = same_tap or matches
-        cat = candidates[0] if candidates else None
+        # Describe the copy that is installed: a tap can ship one name twice,
+        # and `same_tap[0]` showed the other copy's description beside this
+        # one's `source`.
+        if same_tap:
+            cat, _ = catalog.select_lock_source(same_tap, lock)
+        else:
+            cat = matches[0] if matches else None
     else:
         cat = catalog.resolve_one(args.name)   # raises if unknown anywhere
     # `lock`/`plock` only ever hold a *skill* lock entry (they read the
@@ -548,11 +551,7 @@ def cmd_info(argv):
     sdir = store.skill_store_dir(name)
     skill_dir = sdir if lock and sdir.is_dir() else None
     if skill_dir is None and plock:
-        for m in plock.get("materializations") or []:
-            cand = scopes.resolve_in_base(pbase, m.get("path"))
-            if cand is not None and cand.is_dir():
-                skill_dir = cand
-                break
+        skill_dir = integrity.project_skill_dir(plock, pbase)
     if skill_dir is None and cat:
         try:
             skill_dir = store.source_dir_for(cat)
@@ -1237,7 +1236,11 @@ def cmd_deps(argv):
     # `requires:`/`conflicts:` name an installed item, not a kind — a
     # requirement met by an installed rule or workflow is met, and denying it
     # ("✗ not installed" while `boost list` shows it) was the section-blind lie.
-    have = set(chain.from_iterable(lockfile.all_installed().values()))
+    # The repo's own lock counts too: a requirement installed `--local` beside
+    # its dependent is met, and the old hint to `boost install` it again would
+    # have added a second, user-scope copy.
+    pbase, project = integrity.project_skills()
+    have = set(prereq.installed_names(pbase))
 
     if args.name:
         text, _kind, _lock, _cat = _resolve_text(args.name)
@@ -1245,7 +1248,8 @@ def cmd_deps(argv):
         requires = deps.requirement_names(meta)
         conflicts = deps.conflict_names(meta)
         req_rows = [deps.requirement_row(
-                        r, have, deps.requirement_names(_skill_meta(r) or {}))
+                        r, have, deps.requirement_names(
+                            _skill_meta(r, project, pbase) or {}))
                     for r in requires]
         conflict_rows = [deps.conflict_row(c, have) for c in conflicts]
         _qualifier, bare = catalog.split_name(args.name)
@@ -1289,8 +1293,9 @@ def cmd_deps(argv):
     unmet: list[dict] = []
     pairs: list[dict] = []
     seen: set = set()
-    for name in sorted(inst):
-        meta = _skill_meta(name) or {}
+    names = sorted(set(inst) | set(project))
+    for name in names:
+        meta = _skill_meta(name, project, pbase) or {}
         unmet.extend(
             {"skill": name, "requires": deps.requirement_row(r, have)}
             for r in deps.requirement_names(meta)
@@ -1305,7 +1310,7 @@ def cmd_deps(argv):
     if args.json:
         print(json.dumps({"unmet": unmet, "conflicts": pairs}, indent=2))
         return 1 if unmet or pairs else 0
-    if not inst:
+    if not names:
         print(out.empty_state("no skills installed",
                               hint="boost install <skill> to start"))
         return 0
@@ -1318,7 +1323,7 @@ def cmd_deps(argv):
                                out.role("conflicts with", "danger"), out.c(pair["b"], out.BOLD)))
     if not unmet and not pairs:
         out.ok("no unmet requirements or conflicts across %d skill%s"
-               % (len(inst), "" if len(inst) == 1 else "s"))
+               % (len(names), "" if len(names) == 1 else "s"))
         return 0
     if unmet:
         missing = sorted({u["requires"]["name"] for u in unmet})

{boost_skill_cli-1.2.200 → boost_skill_cli-1.2.202}/boost_cli/commands/intelligence.py

@@ -130,15 +130,19 @@ def _save_state(fname: str, data: dict) -> None:
 
 
 def _save_generated_fallback(name: str, text: str, reason: str) -> None:
-    fallback = Path.cwd() / ("%s.SKILL.md" % name)
-    fallback.write_text(text, encoding="utf-8")
+    # Never over an existing <name>.SKILL.md: that file is the user's, and this
+    # runs on the very path where they just declined a replace.
+    fallback = util.write_unclaimed(Path.cwd(), name, ".SKILL.md", text)
     out.warn("not installed: %s" % reason)
     out.info("generated skill saved to %s" % _tilde(fallback))
 
 
-def _install_generated(name: str, text: str, yes: bool = False) -> None:
+def _install_generated(name: str, text: str, yes: bool = False) -> bool:
     """Write a generated SKILL.md to a tempdir and install it as `name`.
 
+    Returns False when the install did not happen (the generation is saved
+    beside the cwd instead), so the caller can exit non-zero.
+
     The tempdir is the only copy of a just-generated skill, so a refused install
     must not be allowed to propagate out of the ``with`` block and delete it —
     that would discard an LLM generation the user paid for, with nothing on disk
@@ -161,7 +165,7 @@ def _install_generated(name: str, text: str, yes: bool = False) -> None:
             "%s is already installed from %s — replace it?" % (name, owner))):
         _save_generated_fallback(
             name, text, "%s is already installed from %s" % (name, owner))
-        return
+        return False
     with tempfile.TemporaryDirectory(prefix="boost-gen-") as td:
         src = Path(td) / name
         src.mkdir()
@@ -175,11 +179,12 @@ def _install_generated(name: str, text: str, yes: bool = False) -> None:
             res = store.install_from_path(src, name=name, tap_label="local")
         except BoostError as err:
             _save_generated_fallback(name, text, err.message)
-            return
+            return False
     out.ok("%s %s → %s" % ("replaced" if owner else "installed", name, _tilde(res.dest)))
     if res.linked:
         out.info(out.role("linked into: %s" % ", ".join(res.linked), "muted"))
     _warn_unwritable(res)
+    return True
 
 
 def _write_generated(dest: Path, text: str, yes: bool = False) -> bool:
@@ -231,8 +236,12 @@ def cmd_distill(argv: list[str]) -> int:
         meta, body = frontmatter.parse(text)
         sources.append({"name": name, "origin": origin, "text": text,
                         "meta": meta, "body": body})
-    new = util.resolve_slug(args.output, what="output name") if args.output \
-        else names[0] + "-distilled"
+    # The default comes from the *bare* first name: `fx:tdd-workflow` would
+    # otherwise name the output `fx:tdd-workflow-distilled`, which the printed
+    # `boost import` hint then rejects as an invalid skill name.
+    new = util.resolve_slug(
+        args.output or catalog.split_name(names[0])[1] + "-distilled",
+        what="output name")
 
     out.heading("distilling %s → %s" % (", ".join(names), new))
     merged = _distill_ai(new, sources) if ai.available() else None
@@ -241,7 +250,8 @@ def cmd_distill(argv: list[str]) -> int:
         merged = _distill_merge(new, sources)
 
     if args.install:
-        _install_generated(new, merged, yes=args.yes)
+        if not _install_generated(new, merged, yes=args.yes):
+            return 1
     else:
         dest = Path.cwd() / new / "SKILL.md"
         if not _write_generated(dest, merged, yes=args.yes):
@@ -292,7 +302,7 @@ def _distill_merge(new: str, sources: list[dict]) -> str:
     """Mechanical merge: union tags, dedupe exact-duplicate body lines."""
     tags: list[str] = []
     for s in sources:
-        for t in s["meta"].get("tags") or []:
+        for t in frontmatter.tags_of(s["meta"]):
             if t not in tags:
                 tags.append(t)
     desc = next((str(s["meta"].get("description") or "").strip()
@@ -420,7 +430,8 @@ def cmd_infer(argv: list[str]) -> int:
         text = _infer_template(name, facts)
 
     if args.install:
-        _install_generated(name, text, yes=args.yes)
+        if not _install_generated(name, text, yes=args.yes):
+            return 1
         journal.log("infer", name, path=str(root))
     elif args.output:
         if not _write_generated(paths.expand(args.output), text, yes=args.yes):
@@ -676,7 +687,8 @@ def cmd_absorb(argv: list[str]) -> int:
         _note_fallback()
         text = _absorb_template(name, patterns)
     if args.install:
-        _install_generated(name, text, yes=args.yes)
+        if not _install_generated(name, text, yes=args.yes):
+            return 1
     else:
         print(text, end="" if text.endswith("\n") else "\n")
     journal.log("absorb", name, patterns=len(patterns), files=len(files))
@@ -1158,7 +1170,7 @@ def cmd_focus(argv: list[str]) -> int:
                                   wrap=True))
         return 0
 
-    names = list(dict.fromkeys(args.skills))
+    names = list(dict.fromkeys(store.installed_name(n) for n in args.skills))
     inst = lockfile.installed()
     for name in names:
         entry = inst.get(name)
@@ -1212,6 +1224,7 @@ def cmd_impact(argv: list[str]) -> int:
 
     inst = lockfile.installed()
     if args.name:
+        args.name = store.installed_name(args.name)
         if args.name not in inst:
             found = lockfile.find_any(args.name)
             if found is not None: