@andespindola/crow-skills 0.13.1 → 0.15.0

package/crow_skills/cli.py

@@ -18,7 +18,7 @@ from . import projection
 from . import resources
 from . import machine
 from . import ui
-from .agents import AGENTS, destinations, inventory
+from .agents import AGENTS, destinations, inventory, legacy_shared_dir
 from .source import CrowError, Source, valid_name
 from .storage import Store, checked
 
@@ -166,6 +166,12 @@ def parser():
                            help="Não aplicar/remover as integrações de interface (status line, tmux) em --global")
         if name != "uninstall":
             child.add_argument("--no-trust", action="store_true", help=TRUST_HELP)
+        if name == "uninstall":
+            # Interno: a migração da pasta compartilhada roda como um uninstall logo depois de um
+            # install, e precisa ficar atrelada a ele para que um rollback do install desfaça os dois.
+            child.add_argument("--linked-to", dest="linked_to", metavar="TXID", default=argparse.SUPPRESS,
+                               help=argparse.SUPPRESS)  # SUPPRESS: ausente não cria atributo, então
+            # uma invocação existente continua parseando com exatamente o mesmo conjunto de atributos.
     child = command_parser(sub, "guide", [common])
     child.add_argument("action", choices=("install", "status", "uninstall"))
     child.add_argument("--replace", action="store_true", help="Autorizar backup e substituição de conteúdo não gerenciado no caminho do guia")
@@ -367,9 +373,9 @@ def guide_sync(args, home, store, command, targets, plan, source):
     return report, gplan
 
 
-def apply_chain(store, plan, gplan, home):
+def apply_chain(store, plan, gplan, home, linked=None):
     """Skills first, then the guide; a failed guide rolls the skills back."""
-    txid = store.apply(plan)
+    txid = store.apply(plan, linked=linked)
     if gplan is None:
         return txid, None
     try:
@@ -716,24 +722,31 @@ def resync_integrations(home, store):
         pass  # Reported by status/doctor; never turns a completed rollback into a failure.
 
 
+def linked_transactions(store, txid):
+    """Committed transactions that COMPLETE the given one and must be undone before it: the guide,
+    and the uninstall that migrated the legacy shared folder after an install."""
+    return [t["id"] for t in store.transactions()
+            if t.get("linked") == txid and t["phase"] == "committed"]
+
+
 def linked_guides(store, txid):
     """Committed guide transactions that completed the given skills transaction."""
     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).
+# Every CLI, codex included since 0.15.0, has its skills installed in its OWN dir, the same one
+# Uniflow links into, so a native copy of a name always just wins there (no second directory).
 NATIVE_EFFECT = {
     "claude": "skipped", "gemini": "skipped", "devin": "skipped",
-    "codex": "both",
+    "codex": "skipped",
 }
 
 
 def uniflow_notice(home, store, targets, plan):
     """Installing into the Uniflow store while native crow-* copies remain. Uniflow does
     not link a name a CLI already has in the same dir, so that copy (possibly another
-    revision) wins there; codex reads ~/.agents/skills and Uniflow's ~/.codex/skills
-    link, so it sees both. Report it and the explicit command; never remove anything."""
+    revision) wins there. Report it and the explicit command; never remove anything."""
     if not any("uniflow" in t["agents"] for t in targets):
         return None
     names = sorted({c["name"] for c in plan["changes"] if "uniflow" in c["agents"]})
@@ -765,8 +778,9 @@ def uniflow_notice(home, store, targets, plan):
                 for names_, agents_ in groups.items()]
     return {"native_duplicates": list(native.values()), "uninspected": uninspected,
             "note": "effect=skipped: o Uniflow não cria o link de um nome que o agente já tem nativo, e essa cópia vale no lugar do "
-                    "store. 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.",
+                    "store. Desde a 0.15.0 nenhum destino produz effect=both: todo CLI instala no diretório dele, o mesmo em que o "
+                    "Uniflow projeta o store, então não há uma segunda raiz em que o mesmo nome apareça de novo. Nada foi removido. "
+                    "Remover a cópia nativa de crow-behaviour remove também o guia daquele agente.",
             "suggested_commands": commands, "suggested_command": " && ".join(commands) if commands else None}
 
 
@@ -803,7 +817,7 @@ 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
+        return None  # a dir shared with another agent is not Codex's own projected dir
     projected = projection.projected("codex", home, store)
     if not projected:
         return None
@@ -946,16 +960,30 @@ def run(args):
                   "mode": hook.read_mode(home), "activation_verified": False,
                   "reload_hint": "Peça ao host para recarregar/listar skills; reinicie a sessão se necessário."}
         if any(projection.native_target("codex", t, home) for t in targets):
-            rows += projection.status_rows(home, store, rows)
+            rows[:] = projection.status_rows(home, store, rows)  # enriquece no lugar; += contaria duas vezes
             dupes = projection.duplicates(home, store)
             names_ = dupes["remove"] + dupes["modified"] + dupes["shared"]
             if names_:
                 # A warning, not unhealthy: both copies are intact and work; Codex just lists them twice.
-                result["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.setdefault("warnings", []).append({"code": "codex_duplicates", "skills": names_,
+                                       "message": "O Codex vê " + str(len(names_)) + " skill(s) duas vezes: cópia antiga na pasta "
+                                                  "compartilhada " + str(legacy_shared_dir(home)) + " e a instalação em "
+                                                  + str(projection.codex_skills_dir(home)) + ". O crow-skills não usa mais a pasta "
+                                                  "compartilhada; remover as cópias de lá encerra a duplicação.",
+                                       "fix": "crow-skills uninstall " + ",".join(names_) + " --dest "
+                                              + str(legacy_shared_dir(home)) + " --yes"
+                                              + (" --overwrite-modified" if dupes["modified"] else "")})
+            leftovers = [n for n in projection.legacy_leftovers(home, store) if n not in names_]
+            if leftovers:
+                # Sem Uniflow nada disso duplica uma projeção, então o aviso acima nunca apareceria
+                # e uma instalação feita pela 0.14.0 ficaria invisível aqui, ainda carregada pelo Codex.
+                result.setdefault("warnings", []).append(
+                    {"code": "codex_legacy_shared", "skills": leftovers,
+                     "message": "O crow-skills ainda tem " + str(len(leftovers)) + " skill(s) instalada(s) na pasta "
+                                "compartilhada antiga " + str(legacy_shared_dir(home)) + ", que esta versão não usa mais; o "
+                                "Codex continua carregando de lá.",
+                     "fix": "crow-skills setup --agents codex --yes  (instala no diretório do Codex e migra), ou "
+                            "crow-skills uninstall " + ",".join(leftovers) + " --dest " + str(legacy_shared_dir(home)) + " --yes"})
         result["groups"] = group_coverage(rows)
         try:
             result["autoupdate"] = autoupdate.status(store, home) if global_view else None
@@ -983,7 +1011,7 @@ def run(args):
         # on recover, an interrupted guide also undoes the skills it completed.
         follow = []
         if args.command == "rollback":
-            before_ids = [g for txid in ids for g in linked_guides(store, txid)]
+            before_ids = [g for txid in ids for g in linked_transactions(store, txid)]
             ids, transactions = before_ids + ids, [store.journal(t) for t in before_ids] + transactions
         else:
             follow = [t["linked"] for t in transactions if t.get("linked")
@@ -1064,15 +1092,19 @@ def run(args):
         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}
+                    "; nenhuma cópia é criada para o codex. As cópias que ficaram na pasta compartilhada antiga "
+                    + str(legacy_shared_dir(home)) + " duplicam a projeção e não são removidas por install; remova-as com o "
+                    "comando sugerido ou rode crow-skills setup --yes.",
+            # --dest, nunca --agents codex: esses nomes, no diretório do Codex, são links do Uniflow, e
+            # o uninstall ali recusaria com unsafe_destination.
+            "suggested_command": ("crow-skills uninstall " + " ".join(codex_view["duplicates"]) + " --dest "
+                                  + str(legacy_shared_dir(home)) + " --yes") if codex_view["duplicates"] else None}
     if plan["items"] or (gplan and gplan["items"]) or ui.get("changes"):
         authorize(args, interactive, summary)
     txid = None
     if not getattr(args, "dry_run", False):
-        txid, guides["transaction"] = apply_chain(store, plan, gplan, home)
+        txid, guides["transaction"] = apply_chain(store, plan, gplan, home,
+                                                  linked=getattr(args, "linked_to", None))
         if not ui.get("disabled"):
             # Best effort after the skills/guide transactions; a refusal is reported, never undoes them.
             try:

package/crow_skills/guide.py

@@ -52,7 +52,6 @@ MECHANISMS = {
               "load": "use a ferramenta de skills do Devin ou digite /devin:nome"},
 }
 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.

package/crow_skills/hook.py

@@ -21,8 +21,9 @@ seconds, so most prompts cost one small file read).
 
 crow-broadcast (crow_broadcast.py, copied beside this file): every event also
 keeps the session's presence (git repository, CLI pid, PATHS of files its edit
-tools target) in the snapshot; a prompt event appends a short digest of other
-live sessions in the same repository, only when there are any; ``--check``
+tools target, and the clones its shell calls reach) in the snapshot; a prompt
+event always appends the crow-broadcast block: the digest of the other live
+sessions that touch this work, or one line saying the check found none; ``--check``
 (a synchronous PreToolUse entry for edit and shell tools) warns about another
 live session on the same file or clone without writing anything.
 
@@ -238,13 +239,20 @@ def broadcast_module():
     return _BROADCAST or None
 
 
-def resource_hint(home):
-    """The one-line memory hint, or None (no pressure, no probe, or any failure)."""
+def resource_hint(home, write_through=True):
+    """The one-line memory hint, or None (no pressure, no probe, or any failure).
+
+    write_through=False for `--probe`: the reading is still taken, but a cache miss must not write
+    resources-cache.json, or "exercise the hook without writing anything" would be false."""
     module = resources_module()
     if module is None:
         return None
     try:
-        text = module.hint(module.probe(home, processes=False, use_cache=True))
+        try:
+            reading = module.probe(home, processes=False, use_cache=True, write_through=write_through)
+        except TypeError:  # crow_resources.py copy older than this hook
+            reading = module.probe(home, processes=False, use_cache=True)
+        text = module.hint(reading)
         if text and hasattr(module, "orphan_hint"):
             text += module.orphan_hint(home)  # last orphan scan, a file read: no ps call per prompt
         return text
@@ -419,11 +427,20 @@ def update_session(home, event, extra=None, fallback_cwd=None, presence=None):
             snap.update(extra)
         if presence:
             module, touched, ppid = presence[:3]
+            # (…, cli pid resolved from the process table on Stop/SessionEnd, shell directories)
+            extra = {}
+            if len(presence) > 3 and presence[3]:
+                extra["cli_pid"] = presence[3]
+            if len(presence) > 4 and presence[4]:
+                extra["dirs"] = presence[4]
+            # A crow_broadcast.py copy older than this hook has no "dirs" parameter. The signature is
+            # inspected instead of catching TypeError: a TypeError raised INSIDE fold would otherwise
+            # re-run it over a snapshot it had already half-mutated.
+            code = getattr(getattr(module, "fold", None), "__code__", None)
+            if "dirs" not in getattr(code, "co_varnames", ()):
+                extra.pop("dirs", None)
             try:
-                if len(presence) > 3:  # (…, cli pid resolved from the process table on Stop/SessionEnd)
-                    module.fold(snap, event, touched, ppid=ppid, cli_pid=presence[3])
-                else:
-                    module.fold(snap, event, touched, ppid=ppid)
+                module.fold(snap, event, touched, ppid=ppid, **extra)
             except Exception:  # noqa: BLE001 - presence is best effort
                 pass
         write_json(path, snap)
@@ -695,7 +712,7 @@ def check_only(host, raw, payload, home):
     return broadcast_check(host, raw, home, module, me, touched, tree)
 
 
-def handle(host, raw, payload, home, env=None, check=False):
+def handle(host, raw, payload, home, env=None, check=False, probe=False):
     """Process one hook call; returns the JSON to print (or None). Never raises to the caller."""
     env = os.environ if env is None else env
     if host not in HOSTS or not isinstance(payload, dict) or foreign(host, payload, env, home):
@@ -704,7 +721,7 @@ def handle(host, raw, payload, home, env=None, check=False):
         return check_only(host, raw, payload, home)
     event = normalise(host, raw, payload)
     current = read_mode(home)
-    if raw in PROMPT_EVENTS:
+    if raw in PROMPT_EVENTS and not probe:
         text = prompt_text(payload)
         match = COMMAND.match(text) if text and len(text) < 64 else None
         if match and host in ("codex", "devin", "agy"):
@@ -719,7 +736,7 @@ def handle(host, raw, payload, home, env=None, check=False):
     # 0.9.0 cost; the snapshot's updatedAt is the heartbeat.
     wanted = raw in PROMPT_EVENTS or raw == "SessionStart" or \
         (event["event"] in ("tool_start", "tool_end") and event.get("tool") in BROADCAST_TOOLS)
-    module, presence, touched, tree, checked = broadcast_module() if wanted else None, None, [], [], []
+    module, presence, touched, tree, checked, dirs = broadcast_module() if wanted else None, None, [], [], [], []
     if module is not None:
         try:
             cfg = module.config(home)
@@ -729,7 +746,10 @@ def handle(host, raw, payload, home, env=None, check=False):
                     cwd = event.get("cwd") or process_cwd()
                     touched = module.edit_paths(host, event.get("tool"), tool_input, cwd)
                     checked = list(touched)
-                    tree = module.tree_command(host, event.get("tool"), tool_input, cwd)
+                    try:  # one parse for both: work-tree targets and the clones the call reaches
+                        tree, dirs = module.shell_scan(host, event.get("tool"), tool_input, cwd)
+                    except (AttributeError, TypeError):  # older crow_broadcast.py copy beside this hook
+                        tree, dirs = module.tree_command(host, event.get("tool"), tool_input, cwd), []
                     if touched and cfg["block_on_conflict"]:
                         # An edit the conflict check is about to refuse is not published as this
                         # session's: otherwise the session that edited first would be locked out too.
@@ -738,13 +758,22 @@ def handle(host, raw, payload, home, env=None, check=False):
                         mine = dict(mine, key=key, cwd=mine.get("cwd") or cwd)
                         if module.check(home, key, mine, touched, (), cfg=cfg)[1]:
                             touched = []
-                presence = (module, touched, os.getppid())
+                presence = (module, touched, os.getppid(), None, dirs)
             else:
                 module = None
         except Exception:  # noqa: BLE001 - the broadcast never breaks the event
             module, presence = None, None
-    stamped, snap = record(home, dict(event, mode=current["mode"]), snapshot=True, fallback_cwd=process_cwd(), presence=presence)
-    if raw in STOP_EVENTS:
+    if probe:
+        # Everything a real event would compute, nothing it would write: no event appended, no session
+        # snapshot, no presence. Validating that a CLI's hook is wired must never invent a live session.
+        stamped = dict(event, mode=current["mode"])
+        snap = {"key": session_key(host, event.get("session"), event.get("cwd")), "host": host,
+                "session": event.get("session"), "cwd": event.get("cwd") or process_cwd(),
+                "state": "working", "presence": {}}
+    else:
+        stamped, snap = record(home, dict(event, mode=current["mode"]), snapshot=True, fallback_cwd=process_cwd(),
+                              presence=presence)
+    if raw in STOP_EVENTS and not probe:
         cli = record_processes(home, host, event)
         if cli and snap is not None:
             bmod = broadcast_module()
@@ -773,12 +802,12 @@ def handle(host, raw, payload, home, env=None, check=False):
     stamp = current["mode"] + "@" + str(current["updatedAt"])
     if host in ("codex", "gemini", "devin") and (raw == "SessionStart" or (seen and seen != stamp)):
         system = indicator(current["mode"])  # visible line only at start or when the mode changed
-    if snap is not None and seen != stamp:
+    if snap is not None and seen != stamp and not probe:
         update_session(home, dict(stamped, event="other"), {"modeSeen": stamp, "mode": current["mode"]})
     if raw == "SessionStart":
         return output_for(host, raw, system=system) if system else None
     context = context_line(current["mode"])
-    memory = resource_hint(home)
+    memory = resource_hint(home, write_through=not probe)
     if memory:
         context += "\n" + memory
     if module is not None and snap is not None:
@@ -841,8 +870,8 @@ def fast_hook_args(argv):
         if name in ("--host", "--event", "--home") and i + 1 < len(argv):
             values[name[2:]] = argv[i + 1]
             i += 2
-        elif name == "--check":
-            flags.add("check")
+        elif name in ("--check", "--probe"):
+            flags.add(name[2:])
             i += 1
         else:
             return None
@@ -850,7 +879,7 @@ def fast_hook_args(argv):
         return None
     import types
     return types.SimpleNamespace(command="hook", host=values["host"], event=values["event"], home=values.get("home"),
-                                 check="check" in flags)
+                                 check="check" in flags, probe="probe" in flags)
 
 
 def main(argv=None):
@@ -869,6 +898,8 @@ def parse_args(argv):
     hook.add_argument("--event", required=True)
     hook.add_argument("--home")
     hook.add_argument("--check", action="store_true")
+    # Exercise the hook without side effects: validating a CLI's wiring must not register a session.
+    hook.add_argument("--probe", action="store_true")
     mode = sub.add_parser("mode")
     mode.add_argument("action", nargs="?", default="status", choices=("on", "off", "status", "toggle"))
     mode.add_argument("--home")
@@ -895,11 +926,11 @@ def run_main(args):
     try:
         raw = sys.stdin.buffer.read(MAX_STDIN + 1) if not sys.stdin.isatty() else b""
         payload = json.loads(raw.decode("utf-8")) if raw.strip() and len(raw) <= MAX_STDIN else {}
-        result = handle(args.host, args.event, payload, home, check=args.check)
+        result = handle(args.host, args.event, payload, home, check=args.check, probe=getattr(args, "probe", False))
         if result:
             sys.stdout.write(json.dumps(result, ensure_ascii=False) + "\n")
             sys.stdout.flush()
-        if args.event == "SessionStart" and not args.check:
+        if args.event == "SessionStart" and not args.check and not getattr(args, "probe", False):
             prune_sessions(home)
             module = broadcast_module()
             if module is not None:

package/crow_skills/machine.py

@@ -30,7 +30,7 @@ from . import hook
 from . import integrations
 from . import resources
 from . import ui
-from .agents import destinations, uniflow_config_dir
+from .agents import destinations, legacy_shared_dir, uniflow_config_dir
 from .source import CrowError, Source
 from .storage import Store
 
@@ -251,6 +251,9 @@ def configure_agent(args, home, store, agent, names, dry_run, store_names=()):
         if not install:
             entry.update(refresh_extras(agent, home, dry_run, not getattr(args, "no_trust", False), getattr(args, "source", None),
                                         getattr(args, "ref", None), replace, overwrite))
+            if agent == "codex":
+                # Nada a instalar: o que vale como substituto é o que já está lá (unchanged).
+                migrate_legacy(args, home, store, entry, dry_run, planned=entry["unchanged"])
             return entry
         argv = ["install", *install, "--agents", agent, "--global", "--json", "--home", str(home),
                 "--dry-run" if dry_run else "--yes"]
@@ -275,22 +278,139 @@ def configure_agent(args, home, store, agent, names, dry_run, store_names=()):
     entry["transaction"] = data.get("transaction")
     if data.get("uniflow"):
         entry["uniflow"] = data["uniflow"]
+    if agent == "codex":
+        # Depois da instalação no diretório do Codex, nunca antes: a cópia legada só sai quando
+        # existe uma instalação no lugar novo. Num dry run o disco não foi tocado, então o que este
+        # run instalaria conta como substituto — senão o preview mentiria sobre o apply.
+        migrate_legacy(args, home, store, entry, dry_run,
+                       planned=(entry["changed"] + entry["unchanged"]) if dry_run else ())
     return entry
 
 
 DUPLICATE = "removida: duplicava a projeção do Uniflow"
 
 
+def migrate_legacy(args, home, store, entry, dry_run, planned=()):
+    """legacy_shared_step, but a failure there never costs the agent its result.
+
+    planned: names this run installs (or already has) in the CLI's own dir. In a dry run nothing is
+    written there, so without this the preview would judge every name as "has no replacement" and
+    predict the opposite of what the apply does."""
+    try:
+        legacy_shared_step(args, home, store, entry, dry_run, planned=planned)
+    except (CrowError, OSError, ValueError, KeyError, TypeError) as exc:
+        entry["legacy_shared"] = {"state": "warn", "note": "migração da pasta compartilhada antiga não concluída: " + str(exc),
+                                  "fix": "crow-skills doctor"}
+
+
+def legacy_shared_step(args, home, store, entry, dry_run, planned=()):
+    """Remove what crow-skills left in the legacy shared folder (~/.agents/skills), where codex
+    installed until 0.14.0, now that codex installs in its own dir.
+
+    duplicates() only sees names Uniflow projects, so a copy of a NON-projected skill (the
+    coordinator itself, typically) would otherwise stay there for ever and keep being listed by
+    Codex beside the real install. Only crow-skills-managed, intact copies go, through the normal
+    uninstall (backup, transaction, rollback); an edited copy, or one also recorded for another
+    agent of that dir, is kept and reported. Nothing that crow-skills did not install is touched.
+
+    A copy is removed ONLY when that name really works in Codex's own dir — an intact install of
+    ours, or a healthy Uniflow link. Otherwise the legacy copy is the only working skill Codex has
+    (a broken store entry leaves the link occupying the name in the new dir), and removing it would
+    take the skill away instead of migrating it.
+    """
+    legacy = legacy_shared_dir(home)
+    # Mesmo diretório (inclusive via symlink): não há nada para migrar e avisar seria ruído.
+    if os.path.realpath(legacy) == os.path.realpath(entry["target"]):
+        return
+    if legacy.is_symlink():
+        # Não seguimos symlink para apagar nada, mas quem tem a pasta nos dotfiles precisa saber
+        # que a migração não aconteceu, em vez de supor que aconteceu.
+        entry["legacy_shared"] = {"state": "warn", "action": "skip", "path": str(legacy),
+                                  "note": "a pasta compartilhada antiga é um symlink; nada foi tocado e a migração não "
+                                          "aconteceu. Mova o conteúdo você mesmo ou aponte --dest para o caminho físico."}
+        return
+    if not legacy.is_dir():
+        return
+    target = {"path": str(legacy), "agents": ["codex"]}
+    try:
+        records = store.state(target["path"])["installed"]
+        rows = {r["name"]: r for r in store.status([target], sorted(records)) if r["name"]}
+    except (CrowError, OSError) as exc:
+        entry["legacy_shared"] = {"state": "warn", "note": str(exc), "path": str(legacy)}
+        return
+    # What actually works in Codex's own dir right now: our intact install, or a healthy projection.
+    from . import projection
+    try:
+        own = {r["name"]: r["status"] for r in store.status([destinations("codex", home)[0]], sorted(records)) if r["name"]}
+    except (CrowError, OSError):
+        own = {}
+    try:
+        healthy = {k for k, kind in projection.links(home, store).items() if kind == "managed"}
+    except (CrowError, OSError):
+        healthy = set()
+    # One reason per name: a more specific one already recorded for this name (a broken projection,
+    # an unsafe target) explains it better than anything this step would add.
+    already = {k["name"] for k in entry.get("kept") or []}
+    remove, kept, deferred = [], [], []
+    for name in sorted(records):
+        row = rows.get(name)
+        if not row or row["status"] not in ("installed", "modified", "missing"):
+            continue  # unmanaged, absent or unreadable: not ours to remove
+        if name in already:
+            deferred.append(name)  # já explicado por uma razão mais específica deste mesmo nome
+            continue
+        if own.get(name) != "installed" and name not in healthy and name not in set(planned or ()):
+            kept.append({"name": name, "status": "legacy_shared_without_replacement",
+                         "reason": "a cópia na pasta compartilhada antiga é a única que funciona: no diretório do Codex "
+                                   "este nome não tem instalação íntegra nem projeção saudável do Uniflow",
+                         "fix": "conserte a instalação no diretório do Codex (por exemplo crow-skills setup --agents codex "
+                                "--yes, ou corrija a entrada do store do Uniflow) e rode de novo"})
+            continue
+        others = set(records.get(name, {}).get("agents") or ["codex"]) - {"codex"}
+        if others:
+            kept.append({"name": name, "status": "legacy_shared_of_another_agent",
+                         "reason": "também registrada para " + ",".join(sorted(others)) + " naquele diretório",
+                         "fix": "crow-skills uninstall " + name + " --dest " + str(legacy) + " --yes"})
+        elif row["status"] == "installed":
+            remove.append(name)
+        else:
+            kept.append({"name": name, "status": "legacy_shared_modified",
+                         "reason": "cópia editada na pasta compartilhada antiga",
+                         "fix": "crow-skills uninstall " + name + " --dest " + str(legacy) + " --overwrite-modified --yes"})
+    entry["kept"] += kept
+    if not remove:
+        # Nunca silencioso: se ainda há cópias nossas lá, o resumo diz que a pasta foi olhada e por
+        # que nada saiu — senão não há como auditar uma migração que não aconteceu.
+        if kept or deferred:
+            entry["legacy_shared"] = {"state": "warn", "action": "keep", "path": str(legacy),
+                                      "kept": [k["name"] for k in kept] + deferred}
+        return
+    argv = ["uninstall", *remove, "--dest", str(legacy), "--json", "--home", str(home),
+            "--dry-run" if dry_run else "--yes", "--no-integrations"]
+    if entry.get("transaction"):
+        # Atrelada à transação do install: um rollback dele restaura primeiro estas cópias, em vez
+        # de tirar a instalação nova e deixar o usuário sem nenhuma.
+        argv += ["--linked-to", entry["transaction"]]
+    data = _cli().run(_cli().parser().parse_args(argv))
+    entry["legacy_shared"] = {"state": "ok", "action": "plan" if dry_run else "remove", "path": str(legacy),
+                              "removed": [c["name"] for c in data["changes"] if c["action"] != "unchanged"],
+                              "transaction": data.get("transaction"),
+                              "note": "o crow-skills não usa mais a pasta compartilhada; as cópias de lá foram removidas "
+                                      "(com backup) agora que o codex instala no diretório dele"}
+
+
 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."""
+    """Codex sees its own dir (where crow-skills installs and Uniflow links its store) and also the legacy
+    shared ~/.agents/skills, so a copy left there by a version before 0.15.0 is still listed twice. A name
+    Codex sees via a managed projection gets no copy of its own, and an intact managed legacy copy of it is
+    removed through uninstall against that legacy dir (backup, transaction, rollback). Returns the names
+    still to install."""
     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",
+                                  "reason": guide.BROKEN_REASON + "; o link do Uniflow ocupa este nome no diretório do "
+                                            "Codex, então conserte a entrada do store",
                                   "fix": guide.broken_fix(name)})
     projected = projection.projected("codex", home, store)
     if not projected:
@@ -310,18 +430,20 @@ def codex_projection_step(args, home, store, entry, names, install, waiting, sto
     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",
+                                  "reason": "cópia editada na pasta compartilhada antiga, 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",
+                                  "reason": "cópia na pasta compartilhada antiga também registrada para outro agente que lê "
+                                            "aquele diretório; mantida, e o Codex a vê duas vezes",
                                   "fix": "se nenhum outro host precisa dela: crow-skills uninstall " + name +
-                                         " --agents codex,shared --global --yes"})
+                                         " --dest " + str(legacy_shared_dir(home)) + " --yes"})
     if remove:
         cli = _cli()
-        argv = ["uninstall", *remove, "--agents", "codex", "--global", "--json", "--home", str(home),
+        # The duplicates live in the legacy shared folder, never in Codex's own dir: --dest targets it
+        # explicitly, since no agent name points there any more.
+        argv = ["uninstall", *remove, "--dest", str(legacy_shared_dir(home)), "--json", "--home", str(home),
                 "--dry-run" if dry_run else "--yes"]
         if overwrite:
             argv.append("--overwrite-modified")
@@ -473,6 +595,16 @@ def summarize(detected, entries, store, home, probe, dry_run, trust=True):
             parts.append(str(len(entry["removed"])) + (" a remover" if dry_run else " removidas") + " (duplicavam o Uniflow)")
         if kept:
             parts.append(str(len(kept)) + " mantidas")
+        legacy = entry.get("legacy_shared") or {}
+        if legacy.get("removed"):
+            # Apagar diretórios do usuário nunca é silencioso: aparece na linha do agente e na nota,
+            # com o caminho, para quem só lê a saída humana saber o que saiu.
+            parts.append(str(len(legacy["removed"])) + (" a tirar" if dry_run else " tiradas") + " da pasta compartilhada antiga")
+            item["notes"].append(("a remover de " if dry_run else "removidas de ") + legacy.get("path", "?") + ": " +
+                                 ", ".join(legacy["removed"]))
+        elif legacy.get("state") == "warn":
+            item["notes"].append("pasta compartilhada antiga " + legacy.get("path", "?") + ": " +
+                                 (legacy.get("note") or ("mantidas " + ", ".join(legacy.get("kept") or []))))
         item["skills"] = ", ".join(parts) or "—"
         guides = entry.get("guides") or {}
         guide_change = next((c for c in guides.get("changes", []) if c.get("agent") == cli["agent"]), None)