@andespindola/crow-skills 0.6.1 → 0.7.0

package/README.md

@@ -2,7 +2,7 @@
 
 Skills com escopo explícito, conhecimento especializado preservado e fluxos comuns reutilizáveis.
 
-**Versão 0.6.1** ([mudanças](CHANGELOG.md)): crow-behaviour mostra o progresso na própria conversa e no plano nativo do host, sem abrir janela ou painel. A 0.6.0 trouxe as regras de entrega das 32 skills especialistas, a partir da [validação no Codex](docs/evaluations/2026-10-26-codex.md).
+**Versão 0.7.0** ([mudanças](CHANGELOG.md)): o Uniflow vira agente de instalação (`--agents uniflow`): as skills crow vão para o store de skills dele, que ele projeta nos CLIs que sobe. A 0.6.1 passou a mostrar o progresso da crow-behaviour na própria conversa; a 0.6.0 trouxe as regras de entrega das 32 skills especialistas, a partir da [validação no Codex](docs/evaluations/2026-10-26-codex.md).
 
 **Reconstrução em andamento.** A primeira versão com 32 contratos genéricos não atende à preservação de capacidades solicitada. Não use esse número nem o mapeamento por categoria como prova de substituição das originais. A revisão passa a abranger cada definição e seus recursos, modos e dependências, sem número fixo de skills ou limite artificial de linhas. Veja [critérios e progresso](docs/reconstruction.md).
 
@@ -27,10 +27,10 @@ Exemplos:
 
 ## Instalação e portabilidade
 
