@tacuchi/agent-workflow-cli 25.3.0 → 25.4.0

package/dist/application/self/skills-manager.js

@@ -1,33 +1,25 @@
-// Standalone-skills engine (skills.sh model): canonical copy in
-// ~/.agents/skills/<n> (the open-standard anchor that non-Claude hosts scan)
-// + replica in ~/.claude/skills/<n> via symlink, with a copy fallback
-// (Windows without links).
+// Standalone-skills INVENTORY and ownership (skills.sh model): canonical copy
+// in ~/.agents/skills/<n> (the open-standard anchor that non-Claude hosts
+// scan) + a replica per host that does not read it.
 //
-// The user-level registry (skills-registry.ts) is the source of truth for WHAT
-// this engine manages. Ownership guards (the engine writes under the user's
-// real HOME, which also hosts the `w` bundle, plugin skills and manual
-// skills):
-//   - every operation requires a registered name (SKILL_NOT_REGISTERED);
-//   - the canonical dir is only created/deleted if this engine materialized it
-//     — signal: `installedAt` in the registry (SKILL_NAME_COLLISION when
-//     colliding with a foreign dir; on uninstall/remove the foreign dir is
-//     preserved with a warning);
-//   - the Claude replica is ours only if it is a symlink THAT POINTS AT the
-//     canonical or a dir with registered mode:"copy" (FOREIGN_REPLICA
-//     otherwise), verified BEFORE mutating anything;
-//   - an unreadable registry (read warning) aborts every mutation: never
-//     rewrite over entries that could not be read.
-import { readFile, readdir, readlink, rename } from "node:fs/promises";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { basename, isAbsolute, join, relative, resolve } from "node:path";
+// This module READS. Since Spec 043 the only way to change an installation is
+// `prepareSkillChange` + `applySkillChange` (skills-change / skills-apply):
+// one preparation, one preview, one concrete approval and one journal. There
+// is deliberately no mutating function here for a surface to reach for — that
+// was how the TUI could install without showing what it was about to do.
+//
+// The user-level registry (skills-registry.ts) stays the source of truth for
+// WHAT this engine manages, and `installedAt` is still the only signal that
+// says this engine materialized a directory: everything else on those roots
+// belongs to somebody else (the `w` bundle, plugin skills, a manual install)
+// and is reported, never touched.
+import { readFile, readlink } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
 import { harnessByInstallTarget } from "../../domain/harnesses.js";
-import { gitClone, gitCloneSkillManifests, gitSparseAddSkillDir, gitSparseDisable, } from "./install-plugin-skills-git.js";
-import { copyDir, hasValidFrontmatter } from "./install-plugin-skills.js";
+import { hasValidFrontmatter } from "./install-plugin-skills.js";
 import { COMMAND_SKILL_PREFIX, LEGACY_SKILL_NAMES, SKILL_DIR_NAME } from "./install-skill.js";
-import { isValidSkillName, readSkillsRegistry, readSkillsShLockSources, writeSkillsRegistry, } from "./skills-registry.js";
-// skills/<category>/<skill> (mattpocock/skills) fits within 3 levels below the root.
-const MAX_SCAN_DEPTH = 3;
+import { curationOf, isRecommendedEntry, } from "./skills-catalog.js";
+import { isValidSkillName, readSkillsRegistry, readSkillsShLockSources, } from "./skills-registry.js";
 export function canonicalSkillsRoot(home) {
     return join(home, ".agents", "skills");
 }
@@ -91,409 +83,67 @@ async function isSkillDir(dir) {
     }
 }
 /** Frontmatter `name:` — the skill's real name when the source IS a skill dir
- *  (the basename of a temp clone is random, never usable). */
-function frontmatterName(content) {
+ *  (the basename of a temp clone is random, never usable). Exported so the
+ *  path-addressable discovery reads identity the same way this engine does. */
+export function skillFrontmatterName(content) {
     const block = content.match(/^---[ \t]*\r?\n([\s\S]*?)\r?\n---/)?.[1] ?? "";
     return block.match(/^name:\s*(\S[^\r\n]*)/m)?.[1]?.trim() ?? null;
 }
-/** Bounded walk: nested skills up to skills/<category>/<skill>; skips
- *  node_modules, symlinks (a link's Dirent is not isDirectory) and dot-dirs —
- *  EXCEPT `.claude`, the canonical Claude skills home, so a repo that packages
- *  its skills the standard way (`.claude/skills/<skill>`) stays discoverable. */
-async function walkSkillDirs(dir, depth) {
-    if (depth >= MAX_SCAN_DEPTH)
-        return [];
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const out = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        if (entry.name === "node_modules")
-            continue;
-        if (entry.name.startsWith(".") && entry.name !== ".claude")
-            continue;
-        const full = join(dir, entry.name);
-        if (await isSkillDir(full)) {
-            out.push({ name: entry.name, path: full });
-        }
-        else {
-            out.push(...(await walkSkillDirs(full, depth + 1)));
-        }
-    }
-    return out;
-}
-/** Skill dirs of a source: the dir itself (if it IS a skill, named by its
- *  frontmatter) or the tree; duplicate or invalid names are discarded. */
-async function collectCandidates(dir) {
-    if (await isSkillDir(dir)) {
-        const content = await readFile(join(dir, "SKILL.md"), "utf8");
-        const name = frontmatterName(content) ?? basename(dir);
-        return isValidSkillName(name) ? [{ name, path: dir }] : [];
-    }
-    const found = await walkSkillDirs(dir, 0);
-    const byName = new Map();
-    for (const c of found) {
-        if (!isValidSkillName(c.name) || byName.has(c.name))
-            continue;
-        byName.set(c.name, c);
-    }
-    return [...byName.values()];
-}
-/** Brings the source into a readable dir and lists its skills (temp clone for
- *  git). The git clone is manifest-only (just the SKILL.md files) so DISCOVERY
- *  never downloads unrelated repo content; the picked skill's full directory is
- *  fetched later in `prepare`. */
-async function fetchSourceCandidates(resolved, ctx) {
-    if (resolved.kind === "local") {
-        if (!(await ctx.fs.exists(resolved.path))) {
-            return { code: "SOURCE_NOT_FOUND", error: `el path local '${resolved.path}' no existe` };
-        }
-        return {
-            candidates: await collectCandidates(resolved.path),
-            prepare: async (c) => c.path,
-            cleanup: async () => { },
-        };
-    }
-    const temp = await mkdtemp(join(tmpdir(), "aw-skill-fetch-"));
-    const cleanup = async () => {
-        await rm(temp, { recursive: true, force: true }).catch(() => { });
-    };
-    // A server that rejects the partial/sparse clone falls back to a plain full
-    // clone (then `prepare` is identity — everything is already checked out).
-    let sparse;
-    try {
-        await gitCloneSkillManifests(resolved.url, temp, resolved.ref);
-        sparse = true;
-    }
-    catch {
-        await rm(temp, { recursive: true, force: true }).catch(() => { });
-        try {
-            await gitClone(resolved.url, temp, resolved.ref);
-            sparse = false;
-        }
-        catch (err) {
-            await cleanup();
-            return { code: "GIT_CLONE_FAILED", error: `git clone falló: ${err.message}` };
-        }
-    }
-    const prepare = async (c) => {
-        if (!sparse)
-            return c.path;
-        const rel = relative(temp, c.path);
-        // Root-is-skill: the whole repo is the payload → restore the full tree.
-        if (rel === "" || rel === ".")
-            await gitSparseDisable(temp);
-        else
-            await gitSparseAddSkillDir(temp, rel);
-        return c.path;
-    };
-    return { candidates: await collectCandidates(temp), prepare, cleanup };
-}
-/** Read preceding a mutation: an unreadable registry ABORTS — the first write
- *  after a failed read would clobber every prior entry. */
-async function readRegistryForWrite(ctx) {
-    const read = await readSkillsRegistry(ctx);
-    if (read.warning) {
-        return {
-            code: "REGISTRY_UNREADABLE",
-            error: `${read.warning} Corregí (o borrá) el archivo antes de operar.`,
-        };
-    }
-    return { registry: read.registry };
-}
-/** Side-effect-free inspection: lists a source's skills so the wizard can show
- *  the picker + third-party warning BEFORE registering anything. */
-export async function probeSkillSource(ctx, input) {
-    const resolved = resolveSkillSource(input.source, input.ref);
-    if ("error" in resolved)
-        return fail("INVALID_SOURCE", resolved.error);
-    const fetched = await fetchSourceCandidates(resolved, ctx);
-    if ("error" in fetched)
-        return fail(fetched.code, fetched.error);
-    try {
-        if (fetched.candidates.length === 0) {
-            return fail("SOURCE_NOT_FOUND", `no se encontró ninguna skill válida (SKILL.md con name+description) en '${input.source}'`);
-        }
-        return {
-            ok: true,
-            data: { candidates: fetched.candidates.map((c) => c.name).sort() },
-            exitCode: 0,
-        };
-    }
-    finally {
-        await fetched.cleanup();
-    }
-}
-export async function registerSkill(ctx, input) {
-    const resolved = resolveSkillSource(input.source, input.ref);
-    if ("error" in resolved)
-        return fail("INVALID_SOURCE", resolved.error);
-    const fetched = await fetchSourceCandidates(resolved, ctx);
-    if ("error" in fetched)
-        return fail(fetched.code, fetched.error);
-    try {
-        const picked = pickCandidate(fetched.candidates, input);
-        if ("error" in picked)
-            return fail(picked.code, picked.error);
-        if ("candidates" in picked) {
-            return {
-                ok: true,
-                data: {
-                    status: "needs-pick",
-                    candidates: picked.candidates,
-                    summary: `La fuente contiene ${picked.candidates.length} skills; elegí una para registrar.`,
-                },
-                exitCode: 0,
-            };
-        }
-        const read = await readRegistryForWrite(ctx);
-        if ("error" in read)
-            return fail(read.code, read.error);
-        const { registry } = read;
-        if (registry.skills[picked.name]) {
-            return fail("SKILL_ALREADY_REGISTERED", `'${picked.name}' ya está registrada (fuente: ${registry.skills[picked.name]?.source})`);
-        }
-        // `w-*` is the namespace of the bundle's synthesized wrappers
-        // (install-skill.ts) — registering a standalone skill there would leave it
-        // at the mercy of the install/uninstall sweep over the same roots.
-        if (picked.name.startsWith(COMMAND_SKILL_PREFIX)) {
-            return fail("RESERVED_SKILL_PREFIX", `'${picked.name}' usa el prefijo reservado '${COMMAND_SKILL_PREFIX}' (wrappers del bundle) — elegí otro nombre`);
-        }
-        // Ownership guard: an existing UNregistered canonical dir belongs to someone
-        // else (`w` bundle, plugin skill, manual install) — we never adopt it.
-        const canonical = join(canonicalSkillsRoot(ctx.env.homeDir()), picked.name);
-        if (await ctx.fs.exists(canonical)) {
-            return fail("SKILL_NAME_COLLISION", `ya existe ${canonical} y no está en el registro de sueltas — elegí otro nombre o resolvé la colisión a mano`);
-        }
-        const entry = {
-            source: resolved.kind === "git" ? (input.source.split("#")[0] ?? input.source) : resolved.path,
-            ...(resolved.kind === "git" && resolved.ref ? { ref: resolved.ref } : {}),
-        };
-        registry.skills[picked.name] = entry;
-        await writeSkillsRegistry(ctx, registry);
-        return {
-            ok: true,
-            data: {
-                status: "registered",
-                name: picked.name,
-                entry,
-                summary: `Skill '${picked.name}' registrada desde ${entry.source}.`,
-            },
-            exitCode: 0,
-        };
-    }
-    finally {
-        await fetched.cleanup();
-    }
-}
-function pickCandidate(candidates, input) {
-    if (candidates.length === 0) {
-        return {
-            code: "SOURCE_NOT_FOUND",
-            error: `no se encontró ninguna skill válida (SKILL.md con name+description) en '${input.source}'`,
-        };
-    }
-    if (input.pick !== undefined) {
-        const found = candidates.find((c) => c.name === input.pick);
-        return (found ?? {
-            code: "INVALID_PICK",
-            error: `la fuente no contiene la skill '${input.pick}' (disponibles: ${candidates
-                .map((c) => c.name)
-                .sort()
-                .join(", ")})`,
-        });
-    }
-    if (candidates.length === 1 && candidates[0])
-        return candidates[0];
-    return { candidates: candidates.map((c) => c.name).sort() };
-}
-export async function installSkill(ctx, name, opts = { refetch: true }) {
-    const read = await readRegistryForWrite(ctx);
-    if ("error" in read)
-        return fail(read.code, read.error);
-    const entry = read.registry.skills[name];
-    if (!entry)
-        return notRegistered(name);
+export async function inspectSkillOwnership(ctx, name, entry) {
     const home = ctx.env.homeDir();
-    const canonical = join(canonicalSkillsRoot(home), name);
-    // Pre-flight BEFORE mutating anything: a foreign replica (on any host) or a
-    // canonical collision aborts without touching the prior install or the foreign dir.
-    const replicaStates = new Map();
-    for (const host of REPLICA_HOSTS) {
-        const state = await inspectReplica(ctx, name, entry.mode, host);
-        if (state === "foreign") {
-            return fail("FOREIGN_REPLICA", `ya existe ${join(host.root(home), name)} y no lo creó este manager — resolvé la colisión a mano`);
-        }
-        replicaStates.set(host.key, state);
-    }
-    if (opts.refetch && !entry.installedAt && (await ctx.fs.exists(canonical))) {
-        return fail("SKILL_NAME_COLLISION", `ya existe ${canonical} y este manager no lo materializó — resolvé la colisión a mano`);
-    }
-    if (opts.refetch) {
-        const resolved = resolveSkillSource(entry.source, entry.ref);
-        if ("error" in resolved)
-            return fail("INVALID_SOURCE", resolved.error);
-        const fetched = await fetchSourceCandidates(resolved, ctx);
-        if ("error" in fetched)
-            return fail("FETCH_FAILED", fetched.error);
-        try {
-            const skillDir = fetched.candidates.find((c) => c.name === name);
-            if (!skillDir) {
-                return fail("FETCH_FAILED", `la fuente '${entry.source}' ya no contiene la skill '${name}'`);
-            }
-            const srcDir = await fetched.prepare(skillDir);
-            await materializeCanonical(ctx, srcDir, canonical, name);
-        }
-        catch (err) {
-            return fail("MATERIALIZE_FAILED", err.message);
-        }
-        finally {
-            await fetched.cleanup();
-        }
-    }
-    else if (!entry.installedAt || !(await ctx.fs.exists(canonical))) {
-        // Reinstall requires THIS manager to have materialized the canonical dir:
-        // without installedAt, an existing same-named dir is foreign and is not replicated.
-        return fail("SKILL_NOT_INSTALLED", `'${name}' no está instalada (no existe ${canonical} materializada por este manager); usá Install/Update`);
-    }
+    const canonicalPath = join(canonicalSkillsRoot(home), name);
+    const present = await ctx.fs.exists(canonicalPath);
+    // `installedAt` is the only signal that says THIS manager materialized it;
+    // a same-named dir nobody registered belongs to whoever put it there.
+    const canonicalState = !present
+        ? "absent"
+        : entry?.installedAt
+            ? "ours"
+            : "foreign";
     const replicas = [];
     for (const host of REPLICA_HOSTS) {
-        replicas.push(await replicateToHost(ctx, name, replicaStates.get(host.key) ?? "absent", host));
-    }
-    // The registered mode is still the Claude replica's (the primary one): the
-    // TUI's "(copy)" badge flags ITS degradation (Windows without symlinks);
-    // the gemini copy is by-design and authenticates via marker, not mode.
-    const claudeReplica = replicas[0] ?? { path: canonical, mode: "symlink" };
-    // Re-read before writing: the clone can take a while and another invocation
-    // may have touched the registry in between — never write a stale snapshot.
-    const fresh = await readRegistryForWrite(ctx);
-    if ("error" in fresh)
-        return fail(fresh.code, fresh.error);
-    const current = fresh.registry.skills[name] ?? entry;
-    fresh.registry.skills[name] = {
-        ...current,
-        mode: claudeReplica.mode,
-        ...(opts.refetch ? { installedAt: new Date().toISOString() } : {}),
-    };
-    await writeSkillsRegistry(ctx, fresh.registry);
-    return {
-        ok: true,
-        data: {
-            status: opts.refetch ? "installed" : "reinstalled",
-            name,
-            canonical,
-            mode: claudeReplica.mode,
-            replicas: replicas.map((r) => ({ host: r.host, path: r.path, mode: r.mode })),
-            summary: `Skill '${name}' materializada en ${canonical} (réplicas: ${replicas
-                .map((r) => `${r.host} ${r.mode}`)
-                .join(" · ")}).`,
-        },
-        exitCode: 0,
-    };
-}
-/** Reinstall: repairs canonical→replica without touching the source (offline-safe). */
-export async function reinstallSkill(ctx, name) {
-    return installSkill(ctx, name, { refetch: false });
-}
-/** Update: re-fetches the registered ref; git sources only. Staging+swap: a
- *  fetch failure leaves the prior install intact. */
-export async function updateSkill(ctx, name) {
-    const read = await readRegistryForWrite(ctx);
-    if ("error" in read)
-        return fail(read.code, read.error);
-    const entry = read.registry.skills[name];
-    if (!entry)
-        return notRegistered(name);
-    const resolved = resolveSkillSource(entry.source, entry.ref);
-    if ("error" in resolved || resolved.kind !== "git") {
-        return fail("UPDATE_REQUIRES_GIT", `Update re-fetchea git; '${name}' viene de un path local — usá Reinstall (o re-registrá la fuente).`);
-    }
-    if (!(await ctx.fs.exists(join(canonicalSkillsRoot(ctx.env.homeDir()), name)))) {
-        return fail("SKILL_NOT_INSTALLED", `'${name}' no está instalada; usá Install`);
+        replicas.push({
+            host: host.key,
+            path: join(host.root(home), name),
+            state: await inspectReplica(ctx, name, entry?.mode, host),
+        });
     }
-    const result = await installSkill(ctx, name, { refetch: true });
-    if (!result.ok || !result.data)
-        return result;
-    return {
-        ...result,
-        data: {
-            ...result.data,
-            status: "updated",
-            summary: `Skill '${name}' actualizada (ref registrado re-fetcheado).`,
-        },
-    };
+    return { name, canonical: { path: canonicalPath, state: canonicalState }, replicas };
 }
-export async function uninstallSkill(ctx, name) {
-    const read = await readRegistryForWrite(ctx);
-    if ("error" in read)
-        return fail(read.code, read.error);
-    const entry = read.registry.skills[name];
-    if (!entry)
-        return notRegistered(name);
-    const warning = await teardownSkill(ctx, name, entry);
-    read.registry.skills[name] = {
-        source: entry.source,
-        ...(entry.ref ? { ref: entry.ref } : {}),
-    };
-    await writeSkillsRegistry(ctx, read.registry);
+/** The catalog's contribution to a row: what the review says about this name,
+ *  or nothing at all — an unreviewed installation borrows no verdict. */
+function catalogFields(entry) {
+    const curation = curationOf(entry);
     return {
-        ok: true,
-        data: {
-            status: "uninstalled",
-            name,
-            ...(warning ? { warning } : {}),
-            summary: `Skill '${name}' desinstalada; sigue registrada (fuente: ${entry.source}).`,
-        },
-        exitCode: 0,
-    };
-}
-export async function removeSkill(ctx, name) {
-    const read = await readRegistryForWrite(ctx);
-    if ("error" in read)
-        return fail(read.code, read.error);
-    const entry = read.registry.skills[name];
-    if (!entry)
-        return notRegistered(name);
-    const warning = await teardownSkill(ctx, name, entry);
-    delete read.registry.skills[name];
-    await writeSkillsRegistry(ctx, read.registry);
-    return {
-        ok: true,
-        data: {
-            status: "removed",
-            name,
-            ...(warning ? { warning } : {}),
-            summary: `Skill '${name}' desinstalada y quitada del registro.`,
-        },
-        exitCode: 0,
+        ...(entry?.description ? { description: entry.description } : {}),
+        ...(curation !== undefined ? { curation } : {}),
     };
 }
 /** Single list for the TUI: registered (installed or not) + canonicals outside
- *  the registry (`unmanaged`) + unregistered seed. Order: installed → unmanaged
- *  → registered → recommended; alphabetical within each group. */
-export async function listSkills(ctx, seed) {
+ *  the registry (`unmanaged`) + the recommended catalog entries nobody has.
+ *  Order: installed → unmanaged → registered → recommended; alphabetical
+ *  within each group.
+ *
+ *  `catalog` is the WHOLE reviewed record (Spec 043): its metadata reaches
+ *  every row it knows — a withdrawn entry included, which is what keeps an
+ *  installation readable after it stops being recommended — while only the
+ *  recommended entries produce a `recommended` row of their own. */
+export async function listSkills(ctx, catalog) {
     const { registry, warning } = await readSkillsRegistry(ctx);
     const home = ctx.env.homeDir();
-    const seedByName = new Map(seed.map((s) => [s.name, s]));
+    const catalogByName = new Map(catalog.map((s) => [s.name, s]));
     const items = [];
     for (const [name, entry] of Object.entries(registry.skills)) {
         const canonical = await ctx.fs.exists(join(canonicalSkillsRoot(home), name));
         const replica = (await ctx.fs.lstat(join(claudeReplicaRoot(home), name))) !== null;
         const gemini = (await ctx.fs.lstat(join(geminiReplicaRoot(home), name))) !== null;
-        const description = seedByName.get(name)?.description;
         items.push({
             name,
             source: entry.source,
             ...(entry.ref ? { ref: entry.ref } : {}),
             ...(entry.mode ? { mode: entry.mode } : {}),
             ...(entry.installedAt ? { installedAt: entry.installedAt } : {}),
-            ...(description ? { description } : {}),
+            ...catalogFields(catalogByName.get(name)),
             status: canonical ? "installed" : "registered",
             replicas: { agents: canonical, claude: replica, gemini },
         });
@@ -529,6 +179,7 @@ export async function listSkills(ctx, seed) {
                 items.push({
                     name: entry.name,
                     source: lockSources[entry.name] ?? "",
+                    ...catalogFields(catalogByName.get(entry.name)),
                     status: "unmanaged",
                     replicas: { agents: true, claude: replica, gemini },
                 });
@@ -539,18 +190,22 @@ export async function listSkills(ctx, seed) {
             // managed skills are already listed; never empty the tab over this.
         }
     }
-    for (const s of seed) {
+    for (const s of catalog) {
+        // A withdrawn entry is no longer offered: it keeps its metadata for the
+        // rows above, but it never comes back as a `recommended` one.
+        if (!isRecommendedEntry(s))
+            continue;
         if (Object.hasOwn(registry.skills, s.name) || unmanaged.has(s.name))
             continue;
         // Same-named canonical the scan did not list (invalid frontmatter, file,
         // unreadable registry): offering Install guarantees SKILL_NAME_COLLISION —
-        // better not to offer the seed.
+        // better not to offer the catalog entry.
         if (await ctx.fs.exists(join(root, s.name)))
             continue;
         items.push({
             name: s.name,
             source: s.source,
-            description: s.description,
+            ...catalogFields(s),
             status: "recommended",
             replicas: { agents: false, claude: false, gemini: false },
         });
@@ -563,38 +218,6 @@ export async function listSkills(ctx, seed) {
     };
     return items.sort((a, b) => rank[a.status] - rank[b.status] || a.name.localeCompare(b.name));
 }
-// --- internals ---
-/**
- * Copies src into a hidden staging dir and swaps it with the canonical one;
- * the .bak is only discarded once the swap completed — a failure restores the
- * previous state. `renameFn` is injectable to test the restore branch.
- */
-export async function materializeCanonical(ctx, srcDir, canonical, name, renameFn = rename) {
-    const root = canonicalSkillsRoot(ctx.env.homeDir());
-    await ctx.fs.mkdirp(root);
-    const staging = join(root, `.staging-${name}-${process.pid}`);
-    const bak = join(root, `.bak-${name}-${process.pid}`);
-    await ctx.fs.remove(staging);
-    try {
-        await copyDir(srcDir, staging);
-        const hadPrevious = await ctx.fs.exists(canonical);
-        if (hadPrevious)
-            await renameFn(canonical, bak);
-        try {
-            await renameFn(staging, canonical);
-        }
-        catch (err) {
-            if (hadPrevious)
-                await renameFn(bak, canonical).catch(() => { });
-            throw err;
-        }
-        if (hadPrevious)
-            await ctx.fs.remove(bak);
-    }
-    finally {
-        await ctx.fs.remove(staging);
-    }
-}
 /** Replica ownership on a host: ours only if it is a symlink pointing at OUR
  *  canonical, a real dir with the `.aw-replica` marker, or — legacy
  *  (pre-marker copies, Windows) — a real dir with registered mode:"copy". A
@@ -603,7 +226,12 @@ async function inspectReplica(ctx, name, registeredMode, host) {
     const home = ctx.env.homeDir();
     const replicaRoot = host.root(home);
     const replica = join(replicaRoot, name);
-    const existing = await ctx.fs.lstat(replica);
+    // A location this manager cannot even READ is definitely not one it owns —
+    // e.g. somebody left a FILE where the skills root goes. `foreign` is the
+    // honest answer: report it, never write through it.
+    const existing = await ctx.fs.lstat(replica).catch(() => "unreadable");
+    if (existing === "unreadable")
+        return "foreign";
     if (!existing)
         return "absent";
     if (existing.isSymlink) {
@@ -622,62 +250,4 @@ async function inspectReplica(ctx, name, registeredMode, host) {
     // registered mode.
     return host.key === "claude" && registeredMode === "copy" ? "ours" : "foreign";
 }
-/** Materializes the replica on a host (pre-flight already ensured it is not foreign). */
-async function replicateToHost(ctx, name, state, host) {
-    const home = ctx.env.homeDir();
-    const canonical = join(canonicalSkillsRoot(home), name);
-    const replicaRoot = host.root(home);
-    const replica = join(replicaRoot, name);
-    if (state === "ours")
-        await ctx.fs.remove(replica);
-    await ctx.fs.mkdirp(replicaRoot);
-    if (host.preferSymlink) {
-        try {
-            await ctx.fs.symlink(canonical, replica);
-            return { host: host.key, path: replica, mode: "symlink" };
-        }
-        catch {
-            // No symlinks (Windows without Developer Mode / EPERM) → real copy.
-        }
-    }
-    await copyDir(canonical, replica);
-    await ctx.fs.writeText(join(replica, REPLICA_MARKER_FILENAME), `${canonical}\n`);
-    return { host: host.key, path: replica, mode: "copy" };
-}
-/** Tears down replicas and the canonical dir respecting ownership; returns a
- *  warning if a same-named foreign dir was preserved. */
-async function teardownSkill(ctx, name, entry) {
-    const home = ctx.env.homeDir();
-    const warnings = [];
-    for (const host of REPLICA_HOSTS) {
-        const replica = join(host.root(home), name);
-        const replicaState = await inspectReplica(ctx, name, entry.mode, host);
-        if (replicaState === "ours")
-            await ctx.fs.remove(replica);
-        else if (replicaState === "foreign") {
-            warnings.push(`se conservó ${replica}: existe pero no lo creó este manager`);
-        }
-    }
-    const canonical = join(canonicalSkillsRoot(home), name);
-    if (entry.installedAt) {
-        await ctx.fs.remove(canonical);
-    }
-    else if (await ctx.fs.exists(canonical)) {
-        warnings.push(`se conservó ${canonical}: este manager no lo materializó`);
-    }
-    return warnings.length > 0 ? warnings.join(" · ") : undefined;
-}
-function notRegistered(name) {
-    return {
-        ok: false,
-        error: {
-            code: "SKILL_NOT_REGISTERED",
-            message: `'${name}' no está en el registro de sueltas — este manager no toca dirs que no registró (bundle w, skills de plugins o manuales).`,
-        },
-        exitCode: 1,
-    };
-}
-function fail(code, message) {
-    return { ok: false, error: { code, message }, exitCode: 1 };
-}
 //# sourceMappingURL=skills-manager.js.map