fusion-cli 1.2.0__tar.gz → 1.3.1__tar.gz

{fusion_cli-1.2.0 → fusion_cli-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fusion-cli
-Version: 1.2.0
+Version: 1.3.1
 Summary: The Fusion reference CLI — the notary of the Fusion Convention.
 Author: Bluewaves Boutique
 License-Expression: MIT
@@ -38,7 +38,7 @@ uv tool install ./fusion/cli
 fusion --version
 ```
 
-## The nine commands (there is no tenth)
+## The ten commands (there is no eleventh)
 
 | Command | Does |
 |---|---|
@@ -50,9 +50,12 @@ fusion --version
 | `fusion status [path]` | One bucket at a glance |
 | `fusion today` | The composed day, across every bucket in the hub |
 | `fusion agenda` | The wider horizon — dated and active, across the hub |
-| `fusion setup` | Install the skills into every detected agent — the installer's brain. `--remove` undoes it |
+| `fusion setup` | Install the skills to `~/.agents/skills` and serve every detected agent (links only where needed) — the installer's brain. `--remove` undoes it |
+| `fusion update` | Bring the whole system current: upgrade fusion-cli through uv, then re-run setup from the new binary so the skills refresh everywhere. Equivalent to `uv tool upgrade fusion-cli && fusion setup` |
 
-Every command takes `--json` (agents parse, never scrape). `log`, `new`,
+Every command takes `--json` (agents parse, never scrape) — except
+`update`, which composes two processes (uv, then setup) that own
+stdout in turn. `log`, `new`,
 and `index` take `--as <actor>`; the pen defaults to `FUSION_ACTOR`, then
 the OS username. `status` and `log` take `--since <date|last-reflection>`.
 `log` also takes `--bucket` (resolves the ledger; default: walk up from the current directory).

{fusion_cli-1.2.0 → fusion_cli-1.3.1}/README.md

@@ -28,7 +28,7 @@ uv tool install ./fusion/cli
 fusion --version
 ```
 
-## The nine commands (there is no tenth)
+## The ten commands (there is no eleventh)
 
 | Command | Does |
 |---|---|
@@ -40,9 +40,12 @@ fusion --version
 | `fusion status [path]` | One bucket at a glance |
 | `fusion today` | The composed day, across every bucket in the hub |
 | `fusion agenda` | The wider horizon — dated and active, across the hub |
-| `fusion setup` | Install the skills into every detected agent — the installer's brain. `--remove` undoes it |
+| `fusion setup` | Install the skills to `~/.agents/skills` and serve every detected agent (links only where needed) — the installer's brain. `--remove` undoes it |
+| `fusion update` | Bring the whole system current: upgrade fusion-cli through uv, then re-run setup from the new binary so the skills refresh everywhere. Equivalent to `uv tool upgrade fusion-cli && fusion setup` |
 
-Every command takes `--json` (agents parse, never scrape). `log`, `new`,
+Every command takes `--json` (agents parse, never scrape) — except
+`update`, which composes two processes (uv, then setup) that own
+stdout in turn. `log`, `new`,
 and `index` take `--as <actor>`; the pen defaults to `FUSION_ACTOR`, then
 the OS username. `status` and `log` take `--since <date|last-reflection>`.
 `log` also takes `--bucket` (resolves the ledger; default: walk up from the current directory).

{fusion_cli-1.2.0 → fusion_cli-1.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fusion-cli"
-version = "1.2.0"
+version = "1.3.1"
 description = "The Fusion reference CLI — the notary of the Fusion Convention."
 readme = "README.md"
 requires-python = ">=3.11"

{fusion_cli-1.2.0 → fusion_cli-1.3.1}/src/fusion/cli.py

@@ -319,6 +319,21 @@ def _render_setup(report: dict) -> list[str]:
     return lines
 
 
+def cmd_update(args) -> int:
+    from fusion import update as update_mod
+    setup_args = []
+    if args.force:
+        setup_args.append("--force")
+    if args.skills_dir:
+        setup_args += ["--skills-dir", args.skills_dir]
+    if args.no_agents:
+        setup_args.append("--no-agents")
+    try:
+        return update_mod.run_update(Path.home(), setup_args)
+    except update_mod.UpdateError as exc:
+        return _fail(str(exc))
+
+
 # ── parser ───────────────────────────────────────────────────────────────
 
 def build_parser() -> argparse.ArgumentParser:
@@ -404,8 +419,10 @@ def build_parser() -> argparse.ArgumentParser:
 
     p = sub.add_parser("setup", help="install skills into agents; --remove undoes it",
                        description="Install the bundled skills to the canonical "
-                       "skills directory and link them into every detected agent. "
-                       "Idempotent; never destroys what it did not create.")
+                       "skills directory (~/.agents/skills) and make them available "
+                       "to every detected agent — most read that directory "
+                       "natively; agents that do not (Claude Code) get symlinks. "
+                       "--remove undoes exactly what setup can prove it created.")
     p.add_argument("--force", action="store_true",
                    help="replace foreign entries setup would otherwise leave")
     p.add_argument("--remove", action="store_true",
@@ -416,6 +433,20 @@ def build_parser() -> argparse.ArgumentParser:
     flag_json(p)
     p.set_defaults(func=cmd_setup)
 
+    p = sub.add_parser("update", help="upgrade fusion-cli and refresh the skills",
+                       description="Bring the whole system current: upgrade "
+                       "fusion-cli through uv, then re-run `fusion setup` "
+                       "from the new binary so the bundled skills refresh "
+                       "everywhere setup put them. Equivalent to: "
+                       "uv tool upgrade fusion-cli && fusion setup.")
+    p.add_argument("--force", action="store_true",
+                   help="forwarded to setup: replace foreign entries")
+    p.add_argument("--skills-dir",
+                   help="forwarded to setup: canonical destination")
+    p.add_argument("--no-agents", action="store_true",
+                   help="forwarded to setup: skip agent fan-out")
+    p.set_defaults(func=cmd_update)
+
     return parser
 
 

{fusion_cli-1.2.0 → fusion_cli-1.3.1}/src/fusion/setup.py

@@ -99,15 +99,20 @@ def install_canonical(payload: Path, skills_dir: Path,
 # ~/.agents/skills dir, so each fusion-* skill gets a symlink (or copy)
 # in its own skills dir. mode "standard": the agent reads the standard
 # dir — creating links there too would load every skill twice.
+# legacy_subdir: a dir an earlier fusion-cli release linked into before
+# the agent's native standard-dir support was verified; setup sweeps
+# OUR leftovers out of it (attribution-checked, like everything else).
 AGENTS = [
     {"name": "Claude Code", "marker": ".claude",
      "skills_subdir": ".claude/skills", "mode": "link",
      "docs_url": "https://code.claude.com/docs/en/skills"},
     {"name": "Codex", "marker": ".codex",
-     "skills_subdir": ".codex/skills", "mode": "link",
+     "skills_subdir": ".agents/skills", "mode": "standard",
+     "legacy_subdir": ".codex/skills",
      "docs_url": "https://developers.openai.com/codex/skills"},
     {"name": "Pi", "marker": ".pi",
-     "skills_subdir": ".pi/agent/skills", "mode": "link",
+     "skills_subdir": ".agents/skills", "mode": "standard",
+     "legacy_subdir": ".pi/agent/skills",
      "docs_url": "https://pi.dev/docs/latest/skills"},
     {"name": "Cursor", "marker": ".cursor",
      "skills_subdir": ".agents/skills", "mode": "standard",
@@ -128,7 +133,10 @@ def detect_agents(home: Path) -> list[dict]:
     found = []
     for row in AGENTS:
         if (home / row["marker"]).is_dir():
-            found.append({**row, "skills_dir": home / row["skills_subdir"]})
+            entry = {**row, "skills_dir": home / row["skills_subdir"]}
+            if "legacy_subdir" in row:
+                entry["legacy_dir"] = home / row["legacy_subdir"]
+            found.append(entry)
     return found
 
 
@@ -139,11 +147,51 @@ def _points_into(link: Path, canonical: Path) -> bool:
         return False
 
 
+def _sweep_legacy(agent: dict, canonical: Path) -> list[dict]:
+    """Remove OUR leftovers from a dir an earlier release linked into.
+
+    fusion-cli <= 1.2.0 symlinked (or copy-fell-back) into Pi's and
+    Codex's own dirs; both agents read the canonical dir natively, so
+    those entries double-loaded every skill. Attribution-checked:
+    symlinks into the canonical and sentinel-marked copies are ours;
+    anything else is left with a report row. If the legacy dir is
+    itself aliased at the canonical, there is nothing to sweep.
+    """
+    legacy = agent.get("legacy_dir")
+    if legacy is None or not legacy.is_dir():
+        return []
+    if _points_into(legacy, canonical):
+        return []  # the legacy dir IS the canonical through an alias —
+                    # sweeping it would reach canonical entries
+    results = []
+    for entry in sorted(legacy.glob("fusion-*")):
+        row = {"agent": agent["name"], "skill": entry.name}
+        if entry.is_symlink() and _points_into(entry, canonical):
+            entry.unlink()
+            results.append({**row, "action": "unlinked",
+                            "detail": f"{entry} — this agent reads the "
+                                      f"standard dir; the extra link "
+                                      f"double-loaded every skill"})
+        elif (entry.is_dir() and not entry.is_symlink()
+              and (entry / ".fusion-setup").is_file()):
+            shutil.rmtree(entry)
+            results.append({**row, "action": "unlinked",
+                            "detail": f"{entry} — copy from an earlier "
+                                      f"fusion-cli; this agent reads the "
+                                      f"standard dir"})
+        else:
+            results.append({**row, "action": "left",
+                            "detail": f"{entry} is not attributable to "
+                                      f"setup — left in place"})
+    return results
+
+
 def fan_out(canonical: Path, agents: list[dict], force: bool) -> list[dict]:
     results = []
     skills = sorted(canonical.glob("fusion-*"))
     for agent in agents:
         if agent["mode"] == "standard":
+            results.extend(_sweep_legacy(agent, canonical))
             if canonical.resolve() != agent["skills_dir"].resolve():
                 detail = (f"reads ~/.agents/skills — but your skills are "
                           f"at {canonical}, which this agent does not read")
@@ -152,6 +200,13 @@ def fan_out(canonical: Path, agents: list[dict], force: bool) -> list[dict]:
             results.append({"agent": agent["name"], "skill": "*",
                             "action": "standard", "detail": detail})
             continue
+        if _points_into(agent["skills_dir"], canonical):
+            results.append({
+                "agent": agent["name"], "skill": "*", "action": "served",
+                "detail": f"{agent['skills_dir']} resolves into "
+                          f"{canonical} — the canonical install already "
+                          f"serves this agent; nothing to link"})
+            continue
         agent["skills_dir"].mkdir(parents=True, exist_ok=True)
         for skill in skills:
             target = agent["skills_dir"] / skill.name
@@ -170,6 +225,11 @@ def fan_out(canonical: Path, agents: list[dict], force: bool) -> list[dict]:
                 target.unlink()
                 replaced = True
             elif target.is_dir():
+                if target.resolve() == skill.resolve():
+                    results.append({**row, "action": "served",
+                                    "detail": f"{target} already resolves "
+                                              f"to the canonical skill"})
+                    continue
                 if tree_digest(target) == tree_digest(skill):
                     pass          # our current copy, refresh below keeps it current
                 elif (target / ".fusion-setup").is_file():
@@ -211,7 +271,11 @@ def remove_all(canonical: Path, home: Path) -> list[dict]:
     results = []
     for agent in detect_agents(home):
         if agent["mode"] == "standard":
+            results.extend(_sweep_legacy(agent, canonical))
             continue
+        if _points_into(agent["skills_dir"], canonical):
+            continue  # entries here ARE the canonical skills; the
+                      # canonical phase below removes them exactly once
         entries = (sorted(agent["skills_dir"].glob("fusion-*"))
                    if agent["skills_dir"].is_dir() else [])
         for entry in entries:

fusion_cli-1.3.1/src/fusion/update.py

@@ -0,0 +1,85 @@
+"""fusion update — one verb to bring the whole system current.
+
+Upgrades fusion-cli through uv, then re-runs `fusion setup` from the
+NEW binary: this process keeps the old skills payload in memory, so
+setup must run in a child for the refreshed payload to land. Every
+decision is testable without a real subprocess — the runner is a seam.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from .setup import payload_version
+
+
+class UpdateError(Exception):
+    """An update step that cannot proceed."""
+
+
+def _runner():
+    return subprocess.run
+
+
+def find_uv(home: Path) -> Path | None:
+    found = shutil.which("uv")
+    if found:
+        return Path(found)
+    # install.sh's landing spot, for shells whose PATH never learned it
+    for name in ("uv.exe", "uv") if os.name == "nt" else ("uv",):
+        candidate = home / ".local" / "bin" / name
+        if candidate.is_file() and os.access(candidate, os.X_OK):
+            return candidate
+    return None
+
+
+def uv_owns_install(uv: Path, run) -> bool:
+    proc = run([str(uv), "tool", "list"], capture_output=True, text=True)
+    if proc.returncode != 0:
+        return False
+    return any(line.split()[:1] == ["fusion-cli"]
+               for line in proc.stdout.splitlines())
+
+
+def fusion_binary(uv: Path, run) -> Path:
+    proc = run([str(uv), "tool", "dir", "--bin"],
+               capture_output=True, text=True)
+    if proc.returncode != 0 or not proc.stdout.strip():
+        raise UpdateError(
+            "could not resolve uv's tool bin dir — finish by hand: "
+            "uv tool dir --bin, then <that dir>/fusion setup")
+    bin_dir = Path(proc.stdout.strip())
+    for name in ("fusion", "fusion.exe"):
+        candidate = bin_dir / name
+        if candidate.is_file():
+            return candidate
+    raise UpdateError(
+        f"fusion not found in {bin_dir} after the upgrade — "
+        f"check: uv tool list")
+
+
+def run_update(home: Path, setup_args: list[str]) -> int:
+    run = _runner()
+    uv = find_uv(home)
+    if uv is None:
+        raise UpdateError(
+            "uv not found — fusion updates through uv "
+            "(https://docs.astral.sh/uv/). Install it, or upgrade "
+            "fusion-cli with whatever installed it, then run: fusion setup")
+    if not uv_owns_install(uv, run):
+        raise UpdateError(
+            "this fusion-cli is not managed by uv — upgrade it with "
+            "whatever installed it (pip, pipx, a checkout), then run: "
+            "fusion setup")
+    print(f"fusion-cli {payload_version()} — asking uv for newer…")
+    sys.stdout.flush()  # keep our line ahead of uv's inherited stdio
+    if run([str(uv), "tool", "upgrade", "fusion-cli"]).returncode != 0:
+        raise UpdateError(
+            "uv tool upgrade failed — on Windows the running fusion.exe "
+            "can hold the lock. Exit this process, then run: "
+            "uv tool upgrade fusion-cli && fusion setup")
+    child = run([str(fusion_binary(uv, run)), "setup", *setup_args])
+    return child.returncode

fusion_cli-1.3.1/tests/test_cli_update.py

@@ -0,0 +1,140 @@
+"""fusion update end to end through the CLI surface.
+
+Same isolation contract as test_cli_setup.py: no real subprocess is
+ever reached; a fake runner records the exact command sequence.
+"""
+import subprocess
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from fusion import update
+from fusion.cli import build_parser, main
+
+# find_uv wraps which()'s answer in Path, so the argv the runner sees is
+# the platform's rendering of this stub ("\\stub\\uv" on Windows).
+STUB_UV = str(Path("/stub/uv"))
+
+
+class FakeRunner:
+    """Answers uv/fusion invocations from a script of canned results."""
+
+    def __init__(self, bin_dir: Path, *, list_stdout="fusion-cli v1.2.1\n- fusion\n",
+                 list_rc=0, upgrade_rc=0, setup_rc=0):
+        self.bin_dir = bin_dir
+        self.list_stdout = list_stdout
+        self.list_rc = list_rc
+        self.upgrade_rc = upgrade_rc
+        self.setup_rc = setup_rc
+        self.calls = []
+
+    def __call__(self, argv, **kwargs):
+        self.calls.append([str(a) for a in argv])
+        prog, rest = Path(argv[0]).name, [str(a) for a in argv[1:]]
+        if prog.startswith("uv") and rest == ["tool", "list"]:
+            return SimpleNamespace(returncode=self.list_rc,
+                                   stdout=self.list_stdout, stderr="")
+        if prog.startswith("uv") and rest == ["tool", "upgrade", "fusion-cli"]:
+            return SimpleNamespace(returncode=self.upgrade_rc, stdout="", stderr="")
+        if prog.startswith("uv") and rest == ["tool", "dir", "--bin"]:
+            return SimpleNamespace(returncode=0, stdout=f"{self.bin_dir}\n", stderr="")
+        if prog.startswith("fusion") and rest[:1] == ["setup"]:
+            return SimpleNamespace(returncode=self.setup_rc, stdout="", stderr="")
+        raise AssertionError(f"unexpected command: {argv}")
+
+
+@pytest.fixture
+def sandbox(tmp_path, monkeypatch):
+    home = tmp_path / "home"
+    home.mkdir()
+    monkeypatch.setenv("HOME", str(home))
+    monkeypatch.setenv("USERPROFILE", str(home))          # windows
+    monkeypatch.setattr(Path, "home", classmethod(lambda cls: home))
+    monkeypatch.setattr(update.shutil, "which",
+                        lambda name, *a, **kw: "/stub/uv" if name == "uv" else None)
+    monkeypatch.setattr(subprocess, "run",
+                        lambda *a, **kw: pytest.fail("real subprocess reached"))
+    bin_dir = tmp_path / "toolbin"
+    bin_dir.mkdir()
+    (bin_dir / "fusion").write_text("")
+    return SimpleNamespace(home=home, bin_dir=bin_dir)
+
+
+def _install_runner(monkeypatch, runner):
+    monkeypatch.setattr(update, "_runner", lambda: runner)
+
+
+def test_update_happy_path_runs_upgrade_then_setup(sandbox, monkeypatch, capsys):
+    runner = FakeRunner(sandbox.bin_dir)
+    _install_runner(monkeypatch, runner)
+    assert main(["update"]) == 0
+    assert runner.calls == [
+        [STUB_UV, "tool", "list"],
+        [STUB_UV, "tool", "upgrade", "fusion-cli"],
+        [STUB_UV, "tool", "dir", "--bin"],
+        [str(sandbox.bin_dir / "fusion"), "setup"],
+    ]
+
+
+def test_update_forwards_setup_flags(sandbox, monkeypatch):
+    runner = FakeRunner(sandbox.bin_dir)
+    _install_runner(monkeypatch, runner)
+    custom = str(sandbox.home / "custom-skills")
+    assert main(["update", "--force", "--skills-dir", custom,
+                 "--no-agents"]) == 0
+    assert runner.calls[-1] == [str(sandbox.bin_dir / "fusion"), "setup",
+                                "--force", "--skills-dir", custom,
+                                "--no-agents"]
+
+
+def test_update_propagates_setup_exit_code(sandbox, monkeypatch):
+    runner = FakeRunner(sandbox.bin_dir, setup_rc=3)
+    _install_runner(monkeypatch, runner)
+    assert main(["update"]) == 3
+
+
+def test_update_without_uv_fails_with_manual_path(sandbox, monkeypatch, capsys):
+    monkeypatch.setattr(update.shutil, "which", lambda name, *a, **kw: None)
+    _install_runner(monkeypatch, FakeRunner(sandbox.bin_dir))
+    assert main(["update"]) == 1
+    err = capsys.readouterr().err
+    assert "uv" in err and "fusion setup" in err
+
+
+def test_update_finds_uv_at_install_sh_fallback(sandbox, monkeypatch):
+    monkeypatch.setattr(update.shutil, "which", lambda name, *a, **kw: None)
+    fallback = sandbox.home / ".local" / "bin" / "uv"
+    fallback.parent.mkdir(parents=True)
+    fallback.write_text("")
+    fallback.chmod(0o755)
+    runner = FakeRunner(sandbox.bin_dir)
+    _install_runner(monkeypatch, runner)
+    assert main(["update"]) == 0
+    assert runner.calls[0][0] == str(fallback)
+
+
+def test_update_refuses_non_uv_install(sandbox, monkeypatch, capsys):
+    runner = FakeRunner(sandbox.bin_dir, list_stdout="black v24.0.0\n- black\n")
+    _install_runner(monkeypatch, runner)
+    assert main(["update"]) == 1
+    err = capsys.readouterr().err
+    assert "not managed by uv" in err and "fusion setup" in err
+    # never got as far as upgrading
+    assert [STUB_UV, "tool", "upgrade", "fusion-cli"] not in runner.calls
+    assert runner.calls == [[STUB_UV, "tool", "list"]]
+
+
+def test_update_reports_failed_upgrade_with_retry_ritual(sandbox, monkeypatch,
+                                                         capsys):
+    runner = FakeRunner(sandbox.bin_dir, upgrade_rc=1)
+    _install_runner(monkeypatch, runner)
+    assert main(["update"]) == 1
+    err = capsys.readouterr().err
+    assert "uv tool upgrade fusion-cli && fusion setup" in err
+    # setup never ran on a failed upgrade
+    assert all(c[1:2] != ["setup"] for c in runner.calls)
+
+
+def test_update_appears_in_help(sandbox):
+    assert "update" in build_parser().format_help()

{fusion_cli-1.2.0 → fusion_cli-1.3.1}/tests/test_setup_agents.py

@@ -26,7 +26,12 @@ def test_registry_shape():
             "opencode", "Goose"} == names
     modes = {a["name"]: a["mode"] for a in setup.AGENTS}
     assert modes["Claude Code"] == "link"
+    assert modes["Pi"] == "standard"
+    assert modes["Codex"] == "standard"
     assert modes["Cursor"] == "standard"
+    legacy = {a["name"]: a.get("legacy_subdir") for a in setup.AGENTS}
+    assert legacy["Pi"] == ".pi/agent/skills"
+    assert legacy["Codex"] == ".codex/skills"
 
 
 def test_detect_agents_only_present(home):
@@ -97,15 +102,15 @@ def test_fan_out_leaves_plain_file_unless_forced(home, canonical):
 
 
 def test_fan_out_copies_when_symlink_unavailable(home, canonical, monkeypatch):
-    (home / ".pi").mkdir()
+    (home / ".claude").mkdir()
 
     def no_symlink(*a, **k):
         raise OSError("symlinks disabled")
     monkeypatch.setattr(setup.os, "symlink", no_symlink)
     results = setup.fan_out(canonical, setup.detect_agents(home), force=False)
-    pi = [r for r in results if r["agent"] == "Pi"]
-    assert {r["action"] for r in pi} == {"copied"}
-    copied = home / ".pi" / "agent" / "skills" / "fusion-intake"
+    claude = [r for r in results if r["agent"] == "Claude Code"]
+    assert {r["action"] for r in claude} == {"copied"}
+    copied = home / ".claude" / "skills" / "fusion-intake"
     assert copied.is_dir() and not copied.is_symlink()
     # the copy carries a provenance sentinel — that's how we know it's ours
     sentinel = copied / ".fusion-setup"
@@ -117,8 +122,8 @@ def test_fan_out_copies_when_symlink_unavailable(home, canonical, monkeypatch):
     # itself is an extra file — so the sentinel is what proves provenance)
     (copied / "SKILL.md").write_text("stale")
     again = setup.fan_out(canonical, setup.detect_agents(home), force=False)
-    pi_intake = [r for r in again if r["skill"] == "fusion-intake"][0]
-    assert pi_intake["action"] == "copied"
+    claude_intake = [r for r in again if r["skill"] == "fusion-intake"][0]
+    assert claude_intake["action"] == "copied"
     assert (copied / ".fusion-setup").is_file()
 
 
@@ -136,34 +141,122 @@ def test_remove_all_is_attribution_checked(home, canonical):
 
 def test_remove_all_removes_sentinel_copies_and_leaves_foreign(
         home, canonical, monkeypatch):
-    (home / ".pi").mkdir()
+    (home / ".claude").mkdir()
+    # a foreign dir sharing a canonical skill's name — same shape, no
+    # sentinel, different content — must survive removal untouched
+    foreign = home / ".claude" / "skills" / "fusion-planner"
+    foreign.mkdir(parents=True)
+    (foreign / "SKILL.md").write_text("---\nname: my-own-tool\n---\n")
+    (foreign / "data.txt").write_text("do not touch\n")
 
     def no_symlink(*a, **k):
         raise OSError("symlinks disabled")
     monkeypatch.setattr(setup.os, "symlink", no_symlink)
     setup.fan_out(canonical, setup.detect_agents(home), force=False)
-    ours = home / ".pi" / "agent" / "skills" / "fusion-intake"
-    assert (ours / ".fusion-setup").is_file()     # our sentinel-marked copy
+    ours = home / ".claude" / "skills" / "fusion-intake"
+    assert (ours / ".fusion-setup").is_file()   # our sentinel-marked copy
 
-    # a foreign dir sharing a canonical skill's name — same shape, no
-    # sentinel, different content — must survive removal untouched, even
-    # discovered fresh (this agent never went through fan_out)
+    results = setup.remove_all(canonical, home)
+
+    assert not ours.exists()                     # our copy: removed
+    intake = [r for r in results if r["agent"] == "Claude Code"
+              and r["skill"] == "fusion-intake"][0]
+    assert intake["action"] == "removed"
+    assert foreign.is_dir()                      # foreign: left in place
+    assert (foreign / "data.txt").read_text() == "do not touch\n"
+    planner = [r for r in results if r["agent"] == "Claude Code"
+               and r["skill"] == "fusion-planner"][0]
+    assert planner["action"] == "left"
+
+
+def test_fan_out_survives_skills_dir_symlinked_to_canonical(home, canonical):
+    # the topology that destroyed skills in v1.1.0-v1.2.0: the agent's
+    # whole skills dir is a symlink AT the canonical directory
     (home / ".claude").mkdir()
-    foreign = home / ".claude" / "skills" / "fusion-intake"
-    foreign.mkdir(parents=True)
-    (foreign / "SKILL.md").write_text("---\nname: my-own-tool\n---\n")
-    (foreign / "data.txt").write_text("do not touch\n")
+    (home / ".claude" / "skills").symlink_to(
+        canonical, target_is_directory=True)
+    results = setup.fan_out(canonical, setup.detect_agents(home),
+                            force=False)
+    claude = [r for r in results if r["agent"] == "Claude Code"]
+    assert len(claude) == 1 and claude[0]["action"] == "served"
+    # the canonical skills are alive, real, and readable
+    assert (canonical / "fusion-intake" / "SKILL.md").is_file()
+    assert not (canonical / "fusion-intake").is_symlink()
+
 
+def test_remove_all_survives_skills_dir_symlinked_to_canonical(
+        home, canonical):
+    (home / ".claude").mkdir()
+    (home / ".claude" / "skills").symlink_to(
+        canonical, target_is_directory=True)
     results = setup.remove_all(canonical, home)
+    # the guard means the agent sweep never touches the alias — every
+    # removal row must come from the canonical phase
+    assert not any(r["agent"] == "Claude Code" for r in results)
+    # the canonical phase removed the skills exactly once; the user's
+    # own dir-level symlink is not ours and stays
+    assert not (canonical / "fusion-intake").exists()
+    assert (home / ".claude" / "skills").is_symlink()
 
-    assert not ours.exists()                      # our copy: removed
-    pi_result = [r for r in results
-                 if r["agent"] == "Pi" and r["skill"] == "fusion-intake"][0]
-    assert pi_result["action"] == "removed"
 
-    assert foreign.is_dir()                        # foreign: left in place
-    assert (foreign / "data.txt").read_text() == "do not touch\n"
-    claude_result = [r for r in results
-                      if r["agent"] == "Claude Code"
-                      and r["skill"] == "fusion-intake"][0]
-    assert claude_result["action"] == "left"
+def test_fan_out_standard_sweeps_our_legacy_links(home, canonical):
+    (home / ".pi").mkdir()
+    legacy = home / ".pi" / "agent" / "skills"
+    legacy.mkdir(parents=True)
+    (legacy / "fusion-intake").symlink_to(
+        canonical / "fusion-intake", target_is_directory=True)
+    stale_copy = legacy / "fusion-planner"     # 1.2.0 copy-fallback relic
+    stale_copy.mkdir()
+    (stale_copy / "SKILL.md").write_text("old payload")
+    (stale_copy / ".fusion-setup").write_text("1.0\nabc\n")
+    mine = legacy / "fusion-mine"              # the user's own, not ours
+    mine.mkdir()
+    results = setup.fan_out(canonical, setup.detect_agents(home),
+                            force=False)
+    pi = {r["skill"]: r for r in results if r["agent"] == "Pi"}
+    assert pi["fusion-intake"]["action"] == "unlinked"
+    assert not (legacy / "fusion-intake").exists()
+    assert pi["fusion-planner"]["action"] == "unlinked"
+    assert not stale_copy.exists()
+    assert pi["fusion-mine"]["action"] == "left"
+    assert mine.is_dir()
+    assert pi["*"]["action"] == "standard"     # and Pi reads the std dir
+    # no new links were created in the legacy dir
+    assert not (legacy / "fusion-analyst").exists()
+
+
+def test_remove_all_sweeps_legacy_dirs(home, canonical):
+    (home / ".codex").mkdir()
+    legacy = home / ".codex" / "skills"
+    legacy.mkdir(parents=True)
+    (legacy / "fusion-intake").symlink_to(
+        canonical / "fusion-intake", target_is_directory=True)
+    results = setup.remove_all(canonical, home)
+    assert not (legacy / "fusion-intake").exists()
+    assert any(r["agent"] == "Codex" and r["action"] == "unlinked"
+               for r in results)
+    assert not (canonical / "fusion-intake").exists()
+
+
+def test_sweep_legacy_skips_dir_aliased_at_canonical(home, canonical):
+    # topology B from the v1.2.1 final review: legacy dir symlinked AT
+    # the canonical, plus a canonical entry that is itself a symlink
+    # resolving into the canonical — the sweep must not reach through
+    # the alias and unlink it
+    (home / ".pi").mkdir()
+    (home / ".pi" / "agent").mkdir()
+    (home / ".pi" / "agent" / "skills").symlink_to(
+        canonical, target_is_directory=True)
+    store = canonical / "_store" / "fusion-extra"
+    store.mkdir(parents=True)
+    (store / "SKILL.md").write_text("---\nname: fusion-extra\n---\n")
+    user_link = canonical / "fusion-extra"
+    user_link.symlink_to(store, target_is_directory=True)
+    results = setup.fan_out(canonical, setup.detect_agents(home),
+                            force=False)
+    assert user_link.is_symlink()          # the user's link survives
+    pi = [r for r in results if r["agent"] == "Pi"]
+    assert [r["action"] for r in pi] == ["standard"]  # sweep stayed out
+    # remove is equally alias-safe
+    setup.remove_all(canonical, home)
+    assert user_link.is_symlink()

{fusion_cli-1.2.0 → fusion_cli-1.3.1}/uv.lock

@@ -13,7 +13,7 @@ wheels = [
 
 [[package]]
 name = "fusion-cli"
-version = "1.2.0"
+version = "1.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },