skillshop 4.0.0 → 4.1.0

package/src/legacy-cli.js

@@ -27,6 +27,10 @@ import {
   validatePersonalSkillDirectory
 } from './personal-library.js';
 import { downloadPersonalSkill, GitHubLibraryError } from './github-library.js';
+import {
+  assertRegularPath, readInstallationManifest, writeInstallationManifest,
+  readInstallationIndex, registerInstallationDirectory, sameOwner
+} from './installation-state.js';
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const skillsContentRoot = path.join(packageRoot, 'skills-content');
@@ -60,7 +64,82 @@ function lockPathFor(root) {
 }
 
 function hasLock(root) {
-  return fs.existsSync(path.join(root, lockFileName)) || fs.existsSync(path.join(root, legacyLockFileName));
+  return fs.existsSync(path.join(root, lockFileName)) || fs.existsSync(path.join(root, legacyLockFileName)) ||
+    installationDirectories(root).some((directory) => fs.existsSync(path.join(directory, lockFileName)));
+}
+
+function installationDirectories(root = null) {
+  const base = root ?? os.homedir();
+  const directories = agentOptions.map((agent) => path.join(base, root ? agent.local : agent.global));
+  for (const item of readInstallationIndex(skillshopHome())) {
+    if (root ? item.scope === 'project' && canonicalPath(item.root) === canonicalPath(root) : item.scope === 'global') {
+      assertLocalDestination(base, item.directory, 'indexed installation directory');
+      directories.push(item.directory);
+    }
+  }
+  return [...new Set(directories.map((directory) => path.resolve(directory)))];
+}
+
+function cliOwner(root = null) {
+  return { kind: 'skillshop', id: root ? 'project' : 'global' };
+}
+
+function installationManifestExists(directory) {
+  try { fs.lstatSync(path.join(directory, lockFileName)); return true; }
+  catch (error) { if (error.code === 'ENOENT') return false; throw error; }
+}
+
+function directoryOwnedEntries(root = null) {
+  const result = [];
+  for (const directory of installationDirectories(root)) {
+    if (!installationManifestExists(directory)) continue;
+    for (const [name, entry] of Object.entries(readInstallationManifest(directory).skills)) {
+      if (sameOwner(entry.owner, cliOwner(root))) result.push({ name, entry, target: path.join(directory, name) });
+    }
+  }
+  return result;
+}
+
+function saveDirectoryOwnership(root, lock) {
+  const owner = cliOwner(root);
+  const directories = new Set(installationDirectories(root));
+  const wanted = new Map();
+  for (const [name, entry] of Object.entries(lock.skills)) {
+    const targets = root ? lockedTargets(root, name, entry) : globalTargets(name, entry);
+    for (const target of targets) {
+      assertRegularPath(path.dirname(target));
+      const directory = path.dirname(target);
+      directories.add(directory);
+      const metadata = root ? entry : { ...entry, ...entry.copies?.[target] };
+      const copy = { owner, ...(typeof metadata.version === 'string' ? { version: metadata.version } : {}),
+        ...(typeof metadata.author === 'string' ? { author: metadata.author } : {}),
+        ...(metadata.source ? { source: metadata.source } : {}) };
+      if (!wanted.has(directory)) wanted.set(directory, {});
+      wanted.get(directory)[name] = copy;
+    }
+  }
+  // Validate every directory before changing ownership in any of them.
+  const planned = [];
+  for (const directory of directories) {
+    if (!wanted.has(directory) && !installationManifestExists(directory)) continue;
+    const manifest = readInstallationManifest(directory);
+    const skills = Object.fromEntries(Object.entries(manifest.skills).filter(([, entry]) => !sameOwner(entry.owner, owner)));
+    for (const [name, entry] of Object.entries(wanted.get(directory) ?? {})) {
+      if (skills[name]) throw new CliError(`${path.join(directory, name)} is owned by ${skills[name].owner.kind}:${skills[name].owner.id}`);
+      skills[name] = entry;
+    }
+    if (Object.keys(skills).length || fs.existsSync(path.join(directory, lockFileName))) planned.push({ directory, manifest: { manifestVersion: 1, skills } });
+  }
+  for (const { directory, manifest } of planned) {
+    writeInstallationManifest(directory, manifest);
+    registerInstallationDirectory(directory, { root, home: skillshopHome() });
+  }
+  const legacyFiles = root ? [path.join(root, lockFileName), path.join(root, legacyLockFileName)]
+    : [path.join(skillshopHome(), globalSkillsFileName)];
+  for (const file of legacyFiles) {
+    assertRegularPath(file);
+    fs.rmSync(file, { force: true });
+  }
 }
 const agentOptions = [
   { id: 'copilot', label: 'Copilot', local: '.github/skills', global: '.copilot/skills' },
@@ -353,20 +432,38 @@ function emptyLock() {
 
 function readLock(root) {
   const lockPath = lockPathFor(root);
-  if (!fs.existsSync(lockPath)) return emptyLock();
-
-  let lock;
-  try {
-    lock = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
-  } catch (error) {
-    throw new CliError(`cannot parse ${lockPath}: ${error.message}`);
+  let lock = emptyLock();
+  if (fs.existsSync(lockPath)) {
+    assertRegularPath(lockPath);
+    const olderPath = path.join(root, legacyLockFileName);
+    if (lockPath !== olderPath && fs.existsSync(olderPath)) {
+      assertRegularPath(olderPath);
+      if (!fs.readFileSync(lockPath).equals(fs.readFileSync(olderPath))) {
+        throw new CliError(`${root} has conflicting .skillshop-lock and .skillz-lock records; reconcile them before migrating`);
+      }
+    }
+    try { lock = JSON.parse(fs.readFileSync(lockPath, 'utf8')); }
+    catch (error) { throw new CliError(`cannot parse ${lockPath}: ${error.message}`); }
+    if (![1, 2].includes(lock?.lockfileVersion) || lock.registry !== 'local' ||
+        !lock.skills || typeof lock.skills !== 'object' || Array.isArray(lock.skills)) {
+      throw new CliError(`${lockPath} is not a supported skillshop lockfile`);
+    }
+    for (const [name, entry] of Object.entries(lock.skills)) {
+      for (const target of lockedTargets(root, name, entry)) {
+        assertRegularPath(target);
+        const claim = readInstallationManifest(path.dirname(target)).skills[name];
+        if (claim && !sameOwner(claim.owner, cliOwner(root))) throw new CliError(`${target} is owned by ${claim.owner.kind}:${claim.owner.id}`);
+      }
+    }
   }
-
-  if (![1, 2].includes(lock?.lockfileVersion) || lock.registry !== 'local' ||
-      !lock.skills || typeof lock.skills !== 'object' || Array.isArray(lock.skills)) {
-    throw new CliError(`${lockPath} is not a supported skillshop lockfile`);
+  for (const { name, entry, target } of directoryOwnedEntries(root)) {
+    const { owner, ...metadata } = entry;
+    const previous = lock.skills[name];
+    if (previous && JSON.stringify(previous.source ?? null) !== JSON.stringify(metadata.source ?? null)) {
+      throw new CliError(`${name} has conflicting installation sources in ${root}`);
+    }
+    lock.skills[name] = { ...metadata, paths: [...new Set([...(previous?.paths ?? (previous?.path ? [previous.path] : [])), relativePath(root, target)])] };
   }
-
   return lock;
 }
 
@@ -410,23 +507,8 @@ function localSkillDirectories(root, lock, cwd) {
 }
 
 function writeLock(root, lock) {
-  const skills = Object.fromEntries(
-    Object.entries(lock.skills)
-      .sort(([left], [right]) => left.localeCompare(right))
-      .map(([name, entry]) => [name, {
-        ...(typeof entry.version === 'string' ? { version: entry.version } : {}),
-        ...(typeof entry.author === 'string' ? { author: entry.author } : {}),
-        ...(entry.source ? { source: entry.source } : {}),
-        paths: lockedTargets(root, name, entry).map((target) => relativePath(root, target)).sort()
-      }])
-  );
-  const stableLock = { lockfileVersion: 2, registry: 'local', skills };
-  const lockPath = path.join(root, lockFileName);
-  const contents = `${JSON.stringify(stableLock, null, 2)}\n`;
-  if (fs.existsSync(lockPath) && fs.readFileSync(lockPath, 'utf8') === contents) return;
-  const temporaryPath = `${lockPath}.tmp-${process.pid}`;
-  fs.writeFileSync(temporaryPath, contents);
-  fs.renameSync(temporaryPath, lockPath);
+  saveDirectoryOwnership(root, lock);
+  syncGitExclude(root, lock);
 }
 
 function registryPath() {
@@ -497,9 +579,14 @@ function staleTargets(previousTargets, targetDirs) {
   return previousTargets.filter((target) => !destinations.has(canonicalDestination(target)));
 }
 
-function assertTargetsAvailable(name, targetDirs, previousTargets) {
+function assertTargetsAvailable(name, targetDirs, previousTargets, root) {
   const managedDestinations = new Set(previousTargets.map(canonicalDestination));
   for (const targetDir of targetDirs) {
+    assertRegularPath(targetDir);
+    const claim = readInstallationManifest(path.dirname(targetDir)).skills[name];
+    if (claim && !sameOwner(claim.owner, cliOwner(root))) {
+      throw new CliError(`${targetDir} is owned by ${claim.owner.kind}:${claim.owner.id}`);
+    }
     if (fs.existsSync(targetDir) && !managedDestinations.has(canonicalDestination(targetDir))) {
       throw new CliError(`${targetDir} exists and is not managed as ${name} in ${lockFileName}`);
     }
@@ -538,7 +625,11 @@ function managedGitPaths(root, lock) {
   const gitRoot = canonicalPath(gitOutput(root, ['rev-parse', '--show-toplevel']));
   const scope = relativePath(gitRoot, canonicalPath(root));
   const scopedPath = (target) => relativePath(gitRoot, path.join(root, target));
-  const paths = [scopedPath(lockFileName)];
+  const paths = [];
+  if (fs.existsSync(path.join(root, lockFileName))) paths.push(scopedPath(lockFileName));
+  for (const directory of installationDirectories(root)) {
+    if (fs.existsSync(path.join(directory, lockFileName))) paths.push(relativePath(gitRoot, path.join(directory, lockFileName)));
+  }
   if (fs.existsSync(path.join(root, legacyLockFileName))) paths.push(scopedPath(legacyLockFileName));
 
   for (const [name, entry] of Object.entries(lock.skills)) {
@@ -679,16 +770,34 @@ function repairInstalledManifest(name, entry, manifestPath) {
 
 function readGlobalSkills() {
   const filePath = path.join(skillshopHome(), globalSkillsFileName);
-  if (!fs.existsSync(filePath)) return emptyLock();
-  let lock;
-  try {
-    lock = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch (error) {
-    throw new CliError(`cannot parse ${filePath}: ${error.message}`);
+  let lock = emptyLock();
+  if (fs.existsSync(filePath)) {
+    assertRegularPath(filePath);
+    try { lock = JSON.parse(fs.readFileSync(filePath, 'utf8')); }
+    catch (error) { throw new CliError(`cannot parse ${filePath}: ${error.message}`); }
+    if (lock?.lockfileVersion !== 2 || lock.registry !== 'local' ||
+        !lock.skills || typeof lock.skills !== 'object' || Array.isArray(lock.skills)) {
+      throw new CliError(`${filePath} is not a supported skillshop global manifest`);
+    }
+    for (const [name, entry] of Object.entries(lock.skills)) {
+      for (const target of globalTargets(name, entry)) {
+        assertRegularPath(target);
+        const claim = readInstallationManifest(path.dirname(target)).skills[name];
+        if (claim && !sameOwner(claim.owner, cliOwner())) throw new CliError(`${target} is owned by ${claim.owner.kind}:${claim.owner.id}`);
+      }
+    }
   }
-  if (lock?.lockfileVersion !== 2 || lock.registry !== 'local' ||
-      !lock.skills || typeof lock.skills !== 'object' || Array.isArray(lock.skills)) {
-    throw new CliError(`${filePath} is not a supported skillshop global manifest`);
+  for (const { name, entry, target } of directoryOwnedEntries()) {
+    const { owner, ...metadata } = entry;
+    const previous = lock.skills[name] ?? { paths: [], copies: {} };
+    const oldCopy = previous.copies?.[target];
+    if (oldCopy && JSON.stringify(oldCopy.source ?? previous.source ?? null) !== JSON.stringify(metadata.source ?? null)) {
+      throw new CliError(`${name} has conflicting global installation sources`);
+    }
+    previous.paths = [...new Set([...previous.paths, target])];
+    previous.copies ??= {};
+    previous.copies[target] = metadata;
+    lock.skills[name] = previous;
   }
   return lock;
 }
@@ -709,24 +818,7 @@ function globalTargets(name, entry) {
 }
 
 function writeGlobalSkills(lock) {
-  const skills = Object.fromEntries(Object.entries(lock.skills).sort(([left], [right]) => left.localeCompare(right))
-    .map(([name, entry]) => {
-      const paths = globalTargets(name, entry).sort();
-      return [name, {
-        ...(typeof entry.version === 'string' ? { version: entry.version } : {}),
-        ...(typeof entry.author === 'string' ? { author: entry.author } : {}),
-        ...(entry.source ? { source: entry.source } : {}),
-        paths,
-        copies: Object.fromEntries(paths.map((target) => [target, entry.copies?.[target] ?? {}]))
-      }];
-    }));
-  const filePath = path.join(skillshopHome(), globalSkillsFileName);
-  const contents = `${JSON.stringify({ ...emptyLock(), skills }, null, 2)}\n`;
-  if (fs.existsSync(filePath) && fs.readFileSync(filePath, 'utf8') === contents) return;
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  const temporaryPath = `${filePath}.tmp-${process.pid}`;
-  fs.writeFileSync(temporaryPath, contents);
-  fs.renameSync(temporaryPath, filePath);
+  saveDirectoryOwnership(null, lock);
 }
 
 function repairTrackedSkills(root, lock) {
@@ -771,7 +863,7 @@ function reconcileRepository(root, { register = true } = {}) {
 }
 
 function reconcileCurrentRepository() {
-  if (fs.existsSync(path.join(skillshopHome(), globalSkillsFileName))) {
+  if (fs.existsSync(path.join(skillshopHome(), globalSkillsFileName)) || installationDirectories().some((directory) => fs.existsSync(path.join(directory, lockFileName)))) {
     const globalSkills = readGlobalSkills();
     repairTrackedSkills(null, globalSkills);
     writeGlobalSkills(globalSkills);
@@ -1171,13 +1263,13 @@ function syncPersonalCopies(cwd) {
   }
 
   for (const context of contexts) {
-    if (context.kind === 'project' && JSON.stringify(context.lock) !== context.original) {
+    if (context.kind === 'project' && (JSON.stringify(context.lock) !== context.original || fs.existsSync(lockPathFor(context.root)))) {
       try { writeLock(context.root, context.lock); }
       catch (error) { failures.push(`project ${context.root} state: ${error.message}`); }
     }
   }
 
-  if (globalLock && JSON.stringify(globalLock) !== contexts.find(({ kind }) => kind === 'global')?.original) {
+  if (globalLock && (JSON.stringify(globalLock) !== contexts.find(({ kind }) => kind === 'global')?.original || fs.existsSync(path.join(skillshopHome(), globalSkillsFileName)))) {
     try { writeGlobalSkills(globalLock); }
     catch (error) { failures.push(`global state: ${error.message}`); }
   }
@@ -1283,9 +1375,11 @@ function installGlobal(name, requestedVersion) {
       assertNoManagedSymlink(os.homedir(), targetDir, `global install destination for ${name}`);
       assertInstallPathsDoNotOverlap(metadata.sourceDir, targetDir);
     }
-    if (metadata.kind === 'personal' && fs.existsSync(targetDir) && !managedTargets.has(canonicalDestination(targetDir))) {
+    if (fs.existsSync(targetDir) && !managedTargets.has(canonicalDestination(targetDir))) {
       throw new CliError(`${targetDir} exists and is not a Skillshop-managed copy of ${name}`);
     }
+    const claim = readInstallationManifest(skillDirectory).skills[name];
+    if (claim && !sameOwner(claim.owner, cliOwner())) throw new CliError(`${targetDir} is owned by ${claim.owner.kind}:${claim.owner.id}`);
     return { skillDirectory, targetDir };
   });
   for (const { skillDirectory, targetDir } of targetPairs) {
@@ -1536,7 +1630,7 @@ function installLocal(name, requestedVersion, cwd) {
     );
   }
   for (const { metadata, targetDirs, previousTargets } of installs) {
-    assertTargetsAvailable(metadata.name, targetDirs, previousTargets);
+    assertTargetsAvailable(metadata.name, targetDirs, previousTargets, root);
     for (const targetDir of targetDirs) {
       if (metadata.kind === 'personal') {
         assertNoManagedSymlink(root, targetDir, `install destination for ${metadata.name}`);
@@ -1561,31 +1655,26 @@ function installLocal(name, requestedVersion, cwd) {
 
   writeLock(root, lock);
   maintainRepository(root, lock);
-  console.log(`Wrote ${path.join(root, lockFileName)}`);
+  console.log(`Wrote installation manifests for ${root}`);
 }
 
 function uninstallGlobal(name) {
-  const config = readConfig();
-  const skillDirectories = config
-    ? configuredSkillDirectories(config, 'global')
-    : [path.join(os.homedir(), '.agents', 'skills')];
-  const targets = skillDirectories.map((directory) => path.join(directory, name));
-  const installedTargets = targets.filter((target) => fs.existsSync(target));
-  if (installedTargets.length === 0) {
-    throw new CliError(`${name} is not installed globally in the configured skill directories`);
-  }
-
-  for (const targetDir of installedTargets) {
-    fs.rmSync(targetDir, { recursive: true });
-    console.log(`Uninstalled ${name} from ${targetDir}`);
-  }
   const globalSkills = readGlobalSkills();
-  if (globalSkills.skills[name]) {
-    const remaining = staleTargets(globalTargets(name, globalSkills.skills[name]), installedTargets);
-    if (remaining.length) globalSkills.skills[name].paths = remaining;
-    else delete globalSkills.skills[name];
-    writeGlobalSkills(globalSkills);
+  const entry = globalSkills.skills[name];
+  if (!entry) throw new CliError(`${name} is not a Skillshop-managed global installation`);
+  const config = readConfig();
+  const directories = config ? configuredSkillDirectories(config, 'global') : [path.join(os.homedir(), '.agents', 'skills')];
+  const targets = globalTargets(name, entry).filter((target) => directories.includes(path.dirname(target)));
+  if (!targets.length) throw new CliError(`${name} is not installed globally in the configured skill directories`);
+  for (const target of targets) assertRegularPath(target);
+  for (const target of targets) {
+    fs.rmSync(target, { recursive: true, force: true });
+    console.log(`Uninstalled ${name} from ${target}`);
   }
+  const remaining = globalTargets(name, entry).filter((target) => !targets.includes(target));
+  if (remaining.length) entry.paths = remaining;
+  else delete globalSkills.skills[name];
+  writeGlobalSkills(globalSkills);
 }
 
 function uninstallLocal(name, cwd) {
@@ -1604,7 +1693,7 @@ function uninstallLocal(name, cwd) {
   maintainRepository(root, lock);
 
   for (const targetDir of targetDirs) console.log(`Uninstalled ${name} from ${targetDir}`);
-  console.log(`Updated ${path.join(root, lockFileName)}`);
+  console.log(`Updated installation manifests for ${root}`);
 }
 
 function updateLocal(requestedName, cwd, options = {}) {
@@ -1632,7 +1721,7 @@ function updateLocal(requestedName, cwd, options = {}) {
     return { metadata, targetDirs, previousTargets };
   });
   for (const { metadata, targetDirs, previousTargets } of updates) {
-    assertTargetsAvailable(metadata.name, targetDirs, previousTargets);
+    assertTargetsAvailable(metadata.name, targetDirs, previousTargets, root);
     for (const targetDir of targetDirs) {
       if (metadata.kind === 'personal') {
         assertNoManagedSymlink(root, targetDir, `update destination for ${metadata.name}`);
@@ -1654,7 +1743,7 @@ function updateLocal(requestedName, cwd, options = {}) {
 
   writeLock(root, lock);
   maintainRepository(root, lock, options);
-  console.log(`Updated ${path.join(root, lockFileName)}`);
+  console.log(`Updated installation manifests for ${root}`);
 }
 
 function updateAllRepositories() {
@@ -1861,6 +1950,7 @@ function refreshManagedCopies(scope) {
     } else {
       try {
         const lock = readLock(owner.root);
+        if (fs.existsSync(lockPathFor(owner.root))) writeLock(owner.root, lock);
         refreshManagedLock(owner.root, lock, { summary });
       } catch (error) {
         summary.failed.push(`${owner.root}: ${error.message}`);
@@ -1869,6 +1959,7 @@ function refreshManagedCopies(scope) {
   } else if (scope === 'global') {
     try {
       const globalLock = readGlobalSkills();
+      if (fs.existsSync(path.join(skillshopHome(), globalSkillsFileName))) writeGlobalSkills(globalLock);
       refreshManagedLock(null, globalLock, { global: true, summary });
     } catch (error) {
       summary.failed.push(`global managed copies: ${error.message}`);
@@ -1880,6 +1971,7 @@ function refreshManagedCopies(scope) {
         if (!hasLock(root)) continue;
         try {
           const lock = readLock(root);
+          if (fs.existsSync(lockPathFor(root))) writeLock(root, lock);
           refreshManagedLock(root, lock, { summary });
         } catch (error) {
           summary.failed.push(`${root}: ${error.message}`);
@@ -1922,11 +2014,18 @@ function discoverLockRoots(startPath, roots) {
   }
 
   if (stat.isFile()) {
+    if (path.basename(startPath) === lockFileName) {
+      try { if (JSON.parse(fs.readFileSync(startPath, 'utf8')).manifestVersion === 1) return; } catch {}
+    }
     if ([lockFileName, legacyLockFileName].includes(path.basename(startPath))) roots.add(canonicalPath(path.dirname(startPath)));
     return;
   }
   if (!stat.isDirectory()) return;
 
+  // An installation manifest is not a nested project ownership file.
+  if (path.basename(startPath) === 'skills' && fs.existsSync(path.join(startPath, lockFileName))) {
+    try { if (JSON.parse(fs.readFileSync(path.join(startPath, lockFileName), 'utf8')).manifestVersion === 1) return; } catch {}
+  }
   if (hasLock(startPath)) roots.add(canonicalPath(startPath));
 
   let entries;

package/src/user-install.js

@@ -1,8 +1,9 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { importSkill } from './import.js';
+import { importSkill, resolveSkill } from './import.js';
 import { normalizeSkillSpecifier, skillName } from './specifier.js';
+import { assertInstallationOwner, assertRegularPath, readInstallationManifest, writeInstallationManifest, sameOwner } from './installation-state.js';
 
 function declaredUserSkills(packageRoot) {
   const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
@@ -30,6 +31,7 @@ export async function installUserSkill({
     targetDir: path.resolve(userSkillsDir, skillName(normalized)),
     cwd,
     overwrite: true,
+    ownerKind: 'package',
   });
 }
 
@@ -40,9 +42,40 @@ export async function installDeclaredUserSkills({
 } = {}) {
   const packageRoot = path.resolve(cwd, library);
   const declared = declaredUserSkills(packageRoot);
+  const directory = path.resolve(userSkillsDir ?? path.join(os.homedir(), '.agents', 'skills'));
+  const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+  const owner = { kind: 'package', id: pkg.name || packageRoot };
+  // Check the complete declaration before copying its first skill.
+  for (const specifier of declared) {
+    const skill = await resolveSkill({ library: packageRoot, specifier, cwd });
+    assertInstallationOwner(directory, skill.name, owner);
+  }
+  const keep = new Set(declared.map(skillName));
+  const obsolete = Object.entries(readInstallationManifest(directory).skills)
+    .filter(([name, entry]) => sameOwner(entry.owner, owner) && !keep.has(name)).map(([name]) => name);
+  for (const name of obsolete) assertRegularPath(path.join(directory, name));
   const results = [];
   for (const specifier of declared) {
     results.push(await installUserSkill({ library: packageRoot, specifier, cwd, userSkillsDir }));
   }
+  if (obsolete.length) {
+    const manifest = readInstallationManifest(directory);
+    for (const name of obsolete) {
+      fs.rmSync(path.join(directory, name), { recursive: true, force: true });
+      delete manifest.skills[name];
+    }
+    writeInstallationManifest(directory, manifest);
+  }
   return results;
 }
+
+export function uninstallUserSkill({ library, specifier, cwd = process.cwd(), userSkillsDir = path.join(os.homedir(), '.agents', 'skills') }) {
+  const packageRoot = path.resolve(cwd, library);
+  const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+  const name = skillName(normalizeSkillSpecifier(specifier));
+  const directory = path.resolve(userSkillsDir);
+  const manifest = assertInstallationOwner(directory, name, { kind: 'package', id: pkg.name || packageRoot }, { requireOwned: true });
+  fs.rmSync(path.join(directory, name), { recursive: true, force: true });
+  delete manifest.skills[name];
+  writeInstallationManifest(directory, manifest);
+}

package/templates/skillshop-library/README.md

@@ -36,3 +36,5 @@ skillshop sync                         # update recorded local and global copies
 `sync` is also the explicit migration step for tracked copies made by older bundled Skillshop installs; `library init` never migrates. A source already in the selected library wins and updates the tracked copies. If the source is missing, Skillshop imports it only when every surviving tracked project and global copy agrees in paths, file bytes, and modes. Conflicts, unknown source kinds, malformed ownership state, unmanaged directories, and package-import snapshots are preserved and reported. Missing recorded destinations are pruned, never recreated.
 
 The `skillsDirectory` field can name another safe relative directory inside this library. Set it to `.` to use skill folders directly in the library root.
+
+Installation ownership is recorded in `.skillshop-lock` inside each destination skills directory, not at the library or project root. Project dependency declarations (`skillshop.json`) and their reproducibility lock (`skillshop-lock.json`) are a separate opt-in workflow.