@andespindola/crow-skills 0.27.1 → 0.28.0

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, legacy_shared_dir, uniflow_config_dir
+from .agents import destinations, legacy_shared_dir
 from .source import CrowError, Source
 from .storage import Store
 
@@ -47,12 +47,10 @@ CLIS = (
      "agent": "gemini", "integrations": ("agy-hooks", "agy-statusline")},
     {"id": "devin", "label": "Devin CLI", "binary": "devin",
      "config": lambda h: Path(destinations("devin", h)[0]["path"]).parent, "agent": "devin", "integrations": ("devin-hooks",)},
-    {"id": "uniflow", "label": "Uniflow", "binary": "uniflow", "config": uniflow_config_dir, "agent": "uniflow",
-     "integrations": ()},
     {"id": "tmux", "label": "tmux", "binary": "tmux", "flag": "-V", "config": None, "agent": None,
      "integrations": ("tmux-status",)},
 )
-AGENT_ORDER = ("claude", "codex", "gemini", "devin", "uniflow")  # natives first: the uniflow notice sees them
+AGENT_ORDER = ("claude", "codex", "gemini", "devin")
 GUIDE_WORDS = {"install": "aplicado", "update": "atualizado", "replace": "atualizado", "unchanged": "já em dia",
                "uninstall": "removido", "remove": "removido"}
 BAD_SKILL = ("modified", "missing", "unsafe", "external_link")
@@ -81,10 +79,12 @@ def detect(home, probe=True):
     rows = []
     for cli in CLIS:
         binary = shutil.which(cli["binary"])
-        config = cli["config"](home) if cli["config"] else None
+        config = None
         try:
-            config_found = bool(config and config.exists())
-        except OSError:
+            config = cli["config"](home) if cli["config"] else None
+            from .agents import physical
+            config_found = bool(config and Path(physical(config)).exists())
+        except (CrowError, OSError):
             config_found = False
         rows.append({"id": cli["id"], "label": cli["label"], "agent": cli["agent"], "binary": binary,
                      "config": str(config) if config else None, "config_found": config_found,
@@ -149,72 +149,30 @@ def fix_for(code, agent):
     return hint
 
 
-DISABLED_REASON = "desabilitada no Uniflow (SKILL.md.disabled no store); não conta como ativa"
-
-
-def store_disabled(home, store):
-    """Names managed by crow-skills in the Uniflow store that Uniflow disabled (SKILL.md.disabled)."""
-    try:
-        return {r["name"] for r in store.status(destinations("uniflow", home), ()) if r["status"] == "disabled"}
-    except (CrowError, OSError):
-        return set()
-
-
-def classify(store, target, names, agent, replace, overwrite, store_names=()):
-    """Split the requested skills into (to install, kept with the reason and fix, projected by Uniflow).
-
-    A skill Uniflow projects into this CLI (a link to its store) is installed for the CLI: its source of
-    truth is the store (--agents uniflow); the link is never followed, replaced or reported as an error."""
+def classify(store, target, names, agent, replace, overwrite):
+    """Select native regular packages, preserving edits and refusing individual links."""
     rows = {r["name"]: r for r in store.status([target], names) if r["name"]}
-    install, kept, via, waiting = [], [], [], []
-    # Uniflow already projects into this dir: what goes into its store arrives by the same projection on the
-    # CLI's next start; a native copy would shadow it. crow-behaviour stays native when absent (guide, hooks).
-    projected = any(r["status"] == "uniflow_link" for r in store.status([target], ()))
-    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()
+    install, kept = [], []
     for name in names:
-        row = rows.get(name) or {"status": "absent"}
-        status = row["status"]
-        if status == "uniflow_link" and name in store_ok:
-            via.append(name)
-        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",
-                         "fix": "revise o store e, para gerenciá-lo com backup: crow-skills setup --agents uniflow --replace --yes"})
-        elif status == "absent" and name in pending and name != "crow-behaviour":
-            via.append(name)
-            waiting.append(name)
-        elif status in ("modified", "missing") and not overwrite:
+        status = (rows.get(name) or {"status": "absent"})["status"]
+        if status in ("modified", "missing") and not overwrite:
             kept.append({"name": name, "status": status, "reason": "editada localmente" if status == "modified" else "arquivos removidos",
                          "fix": "crow-skills setup --agents " + agent + " --overwrite-modified --yes"})
         elif status == "unmanaged" and not replace:
             kept.append({"name": name, "status": status, "reason": "já existe e não é gerenciada pelo crow-skills",
                          "fix": "crow-skills setup --agents " + agent + " --replace --yes"})
-        elif status == "external_link" and not replace and not store.managed_target(
-                os.path.realpath(Path(target["path"]) / name), name):
-            kept.append({"name": name, "status": status, "reason": "link do Uniflow para uma cópia não gerenciada",
-                         "fix": "crow-skills setup --agents uniflow --replace --yes"})
         elif status == "unsafe":
             path = Path(target["path"]) / name
-            what = "é um link para " + os.path.realpath(path) if path.is_symlink() else "não é um diretório regular"
-            kept.append({"name": name, "status": status, "reason": str(path) + " " + what + "; não é lido nem substituído",
+            kept.append({"name": name, "status": status, "reason": str(path) + " não é um pacote regular; não é lido nem substituído",
                          "fix": "remova ou troque você mesmo " + str(path) + " e rode crow-skills setup --yes de novo"})
         else:
             install.append(name)
-    return install, kept, via, waiting
+    return install, kept
 
 
 def refresh_extras(agent, home, dry_run, trust=True, source=None, ref=None, replace=False, overwrite=False):
     """Guide, integrations and hooks of an agent when no skill is (re)installed there, e.g. every crow
-    skill comes from Uniflow's projection. Same commands as guide/integrations install --global."""
+    skill is already installed. Same commands as guide/integrations install --global."""
     cli = _cli()
     out = {"guides": None, "integrations": None}
     if agent not in guide.MECHANISMS or "crow-behaviour" not in guide.managed_skills(agent, home, Store(home)):
@@ -235,19 +193,14 @@ def refresh_extras(agent, home, dry_run, trust=True, source=None, ref=None, repl
     return out
 
 
-def configure_agent(args, home, store, agent, names, dry_run, store_names=()):
+def configure_agent(args, home, store, agent, names, dry_run):
     cli = _cli()
     target = destinations(agent, home)[0]
-    entry = {"agent": agent, "target": target["path"], "changed": [], "unchanged": [], "kept": [], "via_uniflow": [],
+    entry = {"agent": agent, "target": target["path"], "changed": [], "unchanged": [], "kept": [],
              "error": None, "guides": None, "integrations": None}
     replace, overwrite = bool(getattr(args, "replace", False)), bool(getattr(args, "overwrite_modified", False))
     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
+        install, entry["kept"] = classify(store, target, names, agent, replace, overwrite)
         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))
@@ -276,8 +229,6 @@ def configure_agent(args, home, store, agent, names, dry_run, store_names=()):
     entry["guides"] = data.get("guides")
     entry["integrations"] = data.get("integrations")
     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
@@ -287,9 +238,6 @@ def configure_agent(args, home, store, agent, names, dry_run, store_names=()):
     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.
 
@@ -304,19 +252,9 @@ def migrate_legacy(args, home, store, entry, dry_run, planned=()):
 
 
 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.
+    """Migrate intact managed legacy copies only after native replacements exist.
+
+    Modified, foreign, unsafe and shared records are retained with evidence.
     """
     legacy = legacy_shared_dir(home)
     # Mesmo diretório (inclusive via symlink): não há nada para migrar e avisar seria ruído.
@@ -339,15 +277,10 @@ def legacy_shared_step(args, home, store, entry, dry_run, planned=()):
         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 []}
@@ -359,12 +292,12 @@ def legacy_shared_step(args, home, store, entry, dry_run, planned=()):
         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 ()):
+        if own.get(name) != "installed" 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",
+                                   "este nome não tem instalação íntegra regular",
                          "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"})
+                                "--yes) e rode de novo"})
             continue
         others = set(records.get(name, {}).get("agents") or ["codex"]) - {"codex"}
         if others:
@@ -399,61 +332,6 @@ def legacy_shared_step(args, home, store, entry, dry_run, planned=()):
                                       "(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 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 + "; 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:
-        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 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 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 +
-                                         " --dest " + str(legacy_shared_dir(home)) + " --yes"})
-    if remove:
-        cli = _cli()
-        # 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")
-        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).
@@ -589,10 +467,6 @@ def summarize(detected, entries, store, home, probe, dry_run, trust=True):
             parts.append(str(changed) + " " + verb)
         if unchanged:
             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")
         legacy = entry.get("legacy_shared") or {}
@@ -609,9 +483,7 @@ def summarize(detected, entries, store, home, probe, dry_run, trust=True):
         guides = entry.get("guides") or {}
         guide_change = next((c for c in guides.get("changes", []) if c.get("agent") == cli["agent"]), None)
         guide_skip = next((s for s in guides.get("skipped", []) if s.get("agent") == cli["agent"]), None)
-        if cli["agent"] == "uniflow":
-            item["guide"] = "não se aplica"
-        elif guide_change:
+        if guide_change:
             item["guide"] = GUIDE_WORDS.get(guide_change.get("action"), guide_change.get("action", "?"))
         elif guide_skip:
             item["guide"] = "não aplicado"
@@ -637,19 +509,6 @@ def summarize(detected, entries, store, home, probe, dry_run, trust=True):
             item["notes"].append("hooks: " + fix)
         for k in kept:
             item["notes"].append(k["name"] + " mantida (" + k["reason"] + "): " + k["fix"])
-        if entry.get("via_uniflow_pending"):
-            item["notes"].append(", ".join(entry["via_uniflow_pending"]) + ": vai para o store do Uniflow e aparece neste CLI no "
-                                 "próximo início pelo Uniflow (sem cópia nativa, para não sombrear o store)")
-        for dup in (entry.get("uniflow") or {}).get("native_duplicates") or []:
-            names_ = ", ".join(sk["name"] for sk in dup["skills"])
-            effect = ("o Codex vê as duas cópias" if dup.get("effect") == "both" else
-                      "o Uniflow não liga esse nome e a cópia nativa vale ali")
-            item["notes"].append("cópia física em " + ",".join(dup["agents"]) + " (" + dup["target"] + ") de " + names_ +
-                                 ", que o store também tem: " + effect + " (links do Uniflow não contam)")
-        for command in (entry.get("uniflow") or {}).get("suggested_commands") or []:
-            item["notes"].append("para usar só o store: " + command + " --yes" +
-                                 (" (sem a cópia nativa da crow-behaviour, o guia daquele agente sai até o Uniflow ligar o store)"
-                                  if " crow-behaviour " in command else ""))
         problems = [] if dry_run else agent_health(store, home, cli["agent"])
         if entry["error"]:
             item["state"] = "fail"
@@ -674,18 +533,7 @@ def setup(args, home, store, interactive):
     source, names = catalog_names(args)
 
     def build(dry):
-        # The Uniflow store goes first: a name is left to its projection only if the store really has it
-        # (installed, updated or already there); kept or failed names are installed natively.
-        entries = {}
-        store_names = ()
-        if "uniflow" in agents:
-            entries["uniflow"] = configure_agent(args, home, store, "uniflow", names, dry)
-            if not entries["uniflow"]["error"]:
-                store_names = tuple(entries["uniflow"]["changed"]) + tuple(entries["uniflow"]["unchanged"])
-        for agent in agents:
-            if agent != "uniflow":
-                entries[agent] = configure_agent(args, home, store, agent, names, dry, store_names)
-        entries = [entries[a] for a in agents]
+        entries = [configure_agent(args, home, store, agent, names, dry) for agent in agents]
         return entries, machine_steps(args, home, store, dry)
 
     entries, steps = build(True)
@@ -748,8 +596,7 @@ def doctor_reasons(doctor, trust=True):
 
 # --- upgrade -------------------------------------------------------------------------------
 
-AGENT_LABELS = {"claude": "Claude Code", "codex": "Codex CLI", "gemini": "Gemini CLI / Antigravity", "devin": "Devin CLI",
-                "uniflow": "Uniflow"}
+AGENT_LABELS = {"claude": "Claude Code", "codex": "Codex CLI", "gemini": "Gemini CLI / Antigravity", "devin": "Devin CLI"}
 
 
 def upgrade_summary(skills, dry_run):
@@ -757,22 +604,13 @@ def upgrade_summary(skills, dry_run):
     for s in skills:
         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 []),
+                "unchanged": s.get("unchanged", 0), "kept": s.get("kept") 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")
@@ -881,7 +719,7 @@ def render_setup(data, stream=None):
     lines.append("")
     if data.get("nothing_detected"):
         lines.append(ui.mark("warn", stream) + " Nenhum CLI de agente encontrado. Instale um (claude, codex, gemini, agy, devin, "
-                     "uniflow) e rode crow-skills setup de novo.")
+                     "devin) e rode crow-skills setup de novo.")
     elif data.get("dry_run"):
         lines.append("Para aplicar: crow-skills setup --yes")
     elif data.get("healthy"):
@@ -914,7 +752,7 @@ def render_upgrade(data, stream=None):
     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 ""
+                   " (cópias legadas)") if item.get("removed") else ""
         fresh = item.get("installed_new") or []
         # Dito na própria linha do CLI: uma skill nova do catálogo não é "atualizada", é instalada
         # agora — e foi exatamente isso que faltou quando a 0.17.0 publicou a crow-be-human.
@@ -923,10 +761,10 @@ def render_upgrade(data, stream=None):
         rows.append([ui.mark(STATE_MARK[item["state"]], stream), item["label"],
                      ((("a atualizar: " if dry else "atualizadas: ") + changed) if changed else ("" if removed or new_text else "sem mudanças"))
                      + removed + new_text,
-                     str(item["unchanged"]), str(item.get("via_uniflow", 0)), str(len(item["kept"]))])
+                     str(item["unchanged"]), str(len(item["kept"]))])
     if rows:
         lines.append("")
-        lines += ui.table(rows, ["", "CLI", "mudanças", "em dia", "via uniflow", "mantidas"], stream)
+        lines += ui.table(rows, ["", "CLI", "mudanças", "em dia", "mantidas"], stream)
     elif not data.get("handoff"):
         lines += ["", "  Nenhum agente com skills gerenciadas; comece com: crow-skills setup --yes"]
     needs = [(i["label"], n) for i in data.get("summary", []) for n in i["needs_user"]]

package/crow_skills/projection.py

@@ -1,127 +1,15 @@
-"""Uniflow's projection of its store into Codex's own skills dir ($CODEX_HOME/skills, default ~/.codex/skills).
-
-Since 0.15.0 crow-skills installs for codex in that same directory, like it does for every other CLI, so a
-managed copy and a projected link can no longer carry the same name in two places. Codex still scans
-~/.agents/skills as well, so a copy left there by an older version is still listed twice: those legacy copies
-are what duplicates() reports, and removing them is the migration away from the shared folder.
-
-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: never altered nor removed. Note that the LINK being untouched
-does not make the command succeed — that name now lives in the codex destination, and a symlinked entry
-there cannot be managed, so install/setup report it (status "unsafe") and exit 1 until the user resolves it.
-"""
+"""Generic migration of pre-0.15 native Codex copies from ~/.agents/skills."""
 import os
-from pathlib import Path
-
-from .agents import codex_home, codex_skills_dir, destinations, legacy_shared_dir, real_home, uniflow_store
+from .agents import destinations, legacy_shared_dir
 from .source import CrowError
 
-
-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
-    legacy shared copy, or elsewhere. Only "managed" counts as the codex install and allows removing a legacy
-    duplicate. "alias" is a link into the legacy ~/.agents/skills: Codex deduplicates it by canonical path, and
-    crow-skills never alters it — but it occupies the name in the destination, so that name is reported
-    unmanageable rather than installed."""
-    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)
-    # The alias case is a link into the LEGACY shared folder, never into Codex's own dir (where the link
-    # itself lives): comparing against the destination would now test a link against itself.
-    legacy = legacy_shared_dir(home)
-    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(legacy / 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, classified.
-
-    Codex's own dir IS the codex destination since 0.15.0, so `store.status()` already lists these
-    links (as a bare `uniflow_link`). These rows ENRICH the existing one for each name — managed,
-    disabled, edited or unmanaged, each with its reason — and are only appended when the base scan
-    did not report the name. Appending unconditionally would count every projected skill twice.
-    """
-    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 merge_rows(rows, extra, directory)
-
-
-def merge_rows(rows, extra, directory):
-    """Each enriched row replaces the base row of the same name in the same directory; the rest is
-    appended. Returns the merged list (the caller keeps its own list object)."""
-    merged, used = [], set()
-    for row in rows:
-        richer = next((e for e in extra if e["name"] == row.get("name") and row.get("target") == directory), None)
-        if richer is None:
-            merged.append(row)
-            continue
-        used.add(richer["name"])
-        merged.append(dict(row, **{k: v for k, v in richer.items() if k != "revision" or row.get("revision") is None}))
-    merged += [e for e in extra if e["name"] not in used]
-    return merged
-
-
-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 legacy_leftovers(home, store):
-    """Names crow-skills still has installed in the legacy shared folder, INDEPENDENT of Uniflow.
-
-    duplicates() answers "what duplicates a projection", so on a machine without Uniflow it is
-    always empty — and an install made by 0.14.0 (which put codex's copies in that folder) would be
-    invisible to status/doctor while Codex kept loading it. This is the signal for that."""
+    """Names still managed in the former shared native destination."""
     legacy = legacy_shared_dir(home)
     if not legacy.is_dir() or legacy.is_symlink():
         return []
@@ -135,36 +23,3 @@ def legacy_leftovers(home, store):
         return []
     return sorted(n for n, r in rows.items() if r["status"] in ("installed", "modified", "missing"))
 
-
-def duplicates(home, store):
-    """Copies left in the legacy shared folder (~/.agents/skills) that Codex lists a second time.
-
-    Codex scans its own dir and ~/.agents/skills; until 0.15.0 crow-skills installed for codex in the
-    latter. A copy still there duplicates what Uniflow projects into Codex's own dir, so it is the thing
-    to migrate away. 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, which may rely on them."""
-    names = projected("codex", home, store)
-    result = {"remove": [], "modified": [], "shared": []}
-    if not names:
-        return result
-    legacy = legacy_shared_dir(home)
-    if not legacy.is_dir() or legacy.is_symlink():
-        return result
-    target = {"path": str(legacy), "agents": ["codex"]}
-    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