@andespindola/crow-skills 0.11.0 → 0.11.1

package/README.md

@@ -2,7 +2,7 @@
 
 Skills com escopo explícito, conhecimento especializado preservado e fluxos comuns reutilizáveis.
 
-**Versão 0.11.0** ([mudanças](CHANGELOG.md)): `crow-skills setup --yes` configura de uma vez todos os CLIs de agente da máquina e `crow-skills upgrade --yes` atualiza tudo numa só passada; os hooks que o crow-skills grava já saem habilitados (no Codex, aprovados pelo próprio `codex app-server`, só os do crow-skills; `--no-trust` desliga) e `status`/`doctor` mostram se cada CLI vai rodá-los; a ajuda ficou curta e organizada por tarefa. A 0.10.1 passou a tratar swap e CPU como eixos de pressão no controle de recursos (swap quase cheio e carga alta reduzem agentes, jobs e workers; nenhuma recomendação cresce com a pressão), mostrou a CPU% dos CLIs de agente, trouxe `crow-skills resources --exec-prefix` para rodar jobs pesados em prioridade baixa e as regras da crow-behaviour sob pressão (reduzir já, um job pesado por vez, não repetir verificação, validação ampla no CI); os hooks do Codex vão para o `config.toml` quando o `hooks.json` é symlink. A 0.10.0 trouxe o crow-broadcast, que compartilha, de forma passiva, o que cada sessão e cada CLI (Claude Code, Codex, Gemini CLI, Antigravity, Devin, inclusive dentro do Uniflow) está fazendo nesta máquina: repositório, clone, branch, execução crow em andamento e arquivos em edição; o prompt recebe um resumo só quando outra sessão viva está no mesmo repositório, editar um arquivo que outra sessão tocou ou trocar de branch num clone em uso gera aviso (ou bloqueio, se configurado), e `crow-skills broadcast claim` reserva áreas; a crow-behaviour consulta isso antes de planejar e reserva as áreas que delega ([crow-broadcast](docs/broadcast.md)). A 0.9.0 trouxe o controle de memória da máquina: `crow-skills resources` mede memória, pressão e os CLIs de agente em execução e recomenda quantos agentes, jobs pesados e workers rodar em paralelo; a crow-behaviour consulta essa recomendação antes de cada fan-out (sob `warn` reduz, sob `critical` segue sequencial), limita workers de builds e testes, reutiliza um dev server por projeto e encerra o que abriu, e 15 especialistas que sobem processos pesados ganharam a regra correspondente; o hook de prompt e as status lines só avisam quando a máquina está sob pressão. A 0.8.0 trouxe `crow-skills mode on|off`, que liga e desliga a crow-behaviour em todas as sessões e CLIs (Claude Code, Codex, Gemini CLI, Antigravity, Devin) a partir do próximo prompt, com `/crow on|off` dentro da sessão e o indicador `▸▸ crow on` na status line; a crow-behaviour mostra o progresso como a lista de agentes do host (`● main`, `○ dono  atividade`); `crow-skills events` publica um barramento de eventos dos hooks para terminais; `crow-skills autoupdate on` atualiza o CLI e as skills gerenciadas todo dia e no login. A 0.7.1 trouxe as correções da revalidação no Codex às skills especialistas; a 0.7.0 tornou o Uniflow agente de instalação (`--agents uniflow`); 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).
+**Versão 0.11.1** ([mudanças](CHANGELOG.md)): o Codex deixa de mostrar em dobro as skills que o Uniflow já projeta em `~/.codex/skills`. A 0.11.0 trouxe `crow-skills setup --yes`, que configura de uma vez todos os CLIs de agente da máquina, e `crow-skills upgrade --yes`, que atualiza tudo numa só passada; os hooks que o crow-skills grava já saem habilitados (no Codex, aprovados pelo próprio `codex app-server`, só os do crow-skills; `--no-trust` desliga) e `status`/`doctor` mostram se cada CLI vai rodá-los; a ajuda ficou curta e organizada por tarefa. A 0.10.1 passou a tratar swap e CPU como eixos de pressão no controle de recursos (swap quase cheio e carga alta reduzem agentes, jobs e workers; nenhuma recomendação cresce com a pressão), mostrou a CPU% dos CLIs de agente, trouxe `crow-skills resources --exec-prefix` para rodar jobs pesados em prioridade baixa e as regras da crow-behaviour sob pressão (reduzir já, um job pesado por vez, não repetir verificação, validação ampla no CI); os hooks do Codex vão para o `config.toml` quando o `hooks.json` é symlink. A 0.10.0 trouxe o crow-broadcast, que compartilha, de forma passiva, o que cada sessão e cada CLI (Claude Code, Codex, Gemini CLI, Antigravity, Devin, inclusive dentro do Uniflow) está fazendo nesta máquina: repositório, clone, branch, execução crow em andamento e arquivos em edição; o prompt recebe um resumo só quando outra sessão viva está no mesmo repositório, editar um arquivo que outra sessão tocou ou trocar de branch num clone em uso gera aviso (ou bloqueio, se configurado), e `crow-skills broadcast claim` reserva áreas; a crow-behaviour consulta isso antes de planejar e reserva as áreas que delega ([crow-broadcast](docs/broadcast.md)). A 0.9.0 trouxe o controle de memória da máquina: `crow-skills resources` mede memória, pressão e os CLIs de agente em execução e recomenda quantos agentes, jobs pesados e workers rodar em paralelo; a crow-behaviour consulta essa recomendação antes de cada fan-out (sob `warn` reduz, sob `critical` segue sequencial), limita workers de builds e testes, reutiliza um dev server por projeto e encerra o que abriu, e 15 especialistas que sobem processos pesados ganharam a regra correspondente; o hook de prompt e as status lines só avisam quando a máquina está sob pressão. A 0.8.0 trouxe `crow-skills mode on|off`, que liga e desliga a crow-behaviour em todas as sessões e CLIs (Claude Code, Codex, Gemini CLI, Antigravity, Devin) a partir do próximo prompt, com `/crow on|off` dentro da sessão e o indicador `▸▸ crow on` na status line; a crow-behaviour mostra o progresso como a lista de agentes do host (`● main`, `○ dono  atividade`); `crow-skills events` publica um barramento de eventos dos hooks para terminais; `crow-skills autoupdate on` atualiza o CLI e as skills gerenciadas todo dia e no login. A 0.7.1 trouxe as correções da revalidação no Codex às skills especialistas; a 0.7.0 tornou o Uniflow agente de instalação (`--agents uniflow`); 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).
 
