@solaqua/skul 0.1.0

package/dist/index.js

@@ -0,0 +1,4190 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+exports.assertTrackedRootInstructionShadowSafety = assertTrackedRootInstructionShadowSafety;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const picocolors_1 = require("picocolors");
+const bundle_discovery_1 = require("./bundle-discovery");
+const bundle_fetch_1 = require("./bundle-fetch");
+const bundle_items_1 = require("./bundle-items");
+const bundle_materialization_1 = require("./bundle-materialization");
+const cli_1 = require("./cli");
+const git_context_1 = require("./git-context");
+const git_exclude_1 = require("./git-exclude");
+const git_index_1 = require("./git-index");
+const registry_1 = require("./registry");
+const root_instruction_content_1 = require("./root-instruction-content");
+const root_instruction_render_1 = require("./root-instruction-render");
+const root_instruction_state_1 = require("./root-instruction-state");
+const state_layout_1 = require("./state-layout");
+const tool_mapping_1 = require("./tool-mapping");
+// Lazily evaluated so that SKUL_NO_TUI set after module load (e.g. in tests) is respected.
+const pc = new Proxy({}, {
+    get(_t, prop) {
+        return (0, picocolors_1.createColors)(picocolors_1.isColorSupported && !(0, cli_1.isHeadlessMode)())[prop];
+    },
+});
+/** Parses CLI arguments and executes the selected Skul command. */
+async function run(argv, options = {}) {
+    const stateLayout = (0, state_layout_1.resolveGlobalStateLayout)({
+        homeDir: options.homeDir ?? node_os_1.default.homedir(),
+    });
+    const prompts = options.prompts ?? createDefaultPromptClient(stateLayout.libraryDir);
+    const parsed = await (0, cli_1.parseCliArgs)(argv, prompts);
+    const cwd = options.cwd ?? process.cwd();
+    if (parsed.kind === "help") {
+        return (0, cli_1.createHelpText)(parsed.command);
+    }
+    switch (parsed.command) {
+        case "add":
+            if (parsed.options.global) {
+                return applyBundleGlobal({
+                    homeDir: options.homeDir ?? node_os_1.default.homedir(),
+                    prompts,
+                    registryFile: stateLayout.registryFile,
+                    libraryDir: stateLayout.libraryDir,
+                    bundle: parsed.options.bundle,
+                    source: parsed.options.source,
+                    protocol: parsed.options.protocol,
+                    agents: parsed.options.agents,
+                    includeItems: parsed.options.includeItems ?? [],
+                    selectItems: parsed.options.selectItems ?? false,
+                    dryRun: parsed.options.dryRun,
+                    ref: parsed.options.ref,
+                    inferredBundleFromSource: parsed.options.inferredBundleFromSource,
+                    disableModelInvocation: parsed.options.disableModelInvocation,
+                });
+            }
+            return applyBundle({
+                cwd,
+                prompts,
+                registryFile: stateLayout.registryFile,
+                libraryDir: stateLayout.libraryDir,
+                bundle: parsed.options.bundle,
+                source: parsed.options.source,
+                protocol: parsed.options.protocol,
+                agents: parsed.options.agents,
+                includeItems: parsed.options.includeItems ?? [],
+                selectItems: parsed.options.selectItems ?? false,
+                dryRun: parsed.options.dryRun,
+                ref: parsed.options.ref,
+                inferredBundleFromSource: parsed.options.inferredBundleFromSource,
+                disableModelInvocation: parsed.options.disableModelInvocation,
+            });
+        case "list":
+            return renderBundleList({
+                libraryDir: stateLayout.libraryDir,
+                json: parsed.options.json,
+                source: parsed.options.source,
+            });
+        case "status":
+            if (parsed.options.global) {
+                return renderGlobalStatus({
+                    registryFile: stateLayout.registryFile,
+                    json: parsed.options.json,
+                });
+            }
+            return renderStatus({
+                cwd,
+                registryFile: stateLayout.registryFile,
+                json: parsed.options.json,
+            });
+        case "check":
+            return renderUpdateCheck({
+                cwd,
+                registryFile: stateLayout.registryFile,
+                libraryDir: stateLayout.libraryDir,
+                bundle: parsed.options.bundle,
+                json: parsed.options.json,
+            });
+        case "update":
+            return updateBundles({
+                cwd,
+                prompts,
+                registryFile: stateLayout.registryFile,
+                libraryDir: stateLayout.libraryDir,
+                bundle: parsed.options.bundle,
+                dryRun: parsed.options.dryRun,
+            });
+        case "shadow":
+            return shadowWorktree({
+                cwd,
+                registryFile: stateLayout.registryFile,
+                action: parsed.options.action,
+            });
+        case "sync":
+            return syncWorktree({
+                cwd,
+                registryFile: stateLayout.registryFile,
+            });
+        case "reset":
+            if (parsed.options.global) {
+                return resetGlobal({
+                    homeDir: options.homeDir ?? node_os_1.default.homedir(),
+                    prompts,
+                    registryFile: stateLayout.registryFile,
+                    dryRun: parsed.options.dryRun,
+                });
+            }
+            return resetWorktree({
+                cwd,
+                prompts,
+                registryFile: stateLayout.registryFile,
+                dryRun: parsed.options.dryRun,
+            });
+        case "remove":
+            if (parsed.options.global) {
+                return removeGlobalBundle({
+                    homeDir: options.homeDir ?? node_os_1.default.homedir(),
+                    prompts,
+                    registryFile: stateLayout.registryFile,
+                    libraryDir: stateLayout.libraryDir,
+                    bundle: parsed.options.bundle,
+                    source: parsed.options.source,
+                    includeItems: parsed.options.includeItems ?? [],
+                    selectItems: parsed.options.selectItems ?? false,
+                    dryRun: parsed.options.dryRun,
+                    inferredBundleFromSource: parsed.options.inferredBundleFromSource,
+                });
+            }
+            return removeBundle({
+                cwd,
+                prompts,
+                registryFile: stateLayout.registryFile,
+                libraryDir: stateLayout.libraryDir,
+                bundle: parsed.options.bundle,
+                source: parsed.options.source,
+                includeItems: parsed.options.includeItems ?? [],
+                selectItems: parsed.options.selectItems ?? false,
+                dryRun: parsed.options.dryRun,
+                inferredBundleFromSource: parsed.options.inferredBundleFromSource,
+            });
+        case "apply":
+            if (parsed.options.global) {
+                return applyGlobal({
+                    homeDir: options.homeDir ?? node_os_1.default.homedir(),
+                    prompts,
+                    registryFile: stateLayout.registryFile,
+                    libraryDir: stateLayout.libraryDir,
+                    dryRun: parsed.options.dryRun,
+                });
+            }
+            return applyWorktree({
+                cwd,
+                prompts,
+                registryFile: stateLayout.registryFile,
+                libraryDir: stateLayout.libraryDir,
+                dryRun: parsed.options.dryRun,
+            });
+        default:
+            return assertUnreachable(parsed);
+    }
+}
+function shadowWorktree(options) {
+    const gitContext = requireGitContext(options.cwd, "shadow");
+    let registry = readRegistryWithGuidance(options.registryFile);
+    const worktreeState = registry.worktrees[gitContext.worktreeId];
+    const shadowedFiles = worktreeState?.shadowed_files ?? {};
+    const shadowedFilePaths = Object.keys(shadowedFiles);
+    if (shadowedFilePaths.length === 0) {
+        return "No tracked root-instruction shadows found in the current worktree";
+    }
+    const nextShadowedFiles = options.action === "suspend"
+        ? suspendTrackedRootInstructionShadows({
+            repoRoot: gitContext.worktreeRoot,
+            shadowedFiles,
+        })
+        : refreshTrackedRootInstructionShadows({
+            repoRoot: gitContext.worktreeRoot,
+            shadowedFiles,
+        });
+    registry = (0, registry_1.upsertWorktreeState)(registry, gitContext.worktreeId, {
+        repo_fingerprint: worktreeState.repo_fingerprint,
+        path: gitContext.worktreeRoot,
+        materialized_state: worktreeState.materialized_state,
+        shadowed_files: nextShadowedFiles,
+    });
+    (0, registry_1.writeRegistryFile)(options.registryFile, registry);
+    const actionLabel = options.action === "suspend" ? "Suspended" : "Refreshed";
+    return `${actionLabel} tracked root-instruction shadows for ${shadowedFilePaths.sort().join(", ")}`;
+}
+function syncWorktree(options) {
+    const gitContext = requireGitContext(options.cwd, "sync");
+    let registry = readRegistryWithGuidance(options.registryFile);
+    const worktreeState = registry.worktrees[gitContext.worktreeId];
+    const shadowedFilePaths = Object.keys(worktreeState?.shadowed_files ?? {}).sort();
+    let currentShadowedFiles = { ...(worktreeState?.shadowed_files ?? {}) };
+    if (worktreeState && shadowedFilePaths.length > 0) {
+        currentShadowedFiles = suspendTrackedRootInstructionShadows({
+            repoRoot: gitContext.worktreeRoot,
+            shadowedFiles: currentShadowedFiles,
+        });
+        registry = writeShadowedFilesForWorktree({
+            registry,
+            registryFile: options.registryFile,
+            worktreeId: gitContext.worktreeId,
+            worktreeState,
+            shadowedFiles: currentShadowedFiles,
+        });
+    }
+    let syncResult = null;
+    let syncError = null;
+    try {
+        syncResult = runGitPullWithFastForward(gitContext.worktreeRoot);
+    }
+    catch (error) {
+        syncError = normalizeGitCommandError("sync the current branch with git pull --ff-only", error);
+    }
+    if (worktreeState && shadowedFilePaths.length > 0) {
+        try {
+            currentShadowedFiles = refreshTrackedRootInstructionShadowsAfterSync({
+                repoRoot: gitContext.worktreeRoot,
+                shadowedFiles: currentShadowedFiles,
+            });
+            writeShadowedFilesForWorktree({
+                registry,
+                registryFile: options.registryFile,
+                worktreeId: gitContext.worktreeId,
+                worktreeState,
+                shadowedFiles: currentShadowedFiles,
+            });
+        }
+        catch (error) {
+            if (syncError) {
+                throw new Error(`${syncError.message}\nSkul also failed to restore tracked root-instruction shadows: ${describeError(error)}`);
+            }
+            throw error;
+        }
+    }
+    if (syncError) {
+        throw syncError;
+    }
+    return renderSyncWorktreeResult({
+        syncResult: syncResult,
+        shadowRefreshResult: buildShadowRefreshResult({
+            initialShadowedFilePaths: shadowedFilePaths,
+            currentShadowedFiles,
+        }),
+    });
+}
+function refreshTrackedRootInstructionShadowsAfterSync(options) {
+    const refreshableShadowedFiles = {};
+    for (const [filePath, shadowedFile] of Object.entries(options.shadowedFiles)) {
+        const inspection = (0, git_index_1.inspectRootInstructionShadowTarget)({
+            repoRoot: options.repoRoot,
+            filePath,
+        });
+        if (!inspection.headBlob) {
+            node_fs_1.default.rmSync(node_path_1.default.join(options.repoRoot, filePath), { force: true });
+            continue;
+        }
+        refreshableShadowedFiles[filePath] = shadowedFile;
+    }
+    if (Object.keys(refreshableShadowedFiles).length === 0) {
+        return {};
+    }
+    return refreshTrackedRootInstructionShadows({
+        repoRoot: options.repoRoot,
+        shadowedFiles: refreshableShadowedFiles,
+    });
+}
+function writeShadowedFilesForWorktree(options) {
+    const nextRegistry = (0, registry_1.upsertWorktreeState)(options.registry, options.worktreeId, {
+        repo_fingerprint: options.worktreeState.repo_fingerprint,
+        path: options.worktreeState.path,
+        materialized_state: options.worktreeState.materialized_state,
+        shadowed_files: options.shadowedFiles,
+    });
+    (0, registry_1.writeRegistryFile)(options.registryFile, nextRegistry);
+    return nextRegistry;
+}
+function buildShadowRefreshResult(options) {
+    const refreshedFilePaths = Object.keys(options.currentShadowedFiles).sort();
+    return {
+        refreshedFilePaths,
+        retiredFilePaths: options.initialShadowedFilePaths
+            .filter((filePath) => !refreshedFilePaths.includes(filePath))
+            .sort(),
+    };
+}
+function runGitPullWithFastForward(repoRoot) {
+    const previousHead = runGitForOutput(repoRoot, ["rev-parse", "HEAD"]).trim();
+    runGitForOutput(repoRoot, ["pull", "--ff-only"]);
+    const currentHead = runGitForOutput(repoRoot, ["rev-parse", "HEAD"]).trim();
+    return {
+        previousHead,
+        currentHead,
+    };
+}
+function runGitForOutput(repoRoot, args) {
+    return (0, node_child_process_1.execFileSync)("git", args, {
+        cwd: repoRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+function normalizeGitCommandError(action, error) {
+    return new Error(`Failed to ${action}: ${describeGitCommandFailure(error)}`);
+}
+function describeGitCommandFailure(error) {
+    if (error instanceof Error &&
+        "stderr" in error &&
+        typeof error.stderr === "string") {
+        const stderr = error.stderr.trim();
+        if (stderr.length > 0) {
+            return stderr;
+        }
+    }
+    return describeError(error);
+}
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function renderSyncWorktreeResult(options) {
+    const syncMessage = options.syncResult.previousHead === options.syncResult.currentHead
+        ? "Git already up to date"
+        : `Synced git worktree ${options.syncResult.previousHead.slice(0, 7)} -> ${options.syncResult.currentHead.slice(0, 7)}`;
+    const detailMessages = [];
+    if (options.shadowRefreshResult.refreshedFilePaths.length > 0) {
+        detailMessages.push(`refreshed tracked root-instruction shadows for ${options.shadowRefreshResult.refreshedFilePaths.join(", ")}`);
+    }
+    if (options.shadowRefreshResult.retiredFilePaths.length > 0) {
+        detailMessages.push(`retired tracked root-instruction shadows for ${options.shadowRefreshResult.retiredFilePaths.join(", ")} because upstream no longer tracks them`);
+    }
+    if (detailMessages.length === 0) {
+        return syncMessage;
+    }
+    return `${syncMessage}; ${detailMessages.join("; ")}`;
+}
+function suspendTrackedRootInstructionShadows(options) {
+    const plans = Object.entries(options.shadowedFiles)
+        .sort(([leftPath], [rightPath]) => leftPath.localeCompare(rightPath))
+        .map(([filePath, shadowedFile]) => {
+        assertTrackedRootInstructionShadowSafetyForAction({
+            repoRoot: options.repoRoot,
+            filePath,
+            action: "suspend",
+        });
+        if (shadowedFile.skip_worktree) {
+            assertTrackedRootInstructionShadowPristine({
+                repoRoot: options.repoRoot,
+                filePath,
+                shadowedFile,
+                action: "suspend",
+            });
+        }
+        return { filePath, shadowedFile };
+    });
+    for (const plan of plans) {
+        restoreTrackedRootInstructionShadowTarget({
+            repoRoot: options.repoRoot,
+            filePath: plan.filePath,
+        });
+    }
+    return Object.fromEntries(plans.map(({ filePath, shadowedFile }) => [
+        filePath,
+        {
+            ...shadowedFile,
+            skip_worktree: false,
+        },
+    ]));
+}
+function refreshTrackedRootInstructionShadows(options) {
+    const plans = Object.entries(options.shadowedFiles)
+        .sort(([leftPath], [rightPath]) => leftPath.localeCompare(rightPath))
+        .map(([filePath, shadowedFile]) => {
+        assertTrackedRootInstructionShadowSafetyForAction({
+            repoRoot: options.repoRoot,
+            filePath,
+            action: "refresh",
+        });
+        if (shadowedFile.skip_worktree) {
+            assertTrackedRootInstructionShadowPristine({
+                repoRoot: options.repoRoot,
+                filePath,
+                shadowedFile,
+                action: "refresh",
+            });
+        }
+        const headBlob = requireTrackedRootInstructionHeadBlob({
+            repoRoot: options.repoRoot,
+            filePath,
+            action: "refresh",
+        });
+        const render = (0, root_instruction_render_1.renderTrackedRootInstructionShadow)({
+            baseContent: headBlob.content,
+            overlayContent: shadowedFile.overlay,
+            bundleName: shadowedFile.bundle,
+            toolName: shadowedFile.tool,
+            strategy: shadowedFile.strategy,
+            allowReplace: true,
+        });
+        return { filePath, shadowedFile, headBlob, render };
+    });
+    for (const plan of plans) {
+        const targetPath = node_path_1.default.join(options.repoRoot, plan.filePath);
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(targetPath), { recursive: true });
+        node_fs_1.default.writeFileSync(targetPath, plan.render.rendered);
+        (0, git_index_1.setGitSkipWorktree)({ repoRoot: options.repoRoot, filePath: plan.filePath });
+    }
+    return Object.fromEntries(plans.map(({ filePath, shadowedFile, headBlob, render }) => [
+        filePath,
+        {
+            ...shadowedFile,
+            base_blob: headBlob.objectId,
+            overlay: shadowedFile.overlay,
+            overlay_fingerprint: render.overlayFingerprint,
+            rendered_fingerprint: render.renderedFingerprint,
+            skip_worktree: true,
+        },
+    ]));
+}
+function requireTrackedRootInstructionHeadBlob(options) {
+    const inspection = (0, git_index_1.inspectRootInstructionShadowTarget)({
+        repoRoot: options.repoRoot,
+        filePath: options.filePath,
+    });
+    if (inspection.headBlob) {
+        return inspection.headBlob;
+    }
+    throw new Error(`Cannot ${options.action} tracked root-instruction shadow for ${options.filePath} because the target does not have HEAD content`);
+}
+function assertTrackedRootInstructionShadowPristine(options) {
+    const targetPath = node_path_1.default.join(options.repoRoot, options.filePath);
+    if (!node_fs_1.default.existsSync(targetPath) || !node_fs_1.default.statSync(targetPath).isFile()) {
+        return;
+    }
+    if (fingerprintFile(targetPath) === options.shadowedFile.rendered_fingerprint) {
+        return;
+    }
+    throw new Error(`Cannot ${options.action} tracked root-instruction shadow for ${options.filePath} because the shadow file has local manual edits`);
+}
+function createDefaultPromptClient(libraryDir) {
+    if ((0, cli_1.isHeadlessMode)()) {
+        return (0, cli_1.createHeadlessPromptClient)();
+    }
+    const promptClient = (0, cli_1.createPromptClientForSelections)([]);
+    return {
+        async selectBundle(source, requestedTools) {
+            const availableBundles = (0, bundle_discovery_1.listCachedBundles)({ libraryDir })
+                .filter((bundle) => isBundleSelectionCandidate({ bundle, source, requestedTools }))
+                .map((bundle) => buildBundleSelection(bundle.source, bundle.bundle, libraryDir))
+                .sort(compareBundleSelections);
+            if (availableBundles.length === 0 && requestedTools?.length) {
+                throw new Error(`No bundles cached${source ? ` for ${source}` : ""} support selected agent(s): ${requestedTools.join(", ")}`);
+            }
+            return (0, cli_1.createPromptClientForSelections)(availableBundles).selectBundle(source);
+        },
+        selectBundleItems: promptClient.selectBundleItems,
+        selectBundleItemChoices: promptClient.selectBundleItemChoices,
+        selectBundleFromSelections: promptClient.selectBundleFromSelections,
+        selectAgents: promptClient.selectAgents,
+        resolveFileConflict: promptClient.resolveFileConflict,
+        confirmManagedFileRemoval: promptClient.confirmManagedFileRemoval,
+    };
+}
+function isBundleSelectionCandidate(options) {
+    if (options.source !== undefined &&
+        options.bundle.source !== options.source) {
+        return false;
+    }
+    if (!options.requestedTools?.length) {
+        return true;
+    }
+    const availableTools = Object.keys(options.bundle.manifest.tools);
+    return options.requestedTools.every((toolName) => availableTools.includes(toolName));
+}
+function buildBundleSelection(source, bundle, libraryDir) {
+    const revision = (0, bundle_fetch_1.readCachedSourceRevision)({ source, libraryDir });
+    const protocol = revision.remoteUrl
+        ? (0, bundle_discovery_1.detectSourceProtocol)(revision.remoteUrl)
+        : "https";
+    return {
+        bundle,
+        source,
+        protocol,
+    };
+}
+function compareBundleSelections(left, right) {
+    const bundleNameComparison = left.bundle.localeCompare(right.bundle);
+    if (bundleNameComparison !== 0) {
+        return bundleNameComparison;
+    }
+    return (left.source ?? "").localeCompare(right.source ?? "");
+}
+function renderBundleList(options) {
+    const bundles = (0, bundle_discovery_1.listCachedBundles)({ libraryDir: options.libraryDir }).filter((bundle) => options.source === undefined || bundle.source === options.source);
+    if (options.json) {
+        return JSON.stringify({
+            bundles: bundles.map((bundle) => ({
+                name: bundle.bundle,
+                source: bundle.source,
+                tools: Object.keys(bundle.manifest.tools),
+            })),
+        }, null, 2);
+    }
+    if (bundles.length === 0) {
+        return [
+            pc.bold("Available Bundles"),
+            "",
+            options.source !== undefined
+                ? `No cached bundles found for ${options.source}.`
+                : "No cached bundles found.",
+            "",
+            options.source === undefined
+                ? pc.dim("Add one with: skul add github.com/<owner>/<repo> <bundle-name>")
+                : pc.dim(`Cache one with: skul add ${options.source} <bundle-name>`),
+        ].join("\n");
+    }
+    return [
+        pc.bold("Available Bundles"),
+        "",
+        ...bundles.map((bundle) => {
+            const tools = Object.keys(bundle.manifest.tools).join(", ");
+            return `${pc.cyan(bundle.bundle)} [${bundle.source}] ${pc.dim(`(${tools})`)}`;
+        }),
+    ].join("\n");
+}
+function renderStatus(options) {
+    const gitContext = requireGitContext(options.cwd, "status");
+    const registry = readRegistryWithGuidance(options.registryFile);
+    const repoState = registry.repos[gitContext.repoFingerprint];
+    const worktreeState = registry.worktrees[gitContext.worktreeId];
+    const hasMaterializedBundles = worktreeState
+        ? worktreeHasMaterializedBundles(worktreeState.materialized_state)
+        : false;
+    const shadowedInstructionStatuses = collectShadowedInstructionStatuses({
+        repoRoot: gitContext.worktreeRoot,
+        shadowedFiles: worktreeState?.shadowed_files ?? {},
+    });
+    if (options.json) {
+        const desiredState = repoState?.desired_state ?? [];
+        const worktreeData = worktreeState
+            ? {
+                path: gitContext.worktreeRoot,
+                materialized: hasMaterializedBundles,
+                bundles: Object.fromEntries(Object.entries(worktreeState.materialized_state.bundles).map(([bundleName, bundleState]) => [
+                    bundleName,
+                    {
+                        tools: Object.fromEntries(Object.entries(bundleState.tools).map(([toolName, toolState]) => [
+                            toolName,
+                            { files: toolState.files },
+                        ])),
+                    },
+                ])),
+                shadowed_files: buildShadowedFilesJson(shadowedInstructionStatuses),
+                git_exclude_configured: (0, git_exclude_1.hasSkulExcludeBlock)({
+                    gitDir: gitContext.gitDir,
+                }),
+            }
+            : {
+                path: gitContext.worktreeRoot,
+                materialized: false,
+                bundles: {},
+                shadowed_files: buildShadowedFilesJson(shadowedInstructionStatuses),
+                git_exclude_configured: (0, git_exclude_1.hasSkulExcludeBlock)({
+                    gitDir: gitContext.gitDir,
+                }),
+            };
+        const suggestedAction = !hasMaterializedBundles && repoState && repoState.desired_state.length > 0
+            ? "skul apply"
+            : null;
+        return JSON.stringify({
+            repo: { desired_state: desiredState },
+            worktree: worktreeData,
+            ...(suggestedAction !== null
+                ? { suggested_action: suggestedAction }
+                : {}),
+        }, null, 2);
+    }
+    const lines = [pc.bold("Repository Desired State")];
+    if (repoState && repoState.desired_state.length > 0) {
+        for (const entry of repoState.desired_state) {
+            const toolSuffix = entry.tools ? ` (${entry.tools.join(", ")})` : "";
+            lines.push(`Bundle: ${pc.cyan(entry.bundle)}${toolSuffix}`);
+        }
+    }
+    else {
+        lines.push(pc.dim("Configured: no"));
+        lines.push(pc.dim('Run "skul add <bundle>" to get started'));
+    }
+    lines.push("", pc.bold("Current Worktree"), `Path: ${gitContext.worktreeRoot}`);
+    if (!hasMaterializedBundles) {
+        lines.push(pc.dim("Materialized: no"));
+        appendShadowedInstructionLines(lines, shadowedInstructionStatuses);
+        if (repoState && repoState.desired_state.length > 0) {
+            lines.push(pc.yellow('Suggested Action: run "skul apply"'));
+        }
+        return lines.join("\n");
+    }
+    lines.push(pc.green("Materialized: yes"), "", "Files:");
+    for (const [bundleName, bundleState] of Object.entries(worktreeState.materialized_state.bundles)) {
+        lines.push(`  Bundle: ${pc.cyan(bundleName)}`);
+        for (const [toolName, toolState] of Object.entries(bundleState.tools)) {
+            lines.push(`    Tool: ${toolName}`);
+            for (const file of toolState.files) {
+                lines.push(`      ${file}`);
+            }
+        }
+    }
+    appendShadowedInstructionLines(lines, shadowedInstructionStatuses);
+    lines.push("", pc.bold("Git Exclude:"));
+    lines.push(`  ${(0, git_exclude_1.hasSkulExcludeBlock)({ gitDir: gitContext.gitDir }) ? pc.green("configured") : pc.yellow("missing")}`);
+    return lines.join("\n");
+}
+function collectShadowedInstructionStatuses(options) {
+    return Object.entries(options.shadowedFiles)
+        .sort(([leftPath], [rightPath]) => leftPath.localeCompare(rightPath))
+        .map(([filePath, shadowedFile]) => collectShadowedInstructionStatus({
+        repoRoot: options.repoRoot,
+        filePath,
+        shadowedFile,
+    }));
+}
+function collectShadowedInstructionStatus(options) {
+    const inspection = (0, git_index_1.inspectRootInstructionShadowTarget)({
+        repoRoot: options.repoRoot,
+        filePath: options.filePath,
+    });
+    const targetPath = node_path_1.default.join(options.repoRoot, options.filePath);
+    const currentContent = readStatusTargetFile(targetPath);
+    const overlay = extractTrackedRootInstructionOverlay({
+        content: currentContent,
+        bundleName: options.shadowedFile.bundle,
+        strategy: options.shadowedFile.strategy,
+    });
+    return {
+        path: options.filePath,
+        ...options.shadowedFile,
+        active: overlay !== null,
+        base_fresh: inspection.headBlob?.objectId === options.shadowedFile.base_blob,
+        overlay_fresh: overlay !== null &&
+            fingerprintTextContent(overlay) ===
+                options.shadowedFile.overlay_fingerprint,
+        skip_worktree_active: inspection.indexFlags.includes("S"),
+        manual_edit_suspected: currentContent === null ||
+            fingerprintTextContent(currentContent) !==
+                options.shadowedFile.rendered_fingerprint,
+    };
+}
+function buildShadowedFilesJson(shadowedInstructionStatuses) {
+    return Object.fromEntries(shadowedInstructionStatuses.map((status) => [
+        status.path,
+        {
+            tool: status.tool,
+            bundle: status.bundle,
+            strategy: status.strategy,
+            base_blob: status.base_blob,
+            overlay_fingerprint: status.overlay_fingerprint,
+            rendered_fingerprint: status.rendered_fingerprint,
+            skip_worktree: status.skip_worktree,
+            active: status.active,
+            base_fresh: status.base_fresh,
+            overlay_fresh: status.overlay_fresh,
+            skip_worktree_active: status.skip_worktree_active,
+            manual_edit_suspected: status.manual_edit_suspected,
+        },
+    ]));
+}
+function appendShadowedInstructionLines(lines, shadowedInstructionStatuses) {
+    if (shadowedInstructionStatuses.length === 0) {
+        return;
+    }
+    lines.push("", pc.bold("Shadowed Instructions"));
+    for (const status of shadowedInstructionStatuses) {
+        lines.push(`  ${status.path}`);
+        lines.push(`    Bundle: ${pc.cyan(status.bundle)}`);
+        lines.push(`    Tool: ${status.tool}`);
+        lines.push(`    Strategy: ${status.strategy}`);
+        lines.push(`    Active: ${status.active ? pc.green("yes") : pc.yellow("no")}`);
+        lines.push(`    Base: ${status.base_fresh ? pc.green("current") : pc.yellow("stale")}`);
+        lines.push(`    Overlay: ${status.overlay_fresh ? pc.green("current") : pc.yellow("stale")}`);
+        lines.push(`    Skip-worktree: ${status.skip_worktree_active ? pc.green("set") : pc.yellow("missing")}`);
+        lines.push(`    Manual edits: ${status.manual_edit_suspected ? pc.yellow("suspected") : pc.green("no")}`);
+    }
+}
+function readStatusTargetFile(filePath) {
+    if (!node_fs_1.default.existsSync(filePath) || !node_fs_1.default.lstatSync(filePath).isFile()) {
+        return null;
+    }
+    return node_fs_1.default.readFileSync(filePath, "utf8");
+}
+function extractTrackedRootInstructionOverlay(options) {
+    if (options.content === null) {
+        return null;
+    }
+    if (options.strategy === "replace") {
+        return normalizeTrackedRootInstructionStatusContent(options.content);
+    }
+    const startMarker = `<!-- SKUL SHADOW START bundle=${options.bundleName} -->`;
+    const endMarker = "<!-- SKUL SHADOW END -->";
+    const startIndex = options.content.indexOf(startMarker);
+    if (startIndex < 0) {
+        return null;
+    }
+    const endIndex = options.content.indexOf(endMarker, startIndex);
+    if (endIndex < 0) {
+        return null;
+    }
+    return normalizeTrackedRootInstructionStatusContent(options.content.slice(startIndex, endIndex + endMarker.length));
+}
+function normalizeTrackedRootInstructionStatusContent(content) {
+    return content.replace(/\s+$/, "");
+}
+function fingerprintTextContent(content) {
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+function worktreeHasMaterializedBundles(materializedState) {
+    return Object.keys(materializedState.bundles).length > 0;
+}
+function renderUpdateCheck(options) {
+    const gitContext = requireGitContext(options.cwd, "check");
+    const registry = readRegistryWithGuidance(options.registryFile);
+    const repoState = registry.repos[gitContext.repoFingerprint];
+    const worktreeState = registry.worktrees[gitContext.worktreeId];
+    const entries = selectDesiredEntries(repoState?.desired_state ?? [], options.bundle, "check");
+    if (entries.length === 0) {
+        return `No bundles configured for this repository. Run "skul add <bundle>" to add one`;
+    }
+    const results = entries.map((entry) => {
+        const materializedBundle = worktreeState?.materialized_state.bundles[entry.bundle];
+        if (!entry.source) {
+            return {
+                bundle: entry.bundle,
+                status: "local-only",
+                source: null,
+                current_commit: null,
+                latest_commit: null,
+                worktree_commit: materializedBundle?.resolved_commit ?? null,
+                worktree_stale: false,
+            };
+        }
+        const remoteStatus = (0, bundle_fetch_1.inspectRemoteSource)({
+            source: entry.source,
+            libraryDir: options.libraryDir,
+            protocol: entry.protocol,
+            ref: entry.ref,
+        });
+        const desiredCommit = entry.resolved_commit ?? remoteStatus.currentCommit ?? null;
+        const worktreeCommit = materializedBundle?.resolved_commit ?? null;
+        const isPinned = remoteStatus.refKind === "commit";
+        const status = isPinned
+            ? "pinned"
+            : desiredCommit !== null && desiredCommit === remoteStatus.remoteCommit
+                ? "up-to-date"
+                : "update-available";
+        const worktreeStale = worktreeCommit !== null &&
+            desiredCommit !== null &&
+            worktreeCommit !== desiredCommit;
+        return {
+            bundle: entry.bundle,
+            status,
+            source: entry.source,
+            current_commit: desiredCommit,
+            latest_commit: isPinned ? desiredCommit : remoteStatus.remoteCommit,
+            worktree_commit: worktreeCommit,
+            worktree_stale: worktreeStale,
+        };
+    });
+    if (options.json) {
+        return JSON.stringify({ bundles: results }, null, 2);
+    }
+    const lines = results.map((result) => {
+        if (result.status === "local-only") {
+            return `${pc.cyan(result.bundle)}: local-only (no remote source to check)`;
+        }
+        const updateSuffix = result.status === "update-available" &&
+            result.current_commit &&
+            result.latest_commit
+            ? ` ${shortCommit(result.current_commit)} -> ${shortCommit(result.latest_commit)}`
+            : "";
+        const staleSuffix = result.worktree_stale ? " (worktree stale)" : "";
+        return `${pc.cyan(result.bundle)}: ${result.status}${updateSuffix}${staleSuffix}`;
+    });
+    const hasUpdates = results.some((r) => r.status === "update-available");
+    if (hasUpdates) {
+        lines.push("", pc.dim('Run "skul update" to apply available updates'));
+    }
+    return lines.join("\n");
+}
+async function updateBundles(options) {
+    const gitContext = requireGitContext(options.cwd, "update");
+    let registry = readRegistryWithGuidance(options.registryFile);
+    const repoState = registry.repos[gitContext.repoFingerprint];
+    const worktreeState = registry.worktrees[gitContext.worktreeId];
+    const entries = selectDesiredEntries(repoState?.desired_state ?? [], options.bundle, "update");
+    if (entries.length === 0) {
+        return `No bundles configured for this repository. Run "skul add <bundle>" to add one`;
+    }
+    const skippedLocalOnly = [];
+    const updatePlans = entries.flatMap((entry) => {
+        if (!entry.source) {
+            skippedLocalOnly.push(entry.bundle);
+            return [];
+        }
+        const remoteStatus = (0, bundle_fetch_1.inspectRemoteSource)({
+            source: entry.source,
+            libraryDir: options.libraryDir,
+            protocol: entry.protocol,
+            ref: entry.ref,
+        });
+        const currentCommit = entry.resolved_commit ?? remoteStatus.currentCommit;
+        if ((currentCommit !== undefined &&
+            currentCommit === remoteStatus.remoteCommit) ||
+            remoteStatus.refKind === "commit") {
+            return [];
+        }
+        return [
+            {
+                entry,
+                currentCommit,
+                remoteStatus,
+            },
+        ];
+    });
+    const localOnlyNote = skippedLocalOnly.length > 0
+        ? `Skipped (local-only): ${skippedLocalOnly.join(", ")}`
+        : "";
+    if (updatePlans.length === 0) {
+        if (skippedLocalOnly.length === entries.length) {
+            return `No remote-backed bundles to update (${skippedLocalOnly.join(", ")} ${skippedLocalOnly.length === 1 ? "is" : "are"} local-only)`;
+        }
+        return [localOnlyNote, "All selected bundles are already up to date"]
+            .filter(Boolean)
+            .join("\n");
+    }
+    if (options.dryRun) {
+        const dryLines = updatePlans.map(({ entry, currentCommit, remoteStatus }) => `${pc.yellow("DRY RUN:")} Would update ${entry.bundle}${formatCommitTransition(currentCommit, remoteStatus.remoteCommit)}`);
+        return [localOnlyNote, ...dryLines].filter(Boolean).join("\n");
+    }
+    const existingWorktreeState = registry.worktrees[gitContext.worktreeId]?.materialized_state;
+    let currentBundles = {
+        ...(existingWorktreeState?.bundles ?? {}),
+    };
+    let currentShadowedFiles = { ...(worktreeState?.shadowed_files ?? {}) };
+    const nextDesiredState = [...(repoState?.desired_state ?? [])];
+    const outputLines = [];
+    let rootInstructionBaseContents = worktreeState?.materialized_state.root_instruction_base_contents;
+    for (const { entry, currentCommit, remoteStatus } of updatePlans) {
+        const existingBundleState = currentBundles[entry.bundle];
+        const toolsToRefresh = getToolsToRefresh(entry, existingBundleState);
+        const bundleStateToReplace = existingBundleState && toolsToRefresh && toolsToRefresh.length > 0
+            ? {
+                ...existingBundleState,
+                tools: Object.fromEntries(Object.entries(existingBundleState.tools).filter(([toolName]) => toolsToRefresh.includes(toolName))),
+            }
+            : existingBundleState;
+        const initialRevision = (0, bundle_fetch_1.readCachedSourceRevision)({
+            source: entry.source,
+            libraryDir: options.libraryDir,
+            protocol: entry.protocol,
+        });
+        try {
+            const refreshed = (0, bundle_fetch_1.updateCachedRemoteSource)({
+                source: entry.source,
+                libraryDir: options.libraryDir,
+                protocol: entry.protocol,
+                ref: entry.ref,
+            });
+            const cachedBundle = findCachedBundleWithGuidance({
+                libraryDir: options.libraryDir,
+                bundle: entry.bundle,
+                source: entry.source,
+            });
+            const plannedWriteTargets = (0, bundle_materialization_1.previewMaterializeBundleWriteTargets)({
+                repoRoot: gitContext.worktreeRoot,
+                bundleDir: node_path_1.default.dirname(cachedBundle.manifestFile),
+                manifest: cachedBundle.manifest,
+                tools: toolsToRefresh,
+                itemSelectors: entry.items,
+                disableModelInvocation: entry.disable_model_invocation,
+            });
+            const plannedRootInstructionTargets = new Set(plannedWriteTargets.filter((filePath) => (0, root_instruction_render_1.isRootInstructionPath)(filePath)));
+            const trackedRootInstructionShadowPlan = planTrackedRootInstructionShadows({
+                repoRoot: gitContext.worktreeRoot,
+                bundleDir: node_path_1.default.dirname(cachedBundle.manifestFile),
+                manifest: cachedBundle.manifest,
+                toolNames: selectTrackedRootInstructionShadowToolNames({
+                    existingBundleState,
+                    nextToolNames: toolsToRefresh ??
+                        Object.keys(cachedBundle.manifest.tools),
+                }),
+                itemSelectors: entry.items,
+                targetPaths: plannedRootInstructionTargets,
+                bundleName: entry.bundle,
+                bundleSource: entry.source,
+                existingShadowedFiles: currentShadowedFiles,
+                materializedBundles: currentBundles,
+            });
+            if (existingBundleState) {
+                const replacementAllowed = await confirmManagedFileRemovals(gitContext.worktreeRoot, excludeShadowedTrackedRootInstructionTargets(flattenBundleState(bundleStateToReplace), trackedRootInstructionShadowPlan.deferredMaterializationTargets), options.prompts, "replace");
+                if (!replacementAllowed) {
+                    throw new Error("Replacement aborted because a modified managed file was kept");
+                }
+            }
+            assertTrackedRootInstructionShadowPlanCanApply({
+                repoRoot: gitContext.worktreeRoot,
+                bundleName: entry.bundle,
+                existingShadowedFiles: currentShadowedFiles,
+                plan: trackedRootInstructionShadowPlan,
+            });
+            rootInstructionBaseContents = (0, root_instruction_state_1.captureRootInstructionBaseContents)({
+                repoRoot: gitContext.worktreeRoot,
+                targetPaths: trackedRootInstructionShadowPlan.untrackedTargetPaths,
+                existingBaseContents: rootInstructionBaseContents,
+                managedTargetPaths: (0, root_instruction_state_1.collectManagedRootInstructionTargets)(currentBundles),
+            });
+            (0, root_instruction_state_1.assertManagedRootInstructionSyncSourcesCached)({
+                desiredState: nextDesiredState,
+                materializedBundles: currentBundles,
+                targetPaths: trackedRootInstructionShadowPlan.untrackedTargetPaths,
+                resolveCachedBundle: (entry) => resolveDesiredCachedBundle(options.libraryDir, entry),
+            });
+            if (existingBundleState) {
+                assertTrackedRootInstructionShadowSafetyForPaths({
+                    repoRoot: gitContext.worktreeRoot,
+                    operation: "refresh",
+                    filePaths: plannedWriteTargets,
+                });
+            }
+            const desiredIndex = nextDesiredState.findIndex((candidate) => candidate.bundle === entry.bundle);
+            nextDesiredState[desiredIndex] = {
+                ...nextDesiredState[desiredIndex],
+                ...(refreshed.resolvedRef !== undefined
+                    ? { resolved_ref: refreshed.resolvedRef }
+                    : {}),
+                resolved_commit: refreshed.currentCommit,
+            };
+            if (bundleStateToReplace) {
+                removeManagedPaths(gitContext.worktreeRoot, excludeShadowedTrackedRootInstructionTargets(flattenBundleState(bundleStateToReplace), trackedRootInstructionShadowPlan.deferredMaterializationTargets));
+                const materializedResult = await (0, bundle_materialization_1.materializeBundle)({
+                    repoRoot: gitContext.worktreeRoot,
+                    bundleDir: node_path_1.default.dirname(cachedBundle.manifestFile),
+                    manifest: cachedBundle.manifest,
+                    tools: toolsToRefresh,
+                    itemSelectors: entry.items,
+                    bundleName: entry.bundle,
+                    bundleSource: entry.source,
+                    assertSafeWriteTarget: createTrackedRootInstructionShadowSafetyAssertion({
+                        repoRoot: gitContext.worktreeRoot,
+                        operation: existingBundleState ? "refresh" : "create",
+                    }),
+                    allowFileOverwriteTargets: (0, root_instruction_state_1.collectManagedRootInstructionTargets)(currentBundles),
+                    deferredWriteTargets: trackedRootInstructionShadowPlan.deferredMaterializationTargets,
+                    rootInstructionBaseContents,
+                    resolveFileConflict: options.prompts.resolveFileConflict,
+                    disableModelInvocation: entry.disable_model_invocation,
+                });
+                currentBundles = {
+                    ...currentBundles,
+                    [entry.bundle]: buildMaterializedBundleState({
+                        existingBundleState,
+                        materializedResult,
+                        repoRoot: gitContext.worktreeRoot,
+                        source: entry.source,
+                        resolvedCommit: refreshed.currentCommit,
+                        selectedTools: toolsToRefresh,
+                        selectedItems: entry.items,
+                    }),
+                };
+                currentShadowedFiles = applyTrackedRootInstructionShadowPlan({
+                    repoRoot: gitContext.worktreeRoot,
+                    bundleName: entry.bundle,
+                    existingShadowedFiles: currentShadowedFiles,
+                    plan: trackedRootInstructionShadowPlan,
+                });
+                const syncedRootInstructionPaths = (0, root_instruction_state_1.syncManagedRootInstructionFiles)({
+                    repoRoot: gitContext.worktreeRoot,
+                    desiredState: nextDesiredState,
+                    materializedBundles: currentBundles,
+                    rootInstructionBaseContents,
+                    targetPaths: trackedRootInstructionShadowPlan.untrackedTargetPaths,
+                    resolveCachedBundle: (entry) => resolveDesiredCachedBundle(options.libraryDir, entry),
+                });
+                currentBundles = (0, root_instruction_state_1.refreshManagedFileFingerprintsForPaths)(gitContext.worktreeRoot, currentBundles, syncedRootInstructionPaths);
+            }
+            outputLines.push(pc.green(`Updated ${entry.bundle}${formatCommitTransition(currentCommit, remoteStatus.remoteCommit)}`));
+        }
+        catch (error) {
+            if (!initialRevision.cached) {
+                (0, bundle_fetch_1.removeCachedRemoteSource)({
+                    source: entry.source,
+                    libraryDir: options.libraryDir,
+                    protocol: entry.protocol,
+                });
+            }
+            else if (initialRevision.currentCommit) {
+                (0, bundle_fetch_1.restoreCachedRemoteSourceRevision)({
+                    source: entry.source,
+                    libraryDir: options.libraryDir,
+                    protocol: entry.protocol,
+                    ref: entry.ref,
+                    commit: initialRevision.currentCommit,
+                    refName: initialRevision.currentRef,
+                });
+            }
+            throw error;
+        }
+    }
+    registry = (0, registry_1.upsertRepoState)(registry, gitContext.repoFingerprint, {
+        repo_root: gitContext.repoRoot,
+        desired_state: nextDesiredState,
+    });
+    if (registry.worktrees[gitContext.worktreeId] ||
+        Object.keys(currentBundles).length > 0) {
+        const managedFiles = collectAllFiles({
+            bundles: currentBundles,
+            exclude_configured: false,
+            ...(rootInstructionBaseContents !== undefined
+                ? { root_instruction_base_contents: rootInstructionBaseContents }
+                : {}),
+        });
+        const newMaterializedState = {
+            bundles: currentBundles,
+            exclude_configured: managedFiles.length > 0,
+            ...(rootInstructionBaseContents !== undefined
+                ? { root_instruction_base_contents: rootInstructionBaseContents }
+                : {}),
+        };
+        if (Object.keys(currentBundles).length > 0) {
+            if (managedFiles.length > 0) {
+                (0, git_exclude_1.configureSkulExcludeBlock)({
+                    gitDir: gitContext.gitDir,
+                    files: managedFiles,
+                });
+            }
+            else {
+                (0, git_exclude_1.removeSkulExcludeBlock)({ gitDir: gitContext.gitDir });
+            }
+            registry = (0, registry_1.upsertWorktreeState)(registry, gitContext.worktreeId, {
+                repo_fingerprint: gitContext.repoFingerprint,
+                path: gitContext.worktreeRoot,
+                materialized_state: newMaterializedState,
+                shadowed_files: currentShadowedFiles,
+            });
+        }
+        else {
+            (0, git_exclude_1.removeSkulExcludeBlock)({ gitDir: gitContext.gitDir });
+            if (Object.keys(currentShadowedFiles).length > 0) {
+                registry = (0, registry_1.upsertWorktreeState)(registry, gitContext.worktreeId, {
+                    repo_fingerprint: gitContext.repoFingerprint,
+                    path: gitContext.worktreeRoot,
+                    materialized_state: newMaterializedState,
+                    shadowed_files: currentShadowedFiles,
+                });
+            }
+            else {
+                registry = (0, registry_1.removeWorktreeState)(registry, gitContext.worktreeId);
+            }
+        }
+    }
+    (0, registry_1.writeRegistryFile)(options.registryFile, registry);
+    return [localOnlyNote, ...outputLines].filter(Boolean).join("\n");
+}
+async function applyBundle(options) {
+    const gitContext = requireGitContext(options.cwd, "add");
+    // Skip cloning in dry-run: when a remote source is specified and not yet
+    // cached, return a preview message immediately so no network I/O occurs.
+    // (When source is omitted, fetchBundleSourceForApply is a no-op, so the
+    // dryRun guard at the end of this function is sufficient for that case.)
+    if (options.dryRun && options.source) {
+        const { cached } = (0, bundle_fetch_1.readCachedSourceRevision)({
+            source: options.source,
+            libraryDir: options.libraryDir,
+            protocol: options.protocol,
+        });
+        if (!cached) {
+            const toolsLabel = options.agents.length > 0
+                ? options.agents.join(", ")
+                : "available tools";
+            return [
+                pc.dim(`(would clone ${options.source})`),
+                `${pc.yellow("DRY RUN:")} Would apply ${options.bundle} for ${toolsLabel}`,
+            ].join("\n");
+        }
+    }
+    const registryBeforePrepare = readRegistryWithGuidance(options.registryFile);
+    if (shouldApplySelectedItemsAcrossSourceBundles(options)) {
+        return applySelectedItemsAcrossSourceBundles({
+            cwd: options.cwd,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            source: options.source,
+            protocol: options.protocol,
+            agents: options.agents,
+            includeItems: options.includeItems,
+            dryRun: options.dryRun,
+            ref: options.ref,
+            existingDesiredState: registryBeforePrepare.repos[gitContext.repoFingerprint]
+                ?.desired_state ?? [],
+            disableModelInvocation: options.disableModelInvocation,
+        });
+    }
+    const preparedBundle = await prepareApplyBundle({
+        bundle: options.bundle,
+        source: options.source,
+        protocol: options.protocol,
+        requestedTools: options.agents,
+        requestedItems: options.includeItems,
+        selectItems: options.selectItems,
+        replaceItems: options.replaceItems,
+        prompts: options.prompts,
+        libraryDir: options.libraryDir,
+        ref: options.ref,
+        inferredBundleFromSource: options.inferredBundleFromSource,
+        existingDesiredState: registryBeforePrepare.repos[gitContext.repoFingerprint]?.desired_state ??
+            [],
+        refreshedSources: options.refreshedSources,
+    });
+    if (options.dryRun) {
+        return [
+            ...preparedBundle.cloneLines,
+            `${pc.yellow("DRY RUN:")} Would ${formatApplyBundleMessage({
+                bundle: preparedBundle.cachedBundle.bundle,
+                toolLabel: preparedBundle.toolLabel,
+                items: preparedBundle.replacesItemSelection
+                    ? preparedBundle.selectedItems
+                    : undefined,
+            })}`,
+        ].join("\n");
+    }
+    let registry = registryBeforePrepare;
+    const existingWorktreeState = registry.worktrees[gitContext.worktreeId]?.materialized_state;
+    let currentShadowedFiles = {
+        ...(registry.worktrees[gitContext.worktreeId]?.shadowed_files ?? {}),
+    };
+    let rootInstructionBaseContents = existingWorktreeState?.root_instruction_base_contents;
+    const existingBundleState = existingWorktreeState?.bundles[preparedBundle.cachedBundle.bundle];
+    const plannedWriteTargets = (0, bundle_materialization_1.previewMaterializeBundleWriteTargets)({
+        repoRoot: gitContext.worktreeRoot,
+        bundleDir: node_path_1.default.dirname(preparedBundle.cachedBundle.manifestFile),
+        manifest: preparedBundle.cachedBundle.manifest,
+        tools: preparedBundle.selectedTools,
+        itemSelectors: preparedBundle.selectedItems,
+        disableModelInvocation: options.disableModelInvocation,
+    });
+    const plannedRootInstructionTargets = new Set(plannedWriteTargets.filter((filePath) => (0, root_instruction_render_1.isRootInstructionPath)(filePath)));
+    const trackedRootInstructionShadowPlan = planTrackedRootInstructionShadows({
+        repoRoot: gitContext.worktreeRoot,
+        bundleDir: node_path_1.default.dirname(preparedBundle.cachedBundle.manifestFile),
+        manifest: preparedBundle.cachedBundle.manifest,
+        toolNames: selectTrackedRootInstructionShadowToolNames({
+            existingBundleState,
+            nextToolNames: preparedBundle.nextToolNames,
+        }),
+        itemSelectors: preparedBundle.selectedItems,
+        targetPaths: plannedRootInstructionTargets,
+        bundleName: preparedBundle.cachedBundle.bundle,
+        bundleSource: preparedBundle.bundleSource,
+        existingShadowedFiles: currentShadowedFiles,
+        materializedBundles: existingWorktreeState?.bundles ?? {},
+    });
+    rootInstructionBaseContents = (0, root_instruction_state_1.captureRootInstructionBaseContents)({
+        repoRoot: gitContext.worktreeRoot,
+        targetPaths: trackedRootInstructionShadowPlan.untrackedTargetPaths,
+        existingBaseContents: rootInstructionBaseContents,
+        managedTargetPaths: (0, root_instruction_state_1.collectManagedRootInstructionTargets)(existingWorktreeState?.bundles ?? {}),
+    });
+    const existingDesiredState = registry.repos[gitContext.repoFingerprint]?.desired_state ?? [];
+    (0, root_instruction_state_1.assertManagedRootInstructionSyncSourcesCached)({
+        desiredState: existingDesiredState,
+        materializedBundles: existingWorktreeState?.bundles ?? {},
+        targetPaths: trackedRootInstructionShadowPlan.untrackedTargetPaths,
+        resolveCachedBundle: (entry) => resolveDesiredCachedBundle(options.libraryDir, entry),
+    });
+    let pathsToReplace = null;
+    if (existingBundleState) {
+        assertTrackedRootInstructionShadowSafetyForPaths({
+            repoRoot: gitContext.worktreeRoot,
+            operation: "refresh",
+            filePaths: plannedWriteTargets,
+        });
+        // When a tool flag is specified, only replace the selected tool targets.
+        const toolsToReplace = preparedBundle.hasToolSelection
+            ? options.agents.filter((t) => t in existingBundleState.tools)
+            : Object.keys(existingBundleState.tools);
+        pathsToReplace = excludeShadowedTrackedRootInstructionTargets(flattenBundleState({
+            tools: Object.fromEntries(toolsToReplace.map((t) => [t, existingBundleState.tools[t]])),
+        }), trackedRootInstructionShadowPlan.deferredMaterializationTargets);
+        const replacementAllowed = await confirmManagedFileRemovals(gitContext.worktreeRoot, pathsToReplace, options.prompts, "replace");
+        if (!replacementAllowed) {
+            throw new Error("Replacement aborted because a modified managed file was kept");
+        }
+    }
+    const sharedRootInstructionState = (0, root_instruction_state_1.collectSharedRootInstructionState)(existingWorktreeState?.bundles ?? {}, plannedWriteTargets, preparedBundle.cachedBundle.bundle);
+    if (sharedRootInstructionState.files.length > 0) {
+        const replacementAllowed = await confirmManagedFileRemovals(gitContext.worktreeRoot, sharedRootInstructionState, options.prompts, "replace");
+        if (!replacementAllowed) {
+            throw new Error("Replacement aborted because a modified managed file was kept");
+        }
+    }
+    assertTrackedRootInstructionShadowPlanCanApply({
+        repoRoot: gitContext.worktreeRoot,
+        bundleName: preparedBundle.cachedBundle.bundle,
+        existingShadowedFiles: currentShadowedFiles,
+        plan: trackedRootInstructionShadowPlan,
+    });
+    assertTrackedRootInstructionShadowSafetyForPaths({
+        repoRoot: gitContext.worktreeRoot,
+        operation: existingBundleState ? "refresh" : "create",
+        filePaths: plannedWriteTargets,
+    });
+    if (pathsToReplace) {
+        removeManagedPaths(gitContext.worktreeRoot, pathsToReplace);
+    }
+    const materializedResult = await (0, bundle_materialization_1.materializeBundle)({
+        repoRoot: gitContext.worktreeRoot,
+        bundleDir: node_path_1.default.dirname(preparedBundle.cachedBundle.manifestFile),
+        manifest: preparedBundle.cachedBundle.manifest,
+        tools: preparedBundle.selectedTools,
+        itemSelectors: preparedBundle.selectedItems,
+        bundleName: preparedBundle.cachedBundle.bundle,
+        bundleSource: preparedBundle.bundleSource,
+        assertSafeWriteTarget: createTrackedRootInstructionShadowSafetyAssertion({
+            repoRoot: gitContext.worktreeRoot,
+            operation: existingBundleState ? "refresh" : "create",
+        }),
+        allowFileOverwriteTargets: (0, root_instruction_state_1.collectManagedRootInstructionTargets)(existingWorktreeState?.bundles ?? {}),
+        deferredWriteTargets: trackedRootInstructionShadowPlan.deferredMaterializationTargets,
+        rootInstructionBaseContents,
+        resolveFileConflict: options.prompts.resolveFileConflict,
+        disableModelInvocation: options.disableModelInvocation,
+    });
+    currentShadowedFiles = applyTrackedRootInstructionShadowPlan({
+        repoRoot: gitContext.worktreeRoot,
+        bundleName: preparedBundle.cachedBundle.bundle,
+        existingShadowedFiles: currentShadowedFiles,
+        plan: trackedRootInstructionShadowPlan,
+    });
+    const newBundleState = buildMaterializedBundleState({
+        existingBundleState,
+        materializedResult,
+        repoRoot: gitContext.worktreeRoot,
+        source: preparedBundle.bundleSource,
+        resolvedCommit: preparedBundle.sourceRevision?.currentCommit,
+        selectedTools: preparedBundle.selectedTools,
+        selectedItems: preparedBundle.selectedItems,
+    });
+    const newDesiredEntry = buildDesiredEntryForAppliedBundle({
+        existingDesiredState,
+        cachedBundle: preparedBundle.cachedBundle,
+        requestedSource: options.source,
+        requestedProtocol: options.protocol,
+        requestedRef: options.ref,
+        requestedTools: preparedBundle.selectedTools,
+        requestedItems: preparedBundle.selectedItems,
+        replaceRequestedItems: preparedBundle.replacesItemSelection,
+        sourceRevision: preparedBundle.sourceRevision,
+        disableModelInvocation: options.disableModelInvocation,
+    });
+    const newDesiredState = [
+        ...upsertDesiredEntryPreservingOrder(existingDesiredState, newDesiredEntry),
+    ];
+    registry = (0, registry_1.upsertRepoState)(registry, gitContext.repoFingerprint, {
+        repo_root: gitContext.repoRoot,
+        desired_state: newDesiredState,
+    });
+    // Merge into existing materialized state, preserving other bundles
+    const newMatState = {
+        bundles: {
+            ...(existingWorktreeState?.bundles ?? {}),
+            [preparedBundle.cachedBundle.bundle]: newBundleState,
+        },
+        exclude_configured: false,
+        ...(rootInstructionBaseContents !== undefined
+            ? { root_instruction_base_contents: rootInstructionBaseContents }
+            : {}),
+    };
+    const syncedRootInstructionPaths = (0, root_instruction_state_1.syncManagedRootInstructionFiles)({
+        repoRoot: gitContext.worktreeRoot,
+        desiredState: newDesiredState,
+        materializedBundles: newMatState.bundles,
+        rootInstructionBaseContents,
+        targetPaths: trackedRootInstructionShadowPlan.untrackedTargetPaths,
+        resolveCachedBundle: (entry) => resolveDesiredCachedBundle(options.libraryDir, entry),
+    });
+    newMatState.bundles = (0, root_instruction_state_1.refreshManagedFileFingerprintsForPaths)(gitContext.worktreeRoot, newMatState.bundles, syncedRootInstructionPaths);
+    const managedFiles = collectAllFiles(newMatState);
+    newMatState.exclude_configured = managedFiles.length > 0;
+    if (managedFiles.length > 0) {
+        (0, git_exclude_1.configureSkulExcludeBlock)({
+            gitDir: gitContext.gitDir,
+            files: managedFiles,
+        });
+    }
+    else {
+        (0, git_exclude_1.removeSkulExcludeBlock)({ gitDir: gitContext.gitDir });
+    }
+    registry = (0, registry_1.upsertWorktreeState)(registry, gitContext.worktreeId, {
+        repo_fingerprint: gitContext.repoFingerprint,
+        path: gitContext.worktreeRoot,
+        materialized_state: newMatState,
+        shadowed_files: currentShadowedFiles,
+    });
+    (0, registry_1.writeRegistryFile)(options.registryFile, registry);
+    return [
+        ...preparedBundle.cloneLines,
+        pc.green(formatAppliedBundleMessage({
+            bundle: preparedBundle.cachedBundle.bundle,
+            toolLabel: preparedBundle.toolLabel,
+            items: preparedBundle.replacesItemSelection
+                ? preparedBundle.selectedItems
+                : undefined,
+        })),
+    ].join("\n");
+}
+function formatAppliedBundleMessage(options) {
+    return formatApplyBundleMessage({
+        bundle: options.bundle,
+        toolLabel: options.toolLabel,
+        items: options.items,
+        action: "Applied",
+    });
+}
+function formatApplyBundleMessage(options) {
+    const itemLabel = options.items !== undefined && options.items.length > 0
+        ? `: ${options.items.join(", ")}`
+        : "";
+    return `${options.action ?? "apply"} ${options.bundle} for ${options.toolLabel}${itemLabel}`;
+}
+function shouldApplySelectedItemsAcrossSourceBundles(options) {
+    return (options.selectItems &&
+        options.source !== undefined &&
+        options.inferredBundleFromSource === true);
+}
+async function applySelectedItemsAcrossSourceBundles(options) {
+    const refreshedSources = new Set();
+    const cloneLines = refreshBundleSourceForApply({
+        source: options.source,
+        libraryDir: options.libraryDir,
+        protocol: options.protocol,
+        ref: options.ref,
+    }, refreshedSources);
+    const selection = await selectSourceBundleItemApplyTargets({
+        libraryDir: options.libraryDir,
+        source: options.source,
+        requestedTools: options.agents,
+        requestedItems: options.includeItems,
+        prompts: options.prompts,
+        existingDesiredState: options.existingDesiredState,
+    });
+    const outputLines = [];
+    for (const target of selection.removeTargets) {
+        outputLines.push(await removeBundle({
+            cwd: options.cwd,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            bundle: target.bundle,
+            source: target.source,
+            includeItems: [],
+            selectItems: false,
+            dryRun: options.dryRun,
+        }));
+    }
+    for (const target of selection.applyTargets) {
+        outputLines.push(await applyBundle({
+            cwd: options.cwd,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            bundle: target.bundle,
+            source: target.source,
+            protocol: options.protocol,
+            agents: target.tools,
+            includeItems: target.items,
+            selectItems: false,
+            replaceItems: true,
+            dryRun: options.dryRun,
+            ref: options.ref,
+            refreshedSources,
+            disableModelInvocation: options.disableModelInvocation,
+        }));
+    }
+    return [...cloneLines, ...outputLines].filter(Boolean).join("\n");
+}
+async function selectSourceBundleItemApplyTargets(options) {
+    const selectedTools = await selectToolsForSourceBundleItems(options);
+    const choices = listSourceBundleItemApplyChoices({
+        libraryDir: options.libraryDir,
+        source: options.source,
+        tools: selectedTools,
+    });
+    if (choices.length === 0) {
+        throw new Error(`No selectable bundle items found for ${options.source}`);
+    }
+    const requestedItems = (0, bundle_items_1.normalizeBundleItemSelectors)(options.requestedItems);
+    const selectedValues = selectInitialSourceBundleItemApplyValues({
+        choices,
+        requestedItems,
+        existingDesiredState: options.existingDesiredState,
+    });
+    const selections = await options.prompts.selectBundleItemChoices(choices, selectedValues, "install");
+    const removeTargets = listDeselectedSourceBundleApplyTargets({
+        choices,
+        selectedValues: selections,
+        existingDesiredState: options.existingDesiredState,
+        source: options.source,
+    });
+    if (selections.length === 0 && removeTargets.length === 0) {
+        throw new Error("No bundle items selected for install");
+    }
+    return {
+        applyTargets: groupBundleItemApplyTargets({
+            choices,
+            selectedValues: selections,
+        }),
+        removeTargets,
+    };
+}
+async function selectToolsForSourceBundleItems(options) {
+    const availableTools = listSelectableToolsForSource({
+        libraryDir: options.libraryDir,
+        source: options.source,
+    }).filter((toolName) => options.global !== true || (0, tool_mapping_1.globalCapableToolNames)().includes(toolName));
+    if (options.requestedTools.length > 0) {
+        assertRequestedToolsAreSelectableForSource({
+            requestedTools: options.requestedTools,
+            availableTools,
+            source: options.source,
+        });
+        return options.requestedTools;
+    }
+    if (availableTools.length === 0) {
+        throw new Error(`No selectable agents found for ${options.source}`);
+    }
+    if (availableTools.length === 1) {
+        return availableTools;
+    }
+    return options.prompts.selectAgents(availableTools);
+}
+function assertRequestedToolsAreSelectableForSource(options) {
+    const unsupportedTools = options.requestedTools.filter((toolName) => !options.availableTools.includes(toolName));
+    if (unsupportedTools.length === 0) {
+        return;
+    }
+    throw new Error(`Source ${options.source} does not support agent(s): ${unsupportedTools.join(", ")}\nSupported agents: ${options.availableTools.join(", ")}`);
+}
+function listSourceBundleItemApplyChoices(options) {
+    return (0, bundle_discovery_1.listCachedBundles)({ libraryDir: options.libraryDir })
+        .filter((bundle) => bundle.source === options.source)
+        .flatMap((bundle) => {
+        const bundleTools = options.tools.filter((toolName) => Object.keys(bundle.manifest.tools).includes(toolName));
+        if (bundleTools.length === 0) {
+            return [];
+        }
+        const availableItems = (0, bundle_items_1.listSelectableBundleItems)({
+            bundleDir: node_path_1.default.dirname(bundle.manifestFile),
+            manifest: bundle.manifest,
+            tools: bundleTools,
+        });
+        return availableItems.map((item) => ({
+            value: encodeBundleItemApplyChoice({
+                source: bundle.source,
+                bundle: bundle.bundle,
+                item,
+            }),
+            label: `${bundle.bundle}: ${item}`,
+            source: bundle.source,
+            bundle: bundle.bundle,
+            item,
+            tools: bundleTools,
+            availableTools: Object.keys(bundle.manifest.tools),
+        }));
+    });
+}
+function selectInitialSourceBundleItemApplyValues(options) {
+    const selectedValues = new Set();
+    const requestedItemSet = new Set(options.requestedItems);
+    for (const choice of options.choices) {
+        if (requestedItemSet.has(choice.item)) {
+            selectedValues.add(choice.value);
+            continue;
+        }
+        const existingEntry = options.existingDesiredState.find((entry) => entry.bundle === choice.bundle && entry.source === choice.source);
+        if (existingEntry &&
+            bundleItemApplyChoiceMatchesDesiredTools({
+                choice,
+                desiredEntry: existingEntry,
+            }) &&
+            (existingEntry.items === undefined ||
+                existingEntry.items.includes(choice.item))) {
+            selectedValues.add(choice.value);
+        }
+    }
+    const missingItems = options.requestedItems.filter((item) => !options.choices.some((choice) => choice.item === item));
+    if (missingItems.length > 0) {
+        throw new Error(`Bundle item(s) are not available: ${missingItems.join(", ")}`);
+    }
+    return Array.from(selectedValues);
+}
+function listDeselectedSourceBundleApplyTargets(options) {
+    const selectedBundleKeys = new Set(options.selectedValues.map((value) => {
+        const choice = options.choices.find((candidate) => candidate.value === value);
+        if (!choice) {
+            throw new Error(`Selected bundle item is not available: ${value}`);
+        }
+        return encodeBundleIdentity(choice);
+    }));
+    const choicesByBundle = groupBundleItemApplyChoices(options.choices);
+    const targets = [];
+    for (const entry of options.existingDesiredState) {
+        const key = encodeBundleIdentity(entry);
+        if (selectedBundleKeys.has(key)) {
+            continue;
+        }
+        const bundleChoices = choicesByBundle.get(key);
+        if (!bundleChoices) {
+            if (entry.source === options.source) {
+                targets.push({ bundle: entry.bundle, source: entry.source });
+            }
+            continue;
+        }
+        if (!bundleItemApplyChoiceCoversDesiredTools({
+            choice: bundleChoices[0],
+            desiredEntry: entry,
+        })) {
+            continue;
+        }
+        const activeChoices = bundleChoices.filter((choice) => bundleItemApplyChoiceMatchesDesiredState({
+            choice,
+            desiredEntry: entry,
+        }));
+        if (activeChoices.length === 0) {
+            continue;
+        }
+        targets.push({
+            bundle: entry.bundle,
+            source: entry.source ?? activeChoices[0].source,
+        });
+    }
+    return targets;
+}
+function groupBundleItemApplyChoices(choices) {
+    const choicesByBundle = new Map();
+    for (const choice of choices) {
+        const key = encodeBundleIdentity(choice);
+        const bundleChoices = choicesByBundle.get(key) ?? [];
+        bundleChoices.push(choice);
+        choicesByBundle.set(key, bundleChoices);
+    }
+    return choicesByBundle;
+}
+function bundleItemApplyChoiceMatchesDesiredState(options) {
+    return (bundleItemApplyChoiceMatchesDesiredTools(options) &&
+        (options.desiredEntry.items === undefined ||
+            options.desiredEntry.items.includes(options.choice.item)));
+}
+function bundleItemApplyChoiceMatchesDesiredTools(options) {
+    return (options.desiredEntry.tools === undefined ||
+        options.choice.tools.some((toolName) => options.desiredEntry.tools?.includes(toolName)));
+}
+function bundleItemApplyChoiceCoversDesiredTools(options) {
+    const desiredTools = options.desiredEntry.tools ?? options.choice.availableTools;
+    return desiredTools.every((toolName) => options.choice.tools.includes(toolName));
+}
+function groupBundleItemApplyTargets(options) {
+    const groupsByBundle = new Map();
+    for (const value of options.selectedValues) {
+        const choice = options.choices.find((candidate) => candidate.value === value);
+        if (!choice) {
+            throw new Error(`Selected bundle item is not available: ${value}`);
+        }
+        const key = encodeBundleIdentity(choice);
+        const group = groupsByBundle.get(key) ?? {
+            bundle: choice.bundle,
+            source: choice.source,
+            tools: choice.tools,
+            items: [],
+        };
+        group.items.push(choice.item);
+        groupsByBundle.set(key, group);
+    }
+    return Array.from(groupsByBundle.values());
+}
+function encodeBundleItemApplyChoice(choice) {
+    return JSON.stringify([choice.source, choice.bundle, choice.item]);
+}
+async function prepareApplyBundle(options) {
+    const refreshedSources = options.refreshedSources ?? new Set();
+    const cloneLines = refreshBundleSourceForApply(options, refreshedSources);
+    let cachedBundle;
+    let bundleSource;
+    let selectedToolsBeforeBundle;
+    try {
+        cachedBundle = findCachedBundleWithGuidance({
+            libraryDir: options.libraryDir,
+            bundle: options.bundle,
+            source: options.source,
+        });
+        bundleSource = options.source ?? cachedBundle.source;
+    }
+    catch (error) {
+        if (!shouldPromptForInferredBundle({
+            error,
+            libraryDir: options.libraryDir,
+            source: options.source,
+            inferredBundleFromSource: options.inferredBundleFromSource,
+        })) {
+            throw error;
+        }
+        selectedToolsBeforeBundle = await selectToolsBeforeBundle({
+            libraryDir: options.libraryDir,
+            source: options.source,
+            requestedTools: options.requestedTools,
+            prompts: options.preBundlePrompts ?? options.prompts,
+        });
+        const toolsForBundleSelection = selectedToolsBeforeBundle ??
+            (options.requestedTools.length > 0 ? options.requestedTools : undefined);
+        const selection = toolsForBundleSelection
+            ? await options.prompts.selectBundle(options.source, toolsForBundleSelection)
+            : await options.prompts.selectBundle(options.source);
+        cachedBundle = findCachedBundleWithGuidance({
+            libraryDir: options.libraryDir,
+            bundle: selection.bundle,
+            source: selection.source ?? options.source,
+        });
+        bundleSource = selection.source ?? options.source ?? cachedBundle.source;
+    }
+    if (bundleSource &&
+        (options.source !== undefined || options.ref !== undefined)) {
+        cloneLines.push(...refreshBundleSourceForApply({
+            source: bundleSource,
+            libraryDir: options.libraryDir,
+            protocol: options.protocol,
+            ref: options.ref,
+        }, refreshedSources));
+        cachedBundle = findCachedBundleWithGuidance({
+            libraryDir: options.libraryDir,
+            bundle: cachedBundle.bundle,
+            source: bundleSource,
+        });
+    }
+    const sourceRevision = bundleSource
+        ? (0, bundle_fetch_1.readCachedSourceRevision)({
+            source: bundleSource,
+            libraryDir: options.libraryDir,
+        })
+        : undefined;
+    const availableTools = Object.keys(cachedBundle.manifest.tools);
+    const wasExplicitlyRequested = options.requestedTools.length > 0;
+    const toolsToAssert = selectedToolsBeforeBundle ?? options.requestedTools;
+    if (toolsToAssert.length > 0) {
+        assertBundleSupportsRequestedTools(toolsToAssert, availableTools);
+    }
+    const selectedRequestedTools = selectedToolsBeforeBundle ??
+        (wasExplicitlyRequested || availableTools.length <= 1
+            ? wasExplicitlyRequested
+                ? options.requestedTools
+                : availableTools
+            : await options.prompts.selectAgents(availableTools));
+    const hasToolSelection = wasExplicitlyRequested ||
+        selectedRequestedTools.length < availableTools.length;
+    const nextToolNames = selectedRequestedTools;
+    const existingDesiredEntry = options.existingDesiredState.find((entry) => entry.bundle === cachedBundle.bundle);
+    const selectedItems = await resolveSelectedBundleItems({
+        bundleDir: node_path_1.default.dirname(cachedBundle.manifestFile),
+        manifest: cachedBundle.manifest,
+        tools: nextToolNames,
+        requestedItems: options.requestedItems,
+        selectItems: options.selectItems,
+        replaceItems: options.replaceItems,
+        prompts: options.prompts,
+        existingItems: existingDesiredEntry?.items,
+    });
+    return {
+        cloneLines,
+        cachedBundle,
+        bundleSource,
+        sourceRevision,
+        ...(hasToolSelection ? { selectedTools: selectedRequestedTools } : {}),
+        ...(selectedItems !== undefined ? { selectedItems } : {}),
+        nextToolNames,
+        toolLabel: nextToolNames.join(", "),
+        hasToolSelection,
+        replacesItemSelection: options.selectItems || options.replaceItems === true,
+    };
+}
+async function selectToolsBeforeBundle(options) {
+    if (!options.source || options.requestedTools.length > 0) {
+        return undefined;
+    }
+    const availableTools = listSelectableToolsForSource({
+        libraryDir: options.libraryDir,
+        source: options.source,
+    });
+    if (availableTools.length <= 1) {
+        return undefined;
+    }
+    return options.prompts.selectAgents(availableTools);
+}
+function listSelectableToolsForSource(options) {
+    const toolNames = new Set();
+    for (const bundle of (0, bundle_discovery_1.listCachedBundles)({ libraryDir: options.libraryDir })) {
+        if (bundle.source !== options.source) {
+            continue;
+        }
+        for (const toolName of Object.keys(bundle.manifest.tools)) {
+            toolNames.add(toolName);
+        }
+    }
+    return Array.from(toolNames).sort((left, right) => left.localeCompare(right));
+}
+async function resolveSelectedBundleItems(options) {
+    if (!options.selectItems && options.requestedItems.length === 0) {
+        return undefined;
+    }
+    const availableItems = (0, bundle_items_1.listSelectableBundleItems)({
+        bundleDir: options.bundleDir,
+        manifest: options.manifest,
+        tools: options.tools,
+    });
+    (0, bundle_items_1.assertBundleSupportsRequestedItems)({
+        requestedItems: options.requestedItems,
+        availableItems,
+    });
+    const mergedItems = (0, bundle_items_1.mergeDesiredBundleItems)({
+        existingItems: options.existingItems,
+        requestedItems: (0, bundle_items_1.normalizeBundleItemSelectors)(options.requestedItems),
+        replace: options.replaceItems === true,
+    });
+    if (!options.selectItems) {
+        return mergedItems;
+    }
+    return options.prompts.selectBundleItems(availableItems, mergedItems ?? []);
+}
+function shouldPromptForInferredBundle(options) {
+    if (!options.inferredBundleFromSource || !options.source) {
+        return false;
+    }
+    if (!(options.error instanceof Error) ||
+        !/^Bundle not found: /.test(options.error.message)) {
+        return false;
+    }
+    return (0, bundle_discovery_1.listCachedBundles)({ libraryDir: options.libraryDir }).some((bundle) => bundle.source === options.source);
+}
+function refreshBundleSourceForApply(options, refreshedSources) {
+    if (!options.source || refreshedSources.has(options.source)) {
+        return [];
+    }
+    refreshedSources.add(options.source);
+    const initialRevision = (0, bundle_fetch_1.readCachedSourceRevision)({
+        source: options.source,
+        libraryDir: options.libraryDir,
+        protocol: options.protocol,
+    });
+    if (initialRevision.cached && initialRevision.remoteUrl === undefined) {
+        return [];
+    }
+    if (!options.ref && initialRevision.cached) {
+        (0, bundle_fetch_1.clearAndRefetchCachedRemoteSource)({
+            source: options.source,
+            libraryDir: options.libraryDir,
+            protocol: options.protocol,
+        });
+    }
+    else {
+        (0, bundle_fetch_1.updateCachedRemoteSource)({
+            source: options.source,
+            libraryDir: options.libraryDir,
+            protocol: options.protocol,
+            ref: options.ref,
+        });
+    }
+    return initialRevision.cached ? [] : [pc.dim(`Cloned ${options.source}`)];
+}
+function assertBundleSupportsRequestedTools(requestedTools, availableTools) {
+    const unsupportedTools = requestedTools.filter((toolName) => !availableTools.includes(toolName));
+    if (unsupportedTools.length === 0) {
+        return;
+    }
+    throw new Error(`Bundle does not support tool(s): ${unsupportedTools.join(", ")}\nSupported tools: ${availableTools.join(", ")}`);
+}
+function buildDesiredEntryForAppliedBundle(options) {
+    const existingDesiredEntry = options.existingDesiredState.find((entry) => entry.bundle === options.cachedBundle.bundle);
+    const mergedDesiredTools = mergeDesiredTools({
+        existingEntry: existingDesiredEntry,
+        requestedTools: options.requestedTools,
+        replace: options.replaceRequestedTools,
+    });
+    const mergedDesiredItems = (0, bundle_items_1.mergeDesiredBundleItems)({
+        existingItems: existingDesiredEntry?.items,
+        requestedItems: options.requestedItems,
+        replace: options.replaceRequestedItems ?? false,
+    });
+    const preservesExistingRef = existingDesiredEntry?.ref !== undefined &&
+        (options.requestedSource === undefined ||
+            options.requestedSource === existingDesiredEntry.source);
+    const sourceProtocol = options.sourceRevision?.remoteUrl !== undefined
+        ? (0, bundle_discovery_1.detectSourceProtocol)(options.sourceRevision.remoteUrl)
+        : undefined;
+    const desiredProtocol = options.requestedSource !== undefined
+        ? options.requestedProtocol
+        : existingDesiredEntry?.source !== undefined
+            ? (existingDesiredEntry.protocol ?? sourceProtocol ?? "https")
+            : (sourceProtocol ?? existingDesiredEntry?.protocol ?? "https");
+    return {
+        bundle: options.cachedBundle.bundle,
+        ...(options.requestedSource !== undefined
+            ? { source: options.requestedSource }
+            : existingDesiredEntry?.source !== undefined
+                ? { source: existingDesiredEntry.source }
+                : options.cachedBundle.source !== undefined
+                    ? { source: options.cachedBundle.source }
+                    : {}),
+        ...(mergedDesiredTools !== undefined ? { tools: mergedDesiredTools } : {}),
+        ...(mergedDesiredItems !== undefined ? { items: mergedDesiredItems } : {}),
+        protocol: desiredProtocol,
+        ...(options.requestedRef !== undefined
+            ? { ref: options.requestedRef }
+            : preservesExistingRef
+                ? { ref: existingDesiredEntry.ref }
+                : {}),
+        ...(options.sourceRevision?.currentRef !== undefined
+            ? { resolved_ref: options.sourceRevision.currentRef }
+            : existingDesiredEntry?.resolved_ref !== undefined
+                ? { resolved_ref: existingDesiredEntry.resolved_ref }
+                : {}),
+        ...(options.sourceRevision?.currentCommit !== undefined
+            ? { resolved_commit: options.sourceRevision.currentCommit }
+            : existingDesiredEntry?.resolved_commit !== undefined
+                ? { resolved_commit: existingDesiredEntry.resolved_commit }
+                : {}),
+        ...((options.disableModelInvocation ??
+            existingDesiredEntry?.disable_model_invocation)
+            ? { disable_model_invocation: true }
+            : {}),
+    };
+}
+async function resetWorktree(options) {
+    const gitContext = requireGitContext(options.cwd, "reset");
+    let registry = readRegistryWithGuidance(options.registryFile);
+    const worktreeState = registry.worktrees[gitContext.worktreeId];
+    const hasMaterializedBundles = worktreeState
+        ? worktreeHasMaterializedBundles(worktreeState.materialized_state)
+        : false;
+    const hasShadowedFiles = worktreeState
+        ? Object.keys(worktreeState.shadowed_files).length > 0
+        : false;
+    if (options.dryRun) {
+        if (!hasMaterializedBundles && !hasShadowedFiles) {
+            return `${pc.yellow("DRY RUN:")} No Skul-managed files found in the current worktree`;
+        }
+        const allFiles = Object.values(worktreeState.materialized_state.bundles).flatMap((bundleState) => Object.values(bundleState.tools).flatMap((toolState) => toolState.files));
+        const lines = [
+            `${pc.yellow("DRY RUN:")} Would restore ${Object.keys(worktreeState.shadowed_files).length} tracked shadow file(s) and remove ${allFiles.length} managed file(s) from ${gitContext.worktreeRoot}`,
+        ];
+        for (const file of allFiles) {
+            lines.push(`  ${file}`);
+        }
+        for (const filePath of Object.keys(worktreeState.shadowed_files)) {
+            lines.push(`  ${filePath}`);
+        }
+        return lines.join("\n");
+    }
+    if ((hasMaterializedBundles || hasShadowedFiles) && worktreeState) {
+        const allBundlePaths = Object.values(worktreeState.materialized_state.bundles).map(flattenBundleState);
+        // Confirm all removals before touching any files (all-or-nothing)
+        for (const bundlePaths of allBundlePaths) {
+            const resetAllowed = await confirmManagedFileRemovals(gitContext.worktreeRoot, bundlePaths, options.prompts, "reset");
+            if (!resetAllowed) {
+                throw new Error("Reset aborted because a modified managed file was kept");
+            }
+        }
+        const remainingShadowedFiles = retireTrackedRootInstructionShadows({
+            repoRoot: gitContext.worktreeRoot,
+            shadowedFiles: worktreeState.shadowed_files,
+            filePaths: Object.keys(worktreeState.shadowed_files),
+        });
+        for (const bundlePaths of allBundlePaths) {
+            removeManagedPaths(gitContext.worktreeRoot, bundlePaths);
+        }
+        (0, root_instruction_state_1.restoreRootInstructionBaseContents)({
+            repoRoot: gitContext.worktreeRoot,
+            baseContents: worktreeState.materialized_state.root_instruction_base_contents,
+            targetPaths: (0, root_instruction_state_1.collectManagedRootInstructionTargets)(worktreeState.materialized_state.bundles),
+        });
+        if (Object.keys(remainingShadowedFiles).length > 0) {
+            registry = (0, registry_1.upsertWorktreeState)(registry, gitContext.worktreeId, {
+                repo_fingerprint: gitContext.repoFingerprint,
+                path: gitContext.worktreeRoot,
+                materialized_state: {
+                    bundles: {},
+                    exclude_configured: false,
+                    ...(worktreeState.materialized_state
+                        .root_instruction_base_contents !== undefined
+                        ? {
+                            root_instruction_base_contents: worktreeState.materialized_state
+                                .root_instruction_base_contents,
+                        }
+                        : {}),
+                },
+                shadowed_files: remainingShadowedFiles,
+            });
+        }
+        else {
+            registry = (0, registry_1.removeWorktreeState)(registry, gitContext.worktreeId);
+        }
+        (0, registry_1.writeRegistryFile)(options.registryFile, registry);
+    }
+    const excludeRemoved = (0, git_exclude_1.removeSkulExcludeBlock)({ gitDir: gitContext.gitDir });
+    if (!hasMaterializedBundles && !hasShadowedFiles && !excludeRemoved) {
+        return "No Skul-managed files found in the current worktree";
+    }
+    return pc.green("Reset Skul-managed files from the current worktree");
+}
+async function removeBundle(options) {
+    const gitContext = requireGitContext(options.cwd, "remove");
+    let registry = readRegistryWithGuidance(options.registryFile);
+    const repoState = registry.repos[gitContext.repoFingerprint];
+    const worktreeState = registry.worktrees[gitContext.worktreeId];
+    if (shouldRemoveItemsAcrossBundles(options)) {
+        return removeBundleItemsAcrossActiveBundles({
+            cwd: options.cwd,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            repoState,
+            source: options.source,
+            bundle: options.inferredBundleFromSource ? undefined : options.bundle,
+            includeItems: options.includeItems,
+            selectItems: options.selectItems,
+            dryRun: options.dryRun,
+        });
+    }
+    const selection = await resolveRemoveBundleSelection({
+        requestedBundle: options.bundle,
+        requestedSource: options.source,
+        inferredBundleFromSource: options.inferredBundleFromSource,
+        repoState,
+        worktreeState,
+        prompts: options.prompts,
+    });
+    const bundle = selection.bundle;
+    const source = selection.source;
+    const isInDesiredState = repoState?.desired_state.some((e) => e.bundle === bundle && matchesOptionalSource(e.source, source)) ?? false;
+    const desiredEntry = repoState?.desired_state.find((e) => e.bundle === bundle && matchesOptionalSource(e.source, source));
+    const bundleMaterializedState = findMaterializedBundleState({
+        worktreeState,
+        bundle,
+        source,
+    });
+    const shadowedFilesForBundle = Object.entries(worktreeState?.shadowed_files ?? {}).filter(([, shadowedFile]) => shadowedFile.bundle === bundle);
+    if (!isInDesiredState && !bundleMaterializedState) {
+        const configured = repoState?.desired_state
+            .filter((entry) => matchesOptionalSource(entry.source, source))
+            .map((e) => e.bundle) ?? [];
+        const hint = configured.length > 0
+            ? `Configured bundles: ${configured.join(", ")}`
+            : `No bundles are configured yet. Run "skul add <bundle>" to add one`;
+        throw new Error(`Bundle not found in active set: ${bundle}. ${hint}`);
+    }
+    if (options.includeItems.length > 0 || options.selectItems) {
+        const itemRemoval = await removeBundleItems({
+            cwd: options.cwd,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            gitContext,
+            registry,
+            repoState,
+            worktreeState,
+            desiredEntry,
+            bundle,
+            source,
+            includeItems: options.includeItems,
+            selectItems: options.selectItems,
+            dryRun: options.dryRun,
+        });
+        if (itemRemoval.kind === "completed") {
+            return itemRemoval.output;
+        }
+    }
+    if (options.dryRun) {
+        if (bundleMaterializedState || shadowedFilesForBundle.length > 0) {
+            const files = bundleMaterializedState
+                ? Object.values(bundleMaterializedState.tools).flatMap((toolState) => toolState.files)
+                : [];
+            const lines = [
+                `${pc.yellow("DRY RUN:")} Would remove ${bundle} (${files.length + shadowedFilesForBundle.length} file(s))`,
+            ];
+            for (const file of files) {
+                lines.push(`  ${file}`);
+            }
+            for (const [filePath] of shadowedFilesForBundle) {
+                lines.push(`  ${filePath}`);
+            }
+            return lines.join("\n");
+        }
+        return `${pc.yellow("DRY RUN:")} Would remove ${bundle} from desired state (not yet materialized in this worktree)`;
+    }
+    let currentShadowedFiles = { ...(worktreeState?.shadowed_files ?? {}) };
+    if (bundleMaterializedState || shadowedFilesForBundle.length > 0) {
+        const bundlePaths = bundleMaterializedState
+            ? flattenBundleState(bundleMaterializedState)
+            : { files: [], file_fingerprints: {}, directories: [] };
+        const rootInstructionBaseContents = worktreeState?.materialized_state.root_instruction_base_contents;
+        const removedRootInstructionPaths = new Set(bundlePaths.files.filter((filePath) => (0, root_instruction_render_1.isRootInstructionPath)(filePath)));
+        const remainingBundles = { ...worktreeState.materialized_state.bundles };
+        delete remainingBundles[bundle];
+        const remainingDesiredState = repoState?.desired_state.filter((entry) => !matchesBundleIdentity(entry, bundle, source)) ?? [];
+        const rewrittenRootInstructionPaths = new Set(Array.from((0, root_instruction_state_1.collectManagedRootInstructionTargets)(remainingBundles)).filter((filePath) => removedRootInstructionPaths.has(filePath)));
+        (0, root_instruction_state_1.assertManagedRootInstructionSyncSourcesCached)({
+            desiredState: remainingDesiredState,
+            materializedBundles: remainingBundles,
+            targetPaths: rewrittenRootInstructionPaths,
+            resolveCachedBundle: (entry) => resolveDesiredCachedBundle(options.libraryDir, entry),
+        });
+        const removeAllowed = await confirmManagedFileRemovals(gitContext.worktreeRoot, bundlePaths, options.prompts, "remove");
+        if (!removeAllowed) {
+            throw new Error("Removal aborted because a modified managed file was kept");
+        }
+        currentShadowedFiles = retireTrackedRootInstructionShadows({
+            repoRoot: gitContext.worktreeRoot,
+            shadowedFiles: currentShadowedFiles,
+            filePaths: shadowedFilesForBundle.map(([filePath]) => filePath),
+        });
+        if (Object.keys(remainingBundles).length > 0) {
+            assertTrackedRootInstructionShadowSafetyForPaths({
+                repoRoot: gitContext.worktreeRoot,
+                operation: "refresh",
+                filePaths: Array.from(rewrittenRootInstructionPaths),
+            });
+        }
+        removeManagedPaths(gitContext.worktreeRoot, bundlePaths);
+        const remainingRootInstructionTargets = (0, root_instruction_state_1.collectManagedRootInstructionTargets)(remainingBundles);
+        const restoredRootInstructionPaths = new Set(Array.from(removedRootInstructionPaths).filter((filePath) => !remainingRootInstructionTargets.has(filePath)));
+        (0, root_instruction_state_1.restoreRootInstructionBaseContents)({
+            repoRoot: gitContext.worktreeRoot,
+            baseContents: rootInstructionBaseContents,
+            targetPaths: restoredRootInstructionPaths,
+        });
+        const nextRootInstructionBaseContents = rootInstructionBaseContents
+            ? Object.fromEntries(Object.entries(rootInstructionBaseContents).filter(([filePath]) => !restoredRootInstructionPaths.has(filePath)))
+            : undefined;
+        if (Object.keys(remainingBundles).length > 0) {
+            const syncedRootInstructionPaths = (0, root_instruction_state_1.syncManagedRootInstructionFiles)({
+                repoRoot: gitContext.worktreeRoot,
+                desiredState: remainingDesiredState,
+                materializedBundles: remainingBundles,
+                rootInstructionBaseContents: nextRootInstructionBaseContents,
+                targetPaths: rewrittenRootInstructionPaths,
+                resolveCachedBundle: (entry) => resolveDesiredCachedBundle(options.libraryDir, entry),
+            });
+            const refreshedRemainingBundles = (0, root_instruction_state_1.refreshManagedFileFingerprintsForPaths)(gitContext.worktreeRoot, remainingBundles, syncedRootInstructionPaths);
+            const newMatState = {
+                bundles: refreshedRemainingBundles,
+                exclude_configured: false,
+                ...(nextRootInstructionBaseContents !== undefined &&
+                    Object.keys(nextRootInstructionBaseContents).length > 0
+                    ? { root_instruction_base_contents: nextRootInstructionBaseContents }
+                    : {}),
+            };
+            const managedFiles = collectAllFiles(newMatState);
+            newMatState.exclude_configured = managedFiles.length > 0;
+            if (managedFiles.length > 0) {
+                (0, git_exclude_1.configureSkulExcludeBlock)({
+                    gitDir: gitContext.gitDir,
+                    files: managedFiles,
+                });
+            }
+            else {
+                (0, git_exclude_1.removeSkulExcludeBlock)({ gitDir: gitContext.gitDir });
+            }
+            registry = (0, registry_1.upsertWorktreeState)(registry, gitContext.worktreeId, {
+                repo_fingerprint: gitContext.repoFingerprint,
+                path: gitContext.worktreeRoot,
+                materialized_state: newMatState,
+                shadowed_files: currentShadowedFiles,
+            });
+        }
+        else {
+            (0, git_exclude_1.removeSkulExcludeBlock)({ gitDir: gitContext.gitDir });
+            if (Object.keys(currentShadowedFiles).length > 0) {
+                registry = (0, registry_1.upsertWorktreeState)(registry, gitContext.worktreeId, {
+                    repo_fingerprint: gitContext.repoFingerprint,
+                    path: gitContext.worktreeRoot,
+                    materialized_state: {
+                        bundles: {},
+                        exclude_configured: false,
+                    },
+                    shadowed_files: currentShadowedFiles,
+                });
+            }
+            else {
+                registry = (0, registry_1.removeWorktreeState)(registry, gitContext.worktreeId);
+            }
+        }
+    }
+    if (isInDesiredState && repoState) {
+        const newDesiredState = repoState.desired_state.filter((entry) => !matchesBundleIdentity(entry, bundle, source));
+        registry = (0, registry_1.upsertRepoState)(registry, gitContext.repoFingerprint, {
+            ...repoState,
+            repo_root: gitContext.repoRoot,
+            desired_state: newDesiredState,
+        });
+    }
+    (0, registry_1.writeRegistryFile)(options.registryFile, registry);
+    return pc.green(`Removed ${bundle}`);
+}
+function shouldRemoveItemsAcrossBundles(options) {
+    return (options.selectItems ||
+        (options.includeItems.length > 0 &&
+            (options.bundle === undefined ||
+                options.inferredBundleFromSource === true)));
+}
+async function removeBundleItemsAcrossActiveBundles(options) {
+    if (!options.repoState || options.repoState.desired_state.length === 0) {
+        throw new Error(options.source
+            ? `No active bundles found for ${options.source}. Run "skul add ${options.source} <bundle>" to add one first`
+            : 'No active bundles found. Run "skul add <bundle>" to add one first');
+    }
+    const choices = listActiveBundleItemRemovalChoices({
+        libraryDir: options.libraryDir,
+        desiredState: options.repoState.desired_state,
+        source: options.source,
+        bundle: options.bundle,
+    });
+    const requestedItems = (0, bundle_items_1.normalizeBundleItemSelectors)(options.includeItems);
+    const selectedValues = options.selectItems
+        ? await promptForBundleItemRemovalChoices({
+            prompts: options.prompts,
+            choices,
+            requestedItems,
+        })
+        : selectRequestedBundleItemRemovalChoices({
+            choices,
+            requestedItems,
+        });
+    const removalPlan = planBundleItemRemovals({
+        desiredState: options.repoState.desired_state,
+        choices,
+        selectedValues,
+    });
+    if (options.dryRun) {
+        return `${pc.yellow("DRY RUN:")} Would remove ${formatBundleItemRemovalSummary(removalPlan.removedItems)}`;
+    }
+    for (const target of groupBundleItemRemovalTargets(removalPlan.removedItems)) {
+        await removeBundle({
+            cwd: options.cwd,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            bundle: target.bundle,
+            source: target.source,
+            includeItems: target.items,
+            selectItems: false,
+            dryRun: false,
+        });
+    }
+    return pc.green(`Removed ${formatBundleItemRemovalSummary(removalPlan.removedItems)}`);
+}
+function groupBundleItemRemovalTargets(removedItems) {
+    const groupsByBundle = new Map();
+    for (const item of removedItems) {
+        const key = encodeBundleIdentity(item);
+        const group = groupsByBundle.get(key) ?? {
+            bundle: item.bundle,
+            source: item.source,
+            items: [],
+        };
+        group.items.push(item.item);
+        groupsByBundle.set(key, group);
+    }
+    return Array.from(groupsByBundle.values());
+}
+function listActiveBundleItemRemovalChoices(options) {
+    const choices = options.desiredState.flatMap((entry) => {
+        if (!matchesOptionalSource(entry.source, options.source))
+            return [];
+        if (options.bundle !== undefined && entry.bundle !== options.bundle) {
+            return [];
+        }
+        return listDesiredBundleItemRemovalChoices({
+            libraryDir: options.libraryDir,
+            desiredEntry: entry,
+        });
+    });
+    if (choices.length === 0) {
+        throw new Error(options.source
+            ? `No active bundle items found for ${options.source}`
+            : "No active bundle items found");
+    }
+    return choices;
+}
+function listDesiredBundleItemRemovalChoices(options) {
+    const cachedBundle = findCachedBundleWithGuidance({
+        libraryDir: options.libraryDir,
+        bundle: options.desiredEntry.bundle,
+        source: options.desiredEntry.source,
+    });
+    const selectedTools = options.desiredEntry.tools ??
+        Object.keys(cachedBundle.manifest.tools);
+    const availableItems = (0, bundle_items_1.listSelectableBundleItems)({
+        bundleDir: node_path_1.default.dirname(cachedBundle.manifestFile),
+        manifest: cachedBundle.manifest,
+        tools: selectedTools,
+    });
+    const activeItems = options.desiredEntry.items ?? availableItems;
+    return activeItems.map((item) => ({
+        value: encodeBundleItemRemovalChoice({
+            bundle: options.desiredEntry.bundle,
+            source: options.desiredEntry.source,
+            item,
+        }),
+        label: formatBundleItemRemovalChoiceLabel({
+            bundle: options.desiredEntry.bundle,
+            source: options.desiredEntry.source,
+            item,
+        }),
+        bundle: options.desiredEntry.bundle,
+        source: options.desiredEntry.source,
+        item,
+        activeItems,
+    }));
+}
+async function promptForBundleItemRemovalChoices(options) {
+    const selectedValues = selectRequestedBundleItemRemovalChoices({
+        choices: options.choices,
+        requestedItems: options.requestedItems,
+        allowEmptySelection: true,
+    });
+    const selections = await options.prompts.selectBundleItemChoices(options.choices, selectedValues, "remove");
+    if (selections.length === 0) {
+        throw new Error("No bundle items selected for removal");
+    }
+    return selections;
+}
+function selectRequestedBundleItemRemovalChoices(options) {
+    if (options.requestedItems.length === 0 && !options.allowEmptySelection) {
+        throw new Error("No bundle items selected for removal");
+    }
+    const requestedItemSet = new Set(options.requestedItems);
+    const selectedValues = options.choices
+        .filter((choice) => requestedItemSet.has(choice.item))
+        .map((choice) => choice.value);
+    const missingItems = options.requestedItems.filter((item) => !options.choices.some((choice) => choice.item === item));
+    if (missingItems.length > 0) {
+        throw new Error(`Bundle item(s) are not active: ${missingItems.join(", ")}`);
+    }
+    if (selectedValues.length === 0 && !options.allowEmptySelection) {
+        throw new Error("No bundle items selected for removal");
+    }
+    return selectedValues;
+}
+function planBundleItemRemovals(options) {
+    const selectedChoices = options.selectedValues.map((value) => {
+        const choice = options.choices.find((candidate) => candidate.value === value);
+        if (!choice) {
+            throw new Error(`Selected bundle item is not active: ${value}`);
+        }
+        return choice;
+    });
+    const selectedItemsByBundle = new Map();
+    for (const choice of selectedChoices) {
+        const key = encodeBundleIdentity(choice);
+        const items = selectedItemsByBundle.get(key) ?? new Set();
+        items.add(choice.item);
+        selectedItemsByBundle.set(key, items);
+    }
+    for (const entry of options.desiredState) {
+        const selectedItems = selectedItemsByBundle.get(encodeBundleIdentity(entry));
+        if (!selectedItems)
+            continue;
+        const activeItems = options.choices.find((choice) => encodeBundleIdentity(choice) === encodeBundleIdentity(entry))?.activeItems;
+        const inactiveSelectedItems = Array.from(selectedItems).filter((item) => !(activeItems ?? entry.items ?? []).includes(item));
+        if (inactiveSelectedItems.length > 0) {
+            throw new Error(`Bundle item(s) are not active: ${inactiveSelectedItems.join(", ")}`);
+        }
+    }
+    return {
+        removedItems: selectedChoices.map((choice) => ({
+            bundle: choice.bundle,
+            source: choice.source,
+            item: choice.item,
+        })),
+    };
+}
+function encodeBundleItemRemovalChoice(choice) {
+    return JSON.stringify([choice.source ?? null, choice.bundle, choice.item]);
+}
+function encodeBundleIdentity(choice) {
+    return JSON.stringify([choice.source ?? null, choice.bundle]);
+}
+function formatBundleItemRemovalChoiceLabel(choice) {
+    return choice.source
+        ? `${choice.source} / ${choice.bundle}: ${choice.item}`
+        : `${choice.bundle}: ${choice.item}`;
+}
+function formatBundleItemRemovalSummary(removedItems) {
+    return removedItems.map((item) => `${item.bundle}: ${item.item}`).join(", ");
+}
+async function resolveRemoveBundleSelection(options) {
+    if (options.requestedBundle &&
+        isRemoveBundleActive({
+            repoState: options.repoState,
+            worktreeState: options.worktreeState,
+            bundle: options.requestedBundle,
+            source: options.requestedSource,
+        })) {
+        return {
+            bundle: options.requestedBundle,
+            ...(options.requestedSource !== undefined
+                ? { source: options.requestedSource }
+                : {}),
+        };
+    }
+    if (options.requestedBundle && !options.inferredBundleFromSource) {
+        return {
+            bundle: options.requestedBundle,
+            ...(options.requestedSource !== undefined
+                ? { source: options.requestedSource }
+                : {}),
+        };
+    }
+    if (options.requestedSource !== undefined &&
+        options.inferredBundleFromSource) {
+        return promptForActiveRemoveBundleSelection({
+            repoState: options.repoState,
+            worktreeState: options.worktreeState,
+            prompts: options.prompts,
+            source: options.requestedSource,
+        });
+    }
+    if (options.requestedBundle !== undefined) {
+        return { bundle: options.requestedBundle };
+    }
+    return promptForActiveRemoveBundleSelection({
+        repoState: options.repoState,
+        worktreeState: options.worktreeState,
+        prompts: options.prompts,
+    });
+}
+async function promptForActiveRemoveBundleSelection(options) {
+    const activeSelections = listActiveRemoveBundleSelections({
+        repoState: options.repoState,
+        worktreeState: options.worktreeState,
+        source: options.source,
+    });
+    if (activeSelections.length === 0) {
+        throw new Error(options.source
+            ? `No active bundles found for ${options.source}. Run "skul add ${options.source} <bundle>" to add one first`
+            : 'No active bundles found. Run "skul add <bundle>" to add one first');
+    }
+    if (activeSelections.length === 1) {
+        return activeSelections[0];
+    }
+    const selection = await options.prompts.selectBundleFromSelections(activeSelections, options.source);
+    return {
+        bundle: selection.bundle,
+        ...(selection.source !== undefined ? { source: selection.source } : {}),
+    };
+}
+function listActiveRemoveBundleSelections(options) {
+    const selections = [];
+    const seen = new Set();
+    for (const entry of options.repoState?.desired_state ?? []) {
+        if (!matchesOptionalSource(entry.source, options.source))
+            continue;
+        addActiveRemoveBundleSelection(selections, seen, {
+            bundle: entry.bundle,
+            ...(entry.source !== undefined ? { source: entry.source } : {}),
+            protocol: entry.protocol,
+        });
+    }
+    for (const [bundle, state] of Object.entries(options.worktreeState?.materialized_state.bundles ?? {})) {
+        if (!matchesOptionalSource(state.source, options.source))
+            continue;
+        addActiveRemoveBundleSelection(selections, seen, {
+            bundle,
+            ...(state.source !== undefined ? { source: state.source } : {}),
+        });
+    }
+    return selections.sort(compareBundleSelections);
+}
+function addActiveRemoveBundleSelection(selections, seen, selection) {
+    const key = `${selection.source ?? ""}\0${selection.bundle}`;
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    selections.push(selection);
+}
+function isRemoveBundleActive(options) {
+    return ((options.repoState?.desired_state.some((entry) => entry.bundle === options.bundle &&
+        matchesOptionalSource(entry.source, options.source)) ??
+        false) ||
+        findMaterializedBundleState({
+            worktreeState: options.worktreeState,
+            bundle: options.bundle,
+            source: options.source,
+        }) !== undefined);
+}
+function matchesOptionalSource(candidateSource, requestedSource) {
+    return requestedSource === undefined || candidateSource === requestedSource;
+}
+function matchesBundleIdentity(entry, bundle, source) {
+    return entry.bundle === bundle && matchesOptionalSource(entry.source, source);
+}
+function findMaterializedBundleState(options) {
+    const bundleState = options.worktreeState?.materialized_state.bundles[options.bundle];
+    if (!bundleState ||
+        !matchesOptionalSource(bundleState.source, options.source)) {
+        return undefined;
+    }
+    return bundleState;
+}
+async function removeBundleItems(options) {
+    if (!options.repoState || !options.desiredEntry) {
+        throw new Error(`Cannot remove selected items from ${options.bundle} because it is not in desired state`);
+    }
+    const cachedBundle = findCachedBundleWithGuidance({
+        libraryDir: options.libraryDir,
+        bundle: options.bundle,
+        source: options.desiredEntry.source ?? options.source,
+    });
+    const selectedTools = options.desiredEntry.tools ??
+        Object.keys(cachedBundle.manifest.tools);
+    const availableItems = (0, bundle_items_1.listSelectableBundleItems)({
+        bundleDir: node_path_1.default.dirname(cachedBundle.manifestFile),
+        manifest: cachedBundle.manifest,
+        tools: selectedTools,
+    });
+    const currentItems = options.desiredEntry.items ?? availableItems;
+    const requestedItems = (0, bundle_items_1.normalizeBundleItemSelectors)(options.includeItems);
+    (0, bundle_items_1.assertBundleSupportsRequestedItems)({
+        requestedItems,
+        availableItems,
+    });
+    const inactiveRequestedItems = requestedItems.filter((item) => !currentItems.includes(item));
+    if (inactiveRequestedItems.length > 0) {
+        throw new Error(`Bundle item(s) are not active in ${options.bundle}: ${inactiveRequestedItems.join(", ")}`);
+    }
+    const selectedItems = options.selectItems
+        ? await options.prompts.selectBundleItems(currentItems, requestedItems, "remove")
+        : requestedItems;
+    const normalizedSelectedItems = (0, bundle_items_1.normalizeBundleItemSelectors)(selectedItems);
+    const inactiveItems = normalizedSelectedItems.filter((item) => !currentItems.includes(item));
+    if (inactiveItems.length > 0) {
+        throw new Error(`Bundle item(s) are not active in ${options.bundle}: ${inactiveItems.join(", ")}`);
+    }
+    const selectedItemSet = new Set(normalizedSelectedItems);
+    const remainingItems = currentItems.filter((item) => !selectedItemSet.has(item));
+    if (remainingItems.length === 0) {
+        return { kind: "remove-bundle" };
+    }
+    if (options.dryRun) {
+        return {
+            kind: "completed",
+            output: `${pc.yellow("DRY RUN:")} Would remove ${normalizedSelectedItems.join(", ")} from ${options.bundle}`,
+        };
+    }
+    const nextRegistry = (0, registry_1.upsertRepoState)(options.registry, options.gitContext.repoFingerprint, {
+        ...options.repoState,
+        repo_root: options.gitContext.repoRoot,
+        desired_state: options.repoState.desired_state.map((entry) => entry.bundle === options.bundle &&
+            matchesOptionalSource(entry.source, options.source)
+            ? { ...entry, items: remainingItems }
+            : entry),
+    });
+    (0, registry_1.writeRegistryFile)(options.registryFile, nextRegistry);
+    try {
+        await applyWorktree({
+            cwd: options.cwd,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            dryRun: false,
+        });
+    }
+    catch (error) {
+        (0, registry_1.writeRegistryFile)(options.registryFile, options.registry);
+        throw error;
+    }
+    return {
+        kind: "completed",
+        output: pc.green(`Removed ${normalizedSelectedItems.join(", ")} from ${options.bundle}`),
+    };
+}
+async function applyWorktree(options) {
+    const gitContext = requireGitContext(options.cwd, "apply");
+    let registry = readRegistryWithGuidance(options.registryFile);
+    const repoState = registry.repos[gitContext.repoFingerprint];
+    if (!repoState || repoState.desired_state.length === 0) {
+        return `No bundles configured for this repository. Run "skul add <bundle>" to add one`;
+    }
+    const worktreeState = registry.worktrees[gitContext.worktreeId];
+    const materializedBundles = worktreeState?.materialized_state.bundles ?? {};
+    const cloneLines = [];
+    const applyPlans = repoState.desired_state.flatMap((entry) => {
+        // In dry-run mode skip actual cloning; if the source is not yet cached we
+        // can still report intent without a manifest.
+        const sourceRevision = entry.source
+            ? (0, bundle_fetch_1.readCachedSourceRevision)({
+                source: entry.source,
+                libraryDir: options.libraryDir,
+                protocol: entry.protocol,
+            })
+            : undefined;
+        if (entry.source && !sourceRevision?.cached) {
+            if (options.dryRun) {
+                return [{ uncached: true, entry }];
+            }
+            // Non-dry-run: fetch the source so the manifest is available below.
+            const { cloned } = (0, bundle_fetch_1.fetchRemoteSource)({
+                source: entry.source,
+                libraryDir: options.libraryDir,
+                protocol: entry.protocol,
+            });
+            if (cloned)
+                cloneLines.push(pc.dim(`Cloned ${entry.source}`));
+        }
+        const cachedBundle = findCachedBundleWithGuidance({
+            libraryDir: options.libraryDir,
+            bundle: entry.bundle,
+            source: entry.source,
+        });
+        const existingBundleState = materializedBundles[entry.bundle];
+        if (existingBundleState &&
+            isDesiredBundleMaterialized({
+                desiredEntry: entry,
+                materializedBundleState: existingBundleState,
+                availableTools: Object.keys(cachedBundle.manifest.tools),
+            })) {
+            return [];
+        }
+        return [
+            {
+                uncached: false,
+                entry,
+                sourceRevision,
+                cachedBundle,
+                existingBundleState,
+                availableTools: Object.keys(cachedBundle.manifest.tools),
+            },
+        ];
+    });
+    if (applyPlans.length === 0) {
+        return options.dryRun
+            ? "DRY RUN: All bundles are already materialized"
+            : "All bundles are already materialized";
+    }
+    if (options.dryRun) {
+        const lines = applyPlans.map((plan) => {
+            if (plan.uncached) {
+                return `DRY RUN: Would clone ${plan.entry.source} then apply ${plan.entry.bundle}`;
+            }
+            const tools = plan.entry.tools ?? Object.keys(plan.cachedBundle.manifest.tools);
+            return `DRY RUN: Would apply ${plan.entry.bundle} for ${tools.join(", ")}`;
+        });
+        return lines.join("\n");
+    }
+    let currentBundles = { ...materializedBundles };
+    let currentShadowedFiles = { ...(worktreeState?.shadowed_files ?? {}) };
+    let rootInstructionBaseContents = worktreeState?.materialized_state.root_instruction_base_contents;
+    for (const plan of applyPlans) {
+        if (plan.uncached)
+            continue;
+        const { entry, sourceRevision, cachedBundle, existingBundleState, availableTools, } = plan;
+        const refreshesExistingBundle = existingBundleState !== undefined &&
+            entry.resolved_commit !== undefined &&
+            existingBundleState.resolved_commit !== entry.resolved_commit;
+        const toolsToApply = getToolsToApply({
+            desiredEntry: entry,
+            materializedBundleState: existingBundleState,
+            availableTools,
+        });
+        const replacementState = refreshesExistingBundle
+            ? existingBundleState
+            : existingBundleState && toolsToApply
+                ? selectExistingBundleToolState(existingBundleState, toolsToApply)
+                : existingBundleState;
+        const replacesExistingToolState = replacementState !== undefined &&
+            flattenBundleState(replacementState).files.length > 0;
+        const plannedWriteTargets = (0, bundle_materialization_1.previewMaterializeBundleWriteTargets)({
+            repoRoot: gitContext.worktreeRoot,
+            bundleDir: node_path_1.default.dirname(cachedBundle.manifestFile),
+            manifest: cachedBundle.manifest,
+            tools: toolsToApply,
+            itemSelectors: entry.items,
+        });
+        const plannedRootInstructionTargets = new Set(plannedWriteTargets.filter((filePath) => (0, root_instruction_render_1.isRootInstructionPath)(filePath)));
+        const trackedRootInstructionShadowPlan = planTrackedRootInstructionShadows({
+            repoRoot: gitContext.worktreeRoot,
+            bundleDir: node_path_1.default.dirname(cachedBundle.manifestFile),
+            manifest: cachedBundle.manifest,
+            toolNames: selectTrackedRootInstructionShadowToolNames({
+                existingBundleState,
+                nextToolNames: toolsToApply ?? availableTools,
+            }),
+            itemSelectors: entry.items,
+            targetPaths: plannedRootInstructionTargets,
+            bundleName: entry.bundle,
+            bundleSource: entry.source,
+            existingShadowedFiles: currentShadowedFiles,
+            materializedBundles: currentBundles,
+        });
+        rootInstructionBaseContents = (0, root_instruction_state_1.captureRootInstructionBaseContents)({
+            repoRoot: gitContext.worktreeRoot,
+            targetPaths: trackedRootInstructionShadowPlan.untrackedTargetPaths,
+            existingBaseContents: rootInstructionBaseContents,
+            managedTargetPaths: (0, root_instruction_state_1.collectManagedRootInstructionTargets)(currentBundles),
+        });
+        (0, root_instruction_state_1.assertManagedRootInstructionSyncSourcesCached)({
+            desiredState: repoState.desired_state,
+            materializedBundles: currentBundles,
+            targetPaths: trackedRootInstructionShadowPlan.untrackedTargetPaths,
+            resolveCachedBundle: (entry) => resolveDesiredCachedBundle(options.libraryDir, entry),
+        });
+        if (replacesExistingToolState && replacementState) {
+            assertTrackedRootInstructionShadowSafetyForPaths({
+                repoRoot: gitContext.worktreeRoot,
+                operation: "refresh",
+                filePaths: plannedWriteTargets,
+            });
+            const replacementAllowed = await confirmManagedFileRemovals(gitContext.worktreeRoot, excludeShadowedTrackedRootInstructionTargets(flattenBundleState(replacementState), trackedRootInstructionShadowPlan.deferredMaterializationTargets), options.prompts, "replace");
+            if (!replacementAllowed) {
+                throw new Error("Replacement aborted because a modified managed file was kept");
+            }
+        }
+        const sharedRootInstructionState = (0, root_instruction_state_1.collectSharedRootInstructionState)(currentBundles, plannedWriteTargets, cachedBundle.bundle);
+        if (sharedRootInstructionState.files.length > 0) {
+            const replacementAllowed = await confirmManagedFileRemovals(gitContext.worktreeRoot, sharedRootInstructionState, options.prompts, "replace");
+            if (!replacementAllowed) {
+                throw new Error("Replacement aborted because a modified managed file was kept");
+            }
+        }
+        assertTrackedRootInstructionShadowPlanCanApply({
+            repoRoot: gitContext.worktreeRoot,
+            bundleName: entry.bundle,
+            existingShadowedFiles: currentShadowedFiles,
+            plan: trackedRootInstructionShadowPlan,
+        });
+        assertTrackedRootInstructionShadowSafetyForPaths({
+            repoRoot: gitContext.worktreeRoot,
+            operation: existingBundleState ? "refresh" : "create",
+            filePaths: plannedWriteTargets,
+        });
+        if (replacesExistingToolState && replacementState) {
+            const pathsToReplace = excludeShadowedTrackedRootInstructionTargets(flattenBundleState(replacementState), trackedRootInstructionShadowPlan.deferredMaterializationTargets);
+            const replacedRootInstructionPaths = new Set(pathsToReplace.files.filter((filePath) => (0, root_instruction_render_1.isRootInstructionPath)(filePath)));
+            removeManagedPaths(gitContext.worktreeRoot, pathsToReplace);
+            (0, root_instruction_state_1.restoreRootInstructionBaseContents)({
+                repoRoot: gitContext.worktreeRoot,
+                baseContents: rootInstructionBaseContents,
+                targetPaths: new Set(Array.from(replacedRootInstructionPaths).filter((filePath) => !plannedRootInstructionTargets.has(filePath))),
+            });
+        }
+        const materializedResult = await (0, bundle_materialization_1.materializeBundle)({
+            repoRoot: gitContext.worktreeRoot,
+            bundleDir: node_path_1.default.dirname(cachedBundle.manifestFile),
+            manifest: cachedBundle.manifest,
+            tools: toolsToApply,
+            itemSelectors: entry.items,
+            bundleName: entry.bundle,
+            bundleSource: entry.source,
+            assertSafeWriteTarget: createTrackedRootInstructionShadowSafetyAssertion({
+                repoRoot: gitContext.worktreeRoot,
+                operation: existingBundleState ? "refresh" : "create",
+            }),
+            allowFileOverwriteTargets: (0, root_instruction_state_1.collectManagedRootInstructionTargets)(currentBundles),
+            deferredWriteTargets: trackedRootInstructionShadowPlan.deferredMaterializationTargets,
+            rootInstructionBaseContents,
+            resolveFileConflict: options.prompts.resolveFileConflict,
+        });
+        currentBundles = {
+            ...currentBundles,
+            [cachedBundle.bundle]: buildMaterializedBundleState({
+                existingBundleState,
+                materializedResult,
+                repoRoot: gitContext.worktreeRoot,
+                source: entry.source,
+                resolvedCommit: entry.resolved_commit ?? sourceRevision?.currentCommit,
+                selectedTools: refreshesExistingBundle ? undefined : toolsToApply,
+                selectedItems: entry.items,
+            }),
+        };
+        currentShadowedFiles = applyTrackedRootInstructionShadowPlan({
+            repoRoot: gitContext.worktreeRoot,
+            bundleName: entry.bundle,
+            existingShadowedFiles: currentShadowedFiles,
+            plan: trackedRootInstructionShadowPlan,
+        });
+        const syncedRootInstructionPaths = (0, root_instruction_state_1.syncManagedRootInstructionFiles)({
+            repoRoot: gitContext.worktreeRoot,
+            desiredState: repoState.desired_state,
+            materializedBundles: currentBundles,
+            rootInstructionBaseContents,
+            targetPaths: trackedRootInstructionShadowPlan.untrackedTargetPaths,
+            resolveCachedBundle: (entry) => resolveDesiredCachedBundle(options.libraryDir, entry),
+        });
+        currentBundles = (0, root_instruction_state_1.refreshManagedFileFingerprintsForPaths)(gitContext.worktreeRoot, currentBundles, syncedRootInstructionPaths);
+        const newMatState = {
+            bundles: currentBundles,
+            exclude_configured: false,
+            ...(rootInstructionBaseContents !== undefined
+                ? { root_instruction_base_contents: rootInstructionBaseContents }
+                : {}),
+        };
+        const managedFiles = collectAllFiles(newMatState);
+        newMatState.exclude_configured = managedFiles.length > 0;
+        if (managedFiles.length > 0) {
+            (0, git_exclude_1.configureSkulExcludeBlock)({
+                gitDir: gitContext.gitDir,
+                files: managedFiles,
+            });
+        }
+        else {
+            (0, git_exclude_1.removeSkulExcludeBlock)({ gitDir: gitContext.gitDir });
+        }
+        registry = (0, registry_1.upsertWorktreeState)(registry, gitContext.worktreeId, {
+            repo_fingerprint: gitContext.repoFingerprint,
+            path: gitContext.worktreeRoot,
+            materialized_state: newMatState,
+            shadowed_files: currentShadowedFiles,
+        });
+        (0, registry_1.writeRegistryFile)(options.registryFile, registry);
+    }
+    const appliedNames = applyPlans.map(({ entry }) => entry.bundle).join(", ");
+    return [...cloneLines, pc.green(`Applied ${appliedNames}`)].join("\n");
+}
+function selectTrackedRootInstructionShadowToolNames(options) {
+    return Array.from(new Set([
+        ...(options.existingBundleState
+            ? Object.keys(options.existingBundleState.tools)
+            : []),
+        ...options.nextToolNames,
+    ]));
+}
+function planTrackedRootInstructionShadows(options) {
+    const activeOverlayContents = (0, root_instruction_content_1.collectComposedRootInstructionContents)({
+        bundleDir: options.bundleDir,
+        manifest: options.manifest,
+        toolNames: options.toolNames,
+        itemSelectors: options.itemSelectors,
+    });
+    const activeRootInstructionPaths = new Set(Object.keys(activeOverlayContents).filter((targetPath) => (0, root_instruction_render_1.isRootInstructionPath)(targetPath)));
+    const trackedTargetPaths = new Set();
+    for (const targetPath of activeRootInstructionPaths) {
+        const inspection = (0, git_index_1.inspectRootInstructionShadowTarget)({
+            repoRoot: options.repoRoot,
+            filePath: targetPath,
+        });
+        if (inspection.tracked) {
+            trackedTargetPaths.add(targetPath);
+        }
+    }
+    assertTrackedRootInstructionShadowConflicts({
+        targetPaths: trackedTargetPaths,
+        bundleName: options.bundleName,
+        existingShadowedFiles: options.existingShadowedFiles,
+        materializedBundles: options.materializedBundles,
+    });
+    if (trackedTargetPaths.size === 0) {
+        return {
+            writes: [],
+            deferredMaterializationTargets: trackedTargetPaths,
+            untrackedTargetPaths: new Set(activeRootInstructionPaths),
+            activeShadowPaths: trackedTargetPaths,
+        };
+    }
+    const writes = Array.from(options.targetPaths)
+        .filter((targetPath) => trackedTargetPaths.has(targetPath))
+        .map((targetPath) => renderTrackedRootInstructionShadowWrite({
+        repoRoot: options.repoRoot,
+        filePath: targetPath,
+        overlayContent: activeOverlayContents[targetPath] ?? "",
+        bundleName: options.bundleName,
+        toolName: selectShadowToolForPath(options.toolNames, targetPath),
+    }));
+    const untrackedTargetPaths = new Set(Array.from(activeRootInstructionPaths).filter((targetPath) => !trackedTargetPaths.has(targetPath)));
+    return {
+        writes,
+        deferredMaterializationTargets: trackedTargetPaths,
+        untrackedTargetPaths,
+        activeShadowPaths: trackedTargetPaths,
+    };
+}
+function assertTrackedRootInstructionShadowConflicts(options) {
+    for (const targetPath of options.targetPaths) {
+        const existingShadow = options.existingShadowedFiles[targetPath];
+        if (existingShadow && existingShadow.bundle !== options.bundleName) {
+            throw new Error(`Cannot create tracked root-instruction shadow for ${targetPath} because it is already shadowed by ${existingShadow.bundle}`);
+        }
+        for (const [bundleName, bundleState] of Object.entries(options.materializedBundles)) {
+            if (bundleName === options.bundleName) {
+                continue;
+            }
+            const ownsPath = Object.values(bundleState.tools).some((toolState) => toolState.files.includes(targetPath));
+            if (ownsPath) {
+                throw new Error(`Cannot create tracked root-instruction shadow for ${targetPath} because it is already managed by ${bundleName}`);
+            }
+        }
+    }
+}
+function renderTrackedRootInstructionShadowWrite(options) {
+    const inspection = (0, git_index_1.inspectRootInstructionShadowTarget)({
+        repoRoot: options.repoRoot,
+        filePath: options.filePath,
+    });
+    if (!inspection.headBlob) {
+        throw new Error(`Cannot create tracked root-instruction shadow for ${options.filePath} because the target does not have HEAD content`);
+    }
+    const render = (0, root_instruction_render_1.renderTrackedRootInstructionShadow)({
+        baseContent: inspection.headBlob.content,
+        overlayContent: options.overlayContent,
+        bundleName: options.bundleName,
+        toolName: options.toolName,
+        strategy: "append",
+    });
+    return {
+        filePath: options.filePath,
+        rendered: render.rendered,
+        state: {
+            tool: options.toolName,
+            bundle: options.bundleName,
+            strategy: "append",
+            base_blob: inspection.headBlob.objectId,
+            overlay: options.overlayContent,
+            overlay_fingerprint: render.overlayFingerprint,
+            rendered_fingerprint: render.renderedFingerprint,
+            skip_worktree: true,
+        },
+    };
+}
+function selectShadowToolForPath(toolNames, filePath) {
+    const matchingTool = toolNames.find((toolName) => (0, tool_mapping_1.getToolDefinition)(toolName)?.targets.root_instruction?.path === filePath);
+    if (matchingTool) {
+        return matchingTool;
+    }
+    if (filePath === "AGENTS.md") {
+        return "codex";
+    }
+    return toolNames.find((toolName) => toolName !== "codex") ?? "claude-code";
+}
+function applyTrackedRootInstructionShadowPlan(options) {
+    const nextShadowedFiles = { ...options.existingShadowedFiles };
+    for (const [filePath, shadowedFile] of Object.entries(options.existingShadowedFiles)) {
+        if (shadowedFile.bundle !== options.bundleName ||
+            options.plan.activeShadowPaths.has(filePath)) {
+            continue;
+        }
+        assertTrackedRootInstructionShadowRetirementSafety({
+            repoRoot: options.repoRoot,
+            filePath,
+            existingShadowedFile: shadowedFile,
+        });
+        restoreTrackedRootInstructionShadowTarget({
+            repoRoot: options.repoRoot,
+            filePath,
+        });
+        delete nextShadowedFiles[filePath];
+    }
+    for (const write of options.plan.writes) {
+        const targetPath = node_path_1.default.join(options.repoRoot, write.filePath);
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(targetPath), { recursive: true });
+        node_fs_1.default.writeFileSync(targetPath, write.rendered);
+        (0, git_index_1.setGitSkipWorktree)({
+            repoRoot: options.repoRoot,
+            filePath: write.filePath,
+        });
+        nextShadowedFiles[write.filePath] = write.state;
+    }
+    return nextShadowedFiles;
+}
+function assertTrackedRootInstructionShadowPlanCanApply(options) {
+    for (const [filePath, shadowedFile] of Object.entries(options.existingShadowedFiles)) {
+        if (shadowedFile.bundle !== options.bundleName ||
+            options.plan.activeShadowPaths.has(filePath)) {
+            continue;
+        }
+        assertTrackedRootInstructionShadowRetirementSafety({
+            repoRoot: options.repoRoot,
+            filePath,
+            existingShadowedFile: shadowedFile,
+        });
+    }
+    for (const write of options.plan.writes) {
+        assertTrackedRootInstructionShadowWriteSafety({
+            repoRoot: options.repoRoot,
+            filePath: write.filePath,
+            existingShadowedFile: options.existingShadowedFiles[write.filePath],
+            operation: options.existingShadowedFiles[write.filePath]
+                ? "refresh"
+                : "create",
+        });
+    }
+}
+function assertTrackedRootInstructionShadowWriteSafety(options) {
+    assertTrackedRootInstructionShadowSafety({
+        repoRoot: options.repoRoot,
+        filePath: options.filePath,
+        operation: options.operation,
+    });
+    if (!options.existingShadowedFile) {
+        return;
+    }
+    const targetPath = node_path_1.default.join(options.repoRoot, options.filePath);
+    if (!node_fs_1.default.existsSync(targetPath) || !node_fs_1.default.statSync(targetPath).isFile()) {
+        throw new Error(`Cannot refresh tracked root-instruction shadow for ${options.filePath} because the current shadow file is missing`);
+    }
+    if (fingerprintFile(targetPath) !==
+        options.existingShadowedFile.rendered_fingerprint) {
+        throw new Error(`Cannot refresh tracked root-instruction shadow for ${options.filePath} because the current worktree content no longer matches Skul's recorded render`);
+    }
+}
+function assertTrackedRootInstructionShadowRetirementSafety(options) {
+    const targetPath = node_path_1.default.join(options.repoRoot, options.filePath);
+    if (!node_fs_1.default.existsSync(targetPath) || !node_fs_1.default.statSync(targetPath).isFile()) {
+        throw new Error(`Cannot retire tracked root-instruction shadow for ${options.filePath} because the current shadow file is missing`);
+    }
+    if (fingerprintFile(targetPath) !==
+        options.existingShadowedFile.rendered_fingerprint) {
+        throw new Error(`Cannot retire tracked root-instruction shadow for ${options.filePath} because the current worktree content no longer matches Skul's recorded render`);
+    }
+}
+function retireTrackedRootInstructionShadows(options) {
+    const nextShadowedFiles = { ...options.shadowedFiles };
+    for (const filePath of options.filePaths) {
+        const shadowedFile = nextShadowedFiles[filePath];
+        if (!shadowedFile) {
+            continue;
+        }
+        assertTrackedRootInstructionShadowRetirementSafety({
+            repoRoot: options.repoRoot,
+            filePath,
+            existingShadowedFile: shadowedFile,
+        });
+    }
+    for (const filePath of options.filePaths) {
+        const shadowedFile = nextShadowedFiles[filePath];
+        if (!shadowedFile) {
+            continue;
+        }
+        assertTrackedRootInstructionShadowRetirementSafety({
+            repoRoot: options.repoRoot,
+            filePath,
+            existingShadowedFile: shadowedFile,
+        });
+        restoreTrackedRootInstructionShadowTarget({
+            repoRoot: options.repoRoot,
+            filePath,
+        });
+        delete nextShadowedFiles[filePath];
+    }
+    return nextShadowedFiles;
+}
+function restoreTrackedRootInstructionShadowTarget(options) {
+    const inspection = (0, git_index_1.inspectRootInstructionShadowTarget)({
+        repoRoot: options.repoRoot,
+        filePath: options.filePath,
+    });
+    if (!inspection.headBlob) {
+        throw new Error(`Cannot restore tracked root-instruction shadow target for ${options.filePath} because the target does not have HEAD content`);
+    }
+    const targetPath = node_path_1.default.join(options.repoRoot, options.filePath);
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(targetPath), { recursive: true });
+    node_fs_1.default.writeFileSync(targetPath, inspection.headBlob.content);
+    (0, git_index_1.clearGitSkipWorktree)({
+        repoRoot: options.repoRoot,
+        filePath: options.filePath,
+    });
+}
+function excludeShadowedTrackedRootInstructionTargets(state, deferredMaterializationTargets) {
+    if (deferredMaterializationTargets.size === 0) {
+        return state;
+    }
+    const files = state.files.filter((filePath) => !deferredMaterializationTargets.has(filePath));
+    const fileFingerprints = Object.fromEntries(Object.entries(state.file_fingerprints).filter(([filePath]) => !deferredMaterializationTargets.has(filePath)));
+    return {
+        files,
+        file_fingerprints: fileFingerprints,
+        ...(state.directories !== undefined
+            ? { directories: state.directories }
+            : {}),
+    };
+}
+function isDesiredBundleMaterialized(options) {
+    const expectedTools = options.desiredEntry.tools ?? options.availableTools;
+    return (expectedTools.every((toolName) => toolName in options.materializedBundleState.tools &&
+        (0, bundle_items_1.bundleItemSelectionsEqual)(options.desiredEntry.items, options.materializedBundleState.tools[toolName]?.items)) &&
+        (options.desiredEntry.resolved_commit === undefined ||
+            options.materializedBundleState.resolved_commit ===
+                options.desiredEntry.resolved_commit));
+}
+function getToolsToApply(options) {
+    const expectedTools = options.desiredEntry.tools ?? options.availableTools;
+    if (!options.materializedBundleState) {
+        return options.desiredEntry.tools;
+    }
+    if (options.desiredEntry.resolved_commit !== undefined &&
+        options.materializedBundleState.resolved_commit !==
+            options.desiredEntry.resolved_commit) {
+        return options.desiredEntry.tools ?? options.availableTools;
+    }
+    const existingTools = options.materializedBundleState.tools;
+    return expectedTools.filter((toolName) => !(toolName in existingTools) ||
+        !(0, bundle_items_1.bundleItemSelectionsEqual)(options.desiredEntry.items, existingTools[toolName]?.items));
+}
+// Flatten all files and directories from every tool within a single bundle
+function flattenBundleState(bundleState) {
+    const files = new Set();
+    const file_fingerprints = {};
+    const directories = new Set();
+    for (const toolState of Object.values(bundleState.tools)) {
+        for (const file of toolState.files) {
+            files.add(file);
+        }
+        if (toolState.file_fingerprints)
+            Object.assign(file_fingerprints, toolState.file_fingerprints);
+        if (toolState.directories) {
+            for (const directory of toolState.directories) {
+                directories.add(directory);
+            }
+        }
+    }
+    return {
+        files: Array.from(files),
+        file_fingerprints,
+        directories: Array.from(directories),
+    };
+}
+function selectExistingBundleToolState(bundleState, toolNames) {
+    return {
+        ...(bundleState.source !== undefined ? { source: bundleState.source } : {}),
+        ...(bundleState.resolved_commit !== undefined
+            ? { resolved_commit: bundleState.resolved_commit }
+            : {}),
+        tools: Object.fromEntries(toolNames.flatMap((toolName) => {
+            const toolState = bundleState.tools[toolName];
+            return toolState ? [[toolName, toolState]] : [];
+        })),
+    };
+}
+// Build per-tool registry entries from a materialization result
+function buildMaterializedToolStates(repoRoot, result, selectedItems) {
+    return Object.fromEntries(Object.entries(result.byTool).map(([toolName, toolResult]) => [
+        toolName,
+        {
+            files: toolResult.files,
+            file_fingerprints: captureManagedFileFingerprints(repoRoot, toolResult.files),
+            ...(toolResult.directories.length > 0
+                ? { directories: toolResult.directories }
+                : {}),
+            ...(selectedItems !== undefined ? { items: selectedItems } : {}),
+        },
+    ]));
+}
+function buildMaterializedBundleState(options) {
+    const preservedTools = options.existingBundleState && options.selectedTools
+        ? Object.fromEntries(Object.entries(options.existingBundleState.tools).filter(([toolName]) => !options.selectedTools.includes(toolName)))
+        : {};
+    return {
+        ...(options.source !== undefined
+            ? { source: options.source }
+            : options.existingBundleState?.source !== undefined
+                ? { source: options.existingBundleState.source }
+                : {}),
+        ...(options.resolvedCommit !== undefined
+            ? { resolved_commit: options.resolvedCommit }
+            : options.existingBundleState?.resolved_commit !== undefined
+                ? { resolved_commit: options.existingBundleState.resolved_commit }
+                : {}),
+        tools: {
+            ...preservedTools,
+            ...buildMaterializedToolStates(options.repoRoot, options.materializedResult, options.selectedItems),
+        },
+    };
+}
+// Collect all files across every bundle and tool for git-exclude configuration
+function collectAllFiles(materializedState) {
+    return Array.from(new Set(Object.values(materializedState.bundles).flatMap((bundleState) => Object.values(bundleState.tools).flatMap((toolState) => toolState.files))));
+}
+function removeManagedPaths(repoRoot, state) {
+    for (const relativePath of (0, registry_1.listManagedPathsForRemoval)(state)) {
+        const targetPath = node_path_1.default.join(repoRoot, relativePath);
+        if (!node_fs_1.default.existsSync(targetPath)) {
+            continue;
+        }
+        const stats = node_fs_1.default.lstatSync(targetPath);
+        if (stats.isDirectory()) {
+            try {
+                node_fs_1.default.rmdirSync(targetPath);
+            }
+            catch (error) {
+                if (!isDirectoryNotEmptyError(error)) {
+                    throw error;
+                }
+            }
+            continue;
+        }
+        node_fs_1.default.rmSync(targetPath, { force: true });
+    }
+}
+function isDirectoryNotEmptyError(error) {
+    return (error instanceof Error && "code" in error && error.code === "ENOTEMPTY");
+}
+function requireGitContext(cwd, command) {
+    const gitContext = (0, git_context_1.detectGitContext)({ cwd });
+    if (!gitContext) {
+        throw new Error(`skul ${command} requires a Git repository. Run "git init" to initialize one`);
+    }
+    return gitContext;
+}
+/**
+ * Throws when Skul is about to create or refresh a tracked root-instruction
+ * shadow on top of a Git path that is not in a safe state to overwrite.
+ *
+ * Callers typically run it before removing existing managed files and again as
+ * a write-time backstop during materialization.
+ */
+function assertTrackedRootInstructionShadowSafety(options) {
+    assertTrackedRootInstructionShadowSafetyForAction({
+        repoRoot: options.repoRoot,
+        filePath: options.filePath,
+        action: options.operation,
+    });
+}
+function assertTrackedRootInstructionShadowSafetyForAction(options) {
+    const inspection = (0, git_index_1.inspectRootInstructionShadowTarget)({
+        repoRoot: options.repoRoot,
+        filePath: options.filePath,
+    });
+    if (!inspection.tracked) {
+        return;
+    }
+    const actionLabel = options.action;
+    if (inspection.issues.includes("unmerged")) {
+        throw new Error(`Cannot ${actionLabel} tracked root-instruction shadow for ${options.filePath} because the target has unmerged index entries`);
+    }
+    if (inspection.issues.includes("missing-head")) {
+        throw new Error(`Cannot ${actionLabel} tracked root-instruction shadow for ${options.filePath} because the target does not have HEAD content`);
+    }
+    if (inspection.issues.includes("staged-changes")) {
+        throw new Error(`Cannot ${actionLabel} tracked root-instruction shadow for ${options.filePath} because the target has staged changes`);
+    }
+    if (inspection.issues.includes("unstaged-changes")) {
+        throw new Error(`Cannot ${actionLabel} tracked root-instruction shadow for ${options.filePath} because the target has unstaged changes`);
+    }
+    if (inspection.issues.includes("incompatible-index-flags")) {
+        throw new Error(`Cannot ${actionLabel} tracked root-instruction shadow for ${options.filePath} because the target has incompatible index flags: ${inspection.indexFlags.join(", ")}`);
+    }
+}
+function assertTrackedRootInstructionShadowSafetyForPaths(options) {
+    for (const filePath of options.filePaths) {
+        if (!(0, root_instruction_render_1.isRootInstructionPath)(filePath)) {
+            continue;
+        }
+        assertTrackedRootInstructionShadowSafety({
+            repoRoot: options.repoRoot,
+            filePath,
+            operation: options.operation,
+        });
+    }
+}
+function createTrackedRootInstructionShadowSafetyAssertion(options) {
+    return (repoRelativePath) => {
+        if (!(0, root_instruction_render_1.isRootInstructionPath)(repoRelativePath)) {
+            return;
+        }
+        assertTrackedRootInstructionShadowSafety({
+            repoRoot: options.repoRoot,
+            filePath: repoRelativePath,
+            operation: options.operation,
+        });
+    };
+}
+function selectDesiredEntries(desiredState, bundle, command) {
+    if (!bundle) {
+        return desiredState;
+    }
+    const matchingEntry = desiredState.find((entry) => entry.bundle === bundle);
+    if (!matchingEntry) {
+        throw new Error(`Bundle not found in active set: ${bundle}. Run "skul status" to see configured bundles`);
+    }
+    return [matchingEntry];
+}
+function mergeDesiredTools(options) {
+    if (options.requestedTools === undefined) {
+        return undefined;
+    }
+    if (options.replace || options.existingEntry?.tools === undefined) {
+        return [...options.requestedTools];
+    }
+    return Array.from(new Set([...options.existingEntry.tools, ...options.requestedTools])).sort((left, right) => left.localeCompare(right));
+}
+function upsertDesiredEntryPreservingOrder(desiredState, nextEntry) {
+    const existingIndex = desiredState.findIndex((entry) => entry.bundle === nextEntry.bundle);
+    if (existingIndex === -1) {
+        return [...desiredState, nextEntry];
+    }
+    return desiredState.map((entry, index) => index === existingIndex ? nextEntry : entry);
+}
+function getToolsToRefresh(entry, existingBundleState) {
+    if (entry.tools === undefined) {
+        return undefined;
+    }
+    const existingTools = existingBundleState
+        ? Object.keys(existingBundleState.tools)
+        : [];
+    return Array.from(new Set([...entry.tools, ...existingTools])).sort((left, right) => left.localeCompare(right));
+}
+function formatCommitTransition(currentCommit, nextCommit) {
+    return currentCommit
+        ? ` ${shortCommit(currentCommit)} -> ${shortCommit(nextCommit)}`
+        : ` to ${shortCommit(nextCommit)}`;
+}
+function shortCommit(commit) {
+    return commit.slice(0, 7);
+}
+function resolveDesiredCachedBundle(libraryDir, entry) {
+    return findCachedBundleWithGuidance({
+        libraryDir,
+        bundle: entry.bundle,
+        source: entry.source,
+    });
+}
+function readRegistryWithGuidance(registryFile) {
+    try {
+        return (0, registry_1.readRegistryFile)(registryFile);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Registry is corrupted (${detail}). Please repair or remove ${registryFile} and try again.`);
+    }
+}
+function findCachedBundleWithGuidance(options) {
+    try {
+        return (0, bundle_discovery_1.findCachedBundle)(options);
+    }
+    catch (error) {
+        if (error instanceof Error && /^Bundle not found: /.test(error.message)) {
+            const availableBundles = (0, bundle_discovery_1.listCachedBundles)({
+                libraryDir: options.libraryDir,
+            }).map((bundle) => bundle.bundle);
+            if (availableBundles.length === 0) {
+                throw new Error(`${error.message}\n\nNo bundles are cached yet. Add one from a Git source:\n  skul add github.com/<owner>/<repo> <bundle-name>`);
+            }
+            throw new Error(`${error.message}\nAvailable bundles:\n${Array.from(new Set(availableBundles))
+                .sort((left, right) => left.localeCompare(right))
+                .join("\n")}`);
+        }
+        throw error;
+    }
+}
+async function confirmManagedFileRemovals(repoRoot, state, prompts, operation) {
+    for (const relativePath of findModifiedManagedFiles(repoRoot, state)) {
+        const confirmed = await prompts.confirmManagedFileRemoval(relativePath, operation);
+        if (!confirmed) {
+            return false;
+        }
+    }
+    return true;
+}
+function findModifiedManagedFiles(repoRoot, state) {
+    return state.files.filter((relativePath) => {
+        const fingerprint = state.file_fingerprints?.[relativePath];
+        if (!fingerprint) {
+            return false;
+        }
+        const targetPath = node_path_1.default.join(repoRoot, relativePath);
+        if (!node_fs_1.default.existsSync(targetPath) || !node_fs_1.default.lstatSync(targetPath).isFile()) {
+            return false;
+        }
+        return fingerprint !== fingerprintFile(targetPath);
+    });
+}
+function captureManagedFileFingerprints(repoRoot, files) {
+    return Object.fromEntries(files.map((relativePath) => [
+        relativePath,
+        fingerprintFile(node_path_1.default.join(repoRoot, relativePath)),
+    ]));
+}
+function fingerprintFile(filePath) {
+    try {
+        return (0, node_crypto_1.createHash)("sha256").update(node_fs_1.default.readFileSync(filePath)).digest("hex");
+    }
+    catch {
+        // On read failure treat the file as modified so callers prompt before deletion
+        // rather than silently skipping a managed file that may still exist.
+        return "";
+    }
+}
+async function applyBundleGlobal(options) {
+    const supportedTools = (0, tool_mapping_1.globalCapableToolNames)();
+    if (options.agents.length > 0) {
+        const unsupported = options.agents.filter((t) => !supportedTools.includes(t));
+        if (unsupported.length > 0) {
+            throw new Error(`Global mode only supports: ${supportedTools.join(", ")}. Unsupported: ${unsupported.join(", ")}`);
+        }
+    }
+    const repoRelPathRemapper = tool_mapping_1.GLOBAL_TOOL_MATERIALIZATION_LAYOUT.remapRepoRelPath;
+    let registry = readRegistryWithGuidance(options.registryFile);
+    const existingGlobal = registry.global;
+    if (shouldApplySelectedItemsAcrossSourceBundles(options)) {
+        return applySelectedItemsAcrossGlobalSourceBundles({
+            homeDir: options.homeDir,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            source: options.source,
+            protocol: options.protocol,
+            agents: options.agents.length > 0
+                ? options.agents.filter((toolName) => supportedTools.includes(toolName))
+                : [],
+            includeItems: options.includeItems,
+            dryRun: options.dryRun,
+            ref: options.ref,
+            existingDesiredState: existingGlobal?.desired_state ?? [],
+            disableModelInvocation: options.disableModelInvocation,
+        });
+    }
+    // When no --agent is specified, auto-select all globally-capable tools that
+    // the bundle actually supports, rather than requesting all supported tools
+    // upfront (which would fail validation for bundles that don't cover every tool).
+    const globalAutoSelectPrompts = {
+        ...options.prompts,
+        selectAgents: async (availableAgents) => availableAgents.filter((t) => supportedTools.includes(t)),
+    };
+    // Skip cloning in dry-run: when a remote source is specified and not yet
+    // cached, return a preview message immediately so no network I/O occurs.
+    if (options.dryRun && options.source) {
+        const { cached } = (0, bundle_fetch_1.readCachedSourceRevision)({
+            source: options.source,
+            libraryDir: options.libraryDir,
+            protocol: options.protocol,
+        });
+        if (!cached) {
+            const toolsLabel = options.agents.length > 0
+                ? options.agents.join(", ")
+                : "globally supported tools";
+            return [
+                pc.dim(`(would clone ${options.source})`),
+                `${pc.yellow("DRY RUN:")} Would apply ${options.bundle} globally for ${toolsLabel}`,
+            ].join("\n");
+        }
+    }
+    const preparedBundle = await prepareApplyBundle({
+        bundle: options.bundle,
+        source: options.source,
+        protocol: options.protocol,
+        requestedTools: options.agents.length > 0
+            ? options.agents.filter((t) => supportedTools.includes(t))
+            : [],
+        requestedItems: options.includeItems,
+        selectItems: options.selectItems,
+        replaceItems: options.replaceItems,
+        existingDesiredState: existingGlobal?.desired_state ?? [],
+        libraryDir: options.libraryDir,
+        ref: options.ref,
+        prompts: options.agents.length > 0 ? options.prompts : globalAutoSelectPrompts,
+        preBundlePrompts: options.prompts,
+        inferredBundleFromSource: options.inferredBundleFromSource,
+        refreshedSources: options.refreshedSources,
+    });
+    const availableGlobalTools = preparedBundle.nextToolNames.filter((t) => supportedTools.includes(t));
+    if (availableGlobalTools.length === 0) {
+        const bundleTools = Object.keys(preparedBundle.cachedBundle.manifest.tools);
+        throw new Error(`Bundle "${preparedBundle.cachedBundle.bundle}" has no globally installable tools (bundle provides: ${bundleTools.join(", ")}; global mode supports: ${supportedTools.join(", ")})`);
+    }
+    // Warn when auto-selecting (no --agent) and the bundle contains tools that
+    // aren't globally installable — they were silently dropped by globalAutoSelectPrompts.
+    const skippedTools = options.agents.length === 0
+        ? Object.keys(preparedBundle.cachedBundle.manifest.tools).filter((t) => !supportedTools.includes(t))
+        : [];
+    if (options.dryRun) {
+        return [
+            ...preparedBundle.cloneLines,
+            `${pc.yellow("DRY RUN:")} Would ${formatApplyGlobalBundleMessage({
+                bundle: preparedBundle.cachedBundle.bundle,
+                toolLabel: availableGlobalTools.join(", "),
+                items: preparedBundle.replacesItemSelection
+                    ? preparedBundle.selectedItems
+                    : undefined,
+            })}`,
+        ].join("\n");
+    }
+    let rootInstructionBaseContents = existingGlobal?.materialized_state.root_instruction_base_contents;
+    const existingBundleState = existingGlobal?.materialized_state.bundles[preparedBundle.cachedBundle.bundle];
+    const plannedWriteTargets = (0, bundle_materialization_1.previewMaterializeBundleWriteTargets)({
+        repoRoot: options.homeDir,
+        bundleDir: node_path_1.default.dirname(preparedBundle.cachedBundle.manifestFile),
+        manifest: preparedBundle.cachedBundle.manifest,
+        tools: availableGlobalTools,
+        pathLayout: tool_mapping_1.GLOBAL_TOOL_MATERIALIZATION_LAYOUT,
+        itemSelectors: preparedBundle.selectedItems,
+        disableModelInvocation: options.disableModelInvocation,
+    });
+    const plannedRootInstructionTargets = new Set(plannedWriteTargets.filter((p) => (0, root_instruction_render_1.isRootInstructionPath)(p)));
+    const existingBundles = existingGlobal?.materialized_state.bundles ?? {};
+    rootInstructionBaseContents = (0, root_instruction_state_1.captureRootInstructionBaseContents)({
+        repoRoot: options.homeDir,
+        targetPaths: plannedRootInstructionTargets,
+        existingBaseContents: rootInstructionBaseContents,
+        managedTargetPaths: (0, root_instruction_state_1.collectManagedRootInstructionTargets)(existingBundles),
+    });
+    const existingDesiredState = existingGlobal?.desired_state ?? [];
+    (0, root_instruction_state_1.assertManagedRootInstructionSyncSourcesCached)({
+        desiredState: existingDesiredState,
+        materializedBundles: existingBundles,
+        targetPaths: plannedRootInstructionTargets,
+        resolveCachedBundle: (entry) => resolveDesiredCachedBundle(options.libraryDir, entry),
+    });
+    let pathsToReplace = null;
+    if (existingBundleState) {
+        const toolsToReplace = options.agents.length > 0
+            ? options.agents.filter((t) => t in existingBundleState.tools)
+            : Object.keys(existingBundleState.tools);
+        pathsToReplace = flattenBundleState({
+            tools: Object.fromEntries(toolsToReplace.map((t) => [t, existingBundleState.tools[t]])),
+        });
+        const replacementAllowed = await confirmManagedFileRemovals(options.homeDir, pathsToReplace, options.prompts, "replace");
+        if (!replacementAllowed) {
+            throw new Error("Replacement aborted because a modified managed file was kept");
+        }
+    }
+    const sharedRootInstructionState = (0, root_instruction_state_1.collectSharedRootInstructionState)(existingBundles, plannedWriteTargets, preparedBundle.cachedBundle.bundle);
+    if (sharedRootInstructionState.files.length > 0) {
+        const replacementAllowed = await confirmManagedFileRemovals(options.homeDir, sharedRootInstructionState, options.prompts, "replace");
+        if (!replacementAllowed) {
+            throw new Error("Replacement aborted because a modified managed file was kept");
+        }
+    }
+    if (pathsToReplace) {
+        removeManagedPaths(options.homeDir, pathsToReplace);
+    }
+    const materializedResult = await (0, bundle_materialization_1.materializeBundle)({
+        repoRoot: options.homeDir,
+        bundleDir: node_path_1.default.dirname(preparedBundle.cachedBundle.manifestFile),
+        manifest: preparedBundle.cachedBundle.manifest,
+        tools: availableGlobalTools,
+        bundleName: preparedBundle.cachedBundle.bundle,
+        bundleSource: preparedBundle.bundleSource,
+        allowFileOverwriteTargets: (0, root_instruction_state_1.collectManagedRootInstructionTargets)(existingBundles),
+        rootInstructionBaseContents,
+        resolveFileConflict: options.prompts.resolveFileConflict,
+        pathLayout: tool_mapping_1.GLOBAL_TOOL_MATERIALIZATION_LAYOUT,
+        itemSelectors: preparedBundle.selectedItems,
+        disableModelInvocation: options.disableModelInvocation,
+    });
+    const newBundleState = buildMaterializedBundleState({
+        existingBundleState,
+        materializedResult,
+        repoRoot: options.homeDir,
+        source: preparedBundle.bundleSource,
+        resolvedCommit: preparedBundle.sourceRevision?.currentCommit,
+        selectedTools: availableGlobalTools,
+        selectedItems: preparedBundle.selectedItems,
+    });
+    const newDesiredEntry = buildDesiredEntryForAppliedBundle({
+        existingDesiredState,
+        cachedBundle: preparedBundle.cachedBundle,
+        requestedSource: options.source,
+        requestedProtocol: options.protocol,
+        requestedRef: options.ref,
+        requestedTools: availableGlobalTools,
+        replaceRequestedTools: options.agents.length === 0,
+        requestedItems: preparedBundle.selectedItems,
+        replaceRequestedItems: preparedBundle.replacesItemSelection,
+        sourceRevision: preparedBundle.sourceRevision,
+        disableModelInvocation: options.disableModelInvocation,
+    });
+    const newDesiredState = [
+        ...upsertDesiredEntryPreservingOrder(existingDesiredState, newDesiredEntry),
+    ];
+    const newBundles = {
+        ...existingBundles,
+        [preparedBundle.cachedBundle.bundle]: newBundleState,
+    };
+    const syncedRootInstructionPaths = (0, root_instruction_state_1.syncManagedRootInstructionFiles)({
+        repoRoot: options.homeDir,
+        desiredState: newDesiredState,
+        materializedBundles: newBundles,
+        rootInstructionBaseContents,
+        targetPaths: plannedRootInstructionTargets,
+        resolveCachedBundle: (entry) => resolveDesiredCachedBundle(options.libraryDir, entry),
+        repoRelPathRemapper,
+    });
+    const refreshedBundles = (0, root_instruction_state_1.refreshManagedFileFingerprintsForPaths)(options.homeDir, newBundles, syncedRootInstructionPaths);
+    const newGlobalState = {
+        desired_state: newDesiredState,
+        materialized_state: {
+            bundles: refreshedBundles,
+            ...(rootInstructionBaseContents !== undefined
+                ? { root_instruction_base_contents: rootInstructionBaseContents }
+                : {}),
+        },
+    };
+    registry = (0, registry_1.upsertGlobalState)(registry, newGlobalState);
+    (0, registry_1.writeRegistryFile)(options.registryFile, registry);
+    const lines = [
+        ...preparedBundle.cloneLines,
+        pc.green(formatAppliedGlobalBundleMessage({
+            bundle: preparedBundle.cachedBundle.bundle,
+            toolLabel: availableGlobalTools.join(", "),
+            items: preparedBundle.replacesItemSelection
+                ? preparedBundle.selectedItems
+                : undefined,
+        })),
+    ];
+    if (skippedTools.length > 0) {
+        lines.push(pc.yellow(`Note: ${skippedTools.join(", ")} ${skippedTools.length === 1 ? "is" : "are"} not supported in global mode and ${skippedTools.length === 1 ? "was" : "were"} skipped`));
+    }
+    return lines.join("\n");
+}
+function formatAppliedGlobalBundleMessage(options) {
+    return formatApplyGlobalBundleMessage({
+        bundle: options.bundle,
+        toolLabel: options.toolLabel,
+        items: options.items,
+        action: "Applied",
+    });
+}
+function formatApplyGlobalBundleMessage(options) {
+    const itemLabel = options.items !== undefined && options.items.length > 0
+        ? `: ${options.items.join(", ")}`
+        : "";
+    return `${options.action ?? "apply"} ${options.bundle} globally for ${options.toolLabel}${itemLabel}`;
+}
+async function applySelectedItemsAcrossGlobalSourceBundles(options) {
+    const refreshedSources = new Set();
+    const cloneLines = refreshBundleSourceForApply({
+        source: options.source,
+        libraryDir: options.libraryDir,
+        protocol: options.protocol,
+        ref: options.ref,
+    }, refreshedSources);
+    const selection = await selectSourceBundleItemApplyTargets({
+        libraryDir: options.libraryDir,
+        source: options.source,
+        requestedTools: options.agents,
+        requestedItems: options.includeItems,
+        prompts: options.prompts,
+        existingDesiredState: options.existingDesiredState,
+        global: true,
+    });
+    const outputLines = [];
+    for (const target of selection.removeTargets) {
+        outputLines.push(await removeGlobalBundle({
+            homeDir: options.homeDir,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            bundle: target.bundle,
+            source: target.source,
+            includeItems: [],
+            selectItems: false,
+            dryRun: options.dryRun,
+        }));
+    }
+    for (const target of selection.applyTargets) {
+        outputLines.push(await applyBundleGlobal({
+            homeDir: options.homeDir,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            bundle: target.bundle,
+            source: target.source,
+            protocol: options.protocol,
+            agents: target.tools,
+            includeItems: target.items,
+            selectItems: false,
+            replaceItems: true,
+            dryRun: options.dryRun,
+            ref: options.ref,
+            refreshedSources,
+            disableModelInvocation: options.disableModelInvocation,
+        }));
+    }
+    return [...cloneLines, ...outputLines].filter(Boolean).join("\n");
+}
+function renderGlobalStatus(options) {
+    const registry = readRegistryWithGuidance(options.registryFile);
+    const globalState = registry.global;
+    if (options.json) {
+        return JSON.stringify({
+            desired_state: globalState?.desired_state ?? [],
+            materialized: {
+                bundles: Object.fromEntries(Object.entries(globalState?.materialized_state.bundles ?? {}).map(([bundleName, bundleState]) => [
+                    bundleName,
+                    {
+                        tools: Object.fromEntries(Object.entries(bundleState.tools).map(([t, s]) => [
+                            t,
+                            { files: s.files },
+                        ])),
+                    },
+                ])),
+            },
+        }, null, 2);
+    }
+    const lines = [pc.bold("Global Desired State")];
+    if (globalState && globalState.desired_state.length > 0) {
+        for (const entry of globalState.desired_state) {
+            lines.push(`Bundle: ${pc.cyan(entry.bundle)}`);
+        }
+    }
+    else {
+        lines.push(pc.dim("Configured: no"));
+        lines.push(pc.dim('Run "skul add --global <bundle>" to get started'));
+    }
+    lines.push("", pc.bold("Global Materialized State"));
+    if (!globalState ||
+        Object.keys(globalState.materialized_state.bundles).length === 0) {
+        lines.push(pc.dim("Materialized: no"));
+        return lines.join("\n");
+    }
+    lines.push(pc.green("Materialized: yes"), "", "Files:");
+    for (const [bundleName, bundleState] of Object.entries(globalState.materialized_state.bundles)) {
+        lines.push(`  Bundle: ${pc.cyan(bundleName)}`);
+        for (const [toolName, toolState] of Object.entries(bundleState.tools)) {
+            lines.push(`    Tool: ${toolName}`);
+            for (const file of toolState.files) {
+                lines.push(`      ${file}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+async function removeGlobalBundle(options) {
+    const repoRelPathRemapper = tool_mapping_1.GLOBAL_TOOL_MATERIALIZATION_LAYOUT.remapRepoRelPath;
+    let registry = readRegistryWithGuidance(options.registryFile);
+    const globalState = registry.global;
+    if (shouldRemoveItemsAcrossBundles(options)) {
+        return removeGlobalBundleItemsAcrossActiveBundles({
+            homeDir: options.homeDir,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            globalState,
+            source: options.source,
+            bundle: options.inferredBundleFromSource ? undefined : options.bundle,
+            includeItems: options.includeItems,
+            selectItems: options.selectItems,
+            dryRun: options.dryRun,
+        });
+    }
+    const selection = await resolveRemoveGlobalBundleSelection({
+        requestedBundle: options.bundle,
+        requestedSource: options.source,
+        inferredBundleFromSource: options.inferredBundleFromSource,
+        globalState,
+        prompts: options.prompts,
+    });
+    const bundle = selection.bundle;
+    const source = selection.source;
+    const isInDesiredState = globalState?.desired_state.some((e) => e.bundle === bundle && matchesOptionalSource(e.source, source)) ?? false;
+    const desiredEntry = globalState?.desired_state.find((e) => e.bundle === bundle && matchesOptionalSource(e.source, source));
+    const bundleMaterializedState = findGlobalMaterializedBundleState({
+        globalState,
+        bundle,
+        source,
+    });
+    if (!isInDesiredState && !bundleMaterializedState) {
+        const configured = globalState?.desired_state
+            .filter((entry) => matchesOptionalSource(entry.source, source))
+            .map((e) => e.bundle) ?? [];
+        const hint = configured.length > 0
+            ? `Configured global bundles: ${configured.join(", ")}`
+            : `No global bundles configured. Run "skul add --global <bundle>" to add one`;
+        throw new Error(`Bundle not found in global active set: ${bundle}. ${hint}`);
+    }
+    if (options.includeItems.length > 0 || options.selectItems) {
+        const itemRemoval = await removeGlobalBundleItems({
+            homeDir: options.homeDir,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            registry,
+            globalState,
+            desiredEntry,
+            bundle,
+            source,
+            includeItems: options.includeItems,
+            selectItems: options.selectItems,
+            dryRun: options.dryRun,
+        });
+        if (itemRemoval.kind === "completed") {
+            return itemRemoval.output;
+        }
+    }
+    if (options.dryRun) {
+        if (bundleMaterializedState) {
+            const { files } = flattenBundleState(bundleMaterializedState);
+            const lines = [
+                `${pc.yellow("DRY RUN:")} Would remove global ${bundle} (${files.length} file(s))`,
+            ];
+            for (const file of files)
+                lines.push(`  ${file}`);
+            return lines.join("\n");
+        }
+        return `${pc.yellow("DRY RUN:")} Would remove ${bundle} from global desired state`;
+    }
+    if (bundleMaterializedState) {
+        const bundlePaths = flattenBundleState(bundleMaterializedState);
+        const rootInstructionBaseContents = globalState?.materialized_state.root_instruction_base_contents;
+        const removedRootInstructionPaths = new Set(bundlePaths.files.filter((p) => (0, root_instruction_render_1.isRootInstructionPath)(p)));
+        const remainingBundles = { ...globalState.materialized_state.bundles };
+        delete remainingBundles[bundle];
+        const remainingDesiredState = globalState?.desired_state.filter((entry) => !matchesBundleIdentity(entry, bundle, source)) ?? [];
+        const rewrittenRootInstructionPaths = new Set(Array.from((0, root_instruction_state_1.collectManagedRootInstructionTargets)(remainingBundles)).filter((p) => removedRootInstructionPaths.has(p)));
+        (0, root_instruction_state_1.assertManagedRootInstructionSyncSourcesCached)({
+            desiredState: remainingDesiredState,
+            materializedBundles: remainingBundles,
+            targetPaths: rewrittenRootInstructionPaths,
+            resolveCachedBundle: (entry) => resolveDesiredCachedBundle(options.libraryDir, entry),
+        });
+        const removeAllowed = await confirmManagedFileRemovals(options.homeDir, bundlePaths, options.prompts, "remove");
+        if (!removeAllowed) {
+            throw new Error("Removal aborted because a modified managed file was kept");
+        }
+        removeManagedPaths(options.homeDir, bundlePaths);
+        const remainingRootInstructionTargets = (0, root_instruction_state_1.collectManagedRootInstructionTargets)(remainingBundles);
+        const restoredRootInstructionPaths = new Set(Array.from(removedRootInstructionPaths).filter((p) => !remainingRootInstructionTargets.has(p)));
+        (0, root_instruction_state_1.restoreRootInstructionBaseContents)({
+            repoRoot: options.homeDir,
+            baseContents: rootInstructionBaseContents,
+            targetPaths: restoredRootInstructionPaths,
+        });
+        const nextRootInstructionBaseContents = rootInstructionBaseContents
+            ? Object.fromEntries(Object.entries(rootInstructionBaseContents).filter(([p]) => !restoredRootInstructionPaths.has(p)))
+            : undefined;
+        if (Object.keys(remainingBundles).length > 0) {
+            const syncedRootInstructionPaths = (0, root_instruction_state_1.syncManagedRootInstructionFiles)({
+                repoRoot: options.homeDir,
+                desiredState: remainingDesiredState,
+                materializedBundles: remainingBundles,
+                rootInstructionBaseContents: nextRootInstructionBaseContents,
+                targetPaths: rewrittenRootInstructionPaths,
+                resolveCachedBundle: (entry) => resolveDesiredCachedBundle(options.libraryDir, entry),
+                repoRelPathRemapper,
+            });
+            const refreshedBundles = (0, root_instruction_state_1.refreshManagedFileFingerprintsForPaths)(options.homeDir, remainingBundles, syncedRootInstructionPaths);
+            const newGlobalState = {
+                desired_state: remainingDesiredState,
+                materialized_state: {
+                    bundles: refreshedBundles,
+                    ...(nextRootInstructionBaseContents &&
+                        Object.keys(nextRootInstructionBaseContents).length > 0
+                        ? {
+                            root_instruction_base_contents: nextRootInstructionBaseContents,
+                        }
+                        : {}),
+                },
+            };
+            registry = (0, registry_1.upsertGlobalState)(registry, newGlobalState);
+        }
+        else {
+            if (remainingDesiredState.length > 0) {
+                registry = (0, registry_1.upsertGlobalState)(registry, {
+                    desired_state: remainingDesiredState,
+                    materialized_state: { bundles: {} },
+                });
+            }
+            else {
+                registry = { ...registry, global: undefined };
+            }
+        }
+    }
+    else if (isInDesiredState && globalState) {
+        const newDesiredState = globalState.desired_state.filter((entry) => !matchesBundleIdentity(entry, bundle, source));
+        if (newDesiredState.length > 0 ||
+            Object.keys(globalState.materialized_state.bundles).length > 0) {
+            registry = (0, registry_1.upsertGlobalState)(registry, {
+                ...globalState,
+                desired_state: newDesiredState,
+            });
+        }
+        else {
+            registry = { ...registry, global: undefined };
+        }
+    }
+    (0, registry_1.writeRegistryFile)(options.registryFile, registry);
+    return pc.green(`Removed global ${bundle}`);
+}
+async function removeGlobalBundleItemsAcrossActiveBundles(options) {
+    if (!options.globalState || options.globalState.desired_state.length === 0) {
+        throw new Error(options.source
+            ? `No active global bundles found for ${options.source}. Run "skul add --global ${options.source} <bundle>" to add one first`
+            : 'No active global bundles found. Run "skul add --global <bundle>" to add one first');
+    }
+    const choices = listActiveGlobalBundleItemRemovalChoices({
+        libraryDir: options.libraryDir,
+        desiredState: options.globalState.desired_state,
+        source: options.source,
+        bundle: options.bundle,
+    });
+    const requestedItems = (0, bundle_items_1.normalizeBundleItemSelectors)(options.includeItems);
+    const selectedValues = options.selectItems
+        ? await promptForBundleItemRemovalChoices({
+            prompts: options.prompts,
+            choices,
+            requestedItems,
+        })
+        : selectRequestedBundleItemRemovalChoices({
+            choices,
+            requestedItems,
+        });
+    const removalPlan = planBundleItemRemovals({
+        desiredState: options.globalState.desired_state,
+        choices,
+        selectedValues,
+    });
+    if (options.dryRun) {
+        return `${pc.yellow("DRY RUN:")} Would remove ${formatBundleItemRemovalSummary(removalPlan.removedItems)} from global bundles`;
+    }
+    for (const target of groupBundleItemRemovalTargets(removalPlan.removedItems)) {
+        await removeGlobalBundle({
+            homeDir: options.homeDir,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            bundle: target.bundle,
+            source: target.source,
+            includeItems: target.items,
+            selectItems: false,
+            dryRun: false,
+        });
+    }
+    return pc.green(`Removed ${formatBundleItemRemovalSummary(removalPlan.removedItems)} from global bundles`);
+}
+function listActiveGlobalBundleItemRemovalChoices(options) {
+    const choices = options.desiredState.flatMap((entry) => {
+        if (!matchesOptionalSource(entry.source, options.source))
+            return [];
+        if (options.bundle !== undefined && entry.bundle !== options.bundle) {
+            return [];
+        }
+        return listDesiredGlobalBundleItemRemovalChoices({
+            libraryDir: options.libraryDir,
+            desiredEntry: entry,
+        });
+    });
+    if (choices.length === 0) {
+        throw new Error(options.source
+            ? `No active global bundle items found for ${options.source}`
+            : "No active global bundle items found");
+    }
+    return choices;
+}
+function listDesiredGlobalBundleItemRemovalChoices(options) {
+    const cachedBundle = findCachedBundleWithGuidance({
+        libraryDir: options.libraryDir,
+        bundle: options.desiredEntry.bundle,
+        source: options.desiredEntry.source,
+    });
+    const selectedTools = options.desiredEntry.tools ??
+        Object.keys(cachedBundle.manifest.tools).filter((toolName) => (0, tool_mapping_1.globalCapableToolNames)().includes(toolName));
+    const availableItems = (0, bundle_items_1.listSelectableBundleItems)({
+        bundleDir: node_path_1.default.dirname(cachedBundle.manifestFile),
+        manifest: cachedBundle.manifest,
+        tools: selectedTools,
+    });
+    const activeItems = options.desiredEntry.items ?? availableItems;
+    return activeItems.map((item) => ({
+        value: encodeBundleItemRemovalChoice({
+            bundle: options.desiredEntry.bundle,
+            source: options.desiredEntry.source,
+            item,
+        }),
+        label: formatBundleItemRemovalChoiceLabel({
+            bundle: options.desiredEntry.bundle,
+            source: options.desiredEntry.source,
+            item,
+        }),
+        bundle: options.desiredEntry.bundle,
+        source: options.desiredEntry.source,
+        item,
+        activeItems,
+    }));
+}
+async function resolveRemoveGlobalBundleSelection(options) {
+    if (options.requestedBundle &&
+        isGlobalRemoveBundleActive({
+            globalState: options.globalState,
+            bundle: options.requestedBundle,
+            source: options.requestedSource,
+        })) {
+        return {
+            bundle: options.requestedBundle,
+            ...(options.requestedSource !== undefined
+                ? { source: options.requestedSource }
+                : {}),
+        };
+    }
+    if (options.requestedBundle && !options.inferredBundleFromSource) {
+        return {
+            bundle: options.requestedBundle,
+            ...(options.requestedSource !== undefined
+                ? { source: options.requestedSource }
+                : {}),
+        };
+    }
+    if (options.requestedSource !== undefined &&
+        options.inferredBundleFromSource) {
+        return promptForActiveGlobalRemoveBundleSelection({
+            globalState: options.globalState,
+            prompts: options.prompts,
+            source: options.requestedSource,
+        });
+    }
+    if (options.requestedBundle !== undefined) {
+        return { bundle: options.requestedBundle };
+    }
+    return promptForActiveGlobalRemoveBundleSelection({
+        globalState: options.globalState,
+        prompts: options.prompts,
+    });
+}
+async function promptForActiveGlobalRemoveBundleSelection(options) {
+    const activeSelections = listActiveGlobalRemoveBundleSelections({
+        globalState: options.globalState,
+        source: options.source,
+    });
+    if (activeSelections.length === 0) {
+        throw new Error(options.source
+            ? `No active global bundles found for ${options.source}. Run "skul add --global ${options.source} <bundle>" to add one first`
+            : 'No active global bundles found. Run "skul add --global <bundle>" to add one first');
+    }
+    if (activeSelections.length === 1) {
+        return activeSelections[0];
+    }
+    const selection = await options.prompts.selectBundleFromSelections(activeSelections, options.source);
+    return {
+        bundle: selection.bundle,
+        ...(selection.source !== undefined ? { source: selection.source } : {}),
+    };
+}
+function listActiveGlobalRemoveBundleSelections(options) {
+    const selections = [];
+    const seen = new Set();
+    for (const entry of options.globalState?.desired_state ?? []) {
+        if (!matchesOptionalSource(entry.source, options.source))
+            continue;
+        addActiveRemoveBundleSelection(selections, seen, {
+            bundle: entry.bundle,
+            ...(entry.source !== undefined ? { source: entry.source } : {}),
+            protocol: entry.protocol,
+        });
+    }
+    for (const [bundle, state] of Object.entries(options.globalState?.materialized_state.bundles ?? {})) {
+        if (!matchesOptionalSource(state.source, options.source))
+            continue;
+        addActiveRemoveBundleSelection(selections, seen, {
+            bundle,
+            ...(state.source !== undefined ? { source: state.source } : {}),
+        });
+    }
+    return selections.sort(compareBundleSelections);
+}
+function isGlobalRemoveBundleActive(options) {
+    const desiredMatch = options.globalState?.desired_state.some((entry) => entry.bundle === options.bundle &&
+        matchesOptionalSource(entry.source, options.source)) ?? false;
+    return (desiredMatch ||
+        findGlobalMaterializedBundleState({
+            globalState: options.globalState,
+            bundle: options.bundle,
+            source: options.source,
+        }) !== undefined);
+}
+function findGlobalMaterializedBundleState(options) {
+    const bundleState = options.globalState?.materialized_state.bundles[options.bundle];
+    if (!bundleState ||
+        !matchesOptionalSource(bundleState.source, options.source)) {
+        return undefined;
+    }
+    return bundleState;
+}
+async function removeGlobalBundleItems(options) {
+    if (!options.globalState || !options.desiredEntry) {
+        throw new Error(`Cannot remove selected items from global ${options.bundle} because it is not in desired state`);
+    }
+    const cachedBundle = findCachedBundleWithGuidance({
+        libraryDir: options.libraryDir,
+        bundle: options.bundle,
+        source: options.desiredEntry.source ?? options.source,
+    });
+    const selectedTools = options.desiredEntry.tools ??
+        Object.keys(cachedBundle.manifest.tools).filter((toolName) => (0, tool_mapping_1.globalCapableToolNames)().includes(toolName));
+    const availableItems = (0, bundle_items_1.listSelectableBundleItems)({
+        bundleDir: node_path_1.default.dirname(cachedBundle.manifestFile),
+        manifest: cachedBundle.manifest,
+        tools: selectedTools,
+    });
+    const currentItems = options.desiredEntry.items ?? availableItems;
+    const requestedItems = (0, bundle_items_1.normalizeBundleItemSelectors)(options.includeItems);
+    (0, bundle_items_1.assertBundleSupportsRequestedItems)({
+        requestedItems,
+        availableItems,
+    });
+    const inactiveRequestedItems = requestedItems.filter((item) => !currentItems.includes(item));
+    if (inactiveRequestedItems.length > 0) {
+        throw new Error(`Bundle item(s) are not active in global ${options.bundle}: ${inactiveRequestedItems.join(", ")}`);
+    }
+    const selectedItems = options.selectItems
+        ? await options.prompts.selectBundleItems(currentItems, requestedItems, "remove")
+        : requestedItems;
+    const normalizedSelectedItems = (0, bundle_items_1.normalizeBundleItemSelectors)(selectedItems);
+    const inactiveItems = normalizedSelectedItems.filter((item) => !currentItems.includes(item));
+    if (inactiveItems.length > 0) {
+        throw new Error(`Bundle item(s) are not active in global ${options.bundle}: ${inactiveItems.join(", ")}`);
+    }
+    const selectedItemSet = new Set(normalizedSelectedItems);
+    const remainingItems = currentItems.filter((item) => !selectedItemSet.has(item));
+    if (remainingItems.length === 0) {
+        return { kind: "remove-bundle" };
+    }
+    if (options.dryRun) {
+        return {
+            kind: "completed",
+            output: `${pc.yellow("DRY RUN:")} Would remove ${normalizedSelectedItems.join(", ")} from global ${options.bundle}`,
+        };
+    }
+    const nextRegistry = (0, registry_1.upsertGlobalState)(options.registry, {
+        ...options.globalState,
+        desired_state: options.globalState.desired_state.map((entry) => entry.bundle === options.bundle &&
+            matchesOptionalSource(entry.source, options.source)
+            ? { ...entry, items: remainingItems }
+            : entry),
+    });
+    (0, registry_1.writeRegistryFile)(options.registryFile, nextRegistry);
+    try {
+        await applyGlobal({
+            homeDir: options.homeDir,
+            prompts: options.prompts,
+            registryFile: options.registryFile,
+            libraryDir: options.libraryDir,
+            dryRun: false,
+        });
+    }
+    catch (error) {
+        (0, registry_1.writeRegistryFile)(options.registryFile, options.registry);
+        throw error;
+    }
+    return {
+        kind: "completed",
+        output: pc.green(`Removed ${normalizedSelectedItems.join(", ")} from global ${options.bundle}`),
+    };
+}
+async function resetGlobal(options) {
+    let registry = readRegistryWithGuidance(options.registryFile);
+    const globalState = registry.global;
+    if (!globalState ||
+        Object.keys(globalState.materialized_state.bundles).length === 0) {
+        return "No globally materialized Skul bundles found";
+    }
+    const allBundlePaths = Object.values(globalState.materialized_state.bundles).map(flattenBundleState);
+    const allFiles = allBundlePaths.flatMap((bp) => bp.files);
+    if (options.dryRun) {
+        const lines = [
+            `${pc.yellow("DRY RUN:")} Would remove ${allFiles.length} globally managed file(s)`,
+        ];
+        for (const file of allFiles)
+            lines.push(`  ${file}`);
+        return lines.join("\n");
+    }
+    for (const bundlePaths of allBundlePaths) {
+        const resetAllowed = await confirmManagedFileRemovals(options.homeDir, bundlePaths, options.prompts, "reset");
+        if (!resetAllowed) {
+            throw new Error("Reset aborted because a modified managed file was kept");
+        }
+    }
+    for (const bundlePaths of allBundlePaths) {
+        removeManagedPaths(options.homeDir, bundlePaths);
+    }
+    // reset --global removes all bundle materialization entirely; shared root-instruction files
+    // (e.g. .claude/CLAUDE.md) are not re-composed for remaining bundles — base content is restored
+    // as-is. Run `apply --global` afterward to re-materialize from desired state.
+    (0, root_instruction_state_1.restoreRootInstructionBaseContents)({
+        repoRoot: options.homeDir,
+        baseContents: globalState.materialized_state.root_instruction_base_contents,
+        targetPaths: (0, root_instruction_state_1.collectManagedRootInstructionTargets)(globalState.materialized_state.bundles),
+    });
+    registry = (0, registry_1.upsertGlobalState)(registry, {
+        desired_state: globalState.desired_state,
+        materialized_state: { bundles: {} },
+    });
+    (0, registry_1.writeRegistryFile)(options.registryFile, registry);
+    return pc.green("Reset globally managed Skul files");
+}
+async function applyGlobal(options) {
+    const registry = readRegistryWithGuidance(options.registryFile);
+    const globalState = registry.global;
+    if (!globalState || globalState.desired_state.length === 0) {
+        return `No global bundles configured. Run "skul add --global <bundle>" to add one`;
+    }
+    const outputLines = [];
+    const toApply = globalState.desired_state.filter((entry) => {
+        const mat = globalState.materialized_state.bundles[entry.bundle];
+        if (!mat)
+            return true;
+        if (!isDesiredBundleMaterialized({
+            desiredEntry: entry,
+            materializedBundleState: mat,
+            availableTools: (0, tool_mapping_1.globalCapableToolNames)(),
+        }))
+            return true;
+        if (entry.source &&
+            !(0, bundle_fetch_1.readCachedSourceRevision)({
+                source: entry.source,
+                libraryDir: options.libraryDir,
+            }).cached)
+            return true;
+        return false;
+    });
+    if (toApply.length === 0) {
+        return options.dryRun
+            ? "DRY RUN: All global bundles are already materialized"
+            : "All global bundles are already materialized";
+    }
+    if (options.dryRun) {
+        return toApply
+            .map((e) => `${pc.yellow("DRY RUN:")} Would apply ${e.bundle} globally`)
+            .join("\n");
+    }
+    for (const entry of toApply) {
+        try {
+            const result = await applyBundleGlobal({
+                homeDir: options.homeDir,
+                prompts: options.prompts,
+                registryFile: options.registryFile,
+                libraryDir: options.libraryDir,
+                bundle: entry.bundle,
+                source: entry.source,
+                protocol: entry.protocol,
+                agents: entry.tools ?? [],
+                includeItems: entry.items ?? [],
+                selectItems: false,
+                dryRun: false,
+                ref: entry.ref,
+            });
+            outputLines.push(result);
+        }
+        catch (err) {
+            outputLines.push(`${pc.red("ERROR:")} Failed to apply ${entry.bundle}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return outputLines.join("\n");
+}
+function assertUnreachable(_value) {
+    throw new Error("Unhandled command");
+}
+if (require.main === module) {
+    void run(process.argv.slice(2))
+        .then((output) => {
+        console.log(output);
+    })
+        .catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=index.js.map