agentera 3.0.0-dev.1 → 3.0.0-dev.11

package/dist/upgrade/runtimeMigration.js

@@ -5,10 +5,19 @@ import { isFile, pathExists, resolvePath } from "../core/paths.js";
 import { resolveSourceRoot } from "../core/sourceRoot.js";
 import { loadRegistry } from "../registries/runtimeAdapterRegistry.js";
 import { codexCopiedHooksAreAgenteraOnly, codexPluginHooksEnabled, retireCodexCopiedHookTrust, } from "../setup/codex.js";
-import { hasManagedMarker, opencodeCommandTemplate, opencodeConfigDir, } from "../setup/doctor.js";
+import { hasManagedMarker, opencodeConfigDir, } from "../setup/opencode.js";
+import { OPENCODE_SKILL_NAMES } from "../setup/opencodeConstants.js";
 import { resolveUpdateChannel } from "./channels.js";
+import { writeFileAtomic } from "./atomicWriter.js";
+import { applyInstalledHooksRetirementItems, planInstalledHooksRetirementItems, textReferencesV2InstalledHooks, } from "./installedHooksRetirement.js";
+import { projectUsesV3CapabilityInstructionModules } from "./v3CapabilitySurface.js";
 const PYTHON_MANAGED_PATTERNS = [
     /hooks\/validate_artifact\.py/,
+    /hooks\/cursor_session_start\.py/,
+    /hooks\/cursor_pre_tool_use\.py/,
+    /hooks\/cursor_session_stop\.py/,
+    /hooks\/session_start\.py/,
+    /hooks\/session_stop\.py/,
     /\buv run\b/,
     /\buvx\b/,
     /scripts\/agentera/,
@@ -17,8 +26,17 @@ const PYTHON_MANAGED_PATTERNS = [
     /cursor_pre_tool_use\.py/,
     /cursor_session_stop\.py/,
 ];
+export function projectHasProjectLevelRuntimeHooks(project) {
+    const root = resolvePath(project);
+    const candidates = [
+        path.join(root, ".cursor", "hooks.json"),
+        path.join(root, ".codex", "config.toml"),
+        path.join(root, ".codex", "hooks", "codex-hooks.json"),
+        path.join(root, ".github", "hooks"),
+    ];
+    return candidates.some((candidate) => isFile(candidate) || pathExists(candidate));
+}
 const OPENCODE_COMMAND_NAMES = ["agentera"];
-const OPENCODE_SKILL_NAMES = ["agentera", "hej"];
 const CURSOR_AGENT_MARKER = "<!-- agentera: managed -->";
 export function resolveNpxHookCommands(ctx) {
     const env = ctx.env ?? process.env;
@@ -39,16 +57,22 @@ export function resolveNpxHookCommands(ctx) {
         cursorPreTool: `${cliEntrypoint} hook cursor-pre-tool-use`,
     };
 }
-function textUsesPythonManagedEntrypoint(text) {
+export function textUsesPythonManagedEntrypoint(text) {
     if (/AGENTERA_HOME\s*=/.test(text)) {
         return true;
     }
     return PYTHON_MANAGED_PATTERNS.some((pattern) => pattern.test(text));
 }
+const V3_NPX_ENTRYPOINT = /\bnpx\s+-y\s+agentera\b/;
+export function textUsesV3NpmEntrypoint(text) {
+    return V3_NPX_ENTRYPOINT.test(text);
+}
 export function rewireRuntimeText(text, runtime, commands) {
     let next = text;
     next = next.replace(/uv run\s+\\?"?\$\{AGENTERA_HOME\}\/hooks\/validate_artifact\.py\\?"?/g, commands.validate);
+    next = next.replace(/uv run\s+\\?"?\$\{AGENTERA_HOME\}\/app\/hooks\/validate_artifact\.py\\?"?/g, commands.validate);
     next = next.replace(/uv run\s+\\?"?\$\{PLUGIN_ROOT\}\/hooks\/validate_artifact\.py\\?"?/g, commands.validate);
+    next = next.replace(/uv run\s+hooks\/validate_artifact\.py/g, commands.validate);
     if (next.includes("validate_artifact.py")) {
         next = next.replace(/["']?[^"'\n]*hooks\/validate_artifact\.py[^"'\n]*["']?/g, `"${commands.validate}"`);
     }
@@ -81,8 +105,8 @@ function needsChannelNpxRewire(text, cliEntrypoint) {
 function pushRewireItem(items, runtime, filePath, commands) {
     const text = fs.readFileSync(filePath, "utf8");
     const needsBare = needsChannelNpxRewire(text, commands.cliEntrypoint);
-    if (!textUsesPythonManagedEntrypoint(text) && !needsBare) {
-        if (text.includes(commands.cliEntrypoint)) {
+    if (!textUsesPythonManagedEntrypoint(text) && !textReferencesV2InstalledHooks(text) && !needsBare) {
+        if (textUsesV3NpmEntrypoint(text)) {
             items.push({
                 status: "noop",
                 action: "rewire-runtime",
@@ -91,6 +115,8 @@ function pushRewireItem(items, runtime, filePath, commands) {
                 message: "runtime config already references npm self-contained entrypoint",
             });
         }
+        // If the file has no Agentera content at all (no v2 Python, no v3 npm),
+        // it is not Agentera-managed. Do not push a blocked item — just return.
         return;
     }
     const newText = rewireRuntimeText(text, runtime, commands);
@@ -122,49 +148,49 @@ function copyIfChanged(source, target) {
         }
     }
     fs.mkdirSync(path.dirname(target), { recursive: true });
-    fs.copyFileSync(source, target);
+    const sourceBytes = fs.readFileSync(source);
+    writeFileAtomic(target, sourceBytes);
     return true;
 }
-function planCodexItems(items, home, commands, force) {
-    const hooksPath = path.join(home, ".codex", "hooks", "codex-hooks.json");
-    const configPath = path.join(home, ".codex", "config.toml");
-    if (isFile(hooksPath)) {
-        pushRewireItem(items, "codex", hooksPath, commands);
-    }
-    if (isFile(configPath)) {
-        pushRewireItem(items, "codex", configPath, commands);
-        let configText = fs.readFileSync(configPath, "utf8");
+function planCodexItems(items, home, project, commands, force) {
+    for (const root of [project, home]) {
+        const hooksPath = path.join(root, ".codex", "hooks", "codex-hooks.json");
+        const configPath = path.join(root, ".codex", "config.toml");
         if (isFile(hooksPath)) {
-            configText = fs.readFileSync(configPath, "utf8");
+            pushRewireItem(items, "codex", hooksPath, commands);
         }
-        const pluginHooks = codexPluginHooksEnabled(configText);
-        if (pluginHooks && isFile(hooksPath)) {
-            let hooksText;
-            try {
-                hooksText = fs.readFileSync(hooksPath, "utf8");
-            }
-            catch {
-                hooksText = "";
-            }
-            if (codexCopiedHooksAreAgenteraOnly(hooksText)) {
-                items.push({
-                    status: "pending",
-                    action: "retire-hooks",
-                    runtime: "codex",
-                    source: hooksPath,
-                    target: configPath,
-                    message: "will remove Agentera-owned copied Codex hooks because plugin hooks are enabled",
-                });
-            }
-            else if (hooksText.includes("validate_artifact") || hooksText.includes("hook validate-artifact")) {
-                items.push({
-                    status: force ? "pending" : "blocked",
-                    action: "retire-hooks",
-                    runtime: "codex",
-                    source: hooksPath,
-                    target: configPath,
-                    message: "plugin hooks are enabled, but copied hook target needs manual review before retirement",
-                });
+        if (isFile(configPath)) {
+            pushRewireItem(items, "codex", configPath, commands);
+            const configText = fs.readFileSync(configPath, "utf8");
+            const pluginHooks = codexPluginHooksEnabled(configText);
+            if (pluginHooks && isFile(hooksPath)) {
+                let hooksText;
+                try {
+                    hooksText = fs.readFileSync(hooksPath, "utf8");
+                }
+                catch {
+                    hooksText = "";
+                }
+                if (codexCopiedHooksAreAgenteraOnly(hooksText)) {
+                    items.push({
+                        status: "pending",
+                        action: "retire-hooks",
+                        runtime: "codex",
+                        source: hooksPath,
+                        target: configPath,
+                        message: "will remove Agentera-owned copied Codex hooks because plugin hooks are enabled",
+                    });
+                }
+                else if (hooksText.includes("validate_artifact") || hooksText.includes("hook validate-artifact")) {
+                    items.push({
+                        status: force ? "pending" : "blocked",
+                        action: "retire-hooks",
+                        runtime: "codex",
+                        source: hooksPath,
+                        target: configPath,
+                        message: "plugin hooks are enabled, but copied hook target needs manual review before retirement",
+                    });
+                }
             }
         }
     }
@@ -205,12 +231,21 @@ function planCursorItems(items, home, project, sourceRoot, commands) {
                 });
             }
         }
-        if (pathExists(agentsSource)) {
-            for (const entry of fs.readdirSync(agentsSource)) {
-                if (!entry.endsWith(".md"))
-                    continue;
-                const src = path.join(agentsSource, entry);
-                const dst = path.join(agentsDir, entry);
+        const skipInTreeCursorAgents = root === project && projectUsesV3CapabilityInstructionModules(project);
+        if (skipInTreeCursorAgents) {
+            items.push({
+                status: "noop",
+                action: "copy-agent",
+                runtime: "cursor",
+                target: agentsDir,
+                message: "v3 capability instruction modules present; in-tree .cursor/agents/ uses prime --context and is not overwritten",
+            });
+        }
+        else if (pathExists(agentsSource)) {
+            const CURSOR_MANAGED_AGENT = "agentera.md";
+            const src = path.join(agentsSource, CURSOR_MANAGED_AGENT);
+            if (isFile(src)) {
+                const dst = path.join(agentsDir, CURSOR_MANAGED_AGENT);
                 if (!isFile(dst)) {
                     items.push({
                         status: "pending",
@@ -218,21 +253,22 @@ function planCursorItems(items, home, project, sourceRoot, commands) {
                         runtime: "cursor",
                         source: src,
                         target: dst,
-                        message: "will copy managed Cursor capability agent",
+                        message: "will copy managed Cursor Agentera agent",
                     });
-                    continue;
                 }
-                const dstText = fs.readFileSync(dst, "utf8");
-                const srcText = fs.readFileSync(src, "utf8");
-                if (hasCursorManagedAgentMarker(dstText) && dstText !== srcText) {
-                    items.push({
-                        status: "pending",
-                        action: "copy-agent",
-                        runtime: "cursor",
-                        source: src,
-                        target: dst,
-                        message: "will refresh stale managed Cursor capability agent",
-                    });
+                else {
+                    const dstText = fs.readFileSync(dst, "utf8");
+                    const srcText = fs.readFileSync(src, "utf8");
+                    if (hasCursorManagedAgentMarker(dstText) && dstText !== srcText) {
+                        items.push({
+                            status: "pending",
+                            action: "copy-agent",
+                            runtime: "cursor",
+                            source: src,
+                            target: dst,
+                            message: "will refresh stale managed Cursor Agentera agent",
+                        });
+                    }
                 }
             }
         }
@@ -243,9 +279,12 @@ function planOpencodeItems(items, home, sourceRoot, env, commands) {
     const pluginSource = path.join(sourceRoot, ".opencode", "plugins", "agentera.js");
     const pluginTarget = path.join(configDir, "plugins", "agentera.js");
     if (isFile(pluginSource)) {
+        const targetContent = isFile(pluginTarget) ? fs.readFileSync(pluginTarget, "utf8") : "";
+        const sourceContent = fs.readFileSync(pluginSource, "utf8");
         const needsCopy = !isFile(pluginTarget) ||
-            textUsesPythonManagedEntrypoint(fs.readFileSync(pluginTarget, "utf8")) ||
-            needsChannelNpxRewire(fs.readFileSync(pluginTarget, "utf8"), commands.cliEntrypoint);
+            (targetContent !== sourceContent &&
+                (textUsesPythonManagedEntrypoint(targetContent) ||
+                    needsChannelNpxRewire(targetContent, commands.cliEntrypoint)));
         items.push({
             status: needsCopy ? "pending" : "noop",
             action: "copy-plugin",
@@ -261,10 +300,9 @@ function planOpencodeItems(items, home, sourceRoot, env, commands) {
     const commandsTargetDir = path.join(configDir, "commands");
     for (const name of OPENCODE_COMMAND_NAMES) {
         const src = path.join(commandsSourceDir, `${name}.md`);
-        const expected = opencodeCommandTemplate(name);
         const dst = path.join(commandsTargetDir, `${name}.md`);
         if (isFile(src)) {
-            const needsCopy = !isFile(dst) || (hasManagedMarker(fs.readFileSync(dst, "utf8")) && fs.readFileSync(dst, "utf8") !== expected);
+            const needsCopy = !isFile(dst) || (hasManagedMarker(fs.readFileSync(dst, "utf8")) && !fs.readFileSync(src).equals(fs.readFileSync(dst)));
             items.push({
                 status: needsCopy ? "pending" : "noop",
                 action: "copy-command",
@@ -277,12 +315,11 @@ function planOpencodeItems(items, home, sourceRoot, env, commands) {
     }
     const agentsSourceDir = path.join(sourceRoot, ".opencode", "agents");
     const agentsTargetDir = path.join(configDir, "agents");
+    const OPENCODE_MANAGED_AGENT = "agentera.md";
     if (pathExists(agentsSourceDir)) {
-        for (const entry of fs.readdirSync(agentsSourceDir)) {
-            if (!entry.endsWith(".md"))
-                continue;
-            const src = path.join(agentsSourceDir, entry);
-            const dst = path.join(agentsTargetDir, entry);
+        const src = path.join(agentsSourceDir, OPENCODE_MANAGED_AGENT);
+        if (isFile(src)) {
+            const dst = path.join(agentsTargetDir, OPENCODE_MANAGED_AGENT);
             const needsCopy = !isFile(dst) || !fs.readFileSync(src).equals(fs.readFileSync(dst));
             items.push({
                 status: needsCopy ? "pending" : "noop",
@@ -290,12 +327,16 @@ function planOpencodeItems(items, home, sourceRoot, env, commands) {
                 runtime: "opencode",
                 source: src,
                 target: dst,
-                message: needsCopy ? "will copy managed OpenCode capability agent" : "OpenCode agent already current",
+                message: needsCopy ? "will copy managed OpenCode Agentera agent" : "OpenCode Agentera agent already current",
             });
         }
     }
     const skillsSourceRoot = path.join(sourceRoot, "skills");
-    const skillsTargetDir = path.join(configDir, "skills");
+    // D78: ~/.agents/skills is the canonical agent-compatible root (opencode loads
+    // from both ~/.config/opencode/skills and ~/.agents/skills and requires skill
+    // names unique across locations — opencode.ai/docs/skills). Maintain the link
+    // here; the legacy ~/.config/opencode/skills entry is retired below.
+    const skillsTargetDir = path.join(home, ".agents", "skills");
     for (const name of OPENCODE_SKILL_NAMES) {
         const src = path.join(skillsSourceRoot, name);
         const dst = path.join(skillsTargetDir, name);
@@ -347,6 +388,144 @@ function planOpencodeItems(items, home, sourceRoot, env, commands) {
             });
         }
     }
+    // D78: retire the legacy opencode-specific skill symlinks now that
+    // ~/.agents/skills is canonical. The opencode doc requires skill names
+    // unique across its discovery locations; a skill present in both
+    // ~/.config/opencode/skills and ~/.agents/skills is the duplicate-name error
+    // that let a stale copy load.
+    const legacySkillsDir = path.join(configDir, "skills");
+    if (pathExists(legacySkillsDir) && fs.statSync(legacySkillsDir).isDirectory()) {
+        for (const name of OPENCODE_SKILL_NAMES) {
+            const legacy = path.join(legacySkillsDir, name);
+            let linkTarget = null;
+            try {
+                linkTarget = fs.readlinkSync(legacy);
+            }
+            catch {
+                linkTarget = null;
+            }
+            if (linkTarget !== null) {
+                if (linkTarget.toLowerCase().includes("agentera") || path.basename(linkTarget) === name) {
+                    items.push({
+                        status: "pending",
+                        action: "remove-stale-skill",
+                        runtime: "opencode",
+                        source: legacy,
+                        message: `will retire duplicate OpenCode skill symlink ${name} (agent-compatible root ~/.agents/skills is canonical; D78)`,
+                    });
+                }
+                else {
+                    items.push({
+                        status: "blocked",
+                        action: "remove-stale-skill",
+                        runtime: "opencode",
+                        source: legacy,
+                        message: `legacy OpenCode skill symlink ${name} targets a non-agentera path; manual review required`,
+                    });
+                }
+            }
+            else if (pathExists(legacy)) {
+                try {
+                    const dirEntries = fs.readdirSync(legacy);
+                    if (dirEntries.length === 0) {
+                        items.push({
+                            status: "pending",
+                            action: "remove-stale-skill",
+                            runtime: "opencode",
+                            source: legacy,
+                            message: `will retire empty legacy OpenCode skill directory ${name} (agent-compatible root ~/.agents/skills is canonical; D78)`,
+                        });
+                    }
+                    else {
+                        items.push({
+                            status: "blocked",
+                            action: "remove-stale-skill",
+                            runtime: "opencode",
+                            source: legacy,
+                            message: `legacy OpenCode skill path ${name} is a non-empty real directory (entries: ${dirEntries.length}); manual review required (D78 retires agentera-managed symlinks and empty dirs only)`,
+                        });
+                    }
+                }
+                catch {
+                    items.push({
+                        status: "blocked",
+                        action: "remove-stale-skill",
+                        runtime: "opencode",
+                        source: legacy,
+                        message: `legacy OpenCode skill path ${name} could not be inspected; manual review required`,
+                    });
+                }
+            }
+        }
+    }
+}
+export function planStaleCommandCleanupItems(ctx, items) {
+    const env = ctx.env ?? process.env;
+    const home = resolvePath(ctx.home);
+    const commandsDir = path.join(opencodeConfigDir(home, env), "commands");
+    if (!pathExists(commandsDir) || !fs.statSync(commandsDir).isDirectory()) {
+        return;
+    }
+    const currentNames = new Set(OPENCODE_COMMAND_NAMES);
+    for (const entry of fs.readdirSync(commandsDir)) {
+        if (!entry.endsWith(".md")) {
+            continue;
+        }
+        const filePath = path.join(commandsDir, entry);
+        if (!isFile(filePath)) {
+            continue;
+        }
+        const body = fs.readFileSync(filePath, "utf8");
+        if (!hasManagedMarker(body)) {
+            continue;
+        }
+        const name = entry.slice(0, -3);
+        if (currentNames.has(name)) {
+            continue;
+        }
+        items.push({
+            status: "pending",
+            action: "remove-stale-command",
+            runtime: "opencode",
+            source: filePath,
+            message: `will remove stale managed command ${path.basename(filePath)}`,
+        });
+    }
+}
+export function planStaleSkillCleanupItems(ctx, items) {
+    const env = ctx.env ?? process.env;
+    const home = resolvePath(ctx.home);
+    const skillsDir = path.join(opencodeConfigDir(home, env), "skills");
+    if (!pathExists(skillsDir) || !fs.statSync(skillsDir).isDirectory()) {
+        return;
+    }
+    const requiredNames = new Set(OPENCODE_SKILL_NAMES);
+    for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+        if (!entry.isSymbolicLink()) {
+            continue;
+        }
+        const linkPath = path.join(skillsDir, entry.name);
+        let linkTarget;
+        try {
+            linkTarget = fs.readlinkSync(linkPath);
+        }
+        catch {
+            continue;
+        }
+        if (!linkTarget.toLowerCase().includes("agentera")) {
+            continue;
+        }
+        if (requiredNames.has(entry.name)) {
+            continue;
+        }
+        items.push({
+            status: "pending",
+            action: "remove-stale-skill",
+            runtime: "opencode",
+            source: linkPath,
+            message: `will remove stale Agentera skill symlink ${entry.name}`,
+        });
+    }
 }
 function walkJsonHookFiles(dir) {
     if (!pathExists(dir)) {
@@ -388,16 +567,25 @@ function planEnvRuntimeNoops(items, runtime, message) {
     }
 }
 export function planRuntimeMigrationItems(ctx) {
+    if (!ctx.env) {
+        throw new Error("MigrationContext.env is required for runtime migration planning; pass sandboxMigrationEnv(home, sourceRoot) in tests or an explicit env in callers.");
+    }
     const home = resolvePath(ctx.home);
     const project = resolvePath(ctx.project);
-    const env = ctx.env ?? { ...process.env, HOME: home };
+    const env = ctx.env;
     const sourceRoot = resolvePath(ctx.sourceRoot ?? resolveSourceRoot(env));
     const commands = resolveNpxHookCommands({ ...ctx, home, env, sourceRoot });
     const items = [];
-    planCodexItems(items, home, commands, ctx.force);
+    planCodexItems(items, home, project, commands, ctx.force);
     planCursorItems(items, home, project, sourceRoot, commands);
     planOpencodeItems(items, home, sourceRoot, env, commands);
+    planStaleCommandCleanupItems(ctx, items);
+    planStaleSkillCleanupItems(ctx, items);
     planCopilotItems(items, project, commands);
+    const hookRetirement = planInstalledHooksRetirementItems(ctx).filter((item) => item.status === "pending");
+    if (hookRetirement.length > 0 && items.some((item) => item.action === "rewire-runtime" && item.status === "pending")) {
+        items.push(...hookRetirement);
+    }
     planEnvRuntimeNoops(items, "claude", "Claude Code plugin installs expose the app home without local config writes; use --update-packages to refresh marketplace surfaces");
     planEnvRuntimeNoops(items, "cursor-agent", "Cursor Agent CLI inherits workspace Cursor hooks; no separate managed install surface");
     void loadRegistry();
@@ -415,7 +603,7 @@ export function applyRuntimeMigrationItem(item, commands) {
                     item.message = "rewire-runtime missing target or newText";
                     return;
                 }
-                fs.writeFileSync(item.target, item.newText, "utf8");
+                writeFileAtomic(item.target, item.newText, "utf8");
                 item.status = "applied";
                 item.message = "runtime config rewired to npm self-contained entrypoint";
                 break;
@@ -439,9 +627,27 @@ export function applyRuntimeMigrationItem(item, commands) {
                     item.message = "link-skill missing source or target";
                     return;
                 }
+                if (!pathExists(item.source)) {
+                    item.status = "failed";
+                    item.message = `link-skill source disappeared between plan and apply: ${item.source}`;
+                    return;
+                }
                 fs.mkdirSync(path.dirname(item.target), { recursive: true });
-                if (pathExists(item.target)) {
-                    fs.rmSync(item.target, { recursive: true, force: true });
+                // lstat (not stat): stat follows symlinks and ENOENTs on dangling links; rmSync then fails.
+                let targetStat = null;
+                try {
+                    targetStat = fs.lstatSync(item.target);
+                }
+                catch {
+                    /* target absent */
+                }
+                if (targetStat) {
+                    if (targetStat.isSymbolicLink()) {
+                        fs.unlinkSync(item.target);
+                    }
+                    else {
+                        fs.rmSync(item.target, { recursive: true, force: true });
+                    }
                 }
                 fs.symlinkSync(item.source, item.target);
                 item.status = "applied";
@@ -460,12 +666,65 @@ export function applyRuntimeMigrationItem(item, commands) {
                 if (item.target && isFile(item.target)) {
                     const configText = fs.readFileSync(item.target, "utf8");
                     const next = retireCodexCopiedHookTrust(configText, item.source);
-                    fs.writeFileSync(item.target, next, "utf8");
+                    writeFileAtomic(item.target, next, "utf8");
                 }
                 item.status = "applied";
                 item.message = "retired Agentera-owned copied Codex hooks";
                 break;
             }
+            case "remove-stale-command": {
+                if (!item.source) {
+                    item.status = "failed";
+                    item.message = "remove-stale-command missing source";
+                    return;
+                }
+                if (isFile(item.source)) {
+                    fs.rmSync(item.source, { force: true });
+                    item.status = "applied";
+                    item.message = `removed stale managed command ${path.basename(item.source)}`;
+                }
+                else {
+                    item.status = "noop";
+                    item.message = `stale command already absent at ${item.source}`;
+                }
+                break;
+            }
+            case "remove-stale-skill": {
+                if (!item.source) {
+                    item.status = "failed";
+                    item.message = "remove-stale-skill missing source";
+                    return;
+                }
+                try {
+                    const stat = fs.lstatSync(item.source);
+                    if (stat.isSymbolicLink()) {
+                        fs.unlinkSync(item.source);
+                        item.status = "applied";
+                        item.message = `removed stale skill symlink ${path.basename(item.source)}`;
+                    }
+                    else if (stat.isDirectory()) {
+                        const entries = fs.readdirSync(item.source);
+                        if (entries.length === 0) {
+                            fs.rmdirSync(item.source);
+                            item.status = "applied";
+                            item.message = `removed empty skill directory ${path.basename(item.source)}`;
+                        }
+                        else {
+                            item.status = "blocked";
+                            item.message = `skill directory ${path.basename(item.source)} is non-empty (entries: ${entries.length}); manual review required`;
+                        }
+                    }
+                    else {
+                        item.status = "noop";
+                        item.message = "skill path is not a symlink or directory; skipped";
+                    }
+                }
+                catch {
+                    item.status = "noop";
+                    item.message = "stale skill already absent";
+                }
+                break;
+            }
             default:
                 break;
         }
@@ -480,5 +739,6 @@ export function applyRuntimeMigrationItems(items, ctx) {
     for (const item of items) {
         applyRuntimeMigrationItem(item, commands);
     }
+    applyInstalledHooksRetirementItems(items, ctx);
 }
 //# sourceMappingURL=runtimeMigration.js.map