-O pacote de cada skill é somente sua pasta em `skills/`. O [CLI crow-skills](docs/cli.md) instala cópias completas e versionadas em agentes/escopos explícitos, com preview, saída JSON, detecção de conflitos e recuperação. Requer Python 3.10+; Git para fontes em clone, Node 18+ para o launcher npm; mutações em macOS/Linux. A distribuição npm privada `@andespindola/crow-skills` inclui um snapshot completo das skills, sem clone ou hooks que as instalem automaticamente. Em `--global`, instalar a crow-behaviour também grava o guia aditivo do agente (claude, codex, gemini, devin) para usar as skills; `--no-guide` desliga. As integrações de interface (status line do Claude Code e do Codex, segmento tmux) seguem o mesmo fluxo, preservando a configuração existente; `--no-integrations` desliga.
+O pacote de cada skill é somente sua pasta em `skills/`. O [CLI crow-skills](docs/cli.md) instala cópias completas e versionadas em agentes/escopos explícitos, com preview, saída JSON, detecção de conflitos e recuperação. Requer Python 3.10+; Git para fontes em clone, Node 18+ para o launcher npm; mutações em macOS/Linux. A distribuição npm privada `@andespindola/crow-skills` inclui um snapshot completo das skills, sem clone ou hooks que as instalem automaticamente. No [Uniflow](docs/cli.md#uniflow), `--agents uniflow --global` grava as skills no store dele (`~/.config/uniflow/skills`), sem tocar no resto da configuração. Em `--global`, instalar a crow-behaviour também grava o guia aditivo do agente (claude, codex, gemini, devin) para usar as skills; `--no-guide` desliga. As integrações de interface (status line do Claude Code e do Codex, segmento tmux) seguem o mesmo fluxo, preservando a configuração existente; `--no-integrations` desliga.
 
 ```sh
-npm install -g @andespindola/crow-skills@0.6.1
+npm install -g @andespindola/crow-skills@0.7.0
 crow-skills progress
 ./bin/crow-skills list
 ./bin/crow-skills install crow-behaviour --agents claude,codex --global --dry-run

package/crow_skills/__init__.py

@@ -1,3 +1,3 @@
 """Portable, local-first installer for the crow-skills catalogue."""
 
-__version__ = "0.6.1"
+__version__ = "0.7.0"

package/crow_skills/agents.py

@@ -10,9 +10,49 @@ AGENTS = {
     "gemini": (".gemini/skills", ".gemini/skills", "gemini"),
     "devin": (".config/devin/skills", ".devin/skills", "devin"),
     "shared": (".agents/skills", ".agents/skills", None),
+    # Uniflow keeps one store and links it into each CLI's user skills dir; it has
+    # no project scope. The store sits beside config.json (see uniflow_store).
+    "uniflow": (".config/uniflow/skills", None, "uniflow"),
 }
 
 
+def real_home(home):
+    """Environment overrides describe the real profile; an isolated --home ignores them."""
+    return home == Path.home().resolve()
+
+
+def uniflow_config_file(home):
+    """Same resolution as Uniflow: UNIFLOW_CONFIG/CROWFLOW_CONFIG name config.json,
+    otherwise $XDG_CONFIG_HOME/uniflow/config.json, otherwise ~/.config/uniflow/config.json."""
+    if real_home(home):
+        override = os.getenv("UNIFLOW_CONFIG") or os.getenv("CROWFLOW_CONFIG")
+        if override:
+            return Path(os.path.abspath(Path(override).expanduser()))
+        if os.getenv("XDG_CONFIG_HOME"):
+            return Path(os.path.abspath(Path(os.environ["XDG_CONFIG_HOME"]).expanduser() / "uniflow/config.json"))
+    return Path(os.path.abspath(home / ".config/uniflow/config.json"))
+
+
+def uniflow_config_dir(home):
+    return uniflow_config_file(home).parent
+
+
+def uniflow_guards(home):
+    """Uniflow's own paths to protect: its whole config dir, unless that dir is the home
+    or one of its ancestors (UNIFLOW_CONFIG=~/uniflow.json). Then only Uniflow's files
+    and store are protected, never the home itself."""
+    config = uniflow_config_dir(home)
+    profile = Path(os.path.abspath(home))
+    if profile == config or profile.is_relative_to(config):
+        return [uniflow_config_file(home), config / "skills", config / ".bundled-skills.json",
+                config / "skills.required.json"]
+    return [config]
+
+
+def uniflow_store(home):
+    return uniflow_config_dir(home) / "skills"
+
+
 def destinations(names, home, project=None, custom=None):
     if custom:
         if names:
@@ -27,10 +67,15 @@ def destinations(names, home, project=None, custom=None):
         if name not in AGENTS:
             raise CrowError("unknown_agent", "Agente desconhecido: " + name)
         user_path, project_path, _ = AGENTS[name]
+        if project and project_path is None:
+            raise CrowError("unsupported_scope", "O Uniflow só tem o store global (" + user_path + ", ao lado do config.json); "
+                            "use --global. Ele projeta esse store nos agentes por conta própria.")
         path = (Path(project) / project_path) if project else (home / user_path)
         # Respect explicit XDG config, but isolate it when --home selects another profile.
-        if name == "devin" and not project and home == Path.home().resolve() and os.getenv("XDG_CONFIG_HOME"):
+        if name == "devin" and not project and real_home(home) and os.getenv("XDG_CONFIG_HOME"):
             path = Path(os.environ["XDG_CONFIG_HOME"]).expanduser() / "devin/skills"
+        if name == "uniflow":
+            path = uniflow_store(home)
         key = str(path.absolute())
         result.setdefault(key, {"path": key, "agents": []})
         if name not in result[key]["agents"]:
@@ -39,7 +84,12 @@ def destinations(names, home, project=None, custom=None):
 
 
 def inventory(home):
-    return [{"name": name, "executable_found": bool(binary and shutil.which(binary)),
-             "global_path": str(home / user), "project_path": project,
-             "activation_verified": False}
-            for name, (user, project, binary) in AGENTS.items()]
+    rows = []
+    for name, (_, project, binary) in AGENTS.items():
+        path = Path(destinations(name, home)[0]["path"])
+        found = bool(binary and shutil.which(binary))
+        # Detection is PATH or the agent's config dir; neither proves the skills load.
+        rows.append({"name": name, "executable_found": found, "config_found": path.parent.is_dir(),
+                     "detected": found or path.parent.is_dir(), "global_path": str(path),
+                     "project_path": project, "activation_verified": False})
+    return rows

package/crow_skills/cli.py

@@ -248,7 +248,13 @@ def behaviour_agents(home, store, plan=None):
     for agent in guide.MECHANISMS:
         path = os.path.abspath(destinations(agent, home)[0]["path"])
         added, removed = touched.get(path, (set(), set()))
-        if "crow-behaviour" in (set(guide.managed_skills(agent, home, store)) | added) - removed:
+        try:
+            managed = set(guide.managed_skills(agent, home, store))
+        except CrowError:
+            # An unreadable skills root (e.g. a dotfiles symlink) holds nothing this CLI manages;
+            # it must not fail a command aimed at another agent.
+            managed = set()
+        if "crow-behaviour" in (managed | added) - removed:
             result.append(agent)
     return result
 
@@ -321,6 +327,48 @@ 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.
+# Uniflow links codex into ~/.codex/skills, not into ~/.agents/skills (this CLI's codex root).
+NATIVE_EFFECT = {
+    "claude": "skipped", "gemini": "skipped", "devin": "skipped",
+    "codex": "both",
+}
+
+
+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; codex reads ~/.agents/skills and Uniflow's ~/.codex/skills
+    link, so it sees both. 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}
+    agents = sorted({a for n in native.values() for a in n["agents"]})
+    managed = sorted({s["name"] for n in native.values() for s in n["skills"] if s["status"] != "unmanaged"})
+    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. effect=both: o Uniflow liga o store em ~/.codex/skills e o Codex também lê ~/.agents/skills, então vê as "
+                    "duas cópias. Nada foi removido. Remover a cópia nativa de crow-behaviour remove também o guia daquele agente.",
+            "suggested_command": ("crow-skills uninstall " + " ".join(managed) + " --agents " + ",".join(agents) + " --global")
+            if managed else None}
+
+
 def run(args):
     if args.version:
         return {"version": __version__}
@@ -353,7 +401,7 @@ def run(args):
         result = {"installations": rows, "guides": guides, "integrations": ui, "pending_transactions": pending,
                   "activation_verified": False, "reload_hint": "Peça ao host para recarregar/listar skills; reinicie a sessão se necessário."}
         if args.command == "doctor":
-            result.update(healthy=not pending and all(r["status"] not in ("modified", "missing", "unsafe") for r in rows + guides),
+            result.update(healthy=not pending and all(r["status"] not in ("modified", "missing", "unsafe", "external_link") for r in rows + guides),
                           agents=inventory(home))
         return result
     if args.command in ("rollback", "recover"):
@@ -429,6 +477,9 @@ def run(args):
     summary = {"changes": plan["changes"], "revision": source.revision if source else None,
                "relationships": {n: source.related(n) for n in names} if source else {},
                "guides": guides, "integrations": ui, "handoffs_are_optional": True, "activation_verified": False}
+    notice = uniflow_notice(home, store, targets, plan) if args.command != "uninstall" else None
+    if notice is not None:
+        summary["uniflow"] = notice
     if plan["items"] or (gplan and gplan["items"]) or ui.get("changes"):
         authorize(args, interactive, summary)
     txid = None

package/crow_skills/guide.py

@@ -24,8 +24,8 @@ 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
-from .source import CrowError, SHA
+from .agents import destinations, uniflow_guards, uniflow_store
+from .source import NAME, CrowError, SHA
 from .storage import atomic_json, checked, private_dir, read_json
 
 HEADER = "<!-- Gerenciado por crow-skills guide. Não edite; use crow-skills guide install/uninstall. -->"
@@ -53,6 +53,7 @@ MECHANISMS = {
 }
 UNVERIFIED = {
     "shared": "shared é um diretório de skills, não um CLI; não há onde gravar instruções.",
+    "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.
 PROTECTED = (".claude/CLAUDE.md", ".codex/AGENTS.md", ".codex/AGENTS.override.md", ".gemini/GEMINI.md",
@@ -87,17 +88,57 @@ def select(agents):
     return result
 
 
-def protect(path, home):
-    """Refuse symlinked components, shared prompts and anything inside their targets."""
-    path = checked(path)
-    for rel in PROTECTED:
-        guard = Path(os.path.abspath(home / rel))
+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 not os.path.exists(guard):
+        return False
+    for part in (path, *path.parents):
+        try:
+            if os.path.exists(part) and os.path.samefile(part, guard):
+                return True
+        except OSError:
+            continue
+    return False
+
+
+def shielded(path, home):
+    """True when path is a shared prompt, Uniflow's config (as Uniflow resolves it) or inside their targets."""
+    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)))
-        for item in guards:
-            if path == item or path.is_relative_to(item):
-                raise CrowError("protected_path", "Arquivo de prompt compartilhado (ou alvo dele) não é gravado: " + str(path))
+        if any(inside(path, item) for item in guards):
+            return True
+    return False
+
+
+def protect(path, home):
+    """Refuse symlinked components, shared prompts and anything inside their targets."""
+    path = checked(path)
+    if shielded(path, home):
+        raise CrowError("protected_path", "Arquivo de prompt compartilhado (ou alvo dele) não é gravado: " + str(path))
+    return path
+
+
+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))
+    if path.parent == uniflow_store(home) and NAME.fullmatch(path.name):
+        checked(path.parent)
+        return path
+    path = checked(path)
+    if shielded(path, home):
+        raise CrowError("protected_path", UNIFLOW_SKILLS + str(path) + " é protegido.")
     return path
 
 

package/crow_skills/storage.py

@@ -15,6 +15,7 @@ import shutil
 import stat
 import uuid
 
+from .agents import uniflow_store
 from .source import CrowError, MAX_FILE, MAX_PACKAGE, MAX_FILES, SHA, digest, file_entry, safe_relative, valid_name
 
 
@@ -100,6 +101,22 @@ def read_json(path):
         raise CrowError("invalid_state", "Estado/registro transacional inválido; nenhuma alteração aplicada.") from exc
 
 
+DISABLED = "SKILL.md.disabled"
+
+
+def disabled_variant(entries):
+    """The same package as Uniflow leaves it after /skills disable (SKILL.md renamed)."""
+    if not entries or "SKILL.md" not in entries:
+        return None
+    result = dict(entries)
+    result[DISABLED] = result.pop("SKILL.md")
+    return dict(sorted(result.items()))
+
+
+def same_link(path, value):
+    return os.path.islink(path) and os.readlink(path) == value
+
+
 def validate_entries(entries):
     if not isinstance(entries, dict) or len(entries) > MAX_FILES * 2:
         raise CrowError("invalid_state", "Inventário inválido no estado.")
@@ -172,6 +189,8 @@ class Store:
                 if item["target"] not in targets:
                     raise ValueError("item target")
                 valid_name(item["name"])
+                if not isinstance(item.get("link", ""), str) or not isinstance(item.get("disabled", False), bool):
+                    raise ValueError("item link/disabled")
                 for key in ("old", "new"):
                     if item[key] is not None:
                         validate_entries(item[key])
@@ -200,11 +219,42 @@ class Store:
         finally:
             os.close(fd)
 
-    @staticmethod
-    def work(target, txid):
+    def work(self, target, txid):
+        from .guide import shielded
+        target = checked(target)
+        key = hashlib.sha256(str(target).encode()).hexdigest()[:20]
+        # Beside the discovery dir, unless that parent is protected (the Uniflow
+        # config): then staging/backups stay in the private state root instead.
+        base = self.root / "work" if shielded(target.parent / ".crow-skills", self.home) else target.parent / ".crow-skills"
+        return checked(base / key / txid)
+
+    def existing_work(self, target, txid):
+        """Backups of a transaction, wherever the version that made it put them: older
+        transactions kept them beside the target even where that is now protected."""
+        primary = self.work(target, txid)
         target = checked(target)
         key = hashlib.sha256(str(target).encode()).hexdigest()[:20]
-        return checked(target.parent / ".crow-skills" / key / txid)
+        for candidate in (primary, target.parent / ".crow-skills" / key / txid, self.root / "work" / key / txid):
+            if os.path.lexists(candidate):
+                return checked(candidate)
+        return primary
+
+    def managed_target(self, resolved, name):
+        """resolved is a package this CLI manages somewhere and its files match the manifest."""
+        directory = self.root / "targets"
+        if not directory.is_dir():
+            return False
+        for state_file in directory.glob("*/state.json"):
+            try:
+                data = read_json(state_file)
+                validate_state(data, data["target"])
+                record = data["installed"].get(name)
+                place = Path(data["target"]) / name
+                if record and os.path.realpath(place) == resolved and snapshot(place) == record["entries"]:
+                    return True
+            except (CrowError, KeyError, TypeError, OSError):
+                continue
+        return False
 
     def plan(self, command, names, targets, source=None, replace=False, overwrite=False):
         if self.pending():
@@ -220,16 +270,45 @@ class Store:
                 raise CrowError("unsafe_destination", "Não instale sobre o próprio repositório fonte.")
             state = self.state(target)
             key = str(target)
+            from .guide import protect_skill
+            for name in (names or state["installed"]):
+                try:
+                    protect_skill(target / valid_name(name), self.home)
+                except CrowError as exc:
+                    if exc.code != "protected_path" or name not in state["installed"]:
+                        raise
+                    if command != "uninstall":
+                        raise CrowError("protected_path", str(exc) + " Instalação anterior a esta proteção: remova com "
+                                        "crow-skills uninstall " + name + " --dest " + str(target) + " --yes e, se for para o "
+                                        "Uniflow, reinstale com --agents uniflow --global.") from exc
+            # Only the uniflow agent replaces Uniflow's import links; --dest keeps refusing links.
+            store_target = "uniflow" in target_info["agents"] and target == uniflow_store(self.home)
             before[key] = state
             after[key] = json.loads(json.dumps(state))
             selected = list(names) if names else list(state["installed"])
             for name in selected:
                 valid_name(name)
                 record = state["installed"].get(name)
-                current = snapshot(target / name)
+                dest = target / name
+                link, managed_link = None, False
+                if store_target and dest.is_symlink():
+                    # Uniflow imports a native copy as a link store/crow-x -> its realpath.
+                    link = os.readlink(dest)
+                    resolved = os.path.realpath(dest)
+                    managed_link = self.managed_target(resolved, name)
+                    if not (managed_link or replace or overwrite):
+                        raise CrowError("unmanaged_link", str(dest) + " é um link (do Uniflow) para " + resolved +
+                                        ", que não é uma instalação gerenciada pelo crow-skills. Para trocar só o link por uma "
+                                        "cópia gerenciada, sem tocar no alvo: crow-skills install " + name +
+                                        " --agents uniflow --global --replace --yes. Ou remova o link você mesmo.")
+                    current = None
+                else:
+                    current = snapshot(dest)
+                disabled = bool(record and current is not None and current == disabled_variant(record["entries"]))
+                effective = record["entries"] if disabled else current
                 if command != "install" and record is None:
                     raise CrowError("not_managed", "Skill não gerenciada neste destino: " + name)
-                if record and current != record["entries"] and not overwrite:
+                if record and effective != record["entries"] and not overwrite and not managed_link:
                     raise CrowError("local_changes", "Skill modificada/ausente: " + name + ". Revise; --overwrite-modified autoriza preservar backup e substituir/remover.")
                 if not record and current is not None and not replace:
                     raise CrowError("unmanaged_conflict", "Destino já existe e não é gerenciado: " + name + ". Use --replace após revisar.")
@@ -240,12 +319,19 @@ class Store:
                     if name not in packages:
                         packages[name] = source.package(name)
                     new = packages[name].entries
-                if (record and command != "uninstall" and current == new
+                if (record and command != "uninstall" and link is None and effective == new
                         and record["revision"] == source.revision and record.get("source") == str(source.path)):
                     output.append({"name": name, "target": key, "agents": target_info["agents"], "action": "unchanged"})
                     continue
                 action = "remove" if command == "uninstall" else ("replace" if current is not None else "install")
-                items.append({"name": name, "target": key, "old": current, "new": new})
+                if link is not None:
+                    action = "remove_link" if command == "uninstall" else "replace_link"
+                item = {"name": name, "target": key, "old": current, "new": disabled_variant(new) if disabled and new else new}
+                if link is not None:
+                    item["link"] = link
+                if disabled and new:
+                    item["disabled"] = True  # Uniflow disabled it; the update keeps it disabled.
+                items.append(item)
                 output.append({"name": name, "target": key, "agents": target_info["agents"], "action": action})
                 if command == "uninstall":
                     after[key]["installed"].pop(name)
@@ -267,7 +353,7 @@ class Store:
                 if self.state(target) != state:
                     raise CrowError("changed_during_plan", "O estado mudou após o preview; execute novamente.")
             for item in plan["items"]:
-                if snapshot(Path(item["target"]) / item["name"]) != item["old"]:
+                if not self.matches(Path(item["target"]) / item["name"], item):
                     raise CrowError("changed_during_plan", "Um destino mudou após o preview; execute novamente.")
             txid = uuid.uuid4().hex
             data = {k: plan[k] for k in ("before", "after", "items")}
@@ -285,6 +371,8 @@ class Store:
                     if item["new"] is not None:
                         new = self.work(item["target"], txid) / "new" / item["name"]
                         plan["packages"][item["name"]].materialize(new)
+                        if item.get("disabled"):
+                            os.replace(new / "SKILL.md", new / DISABLED)
                         if snapshot(new) != item["new"]:
                             raise CrowError("staging_failed", "Cópia staged não corresponde ao pacote validado.")
                 atomic_json(journal, data)
@@ -293,9 +381,9 @@ class Store:
                     ensure_dir(target)
                     dest = target / item["name"]
                     work = self.work(target, txid)
-                    if snapshot(dest) != item["old"]:
+                    if not self.matches(dest, item):
                         raise CrowError("changed_during_install", "Destino alterado durante instalação.")
-                    if item["old"] is not None:
+                    if item["old"] is not None or item.get("link") is not None:  # a link moves as itself, never its target
                         os.replace(dest, work / "old" / item["name"])
                     if item["new"] is not None:
                         os.replace(work / "new" / item["name"], dest)
@@ -315,6 +403,12 @@ class Store:
                 raise
             return txid
 
+    @staticmethod
+    def matches(dest, item):
+        if item.get("link") is not None:
+            return same_link(dest, item["link"])
+        return snapshot(dest) == item["old"]
+
     def _restore(self, data):
         """Validate every target/backup before changing any during recovery."""
         operations = []
@@ -323,8 +417,18 @@ class Store:
             if current != before and current != data["after"][target]:
                 raise CrowError("recovery_conflict", "Manifesto mudou após a transação; recuperação recusada.")
         for item in reversed(data["items"]):
-            dest = checked(Path(item["target"]) / item["name"])
-            old = self.work(item["target"], data["id"]) / "old" / item["name"]
+            dest = checked(Path(item["target"])) / item["name"]
+            old = self.existing_work(item["target"], data["id"]) / "old" / item["name"]
+            if item.get("link") is not None:
+                if same_link(old, item["link"]):
+                    current = None if not os.path.lexists(dest) else ("link" if dest.is_symlink() else snapshot(dest))
+                    if current not in (None, item["new"]):
+                        raise CrowError("recovery_conflict", "Destino do link substituído foi alterado; recuperação recusada.")
+                    operations.append((dest, old))
+                elif not same_link(dest, item["link"]):
+                    raise CrowError("recovery_conflict", "Link original ausente; recuperação recusada.")
+                continue
+            dest = checked(dest)
             backup = snapshot(old)
             current = snapshot(dest)
             if backup is not None:
@@ -342,7 +446,9 @@ class Store:
         data["phase"] = "restoring"
         atomic_json(self.root / "transactions" / (data["id"] + ".json"), data)
         for dest, backup in operations:
-            if dest.exists():
+            if dest.is_symlink():
+                dest.unlink()
+            elif dest.exists():
                 shutil.rmtree(dest)
             if backup is not None:
                 os.replace(backup, dest)
@@ -390,10 +496,30 @@ class Store:
                                  "note": "Nome externo ao catálogo: não gerenciado nem removido por este CLI."})
                     continue
                 record = state["installed"].get(name)
+                link = target / name
+                store = uniflow_store(self.home)
+                if link.is_symlink() and target == store:
+                    resolved = os.path.realpath(link)
+                    managed = self.managed_target(resolved, name)
+                    rows.append({"name": name, "target": str(target), "agents": target_info["agents"],
+                                 "status": "external_link", "revision": None, "activation_verified": False,
+                                 "note": "Link no store do Uniflow para " + resolved +
+                                 (" (cópia gerenciada pelo crow-skills)" if managed else " (não gerenciado)") +
+                                 ". Troque só o link por uma cópia gerenciada: crow-skills install " + name +
+                                 " --agents uniflow --global" + ("" if managed else " --replace") + " --yes"})
+                    continue
+                if (record is None and link.is_symlink() and not (store / name).is_symlink() and (store / name).is_dir()
+                        and os.path.realpath(target) != os.path.realpath(store)
+                        and os.path.realpath(link) == os.path.realpath(store / name)):
+                    rows.append({"name": name, "target": str(target), "agents": target_info["agents"],
+                                 "status": "uniflow_link", "revision": None, "activation_verified": False,
+                                 "note": "Link projetado pelo Uniflow a partir do seu store; gerenciado em --agents uniflow."})
+                    continue
                 try:
                     entries = snapshot(target / name)
                     status = ("absent" if entries is None else "unmanaged") if record is None else (
-                        "missing" if entries is None else "installed" if entries == record["entries"] else "modified")
+                        "missing" if entries is None else "installed" if entries == record["entries"] else
+                        "disabled" if entries == disabled_variant(record["entries"]) else "modified")
                 except CrowError:
                     status = "unsafe"
                 rows.append({"name": name, "target": str(target), "agents": target_info["agents"],

package/docs/cli.md

@@ -1,4 +1,4 @@
-# crow-skills CLI 0.6.1
+# crow-skills CLI 0.7.0
 
 CLI local-first para humanos e agentes. Python 3.10+, sem bibliotecas Python externas; Git é necessário para fontes em clone, não para o snapshot npm. O launcher npm requer Node 18+. Mutações suportadas em macOS/Linux (locks POSIX). Não instala o agente, não executa scripts das skills e não muda modelos, prompts base ou permissões. Instruções de uso das skills (o guia do agente, abaixo) são gravadas pelo comando `guide` e, por padrão, por `install`/`update`/`uninstall` em `--global` quando a crow-behaviour fica instalada para um agente com mecanismo verificado; `--no-guide` desliga isso. Os mesmos comandos também aplicam as [integrações de interface](#integrações-de-interface-integrations) (status line do Claude Code e do Codex, segmento tmux); `--no-integrations` desliga. `crow-skills progress` mostra o [painel de progresso](#progresso-progress) da execução crow-behaviour ativa.
 
@@ -31,7 +31,7 @@ Para testar/distribuir o arquivo local sem registry:
 
 ```sh
 npm pack
-npm install -g ./andespindola-crow-skills-0.6.1.tgz --ignore-scripts
+npm install -g ./andespindola-crow-skills-0.7.0.tgz --ignore-scripts
 ```
 
 O pacote contém o CLI Python e todas as skills do commit, com `release.json` de hashes. Não requer acesso ao GitHub ou clone para list/install. O launcher Node encaminha argumentos sem shell para Python em modo isolado, evitando imports pelo diretório do chamador/PYTHONPATH. `CROW_SKILLS_PYTHON` pode apontar para outro executável Python 3.10+. Não há dependências npm nem hooks de instalação que instalem skills automaticamente.
@@ -97,7 +97,7 @@ crow-skills recover --yes
 ```
 
 - Manifestos/locks/journals ficam sob `~/.local/state/crow-skills/`, separados da descoberta de skills. Não se escreve `manifest.json` dentro de `.claude/skills`.
-- Staging e backups ficam no diretório reservado `.crow-skills/` ao lado da raiz de skills, na mesma filesystem para permitir renames, nunca dentro dela. Backups são privados e retidos; não há expiração automática nesta versão.
+- Staging e backups ficam no diretório reservado `.crow-skills/` ao lado da raiz de skills, na mesma filesystem para permitir renames, nunca dentro dela. Quando esse lado é protegido (o store do Uniflow), ficam em `~/.local/state/crow-skills/work/`. Backups são privados e retidos; não há expiração automática nesta versão.
 - Todos os destinos passam por preflight antes de aplicar. Renames são atômicos por pasta; uma operação com múltiplos destinos não é um único rename atômico global. Erros comuns provocam restauração; interrupções deixam journal recuperável, bloqueando novas mutações até `recover`.
 - `recover` restaura o estado anterior, não tenta terminar silenciosamente a instalação. A própria restauração tem um estado pendente `restoring`, permitindo retomada se também for interrompida. Confere arquivos/backup antes de substituir. Se houver edições após a interrupção, recusa e conserva os dados para resolução manual.
 - `install`/`update`/`uninstall` que também alteram o guia gravam duas transações encadeadas: skills e depois guia, com o journal do guia apontando a de skills (`linked`). As duas IDs saem no resultado (`transaction` e `guides.transaction`). Se o guia falhar, as skills dessa execução são desfeitas antes do erro. `rollback` da transação de skills desfaz primeiro o guia ligado; `rollback` da transação de guia desfaz só o guia. `recover` de um guia interrompido também desfaz as skills ligadas (`then_rollback` no preview). Uma interrupção exatamente entre as duas deixa as skills aplicadas e o guia `outdated`/`absent`, sem journal pendente: repita o comando ou faça rollback da transação de skills.
@@ -135,11 +135,35 @@ Erros retornam `ok:false` e `error.code/message`. Saídas reais incluem alteraç
 | gemini | `~/.gemini/skills` | `.gemini/skills` |
 | devin | `~/.config/devin/skills` (ou XDG_CONFIG_HOME) | `.devin/skills` |
 | shared | `~/.agents/skills` | `.agents/skills` |
+| uniflow | store do Uniflow: `~/.config/uniflow/skills` (veja [Uniflow](#uniflow)) | não existe; recusado com `unsupported_scope` |
 
 Codex/shared são deduplicados quando apontam para o mesmo diretório. O diretório compartilhado também pode ser lido por outros hosts; não é isolamento entre agentes. `.codex/skills` é uma localização legada encontrada em ambientes existentes; o adaptador usa a localização moderna documentada. Para um destino legado específico, use `--dest` explicitamente.
 
 `agents` só verifica PATH e caminhos, sem iniciar agente/LLM. `status`/`doctor` conferem arquivos e estado de instalação, não provam carregamento, ativação, independência dos workers ou execução correta da skill. Gemini oferece `/skills reload`; para outros hosts, confira sua lista/reload ou reinicie a sessão conforme a versão. Nenhum hook ou system prompt base é alterado para forçar uso; o guia abaixo, aplicado por padrão em `--global` e desligável com `--no-guide`, é aditivo.
 
+### Uniflow
+
+```sh
+crow-skills install --all --agents uniflow --global --dry-run
+crow-skills install --all --agents uniflow --global --yes
+crow-skills status --agents uniflow
+crow-skills update --agents uniflow --global --yes
+crow-skills uninstall --all --agents uniflow --global --yes
+```
+
+O Uniflow guarda as skills num store próprio e cria, ao subir cada CLI, links desse store em `~/.claude/skills`, `~/.codex/skills`, `~/.gemini/skills` e `~/.config/devin/skills`; quando o CLI já tem uma entrada nativa com o mesmo nome, ele pula o link. O agente `uniflow` grava nesse store uma cópia real e gerenciada de cada pacote, com o mesmo manifesto e hashes dos outros agentes; `status`, `update`, `uninstall`, `--overwrite-modified`, `rollback` e `recover` funcionam igual.
+
+- Store: o diretório `skills` ao lado do `config.json` do Uniflow, resolvido como ele resolve: `UNIFLOW_CONFIG` (ou `CROWFLOW_CONFIG`), senão `$XDG_CONFIG_HOME/uniflow`, senão `~/.config/uniflow`. Com `--home` isolado, essas variáveis são ignoradas.
+- Proteção: em todo o diretório de configuração do Uniflow, só `skills/crow-*` é gravável. `config.json`, prompts, backups e as outras skills do store continuam recusados com `protected_path`, inclusive por `--dest`. A comparação usa também a identidade do arquivo, então outra grafia (`~/.config/UNIFLOW` no APFS) não fura a proteção. Se `UNIFLOW_CONFIG` aponta para um arquivo direto no home (ou num ancestral dele), só esse arquivo, o store e os marcadores do Uniflow (`.bundled-skills.json`, `skills.required.json`) são protegidos, nunca o home. Staging e backups dessa instalação ficam em `~/.local/state/crow-skills/work/`, não ao lado do store; `rollback`/`recover` de transações antigas procuram os backups nos dois lugares.
+- Instalações antigas com `--dest` dentro da configuração do Uniflow (fora de `skills/crow-*`): `uninstall` continua permitido para o que está no manifesto; `install`/`update` são recusados com o comando de remoção e a sugestão de reinstalar com `--agents uniflow --global`.
+- Links importados pelo Uniflow: na migração, o Uniflow pode criar `skills/crow-x` como link para a cópia nativa (ex.: `~/.claude/skills/crow-x`). `status`/`doctor` mostram `external_link` (doctor `healthy:false`) com o comando para resolver. `install`/`update` com `--agents uniflow` trocam só o link por uma cópia gerenciada (ação `replace_link`), sem tocar no alvo, e o `rollback` devolve o link. Isso é automático quando o alvo é uma instalação gerenciada pelo crow-skills com arquivos iguais ao manifesto; para outro alvo, o erro `unmanaged_link` explica e pede `--replace`. Links continuam recusados no resto do caminho (store como link, `--dest`).
+- Skills desabilitadas no Uniflow (`SKILL.md` renomeado para `SKILL.md.disabled`): `status` mostra `disabled`, o doctor não acusa problema e `update` (mesmo com `--overwrite-modified`) mantém a skill desabilitada.
+- Só `--global`: o Uniflow não tem store de projeto (`--project` falha com `unsupported_scope`).
+- Sem guia: o Uniflow infere o uso da crow-behaviour por conta própria, então `guide` recusa `uniflow` (`unsupported_guide`) e `install` informa isso em `guides.skipped`. Integrações de interface também não se aplicam.
+- Detecção: `agents` marca `detected` quando `uniflow` está no PATH (`executable_found`) ou o diretório de configuração existe (`config_found`).
+- Cópias nativas duplicadas: se claude, gemini ou devin já têm um pacote crow de mesmo nome, o Uniflow não cria o link para ele e a cópia nativa continua valendo ali, possivelmente em outra revisão (`effect: skipped`). No codex é pior: o crow-skills instala em `~/.agents/skills`, o Uniflow liga o store em `~/.codex/skills` e o Codex lê os dois, vendo duas skills de mesmo nome (`effect: both`). `install`/`update` com `uniflow` listam essas cópias em `uniflow.native_duplicates` (diretórios que não puderam ser lidos, como um `~/.claude` symlink de dotfiles, vão para `uniflow.uninspected` sem derrubar o comando) e sugerem em `uniflow.suggested_command` o `uninstall` explícito; nada é removido sem esse comando. Remover a cópia nativa da crow-behaviour remove também o guia daquele agente, que deixa de valer fora do Uniflow.
+- Links projetados: em `status`/`doctor`, um link do Uniflow para o store num diretório de agente aparece como `uniflow_link`, e não deixa o doctor `healthy:false`.
+
 Fontes primárias consultadas em 2026-10-20: [Codex](https://learn.chatgpt.com/docs/build-skills#where-codex-loads-local-skills), [Claude](https://code.claude.com/docs/en/skills), [Gemini](https://geminicli.com/docs/cli/using-agent-skills/), [Devin](https://docs.devin.ai/cli/extensibility/skills/overview).
 
 ## Instruções para o agente (guide)
@@ -159,7 +183,7 @@ Aplicação automática (padrão em `install`, `update` e `uninstall` com `--glo
 
 - O guia é planejado junto com as skills, a partir do conjunto de skills que o agente terá depois do comando, e conferido antes de gravar qualquer coisa. Install/update que deixam a crow-behaviour instalada aplicam o guia ou o regeneram; mudança de outra skill gerenciada regenera um guia já instalado (também quando a mudança chega pelo diretório compartilhado `~/.agents/skills`, que é o do codex). Uninstall da crow-behaviour remove o guia, devolvendo o arquivo que `--replace` havia deslocado; uninstall de outra skill regenera o guia instalado e nunca cria um novo.
 - Recusa do guia (arquivo não gerenciado sem `--replace`, guia editado/ausente sem `--overwrite-modified`, chave `developer_instructions` alheia, symlink, hard link, prompt compartilhado ou Uniflow) falha o comando inteiro, com código do guia e sugestão de `--replace`, `--overwrite-modified` ou `--no-guide`, sem gravar skills nem guia. Em install/update, `--replace` e `--overwrite-modified` valem para skills e guia.
-- `shared`, `--project` e `--dest` não têm mecanismo: o comando segue e informa em `guides.skipped`. Sem Python 3.11+ (tomllib), o guia do codex também é pulado e informado.
+- `shared`, `uniflow`, `--project` e `--dest` não têm mecanismo: o comando segue e informa em `guides.skipped`. Sem Python 3.11+ (tomllib), o guia do codex também é pulado e informado.
 - `--dry-run` inclui `guides.changes` e `guides.preview` (conteúdo que seria gravado). A saída JSON traz `guides` com `changes`, `skipped`, `revision` e `transaction`.
 
 | Agente | Mecanismo (usuário) | Propriedade |
@@ -171,8 +195,8 @@ Aplicação automática (padrão em `install`, `update` e `uninstall` com `--glo
 
 Cada mecanismo foi verificado em 2026-10-21 (Claude Code 2.1.304, Codex CLI 0.163.0, agy 1.4.3, Devin CLI 3000.11.92) com uma sentinela carregada numa sessão nova junto do prompt base já existente: os mecanismos são aditivos. Versões futuras dos CLIs podem mudar isso; confira abrindo uma sessão nova. O comando não inicia agentes e retorna `activation_verified:false`.
 
-- Só `--global` é suportado. No comando `guide`, `--project`, `--dest` e `shared` são recusados com `unsupported_guide`, porque não há mecanismo verificado.
-- Nunca grava em symlinks, em arquivos com hard links, em prompts compartilhados (`~/.claude/CLAUDE.md`, `~/.codex/AGENTS.md`, `~/.gemini/GEMINI.md`, `~/.config/devin/CLAUDE.md`), em `~/.config/uniflow/` ou nos alvos desses links. Não usa mecanismos que substituem o prompt base (como `model_instructions_file` ou `AGENTS.override.md`).
+- Só `--global` é suportado. No comando `guide`, `--project`, `--dest`, `shared` e `uniflow` são recusados com `unsupported_guide`, porque não há mecanismo verificado.
+- Nunca grava em symlinks, em arquivos com hard links, em prompts compartilhados (`~/.claude/CLAUDE.md`, `~/.codex/AGENTS.md`, `~/.gemini/GEMINI.md`, `~/.config/devin/CLAUDE.md`), em `~/.config/uniflow/` (só `skills/crow-*` é gravável, e só pela instalação de skills) ou nos alvos desses links. Não usa mecanismos que substituem o prompt base (como `model_instructions_file` ou `AGENTS.override.md`).
 - No Codex, uma chave `developer_instructions` definida fora do bloco é recusada sempre, mesmo com `--replace`. A edição é validada por parse TOML (Python 3.11+): o restante do arquivo precisa continuar idêntico. Uninstall devolve o arquivo byte a byte.
 - Arquivo existente não gerenciado exige `--replace`; guia editado ou ausente exige `--overwrite-modified`. Ambos guardam backup privado em `~/.local/state/crow-skills/guide-backups/`. O uninstall devolve o arquivo que `--replace` substituiu (conferido pelo SHA-256 do backup), em vez de apagá-lo, e mantém um `config.toml` que já existia, mesmo vazio.
 - Transações usam o mesmo journal, lock, `rollback` e `recover` das skills. Se o Codex reescrever outras partes do `config.toml` depois, o rollback desfaz só o bloco.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/crow-skills",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Versioned, complementary agent skills with a protected multi-agent installer",
   "license": "UNLICENSED",
   "repository": {

package/release.json

@@ -3,7 +3,7 @@
     "README.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "fe964a6eae4cfd2eafaaa3a21e6a5992a74c5c36899ae2d5e614f8960d0c5283"
+      "sha256": "c5093abfec8d8ee55d73e81fa2130f02c93a1fb53c998fc3dd9bafc4d989bd16"
     },
     "bin/npm-crow-skills.cjs": {
       "executable": true,
@@ -18,7 +18,7 @@
     "crow_skills/__init__.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "3c04bdefdd487772917f0ebf729c9f7248b4ee2c4900b40f0e11380ac6e2fa84"
+      "sha256": "b7e23c635664d60f1afc60f98f3e68d7558fe4357973bb5b0d4592e7822a69aa"
     },
     "crow_skills/__main__.py": {
       "executable": false,
@@ -28,17 +28,17 @@
     "crow_skills/agents.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "36599a33cc707408216ee13880bd8e12c73b42803ccd160327c05042e464fec0"
+      "sha256": "b14c37d2f1becfe38c74411fc413608b375c05bd6961a0757e3ec085ec2e1f66"
     },
     "crow_skills/cli.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "215d90d0d503d98f2262c1b5c7612546309d034959f892f87118dabd4e9bae7c"
+      "sha256": "fd3c4e63be95f0a616932438f1d2648facffabf825a89bb15d9f1a466d33b075"
     },
     "crow_skills/guide.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "65b93fff61c496f7d3e1b3b32eadb008ba3a9cfd543a4db53f73becdb4ceec6f"
+      "sha256": "cabfe0809c0fc607b7deac0cd8df9025acaadddf4deb05f45288158dc51b0391"
     },
     "crow_skills/integrations.py": {
       "executable": false,
@@ -63,7 +63,7 @@
     "crow_skills/storage.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "2c3823f783c1da2f971860e6207a5146275e105fab74a7aa54e57033cd3993f0"
+      "sha256": "bf3c4bcb83888b74c72773aa1d0c0def4b3ba08f0c7bdbb918d2c549438e4d83"
     },
     "docs/cli-security.md": {
       "executable": false,
@@ -73,12 +73,12 @@
     "docs/cli.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "cbffcfdcb59182bf7c857ceeb336df108a67d2b2ba235eb1e393a3993320b992"
+      "sha256": "dd869d0e4e3354954436e78d0bde0254ee86da752195a7f55d9e7a8e5a628bdb"
     },
     "package.json": {
       "executable": false,
       "kind": "file",
-      "sha256": "b73c4f3f6b1381e9fdf8d988cc4e95888e4ecc72af23b99f5202ee8e6605ad0b"
+      "sha256": "ae9338cf496e3fb2691abed08474ad6a85c85932d5bf66c9a5c3a6b106208d2e"
     },
     "skills/crow-accessibility/SKILL.md": {
       "executable": false,
@@ -631,7 +631,7 @@
       "sha256": "4b921ea30ae9b731b5210581873e3d180e830cadfdc02bdbb5b3419ec39baaab"
     }
   },
-  "revision": "15319b7830b484cb0c2f32ff54506ae589d7f85d",
+  "revision": "07e8fbd997cfbeb645fb0b986725934ebb243ce8",
   "schema_version": 1,
-  "version": "0.6.1"
+  "version": "0.7.0"
 }