@@ -42,7 +42,7 @@ Exemplos:
 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 lines do Claude Code, do Codex e do Antigravity, hooks do modo crow em cada CLI, comando `/crow`, segmento tmux) seguem o mesmo fluxo, preservando a configuração existente; `--no-integrations` desliga. O [barramento de eventos](docs/events.md) e a atualização automática (`crow-skills autoupdate on`) estão no [CLI](docs/cli.md).
 
 ```sh
-npm install -g @andespindola/crow-skills@0.11.0
+npm install -g @andespindola/crow-skills@0.11.1
 crow-skills mode
 crow-skills progress
 ./bin/crow-skills list

package/crow_skills/__init__.py

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

package/crow_skills/autoupdate.py

@@ -305,6 +305,60 @@ def preview_self(install, git_pull):
     return {"kind": "unknown", "result": "skipped", "reason": "instalação não reconhecida (brew, npm ou checkout git)"}
 
 
+def broken_projections(agent, home, store, rows):
+    """Uniflow links of this CLI whose store entry was edited or lost files: the CLI may not load them, so
+    upgrade reports them as needing the user (same as setup), with the command that restores the store."""
+    from .guide import broken_fix, store_broken
+    names = set()
+    if any(r["status"] == "uniflow_link" for r in rows):
+        bad = store_broken(home, store)
+        names |= {r["name"] for r in rows if r["status"] == "uniflow_link" and r["name"] in bad}
+    if agent == "codex":
+        from . import projection
+        names |= {n for n, kind in projection.links(home, store).items() if kind == "modified"}
+    return [{"name": n, "status": "uniflow_link_modified", "fix": broken_fix(n)} for n in sorted(names)]
+
+
+def reinstall_behaviour(home, entry, dry_run, trust):
+    """Codex without a working crow-behaviour (its projection is broken, no native copy): install it natively,
+    as setup does, so the guide and hooks keep a coordinator to point to."""
+    from .cli import parser, run as cli_run
+    argv = ["install", "crow-behaviour", "--agents", "codex", "--global", "--json", "--home", str(home),
+            "--dry-run" if dry_run else "--yes"]
+    if not trust:
+        argv.append("--no-trust")
+    data = cli_run(parser().parse_args(argv))
+    if any(c["name"] == "crow-behaviour" and c["action"] != "unchanged" for c in data["changes"]):
+        entry["updated"].append("crow-behaviour")
+        entry["transaction"] = data.get("transaction")
+
+
+def codex_duplicates(home, store, entry, names, dry_run):
+    """Codex sees Uniflow's links in ~/.codex/skills: those names are not updated natively, and intact managed
+    native copies of them are removed through uninstall (backup, transaction). Returns the names to update."""
+    from . import projection
+    from .cli import parser, run as cli_run
+    seen = projection.projected("codex", home, store)
+    if not seen:
+        return names
+    dupes = projection.duplicates(home, store)
+    entry["via_uniflow"] = sorted(set(entry["via_uniflow"]) | seen)
+    entry["kept"] = [k for k in entry["kept"] if k["name"] not in seen]
+    entry["kept"] += [{"name": n, "status": "duplicate_modified"} for n in dupes["modified"]]
+    entry["kept"] += [{"name": n, "status": "duplicate_shared"} for n in dupes["shared"]]
+    if dupes["remove"]:
+        argv = ["uninstall", *dupes["remove"], "--agents", "codex", "--global", "--json", "--home", str(home),
+                "--dry-run" if dry_run else "--yes", "--no-integrations"]
+        try:
+            data = cli_run(parser().parse_args(argv))
+            entry["removed"] = [{"name": c["name"], "reason": "removida: duplicava a projeção do Uniflow"}
+                                for c in data["changes"] if c["action"] != "unchanged"]
+            entry["removal_transaction"] = data.get("transaction")
+        except CrowError as exc:
+            entry["error"] = {"code": exc.code, "message": str(exc)}
+    return [n for n in names if n not in seen]
+
+
 def skills_update(home, trust=True, dry_run=False):
     """update --global for every agent with managed installs; modified skills are kept and reported.
 
@@ -334,17 +388,23 @@ def skills_update(home, trust=True, dry_run=False):
         from .guide import store_managed
         store_ok = store_managed(home, store) if any(r["status"] == "uniflow_link" for r in rows) else set()
         projected = sorted(r["name"] for r in rows if r["status"] == "uniflow_link" and r["name"] in store_ok)
+        if agent == "codex":
+            from . import projection
+            projected = sorted(set(projected) | projection.projected("codex", home, store))  # ~/.codex/skills links
+        broken = broken_projections(agent, home, store, rows)
         rows = [r for r in rows if r["name"] and r["revision"]]
         if not rows:
-            if projected:
+            if projected or broken:
                 # Every crow skill here comes from Uniflow's store (updated as agent uniflow): only the guide,
                 # integrations and hooks of this CLI are refreshed.
                 from . import machine
-                entry = {"agent": agent, "target": target["path"], "updated": [], "unchanged": 0, "kept": [], "error": None,
+                entry = {"agent": agent, "target": target["path"], "updated": [], "unchanged": 0, "kept": list(broken), "error": None,
                          "via_uniflow": projected}
                 if dry_run:
                     entry["dry_run"] = True
                 try:
+                    if agent == "codex" and "crow-behaviour" in [k["name"] for k in broken]:
+                        reinstall_behaviour(home, entry, dry_run, trust)
                     extras = machine.refresh_extras(agent, home, dry_run, trust)
                     entry["guides"] = (extras.get("guides") or {}).get("transaction")
                 except CrowError as exc:
@@ -362,10 +422,23 @@ def skills_update(home, trust=True, dry_run=False):
                 kept.append({"name": r["name"], "status": "other_origin"})  # update --source or install switches it
             else:
                 names.append(r["name"])
-        entry = {"agent": agent, "target": target["path"], "updated": [], "unchanged": 0, "kept": kept, "error": None,
-                 "via_uniflow": projected}
+        entry = {"agent": agent, "target": target["path"], "updated": [], "unchanged": 0, "kept": kept + list(broken),
+                 "error": None, "via_uniflow": projected}
         if dry_run:
             entry["dry_run"] = True
+        if agent == "codex":
+            names = codex_duplicates(home, store, entry, names, dry_run)
+            if "crow-behaviour" in [k["name"] for k in broken] and "crow-behaviour" not in [r["name"] for r in rows]:
+                try:
+                    reinstall_behaviour(home, entry, dry_run, trust)
+                except CrowError as exc:
+                    entry["error"] = {"code": exc.code, "message": str(exc)}
+            if not names and not entry.get("error"):
+                from . import machine
+                try:
+                    machine.refresh_extras(agent, home, dry_run, trust)
+                except CrowError as exc:
+                    entry["error"] = {"code": exc.code, "message": str(exc)}
         if names:
             try:
                 argv = ["update", *names, "--agents", agent, "--global", "--dry-run" if dry_run else "--yes", "--json",

package/crow_skills/cli.py

@@ -14,6 +14,7 @@ from . import guide
 from . import hook
 from . import integrations
 from . import progress
+from . import projection
 from . import resources
 from . import machine
 from . import ui
@@ -332,6 +333,7 @@ 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."})
@@ -387,6 +389,7 @@ 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;
@@ -744,14 +747,43 @@ 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  # --agents shared: other hosts read that dir without Uniflow's codex projection
+    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:
+        merged["before"].update(plan["before"])
+        merged["after"].update(plan["after"])
+        merged["items"] += plan["items"]
+        merged["packages"].update(plan["packages"])
+        merged["changes"] += plan["changes"]
+    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 disabled:
+        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.")
@@ -859,6 +891,17 @@ def run(args):
         result = {"installations": rows, "guides": guides, "integrations": ui, "pending_transactions": pending,
                   "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)
+            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["warnings"] = [{"code": "codex_duplicates", "skills": names_,
+                                       "message": "O Codex vê " + str(len(names_)) + " skill(s) duas vezes (cópia em ~/.agents/skills "
+                                                  "e link do Uniflow em " + str(projection.codex_skills_dir(home)) + ").",
+                                       "fix": "crow-skills setup --agents codex --yes"
+                                              + (" --overwrite-modified" if dupes["modified"] else "")}]
         result["groups"] = group_coverage(rows)
         try:
             result["autoupdate"] = autoupdate.status(store, home) if global_view else None
@@ -942,7 +985,17 @@ 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)
-    plan = store.plan(args.command, names, targets, source, getattr(args, "replace", False), args.overwrite_modified)
+    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)
     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,
@@ -953,6 +1006,14 @@ def run(args):
     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 nativa é criada para o codex. Cópias nativas que duplicam a projeção não são removidas "
+                    "por install; remova-as com o comando sugerido ou rode crow-skills setup --yes.",
+            "suggested_command": ("crow-skills uninstall " + " ".join(codex_view["duplicates"]) + " --agents codex --global")
+            if codex_view["duplicates"] else None}
     if plan["items"] or (gplan and gplan["items"]) or ui.get("changes"):
         authorize(args, interactive, summary)
     txid = None
@@ -1023,6 +1084,8 @@ def render_status(data, doctor=False, stream=None):
                                     ("fail" if h["state"] in machine.BAD_HOOKS else "warn"), stream),
                             h["integration"], ui.word(h["state"]),
                             ui.clean(h.get("fix") or "")] for h in hooks], stream=stream)
+    for warning in data.get("warnings") or []:
+        lines += ["", ui.mark("warn", stream) + " " + ui.clean(warning["message"]) + "\n  Para corrigir: " + warning["fix"]]
     if data.get("pending_transactions"):
         lines += ["", ui.mark("fail", stream) + " Transação pendente: crow-skills recover --yes"]
     if doctor:

package/crow_skills/guide.py

@@ -187,17 +187,39 @@ def managed_skills(agent, home, store):
     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()
-    return sorted(r["name"] for r in rows if r["status"] in ("installed", "modified")
-                  or (r["status"] == "uniflow_link" and r["name"] in store_ok))
+    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_managed(home, store):
-    """Names whose Uniflow store copy is a crow-skills install (a record, files installed or edited).
-    A link to a store entry the user wrote by hand is not a crow-skills install for the CLI."""
+def store_statuses(home, store):
+    """{name: status} of the Uniflow store (crow-skills view); {} when it cannot be read."""
     try:
-        return {r["name"] for r in store.status(destinations("uniflow", home), ()) if r["status"] in ("installed", "modified")}
+        return {r["name"]: r["status"] for r in store.status(destinations("uniflow", home), ()) if r["name"]}
     except (CrowError, OSError):
-        return set()
+        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")
 
 
 def present_skills(agent, home, store, catalog):

package/crow_skills/machine.py

@@ -173,6 +173,7 @@ def classify(store, target, names, agent, replace, overwrite, store_names=()):
     pending = set(store_names) if projected else set()
     store_ok = guide.store_managed(store.home, store) if projected else set()
     disabled = store_disabled(store.home, store) if projected else set()
+    broken = guide.store_broken(store.home, store) if projected else set()
     for name in names:
         row = rows.get(name) or {"status": "absent"}
         status = row["status"]
@@ -181,6 +182,9 @@ def classify(store, target, names, agent, replace, overwrite, store_names=()):
         elif status == "uniflow_link" and name in disabled:
             kept.append({"name": name, "status": "uniflow_link_disabled", "reason": DISABLED_REASON,
                          "fix": "reabilite a skill no Uniflow; o crow-skills mantém a desabilitação"})
+        elif status == "uniflow_link" and name in broken:
+            kept.append({"name": name, "status": "uniflow_link_modified", "reason": guide.BROKEN_REASON,
+                         "fix": guide.broken_fix(name)})
         elif status == "uniflow_link":
             kept.append({"name": name, "status": "uniflow_link_unmanaged",
                          "reason": "link do Uniflow para um pacote do store que o crow-skills não gerencia; não conta como instalada",
@@ -240,6 +244,8 @@ def configure_agent(args, home, store, agent, names, dry_run, store_names=()):
     try:
         install, entry["kept"], entry["via_uniflow"], waiting = classify(store, target, names, agent, replace, overwrite,
                                                                 store_names if agent != "uniflow" else ())
+        if agent == "codex":
+            install = codex_projection_step(args, home, store, entry, names, install, waiting, store_names, dry_run)
         if waiting:
             entry["via_uniflow_pending"] = waiting
         if not install:
@@ -272,6 +278,60 @@ def configure_agent(args, home, store, agent, names, dry_run, store_names=()):
     return entry
 
 
+DUPLICATE = "removida: duplicava a projeção do Uniflow"
+
+
+def codex_projection_step(args, home, store, entry, names, install, waiting, store_names, dry_run):
+    """Codex sees ~/.codex/skills (Uniflow's links to its store) and ~/.agents/skills (our copies) and lists a
+    same-name skill twice. A name Codex sees via a managed projection gets no native copy, and an intact
+    managed native copy of it is removed through uninstall (backup, transaction, rollback). Returns the
+    names still to install natively."""
+    from . import projection
+    for name, kind in sorted(projection.links(home, store).items()):
+        if kind == "modified" and name in names:
+            entry["kept"].append({"name": name, "status": "uniflow_link_modified",
+                                  "reason": guide.BROKEN_REASON + "; a cópia nativa em ~/.agents/skills continua valendo",
+                                  "fix": guide.broken_fix(name)})
+    projected = projection.projected("codex", home, store)
+    if not projected:
+        return install
+    selected = set(names)
+    # Names on their way into the store reach Codex by the same projection on its next start.
+    pending = (set(store_names) - projected - {"crow-behaviour"}) & set(install)
+    pending = {n for n in pending if n not in entry["unchanged"]}
+    native = {r["name"]: r["status"] for r in store.status([destinations("codex", home)[0]], sorted(pending)) if r["name"]}
+    pending = {n for n in pending if native.get(n, "absent") == "absent"}
+    entry["via_uniflow"] = sorted(set(entry["via_uniflow"]) | (projected & selected) | pending)
+    waiting.extend(sorted(pending))
+    dupes = projection.duplicates(home, store)
+    overwrite = bool(getattr(args, "overwrite_modified", False))
+    remove = [n for n in dupes["remove"] + (dupes["modified"] if overwrite else []) if n in selected]
+    entry["kept"] = [k for k in entry["kept"] if k["name"] not in projected]
+    for name in dupes["modified"]:
+        if name in selected and not overwrite:
+            entry["kept"].append({"name": name, "status": "duplicate_modified",
+                                  "reason": "cópia nativa editada que duplica a projeção do Uniflow no Codex",
+                                  "fix": "revise e, para remover com backup: crow-skills setup --agents codex --overwrite-modified --yes"})
+    for name in dupes["shared"]:
+        if name in selected:
+            entry["kept"].append({"name": name, "status": "duplicate_shared",
+                                  "reason": "cópia nativa também registrada para shared (diretório lido por outros hosts); "
+                                            "mantida, e o Codex a vê duas vezes",
+                                  "fix": "se nenhum outro host precisa dela: crow-skills uninstall " + name +
+                                         " --agents codex,shared --global --yes"})
+    if remove:
+        cli = _cli()
+        argv = ["uninstall", *remove, "--agents", "codex", "--global", "--json", "--home", str(home),
+                "--dry-run" if dry_run else "--yes"]
+        if overwrite:
+            argv.append("--overwrite-modified")
+        argv.append("--no-integrations")  # hooks/trust follow in the install/refresh step, with the run's --no-trust
+        data = cli.run(cli.parser().parse_args(argv))
+        entry["removed"] = [{"name": c["name"], "reason": DUPLICATE} for c in data["changes"] if c["action"] != "unchanged"]
+        entry["removal_transaction"] = data.get("transaction")
+    return [n for n in install if n not in projected and n not in pending]
+
+
 def machine_steps(args, home, store, dry_run):
     steps = {}
     # Crow mode: written as on only when the user never chose (no mode file).
@@ -409,6 +469,8 @@ def summarize(detected, entries, store, home, probe, dry_run, trust=True):
             parts.append(str(unchanged) + " já em dia")
         if entry.get("via_uniflow"):
             parts.append(str(len(entry["via_uniflow"])) + " via uniflow")
+        if entry.get("removed"):
+            parts.append(str(len(entry["removed"])) + (" a remover" if dry_run else " removidas") + " (duplicavam o Uniflow)")
         if kept:
             parts.append(str(len(kept)) + " mantidas")
         item["skills"] = ", ".join(parts) or "—"
@@ -466,7 +528,7 @@ def summarize(detected, entries, store, home, probe, dry_run, trust=True):
         elif kept or state in ("warn", "absent"):
             item["state"] = "warn"
         else:
-            item["state"] = "plan" if dry_run and (entry["changed"] or real_changes(entry.get("integrations"))) else "ok"
+            item["state"] = "plan" if dry_run and (entry["changed"] or entry.get("removed") or real_changes(entry.get("integrations"))) else "ok"
         summary.append(item)
     return summary
 
@@ -497,7 +559,7 @@ def setup(args, home, store, interactive):
     entries, steps = build(True)
     result = {"version": __version__, "revision": source.revision, "skills": names, "detected": detected, "agents": agents,
               "absent": [r["id"] for r in detected if not r["detected"]], "trust": not getattr(args, "no_trust", False)}
-    pending = any(e["changed"] or real_changes(e.get("integrations")) or real_changes(e.get("guides"))
+    pending = any(e["changed"] or e.get("removed") or real_changes(e.get("integrations")) or real_changes(e.get("guides"))
                   for e in entries) or any(s["state"] == "plan" for s in steps.values())
     if dry_run or not agents:
         summary = summarize(detected, entries, store, home, False, True)
@@ -564,11 +626,21 @@ def upgrade_summary(skills, dry_run):
         agent = s["agent"]
         item = {"agent": agent, "label": AGENT_LABELS.get(agent, agent), "changed": s.get("updated") or [],
                 "unchanged": s.get("unchanged", 0), "kept": s.get("kept") or [], "via_uniflow": len(s.get("via_uniflow") or []),
+                "removed": [r["name"] for r in s.get("removed") or []],
                 "needs_user": []}
         for k in item["kept"]:
             if k["status"] in ("modified", "missing"):
                 item["needs_user"].append(k["name"] + " editada localmente; para substituir com backup: crow-skills update " +
                                           k["name"] + " --agents " + agent + " --global --overwrite-modified --yes")
+            elif k["status"] == "duplicate_modified":
+                item["needs_user"].append(k["name"] + " (cópia nativa editada) duplica a projeção do Uniflow no Codex; para remover "
+                                          "com backup: crow-skills setup --agents codex --overwrite-modified --yes")
+            elif k["status"] == "uniflow_link_modified":
+                item["needs_user"].append(k["name"] + ": a entrada do store do Uniflow foi editada ou perdeu arquivos; para "
+                                          "restaurá-la com backup: " + k.get("fix", "crow-skills update " + k["name"] +
+                                          " --agents uniflow --global --overwrite-modified --yes").split(": ", 1)[-1])
+            elif k["status"] == "duplicate_shared":
+                item["needs_user"].append(k["name"] + " duplica a projeção do Uniflow no Codex, mas também é de shared; mantida")
             elif k["status"] == "other_origin":
                 item["needs_user"].append(k["name"] + " instalada de outra origem; para trocar: crow-skills install " +
                                           k["name"] + " --agents " + agent + " --global --yes")
@@ -576,7 +648,7 @@ def upgrade_summary(skills, dry_run):
                 item["needs_user"].append(k["name"] + ": " + k["status"])
         if s.get("error"):
             item["needs_user"].insert(0, s["error"]["message"])
-        item["state"] = "fail" if s.get("error") else ("warn" if item["needs_user"] else ("plan" if dry_run and item["changed"] else "ok"))
+        item["state"] = "fail" if s.get("error") else ("warn" if item["needs_user"] else ("plan" if dry_run and (item["changed"] or item["removed"]) else "ok"))
         rows.append(item)
     return rows
 
@@ -698,8 +770,11 @@ def render_upgrade(data, stream=None):
     rows = []
     for item in data.get("summary", []):
         changed = ", ".join(item["changed"]) if len(item["changed"]) <= 3 else str(len(item["changed"])) + " skills"
+        removed = ((" · " if changed else "") + str(len(item["removed"])) + (" a remover" if dry else " removidas") +
+                   " (duplicavam o Uniflow)") if item.get("removed") else ""
         rows.append([ui.mark(STATE_MARK[item["state"]], stream), item["label"],
-                     (("a atualizar: " if dry else "atualizadas: ") + changed) if changed else "sem mudanças",
+                     ((("a atualizar: " if dry else "atualizadas: ") + changed) if changed else ("" if removed else "sem mudanças"))
+                     + removed,
                      str(item["unchanged"]), str(item.get("via_uniflow", 0)), str(len(item["kept"]))])
     if rows:
         lines.append("")

package/crow_skills/projection.py

@@ -0,0 +1,128 @@
+"""Uniflow's projection of its store into Codex's own skills dir ($CODEX_HOME/skills, default ~/.codex/skills).
+
+Codex scans both $CODEX_HOME/skills and ~/.agents/skills (where crow-skills installs for codex), follows
+symlinks and lists a same-name skill twice when the two entries resolve to different directories. Uniflow
+links ~/.codex/skills/crow-x -> <store>/crow-x, so a native copy in ~/.agents/skills duplicates it.
+
+A link counts as the codex install of a skill ("via uniflow") only when it resolves to <store>/<name> and
+that store entry is crow-skills-managed (guide.store_managed); a store entry Uniflow disabled is reported as
+disabled; a link to anything else is ignored. A link ~/.codex/skills/crow-x -> ~/.agents/skills/crow-x is an
+alias Codex deduplicates by canonical path: harmless, never touched.
+"""
+import os
+from pathlib import Path
+
+from .agents import destinations, real_home, uniflow_store
+from .source import CrowError
+
+
+def codex_home(home):
+    """$CODEX_HOME for the real profile (as Codex resolves it); an isolated --home uses <home>/.codex."""
+    home = Path(home)
+    if real_home(home) and os.environ.get("CODEX_HOME"):
+        return Path(os.path.abspath(Path(os.environ["CODEX_HOME"]).expanduser()))
+    return Path(os.path.abspath(home / ".codex"))
+
+
+def codex_skills_dir(home):
+    return codex_home(home) / "skills"
+
+
+def links(home, store):
+    """{name: "managed" | "disabled" | "modified" | "unmanaged" | "alias" | "other"} for crow-* symlinks in Codex's own
+    skills dir: to an intact managed / Uniflow-disabled / edited-or-incomplete managed / hand-written store entry, to our
+    own copy, or elsewhere. Only "managed" counts as the codex install and allows removing a native duplicate."""
+    directory = codex_skills_dir(home)
+    try:
+        if directory.is_symlink() or not directory.is_dir():
+            return {}
+        entries = [p for p in directory.iterdir() if p.name.startswith("crow-") and p.is_symlink()]
+    except OSError:
+        return {}
+    if not entries:
+        return {}
+    store_dir = uniflow_store(home)
+    native = Path(destinations("codex", home)[0]["path"])
+    from .guide import store_statuses
+    statuses = store_statuses(home, store)  # only an intact ("installed") store entry is a working codex install
+    result = {}
+    for link in entries:
+        name = link.name
+        resolved = os.path.realpath(link)
+        if resolved == os.path.realpath(native / name):
+            result[name] = "alias"
+        elif (resolved == os.path.realpath(store_dir / name) and (store_dir / name).is_dir()
+              and not (store_dir / name).is_symlink()):
+            state = statuses.get(name)
+            result[name] = {"installed": "managed", "disabled": "disabled", "modified": "modified",
+                            "missing": "modified"}.get(state, "unmanaged")
+        else:
+            result[name] = "other"
+    return result
+
+
+def status_rows(home, store, rows):
+    """Rows for `status`/`doctor`: Codex's view through Uniflow's links, as a destination of its own."""
+    directory = str(codex_skills_dir(home))
+    extra = []
+    for name, kind in sorted(links(home, store).items()):
+        if kind == "managed":
+            extra.append({"name": name, "target": directory, "agents": ["codex"], "status": "uniflow_link", "revision": None,
+                          "activation_verified": False, "projection": "codex_home",
+                          "note": "Link do Uniflow em " + directory + " para o store; é a instalação do codex (via uniflow)."})
+        elif kind == "disabled":
+            extra.append({"name": name, "target": directory, "agents": ["codex"], "status": "disabled", "revision": None,
+                          "activation_verified": False, "projection": "uniflow_link_disabled",
+                          "note": "Desabilitada no Uniflow (SKILL.md.disabled no store); reabilite no Uniflow para usar."})
+        elif kind == "modified":
+            from .guide import BROKEN_REASON, broken_fix
+            extra.append({"name": name, "target": directory, "agents": ["codex"], "status": "modified", "revision": None,
+                          "activation_verified": False, "projection": "uniflow_link_modified",
+                          "note": BROKEN_REASON[0].upper() + BROKEN_REASON[1:] + ". Para corrigir: " + broken_fix(name)})
+        elif kind == "unmanaged":
+            extra.append({"name": name, "target": directory, "agents": ["codex"], "status": "unmanaged", "revision": None,
+                          "activation_verified": False, "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 extra
+
+
+def projected(agent, home, store):
+    """Names Codex already sees through a managed Uniflow projection (empty for other agents)."""
+    if agent != "codex":
+        return set()
+    return {n for n, kind in links(home, store).items() if kind == "managed"}
+
+
+def native_target(agent, target, home):
+    """target is the user-scope codex install dir (not --project/--dest)."""
+    return agent == "codex" and os.path.abspath(target["path"]) == os.path.abspath(destinations("codex", home)[0]["path"])
+
+
+def duplicates(home, store):
+    """Native copies in ~/.agents/skills that duplicate a managed projection, by what can be done with them.
+
+    Returns {"remove": [...], "modified": [...], "shared": [...]}: "remove" are crow-skills-managed and intact;
+    "modified" were edited locally (kept unless --overwrite-modified); "shared" are also recorded for another
+    agent of that dir (shared), which may rely on them."""
+    names = projected("codex", home, store)
+    result = {"remove": [], "modified": [], "shared": []}
+    if not names:
+        return result
+    target = destinations("codex", home)[0]
+    try:
+        rows = {r["name"]: r for r in store.status([target], sorted(names)) if r["name"]}
+        records = store.state(target["path"])["installed"]
+    except (CrowError, OSError):
+        return result
+    for name in sorted(names):
+        row = rows.get(name)
+        if not row or row["status"] not in ("installed", "modified", "missing"):
+            continue  # absent, unmanaged or unreadable: nothing of ours to remove
+        if set(records.get(name, {}).get("agents") or ["codex"]) - {"codex"}:
+            result["shared"].append(name)
+        elif row["status"] == "installed":
+            result["remove"].append(name)
+        else:
+            result["modified"].append(name)
+    return result

package/docs/cli.md

@@ -1,4 +1,4 @@
-# crow-skills CLI 0.11.0
+# crow-skills CLI 0.11.1
 
 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 lines do Claude Code, do Codex e do Antigravity, hooks do modo crow em cada CLI, comando `/crow`, segmento tmux); `--no-integrations` desliga. `crow-skills mode on|off` liga e desliga a crow-behaviour em [todas as sessões e CLIs](#modo-crow-mode); `crow-skills progress` mostra o [painel de progresso](#progresso-progress) da execução ativa; `crow-skills events` expõe o [barramento de eventos](#eventos-events) dos hooks; `crow-skills autoupdate on` liga a [atualização automática](#atualização-automática-autoupdate).
 
@@ -81,7 +81,7 @@ Para testar/distribuir o arquivo local sem registry:
 
 ```sh
 npm pack
