@iseoane/agent-depot 0.6.6 → 0.6.8

package/CHANGELOG.md

@@ -7,6 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.8] - 2026-11-04
+
+### Fixed
+
+- Versioned Claude Packages now follow the Host's literal plugin cache version,
+  with the plugin manifest taking precedence over marketplace metadata. A newer
+  Source commit at the same version is explained instead of offered as an update
+  Claude cannot apply. Successful literal-version changes are recognized even
+  when the commit is unchanged or the version strings normalize identically.
+- Package comparisons and results in the CLI and TUI now show the observed Host
+  version and commit together. Remembered evidence is labelled as recorded;
+  Pi updates between different commits at the same manifest version remain
+  available when verified Source ancestry proves progress.
+
+## [0.6.7] - 2026-11-04
+
+### Fixed
+
+- Claude Skill installations on Windows now use directory junctions instead of
+  privilege-sensitive directory symlinks. Installation, additional Host exposure
+  and overwrite share the same creation policy; POSIX directory symlinks remain
+  unchanged. Rollback removes the managed link without following its target.
+- User-global Skill removal can now explicitly forget a missing installation
+  record, without removing files, so the Skill can be selected again in Catalog.
+  Recovery refuses unsafe paths, remaining Claude locations, overlapping records
+  and changes to the confirmed installation state. CLI and TUI previews and
+  completion messages distinguish record-only recovery from file removal.
+
 ## [0.6.6] - 2026-10-29
 
 ### Fixed

package/README.md

@@ -184,21 +184,28 @@ segment when that is unique; unknown or ambiguous selections fail before anythin
 changes. It previews every deletion (with adopted/modified warnings), requires
 `--yes`, rechecks the targets, then deletes the files and their installation
 records. It is user-global only: project installations and manifests are never
-read or changed, and the Git cache is retained.
+read or changed, and the Git cache is retained. If a managed Skill's recorded
+installation is verified absent, the preview instead offers an explicit
+`forget missing installation record` action. Confirming removes only that stale
+record; it never removes files. Existing files, including any Claude location,
+unsafe ancestors, ambiguous overlapping records, or filesystem errors fail
+closed. After the record is forgotten, the Skill can be selected and installed
+again through the normal flow.
 
 `skill host add <id|path> --host <host>... [--yes] [--confirm-additional-host]`
 exposes an already installed user-global Skill to more Hosts without changing its
 content or version, then records the new Hosts. Non-Claude Hosts share the
-canonical `~/.agents/skills/<skill>` location and Claude is a symlink to it, so
-only a missing Claude symlink is ever created. The preview lists the new
-locations; because it exposes the Skill to more Hosts it needs both `--yes` and
+canonical `~/.agents/skills/<skill>` location and Claude uses a managed directory
+link to it (relative symlink on POSIX; absolute-target junction on Windows), so
+only a missing Claude link is ever created. The preview lists the new locations;
+because it exposes the Skill to more Hosts it needs both `--yes` and
 `--confirm-additional-host`. It refuses a Claude location that already holds
-anything other than the managed symlink, and a Skill that is not installed at the
+anything other than the managed link, and a Skill that is not installed at the
 canonical location (exposing it would require copying it).
 
 `skill remove <id|path> --host <host>... [--yes]` removes only those Hosts. Only
-the managed Claude symlink can be deleted this way; the canonical directory backs
-every remaining Host (including the Claude symlink) and stays until the last Host
+the managed Claude directory link can be deleted this way; the canonical directory
+backs every remaining Host (including the Claude link) and stays until the last Host
 is removed. Removing every recorded Host is a full removal with the usual
 adopted/modified warnings. The targets are rechecked before deleting and the
 record is updated afterwards. Project installations are not affected.
@@ -310,8 +317,9 @@ select candidates, or install anything automatically.
 ## User-global installation
 
 User-global installations use the same canonical Host locations under the user
-home directory (`.agents/skills/<skill>` and, when requested, a Claude symlink
-at `.claude/skills/<skill>`). They are independent from project manifests and
+home directory (`.agents/skills/<skill>` and, when requested, a Claude directory
+link at `.claude/skills/<skill>`: relative symlink on POSIX, absolute-target
+junction on Windows). They are independent from project manifests and
 are recorded in the shared per-user Source state, so separate CLI invocations
 reuse the same installation records. The selected Source, Skill, Hosts, and
 actual adopted or installed location are previewed before `--yes` confirmation.
@@ -403,8 +411,9 @@ process crash after the original is moved can leave the retained
 inspect the backup and target, and manually rename the retained backup back to the intended installation path when recovery is needed;
 then rerun the install. External installation methods run only after the filesystem
 and selected-scope state transaction succeeds.
-Claude is exposed through a symlink to the canonical `.agents/skills/<skill>`
-installation.
+Claude is exposed through a managed directory link to the canonical
+`.agents/skills/<skill>` installation (relative symlink on POSIX, absolute-target
+junction on Windows).
 
 ## User-provided installation methods
 

package/dist/src/cli.js

@@ -15,11 +15,11 @@ import { createProgress, NO_PROGRESS } from "./progress.js";
 import { skillTreeBaseline } from "./skill-discovery.js";
 import { BUILT_IN_SOURCE, BuiltInSourceError, createSourceOperations, resolveProjectSource, SourceMetadataError, SourceNotFoundError, } from "./sources.js";
 import { AGENT_DEPOT_PACKAGE_NAME, AGENT_DEPOT_PACKAGE_VERSION, builtinPinMismatch, defaultProjectManifestPath, parseProjectManifest, ProjectManifestStore, PROJECT_HOSTS, } from "./project-manifest.js";
-import { inspectProjectSkillInstallation, assertNoOverlappingProjectSkillRemovalTargets, } from "./project-installation.js";
+import { inspectAbsentManagedSkillRecord, inspectProjectSkillInstallation, assertNoOverlappingProjectSkillRemovalTargets, } from "./project-installation.js";
 import { selectUpdateBatch, UpdateBatchSelectionError, } from "./update-batch.js";
 import { describeUnmanagedRemoval, removeInspectedUnmanagedSkills } from "./unmanaged-removal.js";
 import { executeHostAddition, executeHostRemoval, planHostAddition, planHostRemoval } from "./skill-hosts.js";
-import { executeSkillRemoval, inspectSkillRemovals, planSkillRemoval, describeSkillRemoval, recheckSkillRemoval, removeSkillFiles, removeSkillsAndRecords, selectUserGlobalSkills, SkillSelectionError, userGlobalRemovalOptions, } from "./skill-removal.js";
+import { executeSkillRemoval, inspectSkillRemovals, planSkillRemoval, describeSkillRemoval, recheckSkillRemoval, removeSkillFiles, removeSkillsAndRecords, assertManagedInstallationRecordsUnchanged, assertRemovalInspectionUnchanged, selectUserGlobalSkills, SkillSelectionError, userGlobalRemovalOptions, } from "./skill-removal.js";
 import { defaultProjectSkillTreeAccess, executeOrRejectMethod, executeSingleInstall, externalMethodFailure, isValidFixedVersion, findSource, installOne, outputInstallationResult, outputInstallPreview, outputSingleInstallPreview, planSingleInstall, refreshResolvedSource, rejectInstallationCollision, resolveSelection, rollbackTransactions, } from "./skill-install.js";
 import { CliUsageError } from "./usage-error.js";
 import { createSelfUpdateOperations } from "./self-update.js";
