@andespindola/crow-skills 0.27.1 → 0.29.0

package/crow_skills/cli.py

@@ -20,7 +20,7 @@ from . import machine
 from . import mcp
 from . import ui
 from .agents import (AGENTS, destinations, inventory, legacy_shared_dir,
-                      refuse_implausible_destination, refuse_store_as_cli_dir)
+                      refuse_implausible_destination)
 from .source import CrowError, Source, valid_name
 from .storage import Store, checked
 
@@ -32,7 +32,7 @@ TRUST_HELP = "Não habilitar/aprovar os hooks do crow-skills nos CLIs (padrão:
 
 # Per-command help: what it is for and real examples (crow-skills help <cmd> or <cmd> --help).
 COMMANDS = {
-    "setup": ("Detecta os CLIs de agente desta máquina (Claude Code, Codex, Gemini CLI, Antigravity, Devin, Uniflow, tmux) e "
+    "setup": ("Detecta os CLIs de agente desta máquina (Claude Code, Codex, Gemini CLI, Antigravity, Devin, tmux) e "
               "configura cada um no escopo do usuário: todas as skills do catálogo, guia, integrações, hooks do modo crow "
               "habilitados, modo crow e autoupdate. Rodar de novo só corrige o que mudou.",
               ["crow-skills setup --dry-run", "crow-skills setup --yes", "crow-skills setup --agents claude,codex --yes",
@@ -289,7 +289,6 @@ def scope(args, home, interactive=False, read=False):
             agents = prompt("Agentes separados por vírgula (" + ",".join(AGENTS) + "):")
     targets = destinations(agents, home, project, custom)
     if not read:
-        refuse_store_as_cli_dir(targets, home)
         refuse_implausible_destination(targets, home)
     return targets
 
@@ -375,7 +374,6 @@ def guide_sync(args, home, store, command, targets, plan, source):
         if agent not in selected and not (record and path in touched):
             continue
         added, removed = touched.get(path, (set(), set()))
-        removed = removed - projection.projected(agent, home, store)  # still provided by Uniflow's projection
         after = sorted((set(guide.managed_skills(agent, home, store)) | added) - removed)
         if mech["kind"] == "toml" and guide.tomllib is None:
             report["skipped"].append({"agent": agent, "reason": "Python 3.11+ (tomllib) é necessário para editar config.toml; guia não alterado."})
@@ -389,7 +387,7 @@ def guide_sync(args, home, store, command, targets, plan, source):
             report["skipped"].append({"agent": agent, "reason": "crow-behaviour não ficará instalada para " + agent + "; guia não aplicado."})
     # Um guia que não pode ser gravado não derruba a instalação das skills. Desde que o guia também
     # resolve o caminho físico, o caso que sobra aqui é a área PROTEGIDA (prompt compartilhado,
-    # config do Uniflow), que `guide.protect()` recusa com protected_path: aquele agente entra em
+    # alvos dos prompts), que `guide.protect()` recusa com protected_path: aquele agente entra em
     # "skipped", com o motivo, e o resto segue.
     for agent in list(actions):
         mechanism = guide.MECHANISMS.get(agent)
@@ -447,7 +445,6 @@ def behaviour_agents(home, store, plan=None):
         path = os.path.abspath(destinations(agent, home)[0]["path"])
         added, removed = touched.get(path, (set(), set()))
         try:
-            removed = removed - projection.projected(agent, home, store)
             managed = set(guide.managed_skills(agent, home, store))
         except CrowError:
             # An unreadable skills root (e.g. a dotfiles symlink) holds nothing this CLI manages;
@@ -852,56 +849,6 @@ def linked_guides(store, txid):
     return [t["id"] for t in store.transactions() if t.get("kind") == "guide" and t.get("linked") == txid and t["phase"] == "committed"]
 
 
-# What a native copy means once Uniflow links its store into each CLI's user skills dir.
-# Every CLI, codex included since 0.15.0, has its skills installed in its OWN dir, the same one
-# Uniflow links into, so a native copy of a name always just wins there (no second directory).
-NATIVE_EFFECT = {
-    "claude": "skipped", "gemini": "skipped", "devin": "skipped",
-    "codex": "skipped",
-}
-
-
-def uniflow_notice(home, store, targets, plan):
-    """Installing into the Uniflow store while native crow-* copies remain. Uniflow does
-    not link a name a CLI already has in the same dir, so that copy (possibly another
-    revision) wins there. Report it and the explicit command; never remove anything."""
-    if not any("uniflow" in t["agents"] for t in targets):
-        return None
-    names = sorted({c["name"] for c in plan["changes"] if "uniflow" in c["agents"]})
-    native, uninspected = {}, []
-    for agent in ("claude", "codex", "gemini", "devin"):
-        target = destinations(agent, home)[0]
-        try:
-            rows = store.status([target], names)
-        except (CrowError, OSError) as exc:
-            # Informative only: an unreadable native dir (e.g. a dotfiles symlink) never blocks the install.
-            uninspected.append({"agent": agent, "target": target["path"], "reason": str(exc) or "falha de leitura"})
-            continue
-        for row in rows:
-            if row["name"] in names and row["status"] in ("installed", "modified", "unmanaged"):
-                native.setdefault(row["target"], {"target": row["target"], "agents": target["agents"],
-                                                  "effect": NATIVE_EFFECT[agent], "skills": []})
-                native[row["target"]]["skills"].append({"name": row["name"], "status": row["status"]})
-    if not native:
-        return {"native_duplicates": [], "uninspected": uninspected}
-    # One command per destination with only the names physically managed there: crossing names and agents
-    # would reach a Uniflow link (or an absent name) in another CLI and abort the uninstall.
-    # Destinations with the same names share one command (the usual case keeps its single command).
-    groups = {}
-    for item in native.values():
-        managed = tuple(sorted({s["name"] for s in item["skills"] if s["status"] != "unmanaged"}))
-        if managed:
-            groups.setdefault(managed, []).extend(a for a in item["agents"] if a not in groups.get(managed, []))
-    commands = ["crow-skills uninstall " + " ".join(names_) + " --agents " + ",".join(sorted(agents_)) + " --global"
-                for names_, agents_ in groups.items()]
-    return {"native_duplicates": list(native.values()), "uninspected": uninspected,
-            "note": "effect=skipped: o Uniflow não cria o link de um nome que o agente já tem nativo, e essa cópia vale no lugar do "
-                    "store. Desde a 0.15.0 nenhum destino produz effect=both: todo CLI instala no diretório dele, o mesmo em que o "
-                    "Uniflow projeta o store, então não há uma segunda raiz em que o mesmo nome apareça de novo. Nada foi removido. "
-                    "Remover a cópia nativa de crow-behaviour remove também o guia daquele agente.",
-            "suggested_commands": commands, "suggested_command": " && ".join(commands) if commands else None}
-
-
 def pick(source):
     """Terminal picker without dependencies: a group number or name, todas, or skill names. Default: essencial."""
     available = groups_mod.load(source)
@@ -931,19 +878,6 @@ def pick(source):
     return names, ",".join(chosen_groups) or None
 
 
-def codex_projection_split(home, store, targets, names):
-    """The user-scope codex target and which of the names Codex already sees via Uniflow (install skips them)."""
-    target = next((t for t in targets if projection.native_target("codex", t, home)), None)
-    if target is None or set(target["agents"]) - {"codex"}:
-        return None  # a dir shared with another agent is not Codex's own projected dir
-    projected = projection.projected("codex", home, store)
-    if not projected:
-        return None
-    dupes = projection.duplicates(home, store)
-    return {"target": target, "skip": set(names) & projected,
-            "duplicates": sorted(set(dupes["remove"]) | set(dupes["modified"]))}
-
-
 def merge_plans(plans):
     merged = {"before": {}, "after": {}, "items": [], "packages": {}, "changes": []}
     for plan in plans:
@@ -955,29 +889,6 @@ def merge_plans(plans):
     return merged
 
 
-def unmanaged_projections(store, home, rows):
-    """A Uniflow link to a store entry crow-skills does not manage is not an install (same rule as setup)."""
-    if not any(r["status"] == "uniflow_link" for r in rows):
-        return rows
-    managed = guide.store_managed(home, store)
-    disabled = machine.store_disabled(home, store)
-    broken = guide.store_broken(home, store)
-    for row in rows:
-        if row["status"] == "uniflow_link" and row["name"] in broken:
-            # The store entry this link resolves to was edited or lost files: not a working install.
-            row.update(status="modified", projection="uniflow_link_modified",
-                       note=guide.BROKEN_REASON[0].upper() + guide.BROKEN_REASON[1:] + ". Para corrigir: " + guide.broken_fix(row["name"]))
-        elif row["status"] == "uniflow_link" and row["name"] in disabled:
-            # Managed by crow-skills but disabled by Uniflow: reported as such, never as unmanaged (no --replace).
-            row.update(status="disabled", projection="uniflow_link_disabled",
-                       note="Desabilitada no Uniflow (SKILL.md.disabled no store); reabilite no Uniflow para usar.")
-        elif row["status"] == "uniflow_link" and row["name"] not in managed:
-            row.update(status="unmanaged", projection="uniflow_link_unmanaged",
-                       note="Link do Uniflow para um pacote do store que o crow-skills não gerencia; não conta como instalada. "
-                            "Revise o store e, para gerenciá-lo com backup: crow-skills setup --agents uniflow --replace --yes")
-    return rows
-
-
 def group_coverage(rows):
     """Per destination, which catalog groups are fully or partially installed (best effort)."""
     try:
@@ -987,7 +898,7 @@ def group_coverage(rows):
     by_target = {}
     for row in rows:
         item = by_target.setdefault(row["target"], {"target": row["target"], "agents": row["agents"], "names": set()})
-        if row["name"] and row["status"] in ("installed", "modified", "disabled", "uniflow_link"):
+        if row["name"] and row["status"] in ("installed", "modified"):
             item["names"].add(row["name"])
     return [{"target": v["target"], "agents": v["agents"],
              "groups": [c for c in groups_mod.coverage(available, v["names"]) if c["state"] != "absent"]}
@@ -1002,8 +913,6 @@ SKILL_STATE_WORDS = {
     "modificada": "editada no disco",
     "desativada": "instalada, mas desabilitada",
     "ausente": "registrada e não encontrada no disco",
-    "via_uniflow": "projetada do seu store do Uniflow (gerenciada em --agents uniflow)",
-    "link_externo": "link no store do Uniflow para fora dele",
     "nao_gerenciada": "não gerenciada por este CLI",
     "indeterminada": "não foi possível ler o destino",
 }
@@ -1024,15 +933,6 @@ def skill_state(row, source):
         return "desativada"
     if status == "missing":
         return "ausente"
-    if status == "uniflow_link":
-        # Projeção SAUDÁVEL do store do Uniflow: é a topologia normal de quem instala em uniflow e
-        # deixa os CLIs lerem de lá, e o resto do CLI já a conta como instalada (group_coverage).
-        # Chamar isso de "não gerenciada" assustava sem motivo — 33 skills em 4 agentes, aqui.
-        # Projeção quebrada, desabilitada ou para pacote não gerenciado não chega como uniflow_link:
-        # unmanaged_projections() a reescreve antes (modified/disabled/unmanaged).
-        return "via_uniflow"
-    if status == "external_link":
-        return "link_externo"
     if status in ("unmanaged", "absent"):
         return "nao_gerenciada"
     return "indeterminada"  # "unsafe" e qualquer estado novo: nunca contado como em dia
@@ -1089,9 +989,7 @@ def skills_command(args, home, store):
     """Somente leitura: versão e estado de cada skill instalada, contra a fonte atual."""
     source = Source(getattr(args, "source", DEFAULT_SOURCE), getattr(args, "ref", "HEAD"))
     targets = scope(args, home, read=True)
-    # A mesma correção que status/doctor aplicam: projeção do Uniflow quebrada, desabilitada ou para
-    # pacote não gerenciado não pode passar por projeção saudável.
-    rows = unmanaged_projections(store, home, store.status(targets))
+    rows = store.status(targets)
     items = {}
     for row in rows:
         if not row.get("name"):
@@ -1231,7 +1129,7 @@ def mcp_setup_extras(args, home, result):
     supported = {host for host, _rel, _kind in mcp.HOSTS}
     for entry in result.get("entries", []):
         agent = entry["agent"]
-        selected = set(entry.get("changed", []) + entry.get("unchanged", []) + entry.get("via_uniflow", []))
+        selected = set(entry.get("changed", []) + entry.get("unchanged", []))
         if entry.get("error") or "crow-uny-mcp" not in selected:
             continue
         if agent not in supported:
@@ -1337,7 +1235,7 @@ def run(args):
         return skills_command(args, home, store)
     if args.command in ("status", "doctor"):
         targets = scope(args, home, read=True)
-        rows = unmanaged_projections(store, home, store.status(targets))
+        rows = store.status(targets)
         pending = [t["id"] for t in store.pending()]
         global_view = not (getattr(args, "project", None) or getattr(args, "dest", None))
         names = [n.strip() for n in getattr(args, "agents", "").split(",")] if getattr(args, "agents", None) else list(guide.MECHANISMS)
@@ -1351,23 +1249,9 @@ def run(args):
                   "mode": hook.read_mode(home), "activation_verified": False,
                   "reload_hint": "Peça ao host para recarregar/listar skills; reinicie a sessão se necessário."}
         if any(projection.native_target("codex", t, home) for t in targets):
-            rows[:] = projection.status_rows(home, store, rows)  # enriquece no lugar; += contaria duas vezes
-            dupes = projection.duplicates(home, store)
-            names_ = dupes["remove"] + dupes["modified"] + dupes["shared"]
-            if names_:
-                # A warning, not unhealthy: both copies are intact and work; Codex just lists them twice.
-                result.setdefault("warnings", []).append({"code": "codex_duplicates", "skills": names_,
-                                       "message": "O Codex vê " + str(len(names_)) + " skill(s) duas vezes: cópia antiga na pasta "
-                                                  "compartilhada " + str(legacy_shared_dir(home)) + " e a instalação em "
-                                                  + str(projection.codex_skills_dir(home)) + ". O crow-skills não usa mais a pasta "
-                                                  "compartilhada; remover as cópias de lá encerra a duplicação.",
-                                       "fix": "crow-skills uninstall " + ",".join(names_) + " --dest "
-                                              + str(legacy_shared_dir(home)) + " --yes"
-                                              + (" --overwrite-modified" if dupes["modified"] else "")})
-            leftovers = [n for n in projection.legacy_leftovers(home, store) if n not in names_]
+            leftovers = projection.legacy_leftovers(home, store)
             if leftovers:
-                # Sem Uniflow nada disso duplica uma projeção, então o aviso acima nunca apareceria
-                # e uma instalação feita pela 0.14.0 ficaria invisível aqui, ainda carregada pelo Codex.
+
                 result.setdefault("warnings", []).append(
                     {"code": "codex_legacy_shared", "skills": leftovers,
                      "message": "O crow-skills ainda tem " + str(len(leftovers)) + " skill(s) instalada(s) na pasta "
@@ -1490,17 +1374,7 @@ def run(args):
         for name in list(names):
             source.require(name)
             names.extend(n for n in source.catalog[name]["next"] if n not in names)
-    codex_view = None
-    if args.command == "install" and not (getattr(args, "project", None) or getattr(args, "dest", None)):
-        codex_view = codex_projection_split(home, store, targets, names)
-    if codex_view and codex_view["skip"]:
-        # Codex already sees these through Uniflow's links in ~/.codex/skills: no native copy for codex.
-        plans = [store.plan(args.command, [n for n in names if n not in codex_view["skip"]] if t is codex_view["target"] else names,
-                            [t], source, getattr(args, "replace", False), args.overwrite_modified)
-                 for t in targets if t is not codex_view["target"] or set(names) - codex_view["skip"]]
-        plan = merge_plans(plans)
-    else:
-        plan = store.plan(args.command, names, targets, source, getattr(args, "replace", False), args.overwrite_modified)
+    plan = store.plan(args.command, names, targets, source, getattr(args, "replace", False), args.overwrite_modified)
     guides, gplan = guide_sync(args, home, store, args.command, targets, plan, source)
     ui = integrations_preview(args, home, store, plan)
     summary = {"changes": plan["changes"], "revision": source.revision if source else None,
@@ -1513,20 +1387,6 @@ def run(args):
         # Read-only dependency/conflict preview precedes every mutation, including custom targets.
         mcp_guard_runtime_removal(home, plan["items"], [r["agent"] for r in summary["mcp"]["changes"] if r["action"] == "restore"])
         mcp_before_uninstall(home, summary["mcp"], dry_run=True)
-    notice = uniflow_notice(home, store, targets, plan) if args.command != "uninstall" else None
-    if notice is not None:
-        summary["uniflow"] = notice
-    if codex_view and (codex_view["skip"] or codex_view["duplicates"]):
-        summary["codex_projection"] = {
-            "via_uniflow": sorted(codex_view["skip"]), "duplicates": codex_view["duplicates"],
-            "note": "O Codex já vê estas skills pelo link do Uniflow em " + str(projection.codex_skills_dir(home)) +
-                    "; nenhuma cópia é criada para o codex. As cópias que ficaram na pasta compartilhada antiga "
-                    + str(legacy_shared_dir(home)) + " duplicam a projeção e não são removidas por install; remova-as com o "
-                    "comando sugerido ou rode crow-skills setup --yes.",
-            # --dest, nunca --agents codex: esses nomes, no diretório do Codex, são links do Uniflow, e
-            # o uninstall ali recusaria com unsafe_destination.
-            "suggested_command": ("crow-skills uninstall " + " ".join(codex_view["duplicates"]) + " --dest "
-                                  + str(legacy_shared_dir(home)) + " --yes") if codex_view["duplicates"] else None}
     if plan["items"] or (gplan and gplan["items"]) or ui.get("changes"):
         authorize(args, interactive, summary)
     txid = None
@@ -1568,17 +1428,12 @@ def render_status(data, doctor=False, stream=None):
     by_target = {}
     for row in data["installations"]:
         item = by_target.setdefault(row["target"], {"agents": row["agents"], "ok": 0, "via": 0, "bad": [], "kept": []})
-        if row.get("projection") == "uniflow_link_unmanaged":
-            item["kept"].append(row["name"] + " link do Uniflow não gerenciado (crow-skills setup --agents uniflow --replace --yes)")
-        if row["status"] == "uniflow_link":
-            item["ok"] += 1
-            item["via"] += 1  # projected by Uniflow from its store: installed for this CLI
-        elif row["status"] in ("installed", "disabled"):
+        if row["status"] == "installed":
             item["ok"] += 1
         elif row["status"] in ("modified", "missing", "unsafe", "external_link"):
             item["bad"].append((row["name"] or "raiz") + " " + row["status"])
     rows = [[ui.mark("fail" if v["bad"] else ("warn" if v["kept"] else "ok"), stream), ",".join(v["agents"]),
-             str(v["ok"]) + " skills" + (" (" + str(v["via"]) + " via uniflow)" if v["via"] else ""),
+             str(v["ok"]) + " skills",
              "; ".join(v["bad"] + v["kept"])] for v in by_target.values() if v["ok"] or v["bad"] or v["kept"]]
     if rows:
         lines += ui.table(rows, ["", "agente", "instaladas", "problemas"], stream)

package/crow_skills/guide.py

@@ -24,7 +24,7 @@ try:  # Python 3.11+; required only to verify config.toml edits.
 except ImportError:  # pragma: no cover - CI and supported hosts have 3.11+
     tomllib = None
 
-from .agents import destinations, uniflow_guards, uniflow_store
+from .agents import destinations
 from .source import NAME, CrowError, SHA
 from .storage import atomic_json, checked, private_dir, read_json
 
@@ -32,7 +32,7 @@ HEADER = "<!-- Gerenciado por crow-skills guide. Não edite; use crow-skills gui
 BEGIN = "# >>> crow-skills guide (gerenciado; use crow-skills guide uninstall) >>>"
 END = "# <<< crow-skills guide <<<"
 TOML_KEY = "developer_instructions"
-PASSIVE_GUIDE_SKILLS = frozenset({"crow-behaviour", "crow-uny-mcp", "crow-tree-clean-up"})
+PASSIVE_GUIDE_SKILLS = frozenset({"crow-behaviour", "crow-model-level", "crow-uny-mcp", "crow-tree-clean-up"})
 MAX_CONFIG = 4 * 1024 * 1024
 HEX = re.compile(r"[a-f0-9]{64}\Z")
 PRESERVED = re.compile(r"[a-f0-9]{32}/[a-z]+\.bak\Z")
@@ -52,12 +52,10 @@ MECHANISMS = {
               "label": "Devin CLI", "invoke": "/devin:{name}",
               "load": "use a ferramenta de skills do Devin ou digite /devin:nome"},
 }
-UNVERIFIED = {
-    "uniflow": "o Uniflow infere o uso de crow-behaviour por padrão e já projeta o store nos agentes; não há guia a gravar.",
-}
-# Shared prompt files (often symlinks into ~/.config/uniflow) and their targets.
+UNVERIFIED = {}
+# Shared prompt files and their targets remain protected regardless of origin.
 PROTECTED = (".claude/CLAUDE.md", ".codex/AGENTS.md", ".codex/AGENTS.override.md", ".gemini/GEMINI.md",
-             ".config/devin/CLAUDE.md", ".config/devin/AGENTS.md", ".config/uniflow")
+             ".config/devin/CLAUDE.md", ".config/devin/AGENTS.md")
 
 
 def sha(data):
@@ -88,14 +86,13 @@ def select(agents):
     return result
 
 
-UNIFLOW_SKILLS = "Somente ~/.config/uniflow/skills/crow-* (o store de skills do Uniflow) é gravável: "
-
-
 def inside(path, guard):
     """path is guard or below it: textually, or by file identity for an existing guard,
     so a case-insensitive filesystem (APFS) or another spelling does not bypass it."""
     if path == guard or path.is_relative_to(guard):
         return True
+    if guard.is_symlink():
+        return False  # Do not stat a shared-prompt symlink target merely to inspect another path.
     if not os.path.exists(guard):
         return False
     for part in (path, *path.parents):
@@ -108,13 +105,19 @@ def inside(path, guard):
 
 
 def shielded(path, home):
-    """True when path is a shared prompt, Uniflow's config (as Uniflow resolves it) or inside their targets."""
+    """True when path is a shared prompt or inside its target."""
     path = Path(os.path.abspath(path))
-    for guard in [Path(os.path.abspath(home / rel)) for rel in PROTECTED] + uniflow_guards(home):
-        guards = {guard}
-        if os.path.lexists(guard):
-            guards.add(Path(os.path.realpath(guard)))
-        if any(inside(path, item) for item in guards):
+    from .agents import physical
+    for guard in [Path(os.path.abspath(home / rel)) for rel in PROTECTED]:
+        if path == guard or path.is_relative_to(guard):
+            return True
+        try:
+            physical_guard = Path(physical(guard))
+        except CrowError as exc:
+            if exc.code == "unsupported_destination":
+                continue  # Even lstat(guard) could traverse a retired ancestor.
+            raise
+        if any(inside(path, item) for item in {guard, physical_guard}):
             return True
     return False
 
@@ -136,19 +139,10 @@ def protect(path, home):
 
 
 def protect_skill(path, home):
-    """Skill packages follow protect(), with one exception: a crow-* package directly
-    inside the Uniflow store. The store's other entries and the rest of the Uniflow
-    config (config.json, prompts, backups) stay protected. The package entry itself may
-    be a link Uniflow made; the plan decides about it, never following it."""
-    path = Path(os.path.abspath(path))
-    from .agents import physical
-    # Mesmo motivo: o store em dotfiles resolve, e a comparação crua nunca batia.
-    if physical(path.parent) == physical(uniflow_store(home)) and NAME.fullmatch(path.name):
-        checked(path.parent)
-        return path
+    """Skill entries never follow symlinks; shared prompt targets stay protected."""
     path = checked(path)
     if shielded(path, home):
-        raise CrowError("protected_path", UNIFLOW_SKILLS + str(path) + " é protegido.")
+        raise CrowError("protected_path", "Prompt compartilhado ou alvo protegido: " + str(path))
     return path
 
 
@@ -192,44 +186,9 @@ def clean(text):
 
 
 def managed_skills(agent, home, store):
-    """crow-* packages available to the agent: the ones this CLI manages there (edited copies still count) and
-    the ones Uniflow projects into its skills dir from the store (managed with --agents uniflow)."""
-    target = destinations(agent, home)[0]
-    rows = store.status([target], ())
-    store_ok = store_managed(home, store) if any(r["status"] == "uniflow_link" for r in rows) else set()
-    names = {r["name"] for r in rows if r["status"] in ("installed", "modified")
-             or (r["status"] == "uniflow_link" and r["name"] in store_ok)}
-    from .projection import projected
-    return sorted(names | projected(agent, home, store))  # codex: Uniflow's links in ~/.codex/skills
-
-
-def store_statuses(home, store):
-    """{name: status} of the Uniflow store (crow-skills view); {} when it cannot be read."""
-    try:
-        return {r["name"]: r["status"] for r in store.status(destinations("uniflow", home), ()) if r["name"]}
-    except (CrowError, OSError):
-        return {}
-
-
-def store_managed(home, store):
-    """Names whose Uniflow store copy is an intact crow-skills install. A link to a store entry the user wrote
-    by hand, or to a managed entry that was edited or lost files (a CLI may fail to load it), does not count
-    as an install for the CLI."""
-    return {n for n, s in store_statuses(home, store).items() if s == "installed"}
-
-
-def store_broken(home, store):
-    """Managed store entries that were edited or lost files (status modified/missing)."""
-    return {n for n, s in store_statuses(home, store).items() if s in ("modified", "missing")}
-
-
-BROKEN_REASON = ("a entrada do store do Uniflow foi editada ou perdeu arquivos; o CLI pode não carregá-la, então não conta "
-                 "como instalada")
-
-
-def broken_fix(name):
-    return ("revise o store e, para restaurá-lo com backup: crow-skills update " + name +
-            " --agents uniflow --global --overwrite-modified --yes")
+    """Only locally managed native packages count; individual links are unsafe."""
+    rows = store.status(destinations(agent, home), ())
+    return sorted(r["name"] for r in rows if r["status"] in ("installed", "modified"))
 
 
 def present_skills(agent, home, store, catalog):
@@ -271,6 +230,15 @@ def render_body(agent, catalog, revision, skills):
     ]
     if "crow-behaviour" not in skills:
         lines = lines[:4] + ["## Skills especialistas"]
+    if "crow-model-level" in skills:
+        lines[-1:-1] = [
+            "## crow-model-level: nível por unidade, obrigatório ao delegar",
+            "- Carregue " + invoke(name="crow-model-level") + " antes de enviar qualquer delegação, inclusive uma só, e independentemente do modo de orquestração crow-behaviour ON/OFF. É ela que decide o nível, e é a instrução explícita que os hosts exigem para que o esforço de raciocínio possa ser definido em vez de herdado.",
+            "- Cada unidade delegada sai com o nível declarado: modelo e esforço. Campo que o host não expõe, ou que o modo de delegação ignora, entra como ausente e com o motivo, em vez de sumir da linha.",
+            "- O esforço vem do sinal da unidade, não de uma regra única: braçal — resultado que você especifica e aceita pela evidência sem ver o caminho — pede esforço mínimo e o modelo mais barato que dá conta; unidade que exige decidir no caminho (causa-raiz, ameaça, desenho, requisito contraditório) pede esforço alto e o modelo mais forte, mesmo sendo pequena.",
+            "- Instrução do dono sobre modelo ou esforço é o nível e prevalece sobre o sinal lido. Nível alto não aumenta concorrência: o teto de RAM/CPU e o número de agentes continuam sendo os da crow-behaviour.",
+            "",
+        ]
     if "crow-uny-mcp" in skills:
         lines[-1:-1] = [
             "## crow-uny-mcp: gerenciamento passivo obrigatório",