@solaqua/skul 0.1.0 → 0.1.1

package/dist/index.js

@@ -44,14 +44,41 @@ async function run(argv, options = {}) {
         return (0, cli_1.createHelpText)(parsed.command);
     }
     switch (parsed.command) {
-        case "add":
+        case "add": {
+            const addPrompts = parsed.options.yes
+                ? createYesPromptClient(prompts, { selectAllAgents: true })
+                : prompts;
+            if (parsed.options.all) {
+                const addSource = parsed.options.source;
+                if (addSource === undefined) {
+                    throw new Error("Command add --all requires a source");
+                }
+                return applyAllBundles({
+                    cwd,
+                    homeDir: options.homeDir ?? node_os_1.default.homedir(),
+                    prompts: addPrompts,
+                    registryFile: stateLayout.registryFile,
+                    libraryDir: stateLayout.libraryDir,
+                    source: addSource,
+                    protocol: parsed.options.protocol,
+                    agents: parsed.options.agents,
+                    dryRun: parsed.options.dryRun,
+                    ref: parsed.options.ref,
+                    global: parsed.options.global,
+                    disableModelInvocation: parsed.options.disableModelInvocation,
+                });
+            }
+            const addBundle = parsed.options.bundle;
+            if (addBundle === undefined) {
+                throw new Error("Command add requires a bundle name");
+            }
             if (parsed.options.global) {
                 return applyBundleGlobal({
                     homeDir: options.homeDir ?? node_os_1.default.homedir(),
-                    prompts,
+                    prompts: addPrompts,
                     registryFile: stateLayout.registryFile,
                     libraryDir: stateLayout.libraryDir,
-                    bundle: parsed.options.bundle,
+                    bundle: addBundle,
                     source: parsed.options.source,
                     protocol: parsed.options.protocol,
                     agents: parsed.options.agents,
@@ -65,10 +92,10 @@ async function run(argv, options = {}) {
             }
             return applyBundle({
                 cwd,
-                prompts,
+                prompts: addPrompts,
                 registryFile: stateLayout.registryFile,
                 libraryDir: stateLayout.libraryDir,
-                bundle: parsed.options.bundle,
+                bundle: addBundle,
                 source: parsed.options.source,
                 protocol: parsed.options.protocol,
                 agents: parsed.options.agents,
@@ -79,6 +106,7 @@ async function run(argv, options = {}) {
                 inferredBundleFromSource: parsed.options.inferredBundleFromSource,
                 disableModelInvocation: parsed.options.disableModelInvocation,
             });
+        }
         case "list":
             return renderBundleList({
                 libraryDir: stateLayout.libraryDir,
@@ -108,7 +136,7 @@ async function run(argv, options = {}) {
         case "update":
             return updateBundles({
                 cwd,
-                prompts,
+                prompts: parsed.options.yes ? createYesPromptClient(prompts) : prompts,
                 registryFile: stateLayout.registryFile,
                 libraryDir: stateLayout.libraryDir,
                 bundle: parsed.options.bundle,
@@ -129,22 +157,48 @@ async function run(argv, options = {}) {
             if (parsed.options.global) {
                 return resetGlobal({
                     homeDir: options.homeDir ?? node_os_1.default.homedir(),
-                    prompts,
+                    prompts: parsed.options.yes
+                        ? createYesPromptClient(prompts)
+                        : prompts,
                     registryFile: stateLayout.registryFile,
                     dryRun: parsed.options.dryRun,
                 });
             }
             return resetWorktree({
                 cwd,
-                prompts,
+                prompts: parsed.options.yes ? createYesPromptClient(prompts) : prompts,
                 registryFile: stateLayout.registryFile,
                 dryRun: parsed.options.dryRun,
             });
         case "remove":
+            if (parsed.options.all) {
+                const removePrompts = parsed.options.yes
+                    ? createYesPromptClient(prompts)
+                    : prompts;
+                return parsed.options.global
+                    ? removeAllGlobalBundles({
+                        homeDir: options.homeDir ?? node_os_1.default.homedir(),
+                        prompts: removePrompts,
+                        registryFile: stateLayout.registryFile,
+                        libraryDir: stateLayout.libraryDir,
+                        source: parsed.options.source,
+                        dryRun: parsed.options.dryRun,
+                    })
+                    : removeAllWorktreeBundles({
+                        cwd,
+                        prompts: removePrompts,
+                        registryFile: stateLayout.registryFile,
+                        libraryDir: stateLayout.libraryDir,
+                        source: parsed.options.source,
+                        dryRun: parsed.options.dryRun,
+                    });
+            }
             if (parsed.options.global) {
                 return removeGlobalBundle({
                     homeDir: options.homeDir ?? node_os_1.default.homedir(),
-                    prompts,
+                    prompts: parsed.options.yes
+                        ? createYesPromptClient(prompts)
+                        : prompts,
                     registryFile: stateLayout.registryFile,
                     libraryDir: stateLayout.libraryDir,
                     bundle: parsed.options.bundle,
@@ -157,7 +211,7 @@ async function run(argv, options = {}) {
             }
             return removeBundle({
                 cwd,
-                prompts,
+                prompts: parsed.options.yes ? createYesPromptClient(prompts) : prompts,
                 registryFile: stateLayout.registryFile,
                 libraryDir: stateLayout.libraryDir,
                 bundle: parsed.options.bundle,
@@ -171,7 +225,9 @@ async function run(argv, options = {}) {
             if (parsed.options.global) {
                 return applyGlobal({
                     homeDir: options.homeDir ?? node_os_1.default.homedir(),
-                    prompts,
+                    prompts: parsed.options.yes
+                        ? createYesPromptClient(prompts)
+                        : prompts,
                     registryFile: stateLayout.registryFile,
                     libraryDir: stateLayout.libraryDir,
                     dryRun: parsed.options.dryRun,
@@ -179,7 +235,7 @@ async function run(argv, options = {}) {
             }
             return applyWorktree({
                 cwd,
-                prompts,
+                prompts: parsed.options.yes ? createYesPromptClient(prompts) : prompts,
                 registryFile: stateLayout.registryFile,
                 libraryDir: stateLayout.libraryDir,
                 dryRun: parsed.options.dryRun,
@@ -188,6 +244,451 @@ async function run(argv, options = {}) {
             return assertUnreachable(parsed);
     }
 }
+function createYesPromptClient(prompts, options = {}) {
+    return {
+        ...prompts,
+        ...(options.selectAllAgents
+            ? {
+                selectAgents: async (availableAgents) => availableAgents,
+            }
+            : {}),
+        resolveFileConflict: async () => ({ action: "overwrite" }),
+        confirmManagedFileRemoval: async () => true,
+    };
+}
+async function applyAllBundles(options) {
+    if (options.dryRun) {
+        const { cached } = (0, bundle_fetch_1.readCachedSourceRevision)({
+            source: options.source,
+            libraryDir: options.libraryDir,
+            protocol: options.protocol,
+        });
+        if (!cached) {
+            return [
+                pc.dim(`(would clone ${options.source})`),
+                `${pc.yellow("DRY RUN:")} Would apply all bundles from ${options.source}`,
+            ].join("\n");
+        }
+        return renderAllApplyDryRun({
+            libraryDir: options.libraryDir,
+            source: options.source,
+            agents: options.agents,
+            global: options.global,
+        });
+    }
+    const refreshedSources = new Set();
+    const refreshedSourceUpdates = new Map();
+    const cloneLines = refreshBundleSourceForApply({
+        source: options.source,
+        libraryDir: options.libraryDir,
+        protocol: options.protocol,
+        ref: options.ref,
+    }, refreshedSources, refreshedSourceUpdates);
+    const bundles = listAllApplyBundles({
+        libraryDir: options.libraryDir,
+        source: options.source,
+        agents: options.agents,
+        global: options.global,
+    });
+    if (bundles.length === 0) {
+        const agentLabel = options.agents.length > 0
+            ? ` supporting ${options.agents.join(", ")}`
+            : "";
+        throw new Error(`No bundles found for ${options.source}${agentLabel}`);
+    }
+    const outputLines = [];
+    for (const bundle of bundles) {
+        outputLines.push(options.global
+            ? await applyBundleGlobal({
+                homeDir: options.homeDir,
+                prompts: options.prompts,
+                registryFile: options.registryFile,
+                libraryDir: options.libraryDir,
+                bundle: bundle.bundle,
+                source: bundle.source,
+                protocol: options.protocol,
+                agents: options.agents,
+                includeItems: [],
+                selectItems: false,
+                dryRun: options.dryRun,
+                ref: options.ref,
+                refreshedSources,
+                refreshedSourceUpdates,
+                disableModelInvocation: options.disableModelInvocation,
+            })
+            : await applyBundle({
+                cwd: options.cwd,
+                prompts: options.prompts,
+                registryFile: options.registryFile,
+                libraryDir: options.libraryDir,
+                bundle: bundle.bundle,
+                source: bundle.source,
+                protocol: options.protocol,
+                agents: options.agents,
+                includeItems: [],
+                selectItems: false,
+                dryRun: options.dryRun,
+                ref: options.ref,
+                refreshedSources,
+                refreshedSourceUpdates,
+                disableModelInvocation: options.disableModelInvocation,
+            }));
+    }
+    return [...cloneLines, ...outputLines].filter(Boolean).join("\n");
+}
+function renderAllApplyDryRun(options) {
+    const bundles = listAllApplyBundles(options);
+    if (bundles.length === 0) {
+        const agentLabel = options.agents.length > 0
+            ? ` supporting ${options.agents.join(", ")}`
+            : "";
+        throw new Error(`No bundles found for ${options.source}${agentLabel}`);
+    }
+    return bundles
+        .map((bundle) => {
+        const toolLabel = formatAllApplyDryRunToolLabel({
+            bundle,
+            agents: options.agents,
+            global: options.global,
+        });
+        const message = options.global
+            ? formatApplyGlobalBundleMessage({
+                bundle: bundle.bundle,
+                toolLabel,
+            })
+            : formatApplyBundleMessage({
+                bundle: bundle.bundle,
+                toolLabel,
+            });
+        return `${pc.yellow("DRY RUN:")} Would ${message}`;
+    })
+        .join("\n");
+}
+function formatAllApplyDryRunToolLabel(options) {
+    if (options.agents.length > 0) {
+        return options.agents.join(", ");
+    }
+    const bundleTools = Object.keys(options.bundle.manifest.tools);
+    const toolNames = options.global
+        ? bundleTools.filter((toolName) => (0, tool_mapping_1.globalCapableToolNames)().includes(toolName))
+        : bundleTools;
+    return toolNames.join(", ");
+}
+function listAllApplyBundles(options) {
+    const globalTools = (0, tool_mapping_1.globalCapableToolNames)();
+    if (options.global &&
+        options.agents.some((toolName) => !globalTools.includes(toolName))) {
+        throw new Error(`Global mode only supports: ${globalTools.join(", ")}. Unsupported: ${options.agents.filter((toolName) => !globalTools.includes(toolName)).join(", ")}`);
+    }
+    return (0, bundle_discovery_1.listCachedBundles)({ libraryDir: options.libraryDir })
+        .filter((bundle) => isBundleSelectionCandidate({
+        bundle,
+        source: options.source,
+        requestedTools: options.agents,
+    }))
+        .filter((bundle) => !options.global ||
+        Object.keys(bundle.manifest.tools).some((toolName) => globalTools.includes(toolName)))
+        .sort((left, right) => compareBundleSelections({ bundle: left.bundle, source: left.source }, { bundle: right.bundle, source: right.source }));
+}
+async function removeAllWorktreeBundles(options) {
+    const gitContext = requireGitContext(options.cwd, "remove");
+    let registry = readRegistryWithGuidance(options.registryFile);
+    const repoState = registry.repos[gitContext.repoFingerprint];
+    const selections = listActiveRemoveBundleSelections({
+        repoState,
+        worktreeState: registry.worktrees[gitContext.worktreeId],
+        source: options.source,
+    });
+    if (selections.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 (options.dryRun) {
+        return selections
+            .map((selection) => renderWorktreeRemoveDryRun({
+            selection,
+            worktreeState: registry.worktrees[gitContext.worktreeId],
+        }))
+            .join("\n");
+    }
+    const worktreeState = registry.worktrees[gitContext.worktreeId];
+    const selectionKeys = new Set(selections.map(encodeBundleIdentity));
+    const materializedTargets = Object.entries(worktreeState?.materialized_state.bundles ?? {}).filter(([bundle, bundleState]) => selectionKeys.has(encodeBundleIdentity({
+        bundle,
+        ...(bundleState.source !== undefined
+            ? { source: bundleState.source }
+            : {}),
+    })));
+    const shadowedFilePaths = Object.entries(worktreeState?.shadowed_files ?? {})
+        .filter(([, shadowedFile]) => selections.some((selection) => selection.bundle === shadowedFile.bundle))
+        .map(([filePath]) => filePath);
+    const removedBundlePaths = mergeManagedRemovalPaths(materializedTargets.map(([, bundleState]) => flattenBundleState(bundleState)));
+    const removedRootInstructionPaths = new Set(removedBundlePaths.files.filter((filePath) => (0, root_instruction_render_1.isRootInstructionPath)(filePath)));
+    const remainingBundles = {
+        ...(worktreeState?.materialized_state.bundles ?? {}),
+    };
+    for (const [bundle] of materializedTargets) {
+        delete remainingBundles[bundle];
+    }
+    const remainingDesiredState = repoState?.desired_state.filter((entry) => !selectionKeys.has(encodeBundleIdentity(entry))) ?? [];
+    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),
+    });
+    if (removedBundlePaths.files.length > 0 || shadowedFilePaths.length > 0) {
+        const removeAllowed = await confirmManagedFileRemovals(gitContext.worktreeRoot, removedBundlePaths, options.prompts, "remove");
+        if (!removeAllowed) {
+            throw new Error("Removal aborted because a modified managed file was kept");
+        }
+    }
+    let currentShadowedFiles = { ...(worktreeState?.shadowed_files ?? {}) };
+    currentShadowedFiles = retireTrackedRootInstructionShadows({
+        repoRoot: gitContext.worktreeRoot,
+        shadowedFiles: currentShadowedFiles,
+        filePaths: shadowedFilePaths,
+    });
+    if (Object.keys(remainingBundles).length > 0) {
+        assertTrackedRootInstructionShadowSafetyForPaths({
+            repoRoot: gitContext.worktreeRoot,
+            operation: "refresh",
+            filePaths: Array.from(rewrittenRootInstructionPaths),
+        });
+    }
+    removeManagedPaths(gitContext.worktreeRoot, removedBundlePaths);
+    const rootInstructionBaseContents = worktreeState?.materialized_state.root_instruction_base_contents;
+    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 (repoState) {
+        registry = (0, registry_1.upsertRepoState)(registry, gitContext.repoFingerprint, {
+            ...repoState,
+            repo_root: gitContext.repoRoot,
+            desired_state: remainingDesiredState,
+        });
+    }
+    (0, registry_1.writeRegistryFile)(options.registryFile, registry);
+    return selections
+        .map((selection) => `Removed ${selection.bundle}`)
+        .join("\n");
+}
+function renderWorktreeRemoveDryRun(options) {
+    const bundleMaterializedState = findMaterializedBundleState({
+        worktreeState: options.worktreeState,
+        bundle: options.selection.bundle,
+        source: options.selection.source,
+    });
+    const shadowedFilesForBundle = Object.entries(options.worktreeState?.shadowed_files ?? {}).filter(([, shadowedFile]) => shadowedFile.bundle === options.selection.bundle);
+    return renderRemoveDryRun({
+        bundle: options.selection.bundle,
+        prefix: "",
+        materializedState: bundleMaterializedState,
+        extraFiles: shadowedFilesForBundle.map(([filePath]) => filePath),
+        desiredStateLabel: "desired state",
+    });
+}
+function mergeManagedRemovalPaths(states) {
+    return {
+        files: Array.from(new Set(states.flatMap((state) => state.files))),
+        file_fingerprints: Object.assign({}, ...states.map((state) => state.file_fingerprints ?? {})),
+        directories: Array.from(new Set(states.flatMap((state) => state.directories ?? []))),
+    };
+}
+async function removeAllGlobalBundles(options) {
+    let registry = readRegistryWithGuidance(options.registryFile);
+    const selections = listActiveGlobalRemoveBundleSelections({
+        globalState: registry.global,
+        source: options.source,
+    });
+    if (selections.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 (options.dryRun) {
+        return selections
+            .map((selection) => renderGlobalRemoveDryRun({
+            selection,
+            globalState: registry.global,
+        }))
+            .join("\n");
+    }
+    const globalState = registry.global;
+    const selectionKeys = new Set(selections.map(encodeBundleIdentity));
+    const materializedTargets = Object.entries(globalState?.materialized_state.bundles ?? {}).filter(([bundle, bundleState]) => selectionKeys.has(encodeBundleIdentity({
+        bundle,
+        ...(bundleState.source !== undefined
+            ? { source: bundleState.source }
+            : {}),
+    })));
+    const removedBundlePaths = mergeManagedRemovalPaths(materializedTargets.map(([, bundleState]) => flattenBundleState(bundleState)));
+    const removedRootInstructionPaths = new Set(removedBundlePaths.files.filter((filePath) => (0, root_instruction_render_1.isRootInstructionPath)(filePath)));
+    const remainingBundles = {
+        ...(globalState?.materialized_state.bundles ?? {}),
+    };
+    for (const [bundle] of materializedTargets) {
+        delete remainingBundles[bundle];
+    }
+    const remainingDesiredState = globalState?.desired_state.filter((entry) => !selectionKeys.has(encodeBundleIdentity(entry))) ?? [];
+    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),
+    });
+    if (removedBundlePaths.files.length > 0) {
+        const removeAllowed = await confirmManagedFileRemovals(options.homeDir, removedBundlePaths, options.prompts, "remove");
+        if (!removeAllowed) {
+            throw new Error("Removal aborted because a modified managed file was kept");
+        }
+    }
+    removeManagedPaths(options.homeDir, removedBundlePaths);
+    const rootInstructionBaseContents = globalState?.materialized_state.root_instruction_base_contents;
+    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: options.homeDir,
+        baseContents: rootInstructionBaseContents,
+        targetPaths: restoredRootInstructionPaths,
+    });
+    const nextRootInstructionBaseContents = rootInstructionBaseContents
+        ? Object.fromEntries(Object.entries(rootInstructionBaseContents).filter(([filePath]) => !restoredRootInstructionPaths.has(filePath)))
+        : undefined;
+    if (Object.keys(remainingBundles).length > 0 ||
+        remainingDesiredState.length > 0) {
+        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: tool_mapping_1.GLOBAL_TOOL_MATERIALIZATION_LAYOUT.remapRepoRelPath,
+            });
+            const refreshedBundles = (0, root_instruction_state_1.refreshManagedFileFingerprintsForPaths)(options.homeDir, remainingBundles, syncedRootInstructionPaths);
+            registry = (0, registry_1.upsertGlobalState)(registry, {
+                desired_state: remainingDesiredState,
+                materialized_state: {
+                    bundles: refreshedBundles,
+                    ...(nextRootInstructionBaseContents !== undefined &&
+                        Object.keys(nextRootInstructionBaseContents).length > 0
+                        ? {
+                            root_instruction_base_contents: nextRootInstructionBaseContents,
+                        }
+                        : {}),
+                },
+            });
+        }
+        else {
+            registry = (0, registry_1.upsertGlobalState)(registry, {
+                desired_state: remainingDesiredState,
+                materialized_state: { bundles: {} },
+            });
+        }
+    }
+    else {
+        registry = { ...registry, global: undefined };
+    }
+    (0, registry_1.writeRegistryFile)(options.registryFile, registry);
+    return selections
+        .map((selection) => `Removed global ${selection.bundle}`)
+        .join("\n");
+}
+function renderGlobalRemoveDryRun(options) {
+    const bundleMaterializedState = findGlobalMaterializedBundleState({
+        globalState: options.globalState,
+        bundle: options.selection.bundle,
+        source: options.selection.source,
+    });
+    return renderRemoveDryRun({
+        bundle: options.selection.bundle,
+        prefix: "global ",
+        materializedState: bundleMaterializedState,
+        extraFiles: [],
+        desiredStateLabel: "global desired state",
+    });
+}
+function renderRemoveDryRun(options) {
+    if (options.materializedState || options.extraFiles.length > 0) {
+        const materializedFiles = options.materializedState
+            ? flattenBundleState(options.materializedState).files
+            : [];
+        const files = [...materializedFiles, ...options.extraFiles];
+        const lines = [
+            `${pc.yellow("DRY RUN:")} Would remove ${options.prefix}${options.bundle} (${files.length} file(s))`,
+        ];
+        for (const file of files) {
+            lines.push(`  ${file}`);
+        }
+        return lines.join("\n");
+    }
+    return `${pc.yellow("DRY RUN:")} Would remove ${options.bundle} from ${options.desiredStateLabel}`;
+}
 function shadowWorktree(options) {
     const gitContext = requireGitContext(options.cwd, "shadow");
     let registry = readRegistryWithGuidance(options.registryFile);
@@ -1144,6 +1645,7 @@ async function applyBundle(options) {
         existingDesiredState: registryBeforePrepare.repos[gitContext.repoFingerprint]?.desired_state ??
             [],
         refreshedSources: options.refreshedSources,
+        refreshedSourceUpdates: options.refreshedSourceUpdates,
     });
     if (options.dryRun) {
         return [
@@ -1339,6 +1841,7 @@ async function applyBundle(options) {
             items: preparedBundle.replacesItemSelection
                 ? preparedBundle.selectedItems
                 : undefined,
+            updated: preparedBundle.sourceUpdated,
         })),
     ].join("\n");
 }
@@ -1347,6 +1850,7 @@ function formatAppliedBundleMessage(options) {
         bundle: options.bundle,
         toolLabel: options.toolLabel,
         items: options.items,
+        updated: options.updated,
         action: "Applied",
     });
 }
@@ -1354,7 +1858,8 @@ 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}`;
+    const updatedLabel = options.updated ? " (Updated)" : "";
+    return `${options.action ?? "apply"} ${options.bundle} for ${options.toolLabel}${itemLabel}${updatedLabel}`;
 }
 function shouldApplySelectedItemsAcrossSourceBundles(options) {
     return (options.selectItems &&
@@ -1363,12 +1868,13 @@ function shouldApplySelectedItemsAcrossSourceBundles(options) {
 }
 async function applySelectedItemsAcrossSourceBundles(options) {
     const refreshedSources = new Set();
+    const refreshedSourceUpdates = new Map();
     const cloneLines = refreshBundleSourceForApply({
         source: options.source,
         libraryDir: options.libraryDir,
         protocol: options.protocol,
         ref: options.ref,
-    }, refreshedSources);
+    }, refreshedSources, refreshedSourceUpdates);
     const selection = await selectSourceBundleItemApplyTargets({
         libraryDir: options.libraryDir,
         source: options.source,
@@ -1376,6 +1882,7 @@ async function applySelectedItemsAcrossSourceBundles(options) {
         requestedItems: options.includeItems,
         prompts: options.prompts,
         existingDesiredState: options.existingDesiredState,
+        sourceUpdate: getRefreshedSourceUpdate(refreshedSourceUpdates, options.source),
     });
     const outputLines = [];
     for (const target of selection.removeTargets) {
@@ -1407,6 +1914,7 @@ async function applySelectedItemsAcrossSourceBundles(options) {
             dryRun: options.dryRun,
             ref: options.ref,
             refreshedSources,
+            refreshedSourceUpdates,
             disableModelInvocation: options.disableModelInvocation,
         }));
     }
@@ -1418,6 +1926,7 @@ async function selectSourceBundleItemApplyTargets(options) {
         libraryDir: options.libraryDir,
         source: options.source,
         tools: selectedTools,
+        sourceUpdate: options.sourceUpdate,
     });
     if (choices.length === 0) {
         throw new Error(`No selectable bundle items found for ${options.source}`);
@@ -1494,6 +2003,13 @@ function listSourceBundleItemApplyChoices(options) {
                 item,
             }),
             label: `${bundle.bundle}: ${item}`,
+            ...(getUpdatedItemsForBundle({
+                sourceUpdate: options.sourceUpdate,
+                bundle: bundle.bundle,
+                tools: bundleTools,
+            }).has(item)
+                ? { hint: "Updated" }
+                : {}),
             source: bundle.source,
             bundle: bundle.bundle,
             item,
@@ -1616,7 +2132,8 @@ function encodeBundleItemApplyChoice(choice) {
 }
 async function prepareApplyBundle(options) {
     const refreshedSources = options.refreshedSources ?? new Set();
-    const cloneLines = refreshBundleSourceForApply(options, refreshedSources);
+    const refreshedSourceUpdates = options.refreshedSourceUpdates ?? new Map();
+    const cloneLines = refreshBundleSourceForApply(options, refreshedSources, refreshedSourceUpdates);
     let cachedBundle;
     let bundleSource;
     let selectedToolsBeforeBundle;
@@ -1662,7 +2179,7 @@ async function prepareApplyBundle(options) {
             libraryDir: options.libraryDir,
             protocol: options.protocol,
             ref: options.ref,
-        }, refreshedSources));
+        }, refreshedSources, refreshedSourceUpdates));
         cachedBundle = findCachedBundleWithGuidance({
             libraryDir: options.libraryDir,
             bundle: cachedBundle.bundle,
@@ -1691,6 +2208,14 @@ async function prepareApplyBundle(options) {
         selectedRequestedTools.length < availableTools.length;
     const nextToolNames = selectedRequestedTools;
     const existingDesiredEntry = options.existingDesiredState.find((entry) => entry.bundle === cachedBundle.bundle);
+    const sourceUpdate = bundleSource
+        ? getRefreshedSourceUpdate(refreshedSourceUpdates, bundleSource)
+        : createEmptyRefreshedSourceUpdate();
+    const updatedItems = getUpdatedItemsForBundle({
+        sourceUpdate,
+        bundle: cachedBundle.bundle,
+        tools: nextToolNames,
+    });
     const selectedItems = await resolveSelectedBundleItems({
         bundleDir: node_path_1.default.dirname(cachedBundle.manifestFile),
         manifest: cachedBundle.manifest,
@@ -1700,12 +2225,18 @@ async function prepareApplyBundle(options) {
         replaceItems: options.replaceItems,
         prompts: options.prompts,
         existingItems: existingDesiredEntry?.items,
+        updatedItems,
+    });
+    const sourceUpdated = isSelectedBundleUpdated({
+        updatedItems,
+        selectedItems,
     });
     return {
         cloneLines,
         cachedBundle,
         bundleSource,
         sourceRevision,
+        sourceUpdated,
         ...(hasToolSelection ? { selectedTools: selectedRequestedTools } : {}),
         ...(selectedItems !== undefined ? { selectedItems } : {}),
         nextToolNames,
@@ -1760,6 +2291,13 @@ async function resolveSelectedBundleItems(options) {
     if (!options.selectItems) {
         return mergedItems;
     }
+    if (options.updatedItems && options.updatedItems.size > 0) {
+        return options.prompts.selectBundleItemChoices(availableItems.map((item) => ({
+            value: item,
+            label: item,
+            ...(options.updatedItems?.has(item) ? { hint: "Updated" } : {}),
+        })), mergedItems ?? [], "install");
+    }
     return options.prompts.selectBundleItems(availableItems, mergedItems ?? []);
 }
 function shouldPromptForInferredBundle(options) {
@@ -1772,8 +2310,11 @@ function shouldPromptForInferredBundle(options) {
     }
     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)) {
+function refreshBundleSourceForApply(options, refreshedSources, refreshedSourceUpdates) {
+    if (!options.source) {
+        return [];
+    }
+    if (refreshedSources.has(options.source)) {
         return [];
     }
     refreshedSources.add(options.source);
@@ -1782,26 +2323,219 @@ function refreshBundleSourceForApply(options, refreshedSources) {
         libraryDir: options.libraryDir,
         protocol: options.protocol,
     });
+    const initialItemFingerprints = initialRevision.cached
+        ? collectSourceItemFingerprints({
+            libraryDir: options.libraryDir,
+            source: options.source,
+        })
+        : new Map();
     if (initialRevision.cached && initialRevision.remoteUrl === undefined) {
+        refreshedSourceUpdates.set(options.source, createEmptyRefreshedSourceUpdate());
         return [];
     }
+    let updated = false;
     if (!options.ref && initialRevision.cached) {
         (0, bundle_fetch_1.clearAndRefetchCachedRemoteSource)({
             source: options.source,
             libraryDir: options.libraryDir,
             protocol: options.protocol,
         });
+        const refreshedRevision = (0, bundle_fetch_1.readCachedSourceRevision)({
+            source: options.source,
+            libraryDir: options.libraryDir,
+            protocol: options.protocol,
+        });
+        updated =
+            initialRevision.currentCommit !== undefined &&
+                refreshedRevision.currentCommit !== undefined &&
+                initialRevision.currentCommit !== refreshedRevision.currentCommit;
     }
     else {
-        (0, bundle_fetch_1.updateCachedRemoteSource)({
+        const refreshed = (0, bundle_fetch_1.updateCachedRemoteSource)({
             source: options.source,
             libraryDir: options.libraryDir,
             protocol: options.protocol,
             ref: options.ref,
         });
-    }
+        updated =
+            initialRevision.cached &&
+                refreshed.previousCommit !== undefined &&
+                refreshed.currentCommit !== undefined &&
+                refreshed.previousCommit !== refreshed.currentCommit;
+    }
+    refreshedSourceUpdates.set(options.source, {
+        updated,
+        before: initialItemFingerprints,
+        after: updated
+            ? collectSourceItemFingerprints({
+                libraryDir: options.libraryDir,
+                source: options.source,
+            })
+            : new Map(),
+    });
     return initialRevision.cached ? [] : [pc.dim(`Cloned ${options.source}`)];
 }
+function collectSourceItemFingerprints(options) {
+    return new Map((0, bundle_discovery_1.listCachedBundles)({ libraryDir: options.libraryDir })
+        .filter((bundle) => bundle.source === options.source)
+        .map((bundle) => [
+        bundle.bundle,
+        collectBundleToolItemFingerprints({
+            bundleDir: node_path_1.default.dirname(bundle.manifestFile),
+            manifest: bundle.manifest,
+        }),
+    ]));
+}
+function collectBundleToolItemFingerprints(options) {
+    return new Map(Object.keys(options.manifest.tools).map((toolName) => [
+        toolName,
+        collectToolItemFingerprints({
+            bundleDir: options.bundleDir,
+            manifest: options.manifest,
+            toolName,
+        }),
+    ]));
+}
+function collectToolItemFingerprints(options) {
+    return new Map((0, bundle_items_1.listSelectableBundleItems)({
+        bundleDir: options.bundleDir,
+        manifest: options.manifest,
+        tools: [options.toolName],
+    }).map((item) => [
+        item,
+        fingerprintBundleItem({
+            bundleDir: options.bundleDir,
+            manifest: options.manifest,
+            tools: [options.toolName],
+            item,
+        }),
+    ]));
+}
+function fingerprintBundleItem(options) {
+    const itemPaths = listBundleItemSourcePaths(options);
+    const content = itemPaths
+        .map((itemPath) => {
+        const relativePath = node_path_1.default.relative(options.bundleDir, itemPath);
+        return `${relativePath}\0${fingerprintPath(itemPath)}`;
+    })
+        .join("\0");
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+function listBundleItemSourcePaths(options) {
+    const sourcePaths = [];
+    for (const toolName of options.tools) {
+        const targets = options.manifest.tools[toolName];
+        if (!targets) {
+            continue;
+        }
+        if (options.item === "root-instruction") {
+            const rootInstructionPath = targets.root_instruction?.path;
+            if (rootInstructionPath) {
+                sourcePaths.push(node_path_1.default.join(options.bundleDir, rootInstructionPath));
+            }
+            continue;
+        }
+        const [targetName, itemName] = options.item.split("/");
+        const target = targets[targetName];
+        if (!target || !("path" in target) || !itemName) {
+            continue;
+        }
+        sourcePaths.push(...listDirectoryItemSourcePaths({
+            sourceDir: node_path_1.default.join(options.bundleDir, target.path),
+            targetName,
+            itemName,
+        }));
+    }
+    return Array.from(new Set(sourcePaths)).sort((left, right) => left.localeCompare(right));
+}
+function listDirectoryItemSourcePaths(options) {
+    if (!node_fs_1.default.existsSync(options.sourceDir)) {
+        return [];
+    }
+    return node_fs_1.default
+        .readdirSync(options.sourceDir, { withFileTypes: true })
+        .filter((entry) => isMatchingBundleItemEntry(entry, options))
+        .map((entry) => node_path_1.default.join(options.sourceDir, entry.name));
+}
+function isMatchingBundleItemEntry(entry, options) {
+    if (options.targetName === "skills" && !entry.isDirectory()) {
+        return false;
+    }
+    if (options.targetName !== "skills" && !entry.isFile()) {
+        return false;
+    }
+    return stripKnownBundleItemExtension(entry.name) === options.itemName;
+}
+function stripKnownBundleItemExtension(value) {
+    if (value.endsWith(".agent.md")) {
+        return value.slice(0, -".agent.md".length);
+    }
+    return value.replace(/\.(md|toml|yaml|yml|json)$/i, "");
+}
+function fingerprintPath(filePath) {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return "";
+    }
+    const stat = node_fs_1.default.lstatSync(filePath);
+    if (stat.isDirectory()) {
+        return fingerprintDirectory(filePath);
+    }
+    if (stat.isFile()) {
+        return (0, node_crypto_1.createHash)("sha256").update(node_fs_1.default.readFileSync(filePath)).digest("hex");
+    }
+    return "";
+}
+function fingerprintDirectory(directoryPath) {
+    const entries = node_fs_1.default
+        .readdirSync(directoryPath, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() || entry.isFile())
+        .map((entry) => {
+        const entryPath = node_path_1.default.join(directoryPath, entry.name);
+        return `${entry.name}\0${fingerprintPath(entryPath)}`;
+    })
+        .sort((left, right) => left.localeCompare(right))
+        .join("\0");
+    return (0, node_crypto_1.createHash)("sha256").update(entries).digest("hex");
+}
+function getRefreshedSourceUpdate(updates, source) {
+    return updates.get(source) ?? createEmptyRefreshedSourceUpdate();
+}
+function createEmptyRefreshedSourceUpdate() {
+    return { updated: false, before: new Map(), after: new Map() };
+}
+function getUpdatedItemsForBundle(options) {
+    const updatedItems = new Set();
+    if (!options.sourceUpdate?.updated) {
+        return updatedItems;
+    }
+    for (const toolName of options.tools) {
+        const afterItems = options.sourceUpdate.after
+            .get(options.bundle)
+            ?.get(toolName);
+        if (!afterItems) {
+            continue;
+        }
+        for (const [item, afterFingerprint] of afterItems) {
+            const beforeFingerprint = options.sourceUpdate.before
+                .get(options.bundle)
+                ?.get(toolName)
+                ?.get(item);
+            if (beforeFingerprint !== afterFingerprint) {
+                updatedItems.add(item);
+            }
+        }
+    }
+    return updatedItems;
+}
+function isSelectedBundleUpdated(options) {
+    if (!options.updatedItems || options.updatedItems.size === 0) {
+        return false;
+    }
+    if (!options.selectedItems) {
+        return true;
+    }
+    return options.selectedItems.some((item) => options.updatedItems?.has(item));
+}
 function assertBundleSupportsRequestedTools(requestedTools, availableTools) {
     const unsupportedTools = requestedTools.filter((toolName) => !availableTools.includes(toolName));
     if (unsupportedTools.length === 0) {
@@ -3389,6 +4123,7 @@ async function applyBundleGlobal(options) {
         preBundlePrompts: options.prompts,
         inferredBundleFromSource: options.inferredBundleFromSource,
         refreshedSources: options.refreshedSources,
+        refreshedSourceUpdates: options.refreshedSourceUpdates,
     });
     const availableGlobalTools = preparedBundle.nextToolNames.filter((t) => supportedTools.includes(t));
     if (availableGlobalTools.length === 0) {
@@ -3533,6 +4268,7 @@ async function applyBundleGlobal(options) {
             items: preparedBundle.replacesItemSelection
                 ? preparedBundle.selectedItems
                 : undefined,
+            updated: preparedBundle.sourceUpdated,
         })),
     ];
     if (skippedTools.length > 0) {
@@ -3545,6 +4281,7 @@ function formatAppliedGlobalBundleMessage(options) {
         bundle: options.bundle,
         toolLabel: options.toolLabel,
         items: options.items,
+        updated: options.updated,
         action: "Applied",
     });
 }
@@ -3552,16 +4289,18 @@ 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}`;
+    const updatedLabel = options.updated ? " (Updated)" : "";
+    return `${options.action ?? "apply"} ${options.bundle} globally for ${options.toolLabel}${itemLabel}${updatedLabel}`;
 }
 async function applySelectedItemsAcrossGlobalSourceBundles(options) {
     const refreshedSources = new Set();
+    const refreshedSourceUpdates = new Map();
     const cloneLines = refreshBundleSourceForApply({
         source: options.source,
         libraryDir: options.libraryDir,
         protocol: options.protocol,
         ref: options.ref,
-    }, refreshedSources);
+    }, refreshedSources, refreshedSourceUpdates);
     const selection = await selectSourceBundleItemApplyTargets({
         libraryDir: options.libraryDir,
         source: options.source,
@@ -3570,6 +4309,7 @@ async function applySelectedItemsAcrossGlobalSourceBundles(options) {
         prompts: options.prompts,
         existingDesiredState: options.existingDesiredState,
         global: true,
+        sourceUpdate: getRefreshedSourceUpdate(refreshedSourceUpdates, options.source),
     });
     const outputLines = [];
     for (const target of selection.removeTargets) {
@@ -3601,6 +4341,7 @@ async function applySelectedItemsAcrossGlobalSourceBundles(options) {
             dryRun: options.dryRun,
             ref: options.ref,
             refreshedSources,
+            refreshedSourceUpdates,
             disableModelInvocation: options.disableModelInvocation,
         }));
     }