@@ -239,7 +239,10 @@ async function runSourceRemoval(argv, operations, dependencies, output, progress
     const selected = options.all
         ? dependent
         : resolveRemovalSelections(dependent, options.requested);
-    const removalOptions = userGlobalRemovalOptions(path.resolve(dependencies.homeDirectory ?? homedir()), dependencies.installationOptions);
+    const removalOptions = userGlobalRemovalOptions(path.resolve(dependencies.homeDirectory ?? homedir()), {
+        ...dependencies.installationOptions,
+        otherInstallationPaths: installations.filter((record) => !selected.includes(record)).flatMap((record) => record.installation ? [record.installation.path] : []),
+    });
     output(`Preview: remove Git Source ${source.id} from ${source.url}`);
     output(`Dependent user-global Skills (${dependent.length}):`);
     for (const [index, selection] of dependent.entries()) {
@@ -255,14 +258,33 @@ async function runSourceRemoval(argv, operations, dependencies, output, progress
     requireConfirmation(options.confirmed, "Removal not confirmed; rerun with --yes after reviewing every Source and Skill preview");
     // Recheck every selected target before deleting the first one. A changed later
     // target must never result in a partially removed batch.
-    await progress.run("Removing Skill files", async () => {
-        const rechecked = await recheckSkillRemoval(plan, removalOptions);
-        await removeSkillFiles(plan, rechecked, removalOptions);
+    const rechecked = await progress.run("Removing Skill files", async () => {
+        const current = await recheckSkillRemoval(plan, removalOptions);
+        assertManagedInstallationRecordsUnchanged(installations, await operations.listUserGlobalInstallations());
+        await removeSkillFiles(plan, current, removalOptions);
+        return current;
+    });
+    // Source removal persists records rather than reconciling them one by one.
+    // Revalidate every record-only target and the complete record snapshot just
+    // before that persistence boundary so a stale preview cannot forget a changed record.
+    await progress.run("Revalidating Skill records before Source removal", async () => {
+        for (const [index, inspection] of rechecked.inspections.entries()) {
+            if (!inspection.recordOnly)
+                continue;
+            const latest = await inspectAbsentManagedSkillRecord(rechecked.selections[index], removalOptions);
+            assertRemovalInspectionUnchanged(inspection, latest);
+        }
+        assertManagedInstallationRecordsUnchanged(installations, await operations.listUserGlobalInstallations());
     });
     await progress.run(`Removing Git Source ${source.id}`, () => operations.removeGitSource(source.id, selected));
     output(`Removed Git Source: ${source.id}`);
     if (selected.length > 0) {
-        output(`Removed ${selected.length} dependent user-global Skill${selected.length === 1 ? "" : "s"}; other dependent Skills remain tracked`);
+        const forgotten = plan.inspections.filter((inspection) => inspection.recordOnly).length;
+        const removed = selected.length - forgotten;
+        if (removed > 0)
+            output(`Removed ${removed} dependent user-global Skill${removed === 1 ? "" : "s"}; other dependent Skills remain tracked`);
+        if (forgotten > 0)
+            output(`Forgot ${forgotten} missing dependent Skill installation record${forgotten === 1 ? "" : "s"}; no files were removed`);
     }
 }
 function parseMigrateSourceOptions(argv) {
@@ -461,7 +483,10 @@ async function runSkillRemoval(argv, operations, dependencies, output, progress)
     }
     const installations = await operations.listUserGlobalInstallations();
     const selected = selectManagedSkills(installations, requested);
-    const removalOptions = userGlobalRemovalOptions(path.resolve(dependencies.homeDirectory ?? homedir()), dependencies.installationOptions);
+    const removalOptions = userGlobalRemovalOptions(path.resolve(dependencies.homeDirectory ?? homedir()), {
+        ...dependencies.installationOptions,
+        otherInstallationPaths: installations.filter((record) => !selected.includes(record)).flatMap((record) => record.installation ? [record.installation.path] : []),
+    });
     if (hosts.length > 0) {
         await runSkillHostRemoval(selected[0], hosts, installations, confirmed, operations, removalOptions, output, progress);
         return;
@@ -473,7 +498,12 @@ async function runSkillRemoval(argv, operations, dependencies, output, progress)
     output("  Installation records are reconciled after each successful Skill removal");
     requireConfirmation(confirmed, "Removal not confirmed; rerun with --yes after reviewing every Skill preview");
     await progress.run(`Removing ${selected.length} user-global Skill${selected.length === 1 ? "" : "s"}`, () => executeSkillRemoval(plan, operations, removalOptions, installations));
-    output(`Removed ${selected.length} user-global Skill${selected.length === 1 ? "" : "s"}`);
+    const forgotten = plan.inspections.filter((inspection) => inspection.recordOnly).length;
+    const removed = selected.length - forgotten;
+    if (removed > 0)
+        output(`Removed ${removed} user-global Skill${removed === 1 ? "" : "s"}`);
+    if (forgotten > 0)
+        output(`Forgot ${forgotten} missing user-global Skill installation record${forgotten === 1 ? "" : "s"}; no files were removed`);
 }
 /** Resolves `<id|path>` arguments to managed installations, reporting selection problems as usage errors. */
 function selectManagedSkills(installations, requested) {
@@ -488,17 +518,24 @@ function selectManagedSkills(installations, requested) {
 }
 async function runSkillHostRemoval(selection, hosts, installations, confirmed, operations, options, output, progress) {
     const plan = await planHostRemoval(selection, hosts, options).catch(rethrowSelectionError);
+    const recordOnly = plan.kind === "full" && plan.plan.inspections.every((inspection) => inspection.recordOnly);
     output(plan.kind === "full"
-        ? "Preview: remove 1 user-global Skill (every recorded Host is removed)"
+        ? recordOnly
+            ? "Preview: forget 1 missing user-global Skill installation record (every recorded Host is removed)"
+            : "Preview: remove 1 user-global Skill (every recorded Host is removed)"
         : `Preview: remove ${hosts.length} Host${hosts.length === 1 ? "" : "s"} from 1 user-global Skill`);
     for (const line of plan.kind === "full" ? plan.plan.preview : plan.preview)
         output(line);
-    output("  The installation record is reconciled after the locations are removed");
+    output(recordOnly
+        ? "  Only the installation record will be forgotten; no files are removed"
+        : "  The installation record is reconciled after the locations are removed");
     requireConfirmation(confirmed, "Removal not confirmed; rerun with --yes after reviewing the preview");
     await progress.run(plan.kind === "full" ? "Removing 1 user-global Skill" : `Removing Hosts from ${selection.path}`, () => executeHostRemoval(plan, operations, options, installations));
-    output(plan.kind === "full"
-        ? "Removed 1 user-global Skill"
-        : `Removed hosts ${plan.removed.join(", ")} from ${JSON.stringify(selection.path)}`);
+    output(plan.kind === "full" && plan.plan.inspections.every((inspection) => inspection.recordOnly)
+        ? `Forgot missing installation record for ${JSON.stringify(selection.path)}; no files were removed`
+        : plan.kind === "full"
+            ? "Removed 1 user-global Skill"
+            : `Removed hosts ${plan.removed.join(", ")} from ${JSON.stringify(selection.path)}`);
 }
 async function runSkillHostAdd(argv, operations, dependencies, output, progress) {
     const requested = [];
@@ -659,10 +696,13 @@ function assertNoManagedUnmanagedOverlap(managed, unmanaged, message) {
         }
     }
 }
-function outputUninstallSummary(options, removedManagedCount, output) {
-    if (options.skills) {
+function outputUninstallSummary(options, removedManagedCount, forgottenManagedCount, output) {
+    if (options.skills && removedManagedCount > 0) {
         output(`Removed ${removedManagedCount} managed user-global Skill${removedManagedCount === 1 ? "" : "s"}`);
     }
+    if (options.skills && forgottenManagedCount > 0) {
+        output(`Forgot ${forgottenManagedCount} missing managed user-global Skill installation record${forgottenManagedCount === 1 ? "" : "s"}; no files were removed`);
+    }
     if (options.unmanagedSkills.length > 0) {
         output(`Permanently deleted ${options.unmanagedSkills.length} unmanaged user-global Skill${options.unmanagedSkills.length === 1 ? "" : "s"}`);
     }
@@ -723,7 +763,8 @@ async function runUninstall(argv, operations, dependencies, output, progress) {
     if (options.data) {
         await progress.run("Removing catalog data", () => operations.removeCatalogData());
     }
-    outputUninstallSummary(options, selectedInstallations.length, output);
+    const forgottenManagedCount = managedRechecked.inspections.filter((inspection) => inspection.recordOnly).length;
+    outputUninstallSummary(options, selectedInstallations.length - forgottenManagedCount, forgottenManagedCount, output);
 }
 function selfUpdateOperationsFor(dependencies) {
     if (dependencies.selfUpdateOperations !== undefined)

package/dist/src/package-bundles.js

@@ -56,8 +56,8 @@ export function parseClaudePluginManifest(raw, root) {
 /**
  * Reads one marketplace and returns a descriptor per `plugins` entry. The
  * `readPluginManifest` resolver supplies the raw plugin.json for an in-repo
- * entry, because the entry version overrides the plugin manifest version and
- * the plugin manifest owns the component inventory (agents, hooks, and so on).
+ * entry. The plugin manifest owns the component inventory and, when declared,
+ * its version takes precedence over marketplace entry metadata, as in Claude.
  * A `command` source and any source outside the repository yield a descriptor
  * with a warning rather than a throw.
  */
@@ -330,7 +330,7 @@ function buildMarketplaceDescriptor(entry, label, marketplaceRoot, metadataPlugi
         warnings.push(`marketplace entry name ${JSON.stringify(entryName)} differs from plugin manifest name ${JSON.stringify(plugin.name)}`);
     }
     const entryVersion = manifestVersionEvidence(entry.version, "marketplace-entry");
-    const version = entryVersion ?? plugin.version;
+    const version = plugin.version ?? entryVersion;
     return Object.freeze({
         host: "claude",
         coordinates: Object.freeze({ host: "claude", marketplaceRoot, pluginName: entryName }),

package/dist/src/package-cli.js

@@ -92,7 +92,9 @@ export function packageSelectionMatches(selection, value) {
 export function describePackageUpdateCheck(check) {
     const available = check.available === undefined ? "unknown" : describeVersion(check.available);
     const reason = check.reason === undefined ? "" : `; ${check.reason}`;
-    return `Package ${formatPackageSelection(check.installed.selection)}: ${check.status}; available ${available}${reason}`;
+    const installed = check.observed === undefined ? "unknown (host evidence unavailable)" : describeEvidence(check.observed);
+    const commit = check.available?.kind === "manifest-version" && check.availableCommit !== undefined ? `; commit ${check.availableCommit}` : "";
+    return `Package ${formatPackageSelection(check.installed.selection)}: ${check.status}; available ${available}${commit}${reason}; host ${installed}`;
 }
 export function describePackageResult(result) {
     switch (result.status) {
@@ -318,7 +320,9 @@ function formatPackageRecord(record) {
 function describeInspection(selection, inspection, output) {
     output(`Package inspect: ${formatPackageSelection(selection)}`);
     output(`  installed: ${describeEvidence(inspection.installed)}`);
-    output(`  available: ${inspection.available === undefined ? "unknown" : describeVersion(inspection.available)}`);
+    output(`  available: ${inspection.available === undefined ? "unknown" : describeVersion(inspection.available)}${inspection.availableCommit === undefined || inspection.available?.kind === "git-commit" ? "" : `; commit ${inspection.availableCommit}`}`);
+    if (inspection.updateReason !== undefined)
+        output(`  update: ${inspection.updateReason}`);
     output(`  approval: ${inspection.approval}`);
     if (inspection.drift !== undefined) {
         output(`  drift: ${inspection.drift}`);
@@ -389,7 +393,7 @@ function describeEvidence(evidence) {
         case "installed": {
             if (evidence.version !== undefined) {
                 const qualifier = evidence.reason === undefined ? "" : " (HEAD; local changes)";
-                return `installed ${evidence.version}${qualifier}`;
+                return `installed ${evidence.version}${evidence.commit === undefined ? "" : ` (commit ${evidence.commit})`}${qualifier}`;
             }
             if (evidence.commit !== undefined) {
                 return `installed commit ${evidence.commit}`;

package/dist/src/package-flow.js

@@ -4,7 +4,7 @@ import { sameAppVersion } from "./app-version.js";
 import { createPortableExecutableResolver } from "./executable-resolution.js";
 import { claudeMarketplaceName, discoverBundlesInSnapshot } from "./package-bundles.js";
 import { sourceBundleScope } from "./package-content.js";
-import { affectedBy, classifyUpdate, hostInstallId, packageApprovalDigest, planHostSteps, PackagePlanError, } from "./package-host-plans.js";
+import { affectedBy, classifyUpdate, claudeVersionUpdateNotice, hostInstallId, packageApprovalDigest, planHostSteps, PackagePlanError, } from "./package-host-plans.js";
 import { findInstalledBundle, readHostInstallView } from "./package-host-state.js";
 import { activeBundles as classifyActiveBundles, portableSkillConflicts, } from "./package-owned-skills.js";
 import { bundleRoot, describeCoordinates, selectionKey, } from "./package-model.js";
@@ -174,7 +174,9 @@ export function createPackageOperations(environment = {}) {
         const installedCommitIsAncestor = bundle?.resolvedCommit === undefined || installed.kind !== "installed" || installed.commit === undefined
             ? undefined
             : await contentAccess.isCommitAncestor?.(bundle.source, installed.commit, bundle.resolvedCommit).catch(() => undefined);
+        const updateReason = claudeVersionUpdateNotice(selection.host, installed, bundle?.available, bundle?.resolvedCommit);
         return Object.freeze({
+            ...(updateReason === undefined ? {} : { updateReason }),
             ...(bundle === undefined ? {} : { descriptor: bundle.descriptor }),
             installed,
             ...(bundle?.available === undefined ? {} : { available: bundle.available }),
@@ -187,13 +189,16 @@ export function createPackageOperations(environment = {}) {
     async function checkOne(record) {
         try {
             const inspection = await inspect(record.selection);
-            const status = classifyUpdate(inspection.installed, inspection.available, inspection.availableCommit, inspection.installedCommitIsAncestor);
+            const status = classifyUpdate(inspection.installed, inspection.available, inspection.availableCommit, inspection.installedCommitIsAncestor, record.selection.host);
             return Object.freeze({
                 installed: record,
+                observed: inspection.installed,
                 status,
                 ...(inspection.available === undefined ? {} : { available: inspection.available }),
                 ...(inspection.availableCommit === undefined ? {} : { availableCommit: inspection.availableCommit }),
-                ...(status === "unknown" ? { reason: inspection.drift ?? describeEvidence(inspection.installed) } : {}),
+                ...(status === "unknown"
+                    ? { reason: inspection.drift ?? describeEvidence(inspection.installed) }
+                    : inspection.updateReason === undefined ? {} : { reason: inspection.updateReason }),
             });
         }
         catch (error) {
@@ -234,7 +239,7 @@ export function createPackageOperations(environment = {}) {
                 if (contradiction !== undefined) {
                     return { status: "failed", reason: `${contradiction}; the selection record was left untouched` };
                 }
-                const change = installedEvidenceChange(context.previous, observed);
+                const change = installedEvidenceChange(context.previous, observed, context.selection.host, context.available);
                 if (change === "unknown") {
                     return {
                         status: "failed",
@@ -242,9 +247,10 @@ export function createPackageOperations(environment = {}) {
                     };
                 }
                 if (change === "unchanged") {
+                    const notice = claudeVersionUpdateNotice(context.selection.host, observed, context.available, context.origin.resolvedCommit);
                     return {
                         status: "failed",
-                        reason: `The observed version did not change (${describeEvidence(observed)}); the selection record was left untouched`,
+                        reason: `The observed version did not change (${describeEvidence(observed)}); the selection record was left untouched${notice === undefined ? "" : `. ${notice}`}`,
                     };
                 }
                 await writeSelection(context, observed);
@@ -524,15 +530,22 @@ function planDifference(plan, fresh) {
 /**
  * Three outcomes, not two. `unknown` means the two observations carry no
  * comparable evidence, and an update must not report that as a success. A host
- * that had nothing installed and now reports an install has changed.
+ * that had nothing installed and now reports an install has changed. Versioned
+ * Claude plugins use literal cache versions, just as update eligibility does.
  */
-function installedEvidenceChange(previous, observed) {
+function installedEvidenceChange(previous, observed, host, available) {
     if (observed.kind !== "installed" || previous === undefined || previous.kind === "unknown") {
         return "unknown";
     }
     if (previous.kind === "absent") {
         return "changed";
     }
+    if (host === "claude" && available?.kind === "manifest-version") {
+        if (previous.version === undefined || observed.version === undefined
+            || previous.reason !== undefined || observed.reason !== undefined)
+            return "unknown";
+        return previous.version === observed.version ? "unchanged" : "changed";
+    }
     const previousCommit = previous.commit === undefined ? undefined : gitCommitId(previous.commit);
     const observedCommit = observed.commit === undefined ? undefined : gitCommitId(observed.commit);
     if (previousCommit !== undefined && observedCommit !== undefined) {

package/dist/src/package-host-plans.js

@@ -124,13 +124,19 @@ export function packageApprovalDigest(declaration) {
 }
 /**
  * Compares installed evidence with available evidence. Manifest versions compare
- * through `sameAppVersion` and `compareAppVersions`; differing commits compare only
- * when cached Source history proves the installed commit is an ancestor.
+ * through `sameAppVersion` and `compareAppVersions` for Pi. Claude's explicit
+ * plugin version keys its cache: only a different version installs a new copy.
+ * Unversioned bundles compare commits only with proven Source ancestry.
  */
-export function classifyUpdate(installed, available, availableCommit, installedCommitIsAncestor) {
+export function classifyUpdate(installed, available, availableCommit, installedCommitIsAncestor, host = "pi") {
     if (installed.kind !== "installed" || installed.reason !== undefined || available === undefined) {
         return "unknown";
     }
+    if (host === "claude" && available.kind === "manifest-version") {
+        if (installed.version === undefined)
+            return "unknown";
+        return installed.version === available.version ? "current" : "update available";
+    }
     if (installed.commit !== undefined) {
         const sourceCommit = availableCommit ?? (available.kind === "git-commit" ? available.commit : undefined);
         if (sourceCommit === undefined)
@@ -151,6 +157,15 @@ export function classifyUpdate(installed, available, availableCommit, installedC
     }
     return "unknown";
 }
+/** A different Source commit is not a deliverable update to Claude's versioned cache. */
+export function claudeVersionUpdateNotice(host, installed, available, availableCommit) {
+    if (host !== "claude" || installed.kind !== "installed" || installed.reason !== undefined
+        || available?.kind !== "manifest-version" || installed.version !== available.version
+        || installed.commit === undefined || availableCommit === undefined
+        || normalizeCommit(installed.commit) === normalizeCommit(availableCommit))
+        return undefined;
+    return `The Source commit differs, but Claude caches plugin version ${available.version}; the publisher must change the declared plugin version to deliver those changes.`;
+}
 /** Validates one host argv with the shared portable-command rules. */
 export function assertValidHostArgv(argv, label) {
     try {

package/dist/src/project-installation.js

@@ -56,7 +56,7 @@ export async function inspectProjectSkillRemoval(selection, options) {
         actualBaseline.digest !== selection.installation.baseline.digest;
     const paths = [targetPath];
     // A Claude exposure created by Agent Depot is removable only when it is the
-    // exact relative symlink to this canonical installation. Never follow or
+    // exact managed directory link to this canonical installation. Never follow or
     // remove an unrelated path merely because the Skill selected Claude.
     const canonicalPath = path.join(projectRoot, ".agents", "skills", skillName);
     const claudePath = path.join(projectRoot, ".claude", "skills", skillName);
@@ -65,11 +65,11 @@ export async function inspectProjectSkillRemoval(selection, options) {
         try {
             const claudeInformation = await fileSystem.lstat(claudePath);
             if (!claudeInformation.isSymbolicLink()) {
-                throw new ProjectInstallationError("unsafe-target", `Cannot remove the tracked Skill because its Claude location is not the managed symlink: ${claudePath}; no path was changed`);
+                throw new ProjectInstallationError("unsafe-target", `Cannot remove the tracked Skill because its Claude location is not the managed directory link: ${claudePath}; no path was changed`);
             }
             const target = await fileSystem.readlink(claudePath);
             if (path.resolve(path.dirname(claudePath), target) !== canonicalPath) {
-                throw new ProjectInstallationError("unsafe-target", `Cannot remove the tracked Skill because its Claude symlink does not point to the canonical installation: ${claudePath}; no path was changed`);
+                throw new ProjectInstallationError("unsafe-target", `Cannot remove the tracked Skill because its Claude directory link does not point to the canonical installation: ${claudePath}; no path was changed`);
             }
             paths.push(claudePath);
         }
@@ -87,6 +87,46 @@ export async function inspectProjectSkillRemoval(selection, options) {
         ...(nonCanonicalPath === undefined ? {} : { nonCanonicalPath }),
     });
 }
+/**
+ * Explicitly inspects a stale user-global record without making it valid for
+ * host exposure/update. Every relevant ancestor and both managed host locations
+ * are checked; only ENOENT is accepted as absence and no filesystem entry is removed.
+ */
+export async function inspectAbsentManagedSkillRecord(selection, options) {
+    if (!selection.installation)
+        throw new ProjectInstallationError("removal-unavailable", "Cannot forget a Skill without a recorded installation");
+    const fileSystem = options.fileSystem ?? nodeFileSystem;
+    const root = path.resolve(options.projectRoot);
+    const target = resolveInstallationPath(root, selection.installation.path);
+    if (!isSafeRelativePath(selection.installation.path) || selection.installation.path.split("/").some((segment) => segment.toLowerCase() === ".git")) {
+        throw new ProjectInstallationError("unsafe-target", `Tracked Skill installation path is unsafe: ${JSON.stringify(selection.installation.path)}; no record was changed`);
+    }
+    await assertNoSymlinkComponents(root, fileSystem);
+    await assertDirectory(root, fileSystem, "user-global root");
+    await assertNoSymlinkAncestors(root, relativeSegments(root, target), fileSystem);
+    const skillName = skillNameFromSelection(selection);
+    const canonical = path.join(root, ".agents", "skills", skillName);
+    const claude = path.join(root, ".claude", "skills", skillName);
+    for (const otherPath of options.otherInstallationPaths ?? []) {
+        const other = resolveInstallationPath(root, otherPath);
+        if (pathsOverlap(target, other) || pathsOverlap(canonical, other) || pathsOverlap(claude, other)) {
+            throw new ProjectInstallationError("overlapping-targets", `Cannot forget ${JSON.stringify(selection.path)} because its recorded path overlaps another managed Skill record; no record was changed`);
+        }
+    }
+    await assertNoSymlinkAncestors(root, [".agents", "skills", skillName], fileSystem);
+    await assertNoSymlinkAncestors(root, [".claude", "skills", skillName], fileSystem);
+    for (const candidate of new Set([target, canonical, claude])) {
+        try {
+            await fileSystem.lstat(candidate);
+            throw new ProjectInstallationError("unsafe-target", `Cannot forget ${JSON.stringify(selection.path)} because a filesystem object exists at ${candidate}; no record was changed`);
+        }
+        catch (error) {
+            if (!isMissing(error))
+                throw error;
+        }
+    }
+    return Object.freeze({ skillName, paths: Object.freeze([]), digest: "absent-record-only", adopted: selection.installation.adopted, modified: false, recordOnly: true });
+}
 /**
  * Removes a previously inspected user-global Skill after rechecking ownership.
  * `deletePaths` narrows the deletion to a subset of the inspected paths (used
@@ -99,6 +139,7 @@ export async function removeProjectSkill(selection, inspection, options, deleteP
         current.paths.length !== inspection.paths.length ||
         current.paths.some((candidate, index) => candidate !== inspection.paths[index]) ||
         current.digest !== inspection.digest ||
+        current.recordOnly !== inspection.recordOnly ||
         current.adopted !== inspection.adopted ||
         current.modified !== inspection.modified ||
         current.nonCanonicalPath !== inspection.nonCanonicalPath) {
@@ -120,9 +161,9 @@ export async function removeProjectSkill(selection, inspection, options, deleteP
     }
 }
 /**
- * Deletes one managed symlink without ever following or recursing into it:
- * look at the path immediately before, require a symlink, then unlink it.
- * Partial Host removal only ever deletes the Claude symlink, so it uses this
+ * Deletes one managed directory link without ever following or recursing into it:
+ * look at the path immediately before, require a link, then unlink it.
+ * Partial Host removal only ever deletes the Claude link, so it uses this
  * instead of the recursive `rm` that full removal needs for the canonical directory.
  */
 async function unlinkManagedSymlink(candidate, fileSystem) {
@@ -135,7 +176,7 @@ async function unlinkManagedSymlink(candidate, fileSystem) {
 /**
  * Inspects what exposing the installed Skill to `hosts` would change without
  * writing. Non-Claude Hosts share the canonical `.agents/skills` location, and
- * Claude is a symlink to it; anything else at a target location is a conflict.
+ * Claude uses a managed directory link to it; anything else at a target location is a conflict.
  */
 export async function inspectProjectSkillHostAddition(selection, hosts, options) {
     const removal = await inspectProjectSkillRemoval(selection, options);
@@ -161,7 +202,7 @@ export async function inspectProjectSkillHostAddition(selection, hosts, options)
         else {
             const target = existing.isSymbolicLink() ? await fileSystem.readlink(claudePath) : undefined;
             if (target === undefined || path.resolve(path.dirname(claudePath), target) !== canonicalPath) {
-                throw new ProjectInstallationError("target-conflict", `Cannot expose ${JSON.stringify(removal.skillName)} to Claude because ${JSON.stringify(claudePath)} already exists and is not the managed symlink to the installed Skill; no path was changed.`);
+                throw new ProjectInstallationError("target-conflict", `Cannot expose ${JSON.stringify(removal.skillName)} to Claude because ${JSON.stringify(claudePath)} already exists and is not the managed directory link to the installed Skill; no path was changed.`);
             }
         }
     }
@@ -446,7 +487,7 @@ async function inspectSkillLocation(candidate, context) {
         ? Object.freeze({ path: candidate, status: "identical", ...evidence })
         : collisionLocation(candidate, comparison.reason ?? "content-mismatch", evidence);
 }
-/** A Claude symlink is an exposure only when it points to the canonical Skill that was itself found identical. */
+/** A Claude directory link is an exposure only when it points to the canonical Skill that was itself found identical. */
 async function isClaudeExposureOfCanonical(candidate, context) {
     if (candidate !== context.claudePath || !context.canonicalIdentical)
         return false;
@@ -523,7 +564,7 @@ export async function installProjectSkillTransaction(request, options) {
         // prevents a later host check from following a pre-existing symlink after
         // the other host's directories have already been created.
         await assertNoSymlinkAncestors(projectRoot, [".agents", "skills", skillName], fileSystem);
-        // A Claude Skill path may be the managed symlink to the canonical tree;
+        // A Claude Skill path may be the managed directory link to the canonical tree;
         // adoption validates that final component before following it.
         await assertNoSymlinkAncestors(projectRoot, [".claude", "skills"], fileSystem);
         const adoption = await adoptExistingProjectSkill(projectRoot, skillName, request.selection.path, files, hosts, fileSystem, request.confirmAdditionalHostExposure === true, createdPaths, uncertainCreates);
@@ -609,15 +650,14 @@ async function writeInstalledFile(canonicalPath, file, createdPaths, uncertainCr
     await fileSystem.chmod(destination, file.source.executable ? 0o755 : 0o644);
 }
 async function createClaudeSkillSymlink(claudePath, canonicalPath, createdPaths, uncertainCreates, fileSystem) {
-    const linkTarget = path.relative(path.dirname(claudePath), canonicalPath);
     uncertainCreates.add(claudePath);
     try {
-        await fileSystem.symlink(linkTarget, claudePath, "dir");
+        await createClaudeDirectoryLink(fileSystem, claudePath, canonicalPath);
     }
     catch (error) {
         const reason = error instanceof Error ? error.message : String(error);
-        throw new ProjectInstallationError("claude-symlink-failed", `Cannot create the Claude Skill symlink at ${JSON.stringify(claudePath)}: ${reason}. ` +
-            "Grant this process permission to create directory symlinks (on Windows, enable Developer Mode or the required symlink privilege) and retry. " +
+        throw new ProjectInstallationError("claude-symlink-failed", `Cannot create the Claude Skill directory link at ${JSON.stringify(claudePath)}: ${reason}. ` +
+            (process.platform === "win32" ? "Windows junctions do not require symlink privileges; check the target path and filesystem instead. " : "Check that this process can create directory symlinks. ") +
             "No duplicate managed copy was created; the canonical installation was rolled back.");
     }
     await recordCreatedClaudeSymlink(claudePath, createdPaths, uncertainCreates, fileSystem);
@@ -625,7 +665,7 @@ async function createClaudeSkillSymlink(claudePath, canonicalPath, createdPaths,
 async function recordCreatedClaudeSymlink(claudePath, createdPaths, uncertainCreates, fileSystem) {
     const information = await fileSystem.lstat(claudePath);
     if (!information.isSymbolicLink()) {
-        throw new ProjectInstallationError("unsafe-target", `Claude installation path is not a symbolic link: ${claudePath}`);
+        throw new ProjectInstallationError("unsafe-target", `Claude installation path is not a directory link: ${claudePath}`);
     }
     createdPaths.push({ path: claudePath, kind: "symlink", identity: pathIdentity(information) });
     uncertainCreates.delete(claudePath);
@@ -651,7 +691,7 @@ function assertOverwriteCollision(inspection) {
     // would make Claude continue reading the old bytes after the canonical move.
     const claudeLocation = inspection.locations.find((location) => location.path === inspection.claudePath);
     if (inspection.targetPath === inspection.canonicalPath && claudeLocation?.status === "identical" && claudeLocation.identity !== undefined) {
-        throw new ProjectInstallationError("ambiguous-target", `Cannot overwrite ${JSON.stringify(inspection.targetPath)} because the Claude location is a separate real directory rather than the managed symlink; no path was changed`);
+        throw new ProjectInstallationError("ambiguous-target", `Cannot overwrite ${JSON.stringify(inspection.targetPath)} because the Claude location is a separate real directory rather than the managed directory link; no path was changed`);
     }
 }
 function targetLocation(inspection) {
@@ -847,9 +887,8 @@ async function overwriteProjectSkillTransaction(request, options, files, hosts,
         const claudeLocation = inspection.locations.find((location) => location.path === inspection.claudePath);
         if (targetPath === inspection.canonicalPath && hosts.includes("claude") && claudeLocation?.status === "missing") {
             await ensureDirectoryTree(projectRoot, [".claude", "skills"], exposureCreated, exposureUncertain, fileSystem);
-            const linkTarget = path.relative(path.dirname(inspection.claudePath), inspection.canonicalPath);
             exposureUncertain.add(inspection.claudePath);
-            await fileSystem.symlink(linkTarget, inspection.claudePath, "dir");
+            await createClaudeDirectoryLink(fileSystem, inspection.claudePath, inspection.canonicalPath);
             const linkInformation = await fileSystem.lstat(inspection.claudePath);
             if (!linkInformation.isSymbolicLink()) {
                 throw new ProjectInstallationError("unsafe-target", `Claude installation path is not a symbolic link: ${inspection.claudePath}`);
@@ -918,15 +957,19 @@ async function assertExistingSkillMatches(candidate, sourceSkillPath, expectedTr
         throw new ProjectInstallationError("adoption-conflict", `Cannot adopt because an existing Skill already exists at ${JSON.stringify(candidate)} with different content (${comparison.reason}); explicit confirmation would be required to overwrite it, but this safe install flow has no overwrite operation. No path was changed.`);
     }
 }
+async function createClaudeDirectoryLink(fileSystem, claudePath, canonicalPath) {
+    const windows = process.platform === "win32";
+    await fileSystem.symlink(windows ? path.resolve(canonicalPath) : path.relative(path.dirname(claudePath), canonicalPath), claudePath, windows ? "junction" : "dir");
+}
 async function createAdditionalClaudeExposure(projectRoot, canonicalPath, claudePath, fileSystem, createdPaths, uncertainCreates) {
     await ensureDirectoryTree(projectRoot, [".claude", "skills"], createdPaths, uncertainCreates, fileSystem);
     await assertMissing(claudePath, fileSystem, claudePath);
     uncertainCreates.add(claudePath);
     try {
-        await fileSystem.symlink(path.relative(path.dirname(claudePath), canonicalPath), claudePath, "dir");
+        await createClaudeDirectoryLink(fileSystem, claudePath, canonicalPath);
     }
     catch (error) {
-        throw new ProjectInstallationError("claude-symlink-failed", `Cannot create the additional Claude Skill symlink at ${JSON.stringify(claudePath)}: ${errorMessage(error)}. No existing path was changed.`);
+        throw new ProjectInstallationError("claude-symlink-failed", `Cannot create the additional Claude Skill directory link at ${JSON.stringify(claudePath)}: ${errorMessage(error)}. No existing path was changed.`);
     }
     await recordCreatedClaudeSymlink(claudePath, createdPaths, uncertainCreates, fileSystem);
 }
@@ -1207,6 +1250,9 @@ async function rollbackCreatedPaths(createdPaths, uncertainCreates, fileSystem)
                 }
                 await fileSystem.rmdir(created.path);
             }
+            else if (created.kind === "symlink") {
+                await unlinkManagedSymlink(created.path, fileSystem);
+            }
             else {
                 await fileSystem.rm(created.path);
             }

package/dist/src/skill-removal.js

@@ -1,4 +1,4 @@
-import { assertNoOverlappingProjectSkillRemovalTargets, inspectProjectSkillRemoval, removeProjectSkill, } from "./project-installation.js";
+import { assertNoOverlappingProjectSkillRemovalTargets, inspectAbsentManagedSkillRecord, inspectProjectSkillRemoval, ProjectInstallationError, removeProjectSkill, } from "./project-installation.js";
 /** Result of resolving a user-supplied `<id|path>` against managed installations. */
 export class SkillSelectionError extends Error {
 }
@@ -32,11 +32,13 @@ export function userGlobalRemovalOptions(homeDirectory, overrides) {
 }
 /** Preview lines for one inspected removal, including adopted/modified warnings. */
 export function describeSkillRemoval(selection, inspection, label) {
-    const lines = [`  remove ${label}${JSON.stringify(selection.path)} at ${inspection.paths.join(", ")}`];
-    if (inspection.adopted) {
+    const lines = inspection.recordOnly
+        ? [`  forget missing installation record for ${label}${JSON.stringify(selection.path)} (record only; no files removed)`]
+        : [`  remove ${label}${JSON.stringify(selection.path)} at ${inspection.paths.join(", ")}`];
+    if (!inspection.recordOnly && inspection.adopted) {
         lines.push("    WARNING: this Skill was adopted; removal deletes content that Agent Depot did not create");
     }
-    if (inspection.modified) {
+    if (!inspection.recordOnly && inspection.modified) {
         lines.push("    WARNING: this Skill is locally modified or has no trusted baseline; removal deletes those changes");
     }
     return lines;
@@ -48,7 +50,20 @@ export function describeSkillRemoval(selection, inspection, label) {
 export async function inspectSkillRemovals(selections, options, onInspected) {
     const inspections = [];
     for (const selection of selections) {
-        const inspection = await inspectProjectSkillRemoval(selection, options);
+        const otherInstallationPaths = [
+            ...(options.otherInstallationPaths ?? []),
+            ...selections.filter((candidate) => candidate !== selection)
+                .flatMap((candidate) => candidate.installation ? [candidate.installation.path] : []),
+        ];
+        let inspection;
+        try {
+            inspection = await inspectProjectSkillRemoval(selection, { ...options, otherInstallationPaths });
+        }
+        catch (error) {
+            if (!(error instanceof ProjectInstallationError) || error.code !== "missing-installation" || options.installationTrust !== "user-global-state")
+                throw error;
+            inspection = await inspectAbsentManagedSkillRecord(selection, { ...options, otherInstallationPaths });
+        }
         inspections.push(inspection);
         onInspected?.(selection, inspection);
     }
@@ -70,9 +85,9 @@ export async function recheckSkillRemoval(plan, options) {
     return rechecked;
 }
 export function assertRemovalInspectionUnchanged(before, after) {
-    const unchanged = before.digest === after.digest && before.adopted === after.adopted && before.modified === after.modified &&
-        before.skillName === after.skillName && before.paths.length === after.paths.length &&
-        before.paths.every((candidate, pathIndex) => candidate === after.paths[pathIndex]);
+    const unchanged = before.digest === after.digest && before.recordOnly === after.recordOnly && before.adopted === after.adopted && before.modified === after.modified &&
+        before.skillName === after.skillName && before.nonCanonicalPath === after.nonCanonicalPath &&
+        before.paths.length === after.paths.length && before.paths.every((candidate, pathIndex) => candidate === after.paths[pathIndex]);
     if (!unchanged) {
         throw new Error("The inspected Skill removal target changed before deletion; no path was removed");
     }
@@ -86,8 +101,11 @@ export function assertManagedInstallationRecordsUnchanged(expected, actual) {
 }
 /** Deletes the files of every rechecked selection; records are left to the caller. */
 export async function removeSkillFiles(plan, rechecked, options) {
+    assertRemovalBatchUnchanged(plan, rechecked);
     for (const [index, selection] of plan.selections.entries()) {
         assertRemovalInspectionUnchanged(plan.inspections[index], rechecked.inspections[index]);
+        if (rechecked.inspections[index].recordOnly)
+            continue;
         await removeProjectSkill(selection, rechecked.inspections[index], options);
     }
 }
@@ -102,16 +120,35 @@ export async function removeSkillsAndRecords(plan, rechecked, operations, option
     if (!list || !reconcile) {
         throw new Error("Configured Source operations cannot reconcile removed user-global Skills");
     }
+    assertRemovalBatchUnchanged(plan, rechecked);
     let expected = initialManaged;
     for (const [index, selection] of plan.selections.entries()) {
         assertRemovalInspectionUnchanged(plan.inspections[index], rechecked.inspections[index]);
         assertManagedInstallationRecordsUnchanged(expected, await list.call(operations));
-        await removeProjectSkill(selection, rechecked.inspections[index], options);
+        if (rechecked.inspections[index].recordOnly) {
+            const latest = await inspectAbsentManagedSkillRecord(selection, options);
+            assertRemovalInspectionUnchanged(rechecked.inspections[index], latest);
+        }
+        else {
+            await removeProjectSkill(selection, rechecked.inspections[index], options);
+        }
         await reconcile.call(operations, [selection]);
         expected = await list.call(operations);
     }
     return expected;
 }
+/** Compare the complete confirmed batch before any entry can mutate files or records. */
+function assertRemovalBatchUnchanged(plan, rechecked) {
+    if (plan.selections.length !== rechecked.selections.length || plan.inspections.length !== rechecked.inspections.length) {
+        throw new Error("The inspected Skill removal batch changed before deletion; no path was removed");
+    }
+    for (const [index, inspection] of plan.inspections.entries()) {
+        const current = rechecked.inspections[index];
+        if (!current)
+            throw new Error("The inspected Skill removal batch changed before deletion; no path was removed");
+        assertRemovalInspectionUnchanged(inspection, current);
+    }
+}
 /** Execute step: recheck, then remove files and records. */
 export async function executeSkillRemoval(plan, operations, options, initialManaged) {
     const rechecked = await recheckSkillRemoval(plan, options);

package/dist/src/tui/bulk-actions.js

@@ -92,7 +92,9 @@ export async function runBulkUninstall(plan, operations, env) {
         await runUninstall({ ...item.prepared, installations: expected }, operations, env);
         // Only the record this item removed moves the baseline the next item is checked against.
         expected = expected.filter((record) => !item.prepared.plan.selections.some((removed) => sameRecord(removed, record)));
-        return `Removed ${item.label}`;
+        return item.prepared.plan.inspections.every((inspection) => inspection.recordOnly)
+            ? `Forgot missing installation record for ${item.label}; no files were removed`
+            : `Removed ${item.label}`;
     }, (item, error) => (item.kind === "unmanaged" ? errorText(error) : `Failed ${item.label}: ${errorText(error)}`));
     return resultOf(outcomes, plan.skipped);
 }

package/dist/src/tui/catalog-installs.js

@@ -128,15 +128,24 @@ export async function prepareUninstall(operations, environment, skill, installed
     if (matches.length === 0) {
         return { kind: recordsFor(installed.project, skill, installed.sources).length > 0 ? "project-only" : "not-installed" };
     }
-    const options = userGlobalRemovalOptions(homeOf(environment), environment.installationOptions);
     const record = matches[0];
+    const options = userGlobalRemovalOptions(homeOf(environment), {
+        ...environment.installationOptions,
+        otherInstallationPaths: installations.filter((candidate) => candidate !== record).flatMap((candidate) => candidate.installation ? [candidate.installation.path] : []),
+    });
     const plan = await planSkillRemoval([record], options);
-    const scopeNote = `  removes the whole user-global installation, from hosts: ${record.hosts.join(", ")}`;
+    const scopeNote = plan.inspections[0]?.recordOnly
+        ? `  forgets the missing installation record, from hosts: ${record.hosts.join(", ")}; no files are removed`
+        : `  removes the whole user-global installation, from hosts: ${record.hosts.join(", ")}`;
     return { kind: "ready", plan: { ...plan, preview: [...plan.preview, scopeNote] }, installations };
 }
 /** Execute step: rechecks the plan, then removes files and records. */
 export async function runUninstall(prepared, operations, environment) {
-    const options = userGlobalRemovalOptions(homeOf(environment), environment.installationOptions);
+    const selected = new Set(prepared.plan.selections.map((selection) => JSON.stringify(selection)));
+    const options = userGlobalRemovalOptions(homeOf(environment), {
+        ...environment.installationOptions,
+        otherInstallationPaths: prepared.installations.filter((candidate) => !selected.has(JSON.stringify(candidate))).flatMap((candidate) => candidate.installation ? [candidate.installation.path] : []),
+    });
     await executeSkillRemoval(prepared.plan, operations, options, prepared.installations);
 }
 /** The user-global record of the Skill, when it is installed there. */
@@ -178,16 +187,26 @@ export async function runHostAddition(prepared, operations, environment) {
 /** Plan step for removing some hosts of a user-global Skill; removing all of them is a full removal. */
 export async function prepareHostRemoval(operations, environment, skill, installed, hosts) {
     const { record, installations } = await currentGlobalRecord(operations, skill, installed);
-    const options = userGlobalRemovalOptions(homeOf(environment), environment.installationOptions);
+    const options = userGlobalRemovalOptions(homeOf(environment), {
+        ...environment.installationOptions,
+        otherInstallationPaths: installations.filter((candidate) => JSON.stringify(candidate) !== JSON.stringify(record)).flatMap((candidate) => candidate.installation ? [candidate.installation.path] : []),
+    });
     const plan = await planHostRemoval(record, hosts, options).catch(asMessage);
     return { plan, installations, preview: plan.kind === "full" ? plan.plan.preview : plan.preview };
 }
 /** Execute step: rechecks, removes only the chosen hosts' locations, then reconciles the record. */
 export async function runHostRemoval(prepared, operations, environment, skill) {
-    const options = userGlobalRemovalOptions(homeOf(environment), environment.installationOptions);
+    const selection = prepared.plan.kind === "full" ? prepared.plan.plan.selections[0] : prepared.plan.selection;
+    const options = userGlobalRemovalOptions(homeOf(environment), {
+        ...environment.installationOptions,
+        otherInstallationPaths: prepared.installations.filter((candidate) => selection !== undefined && JSON.stringify(candidate) !== JSON.stringify(selection))
+            .flatMap((candidate) => candidate.installation ? [candidate.installation.path] : []),
+    });
     await executeHostRemoval(prepared.plan, operations, options, prepared.installations);
     const { plan } = prepared;
-    return plan.kind === "full"
-        ? `Removed ${skill.name} (${skill.path})`
-        : `Removed hosts ${plan.removed.join(", ")} from ${plan.selection.path}`;
+    return plan.kind === "full" && plan.plan.inspections.every((inspection) => inspection.recordOnly)
+        ? `Forgot missing installation record for ${plan.plan.selections[0]?.path ?? skill.path}; no files were removed`
+        : plan.kind === "full"
+            ? `Removed ${skill.name} (${skill.path})`
+            : `Removed hosts ${plan.removed.join(", ")} from ${plan.selection.path}`;
 }

package/dist/src/tui/installations-rows.js

@@ -15,7 +15,7 @@ function PackageDetails({ row }) {
     const status = row.status.kind === "unknown" && row.status.reason === "local changes"
         ? "update not checked · local changes"
         : row.status.kind === "unknown" ? "cannot assess" : row.status.kind === "current" ? "up to date" : "update available";
-    return (_jsxs(Text, { children: [_jsx(Text, { color: theme.legend, children: "  " }), _jsxs(Text, { color: theme.value, children: [row.selection.host, "  "] }), version === undefined ? _jsx(Text, { color: theme.warning, children: row.installed }) : _jsxs(_Fragment, { children: [_jsx(Text, { color: theme.value, children: installedPrefix }), _jsx(Text, { color: theme.version, children: version }), _jsx(Text, { color: theme.value, children: installedSuffix })] }), _jsx(Text, { color: theme.value, children: "  available " }), _jsx(Text, { color: row.available === "unknown" ? theme.warning : theme.version, children: row.available }), _jsxs(Text, { color: theme.warning, children: ["  ", status] }), row.drift === undefined ? null : _jsxs(Text, { color: theme.warning, children: ["  drift: ", row.drift] })] }));
+    return (_jsxs(Text, { children: [_jsx(Text, { color: theme.legend, children: "  " }), _jsxs(Text, { color: theme.value, children: [row.selection.host, "  "] }), version === undefined ? _jsx(Text, { color: theme.warning, children: row.installed }) : _jsxs(_Fragment, { children: [_jsx(Text, { color: theme.value, children: installedPrefix }), _jsx(Text, { color: theme.version, children: version }), _jsx(Text, { color: theme.value, children: installedSuffix })] }), _jsx(Text, { color: theme.value, children: "  available " }), _jsx(Text, { color: row.available === "unknown" ? theme.warning : theme.version, children: row.available }), _jsxs(Text, { color: theme.warning, children: ["  ", status] }), row.updateReason === undefined ? null : _jsxs(Text, { color: theme.warning, children: ["  ", row.updateReason] }), row.drift === undefined ? null : _jsxs(Text, { color: theme.warning, children: ["  drift: ", row.drift] })] }));
 }
 /** One line of the Installations tree: cursor, indent, mark box, label and the leaf's details. */
 export function TreeRowLine({ row, selected, marked }) {

package/dist/src/tui/manage-actions.js

@@ -139,7 +139,9 @@ function handleConfirmKey(context, mode, input, key) {
             answerYesNo(input, key, () => {
                 void execute(context, `Removing ${mode.skill.name}…`, async () => {
                     await runUninstall(mode.prepared, operations, env);
-                    return `Removed ${mode.skill.name} (${mode.skill.path})`;
+                    return mode.prepared.plan.inspections.every((inspection) => inspection.recordOnly)
+                        ? `Forgot missing installation record for ${mode.skill.path}; no files were removed`
+                        : `Removed ${mode.skill.name} (${mode.skill.path})`;
                 });
             }, cancelWith("Uninstall cancelled"));
             return;

package/dist/src/tui/package-rows.js

@@ -1,10 +1,13 @@
 import { classifyUpdate } from "../package-host-plans.js";
 import { describeCoordinates, } from "../package-model.js";
 /** Version evidence as a short label; `unknown` when the host or the bundle states none. */
-export function packageVersionLabel(evidence) {
+export function packageVersionLabel(evidence, commit) {
     if (evidence === undefined)
         return "unknown";
-    return evidence.kind === "manifest-version" ? evidence.version : evidence.commit.slice(0, 7);
+    return evidence.kind === "manifest-version" ? versionWithCommit(evidence.version, commit) : evidence.commit.slice(0, 7);
+}
+function versionWithCommit(version, commit) {
+    return `${version}${commit === undefined ? "" : ` (${commit.slice(0, 7)})`}`;
 }
 /** What the host reports about an install, as one phrase. Never a guess. */
 export function installedEvidenceLabel(evidence) {
@@ -12,7 +15,7 @@ export function installedEvidenceLabel(evidence) {
         case "installed": {
             if (evidence.version !== undefined) {
                 const qualifier = evidence.reason === undefined ? "" : " (HEAD; local changes)";
-                return `installed ${evidence.version}${qualifier}`;
+                return `installed ${versionWithCommit(evidence.version, evidence.commit)}${qualifier}`;
             }
             if (evidence.reason !== undefined) {
                 const reason = evidence.reason.includes("local modifications") ? "local changes" : evidence.reason;
@@ -52,17 +55,18 @@ export function packageRow(record, inspection) {
         name: inspection.descriptor?.name ?? describeCoordinates(record.selection),
         installed: installedEvidenceLabel(inspection.installed),
         ...(inspection.installed.kind === "installed" && inspection.installed.version !== undefined
-            ? { installedVersion: inspection.installed.version }
+            ? { installedVersion: versionWithCommit(inspection.installed.version, inspection.installed.commit) }
             : inspection.installed.kind === "installed" && inspection.installed.commit !== undefined
                 ? { installedVersion: inspection.installed.commit.slice(0, 7) }
                 : {}),
-        available: packageVersionLabel(inspection.available),
-        status: packageRowStatus(inspection),
+        available: packageVersionLabel(inspection.available, inspection.availableCommit),
+        status: packageRowStatus(record.selection, inspection),
+        ...(inspection.updateReason === undefined ? {} : { updateReason: inspection.updateReason }),
         ...(inspection.drift === undefined ? {} : { drift: inspection.drift }),
     };
 }
-function packageRowStatus(inspection) {
-    const status = classifyUpdate(inspection.installed, inspection.available, inspection.availableCommit, inspection.installedCommitIsAncestor);
+function packageRowStatus(selection, inspection) {
+    const status = classifyUpdate(inspection.installed, inspection.available, inspection.availableCommit, inspection.installedCommitIsAncestor, selection.host);
     if (status === "unknown") {
         return {
             kind: "unknown",

package/dist/src/tui/updates-panel.js

@@ -24,7 +24,7 @@ function updateResultField(line, defaultOk) {
 /** What the last check found out: its age, how the sources were refreshed, and what failed. */
 export function CheckStatus({ data, now }) {
     const errors = data.results.filter((result) => result.error !== undefined);
-    return (_jsxs(BorderPanel, { title: "Update check", children: [_jsxs(Text, { color: theme.field, children: ["checked ", _jsx(Text, { color: theme.value, children: formatAgo(now - data.checkedAt) }), _jsx(Text, { color: theme.legend, children: " \u00B7 " }), _jsx(Text, { color: theme.value, children: describeRefresh(data) })] }), data.refresh.failed.map((failure) => (_jsxs(Text, { children: [_jsx(Text, { color: theme.warning, children: "[WARN] " }), _jsx(FieldLine, { label: "Refresh failed for", value: `${failure.source}: ${failure.reason}` })] }, failure.source))), data.appError ? _jsxs(Text, { children: [_jsx(Text, { color: theme.error, children: "[FAIL] " }), _jsx(FieldLine, { label: "Error (Apps):", value: data.appError })] }) : null, data.packageError ? _jsxs(Text, { children: [_jsx(Text, { color: theme.error, children: "[FAIL] " }), _jsx(FieldLine, { label: "Error (Packages):", value: data.packageError })] }) : null, errors.map((result) => _jsxs(Text, { children: [_jsx(Text, { color: theme.error, children: "[FAIL] " }), _jsx(FieldLine, { label: `Error (${result.scope}):`, value: result.error ?? "" })] }, result.scope))] }));
+    return (_jsxs(BorderPanel, { title: "Update check", children: [_jsxs(Text, { color: theme.field, children: ["checked ", _jsx(Text, { color: theme.value, children: formatAgo(now - data.checkedAt) }), _jsx(Text, { color: theme.legend, children: " \u00B7 " }), _jsx(Text, { color: theme.value, children: describeRefresh(data) })] }), data.refresh.failed.map((failure) => (_jsxs(Text, { children: [_jsx(Text, { color: theme.warning, children: "[WARN] " }), _jsx(FieldLine, { label: "Refresh failed for", value: `${failure.source}: ${failure.reason}` })] }, failure.source))), data.appError ? _jsxs(Text, { children: [_jsx(Text, { color: theme.error, children: "[FAIL] " }), _jsx(FieldLine, { label: "Error (Apps):", value: data.appError })] }) : null, data.rows.filter(row => row.kind === "package" && row.check.status === "current" && row.check.reason !== undefined).map(row => (_jsxs(Text, { color: theme.warning, children: [row.path, ": ", row.reason] }, row.key))), data.packageError ? _jsxs(Text, { children: [_jsx(Text, { color: theme.error, children: "[FAIL] " }), _jsx(FieldLine, { label: "Error (Packages):", value: data.packageError })] }) : null, errors.map((result) => _jsxs(Text, { children: [_jsx(Text, { color: theme.error, children: "[FAIL] " }), _jsx(FieldLine, { label: `Error (${result.scope}):`, value: result.error ?? "" })] }, result.scope))] }));
 }
 /** One line of the list: an update, the fold of unassessable items, or one of those when unfolded. */
 export function EntryLine({ entry, selected, checked, view, showUnknown }) {

package/dist/src/tui/updates.js

@@ -141,8 +141,10 @@ export async function loadUpdateRows(operations, environment, options) {
             check,
             path: `Package: ${describeCoordinates(check.installed.selection)}`,
             policy: formatVersionPolicy(check.installed.selection.version),
-            installed: recordedVersionLabel(check.installed),
-            available: check.available === undefined ? "?" : packageVersionLabel(check.available),
+            installed: check.observed === undefined
+                ? `${recordedVersionLabel(check.installed)} (recorded)`
+                : installedEvidenceLabel(check.observed).replace(/^installed (?:at )?/, ""),
+            available: check.available === undefined ? "?" : packageVersionLabel(check.available, check.availableCommit),
             status: packageStatusLabel(check.status),
             reason: check.reason ?? "the host reports no usable version evidence",
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iseoane/agent-depot",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "description": "A cross-platform catalog for reusable coding-agent skills.",
   "license": "MIT",
   "author": "iseoane",