-npm install -g ./andespindola-crow-skills-0.11.0.tgz --ignore-scripts
+npm install -g ./andespindola-crow-skills-0.11.1.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.
@@ -217,6 +217,18 @@ O Uniflow guarda as skills num store próprio e cria, ao subir cada CLI, links d
 - 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`.
 
+#### Codex e a projeção do Uniflow
+
+O Codex lê duas raízes de skills do usuário: `$CODEX_HOME/skills` (padrão `~/.codex/skills`, onde o Uniflow liga o store) e `~/.agents/skills` (onde o crow-skills instala para o codex). Ele segue symlinks e lista duas vezes uma skill de mesmo nome quando as duas entradas apontam para diretórios diferentes. Por isso:
+
+- Um link `~/.codex/skills/crow-x` → `<store>/crow-x`, com a entrada do store gerenciada pelo crow-skills, conta como a instalação do codex (`via uniflow`). Entrada desabilitada no Uniflow aparece como `disabled`; entrada escrita à mão, como não gerenciada (com o mesmo motivo e correção do resto do Uniflow). `CODEX_HOME` vale para o perfil real; `--home` isolado usa `<home>/.codex`.
+- `setup` e `upgrade` não criam cópia nativa em `~/.agents/skills` para esses nomes e removem, pelo `uninstall` normal (backup, transação, `rollback`), as cópias nativas gerenciadas e intactas que duplicam a projeção (`removida: duplicava a projeção do Uniflow`). Uma cópia editada fica, com aviso e a dica `--overwrite-modified`. Uma cópia também registrada para `shared` (`--agents codex,shared`: o diretório é lido por outros hosts) fica, porque outro host pode depender dela; o motivo e o comando aparecem no resumo.
+- `install --agents codex` não cria cópia nativa de um nome projetado (`codex_projection.via_uniflow` no resumo) e nunca remove nada: as duplicatas existentes aparecem em `codex_projection.duplicates`, com `suggested_command`. Com `--agents codex,shared` instala como antes.
+- A crow-behaviour continua nativa onde o Uniflow não a projeta, e o guia, as integrações e os hooks do Codex seguem funcionando; quando ela é projetada, o guia conta a projeção.
+- Um link `~/.codex/skills/crow-x` → `~/.agents/skills/crow-x` é só um apelido (o Codex o deduplica pelo caminho canônico): nunca é alterado nem removido.
+- `status`/`doctor` mostram `~/.codex/skills` como um destino do codex (`N skills (N via uniflow)`). Duplicatas geram o aviso `codex_duplicates` (`warnings`) com o comando que resolve; o doctor continua `healthy:true`, porque as duas cópias estão íntegras e funcionam (o Codex só as lista duas vezes).
+
+
 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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/crow-skills",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "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": "fe7ae8fa72f3edc6ed2845ed276aeab3e56cd4f8e4a4dea13e0d1adf578107ca"
+      "sha256": "2f357dd4b258621fb3801702907a33b371ec0ff3350f6c9107b60d5c98a736b1"
     },
     "bin/npm-crow-skills.cjs": {
       "executable": true,
@@ -18,7 +18,7 @@
     "crow_skills/__init__.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "eda470f1bc8d44a9fcee33f2506a91d677b853668c17afc696f2f87b37b8cc3c"
+      "sha256": "e2a03185ed4cda7560a68844180c6b1dd684ff3314befe8f0ba978f3e45daf49"
     },
     "crow_skills/__main__.py": {
       "executable": false,
@@ -33,7 +33,7 @@
     "crow_skills/autoupdate.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "b994bd426a3aa3091bfc49bedc3f63a4df632e431c3f193bbe1873fbe42d6d67"
+      "sha256": "bbe3c38f93d8f6e70c0ec428e3d383d7248c61c07c774420c4c47e27c7e9def5"
     },
     "crow_skills/broadcast.py": {
       "executable": false,
@@ -43,7 +43,7 @@
     "crow_skills/cli.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "9839fabde672833229a589ae027a3a23e42673a4117419e640622c411048ee94"
+      "sha256": "1d0730dcfc0bfd2d11747aef884f4bbca9eb7768ce0dd321f0cb7e5506419ab5"
     },
     "crow_skills/events.py": {
       "executable": false,
@@ -58,7 +58,7 @@
     "crow_skills/guide.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "12fe2d42175a971ff9369571186d6a46b9f94da257ab286cecbc0e213ba8b4a8"
+      "sha256": "5b2767b58439c55d1f1d439bc04a9769c54aba2e59a1680aa00a97ba4f5efd0d"
     },
     "crow_skills/hook.py": {
       "executable": false,
@@ -73,7 +73,7 @@
     "crow_skills/machine.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "f8ea1f41256cd7df9579d658cd78087a094e8d31342394fd4b4a911cc8011616"
+      "sha256": "f48bb54b7816ce0fc62e68694dd970f699d355e60db2fb2eab651291294c7012"
     },
     "crow_skills/npm_entry.py": {
       "executable": false,
@@ -85,6 +85,11 @@
       "kind": "file",
       "sha256": "b4c34e8abf29656d38771b0d0ea87664babaeab63507df8c50ac5f248cbe0dc3"
     },
+    "crow_skills/projection.py": {
+      "executable": false,
+      "kind": "file",
+      "sha256": "0f6a7c788e58cc54752bbf293f107a2a8e731cacefa2dcd95d3f4998f2866d4a"
+    },
     "crow_skills/resources.py": {
       "executable": false,
       "kind": "file",
@@ -118,12 +123,12 @@
     "docs/cli.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "918d426b725899b2140df76dac40e147af987f8d4c0164b0c4a290df7f67ed50"
+      "sha256": "4b39fe944290967c083cd79af886a96653ab334a7dbde6d4ad0a5c7059d38503"
     },
     "package.json": {
       "executable": false,
       "kind": "file",
-      "sha256": "c4d7a50a924470c4e4ee4a27b1ce796ca0db0296d8b3f48e13ea7badc72e1ea3"
+      "sha256": "2a4fda62a127bf8ddbd35323f698e2886dda6360d41100126cdb8ba05b2a4c32"
     },
     "skills/crow-accessibility/SKILL.md": {
       "executable": false,
@@ -686,7 +691,7 @@
       "sha256": "e37132ef8b060548191fbf14a5a18a9dd3acd84ea9a35e802174455b9e374d3d"
     }
   },
-  "revision": "e06686f7886a5c816ea91a11ff01197c61cc8fe0",
+  "revision": "06d4a9e1e39dad6c977807ee67f00fa5ed311dd1",
   "schema_version": 1,
-  "version": "0.11.0"
+  "version": "0.11.1"
 }