skillshop 2.2.0 → 4.1.0

package/src/legacy-cli.js

@@ -14,6 +14,23 @@ import {
   composeAgentsInstructions,
   hasProjectInstructions
 } from './agents-instructions.js';
+import {
+  PersonalLibraryError,
+  importTrackedPersonalSkill,
+  inspectPersonalLibrary,
+  initPersonalLibrary,
+  librarySelectionFileName,
+  listPersonalSkills,
+  resolvePersonalSkill,
+  resolveRecordedPersonalSkill,
+  selectedLibraryRoot,
+  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');
@@ -33,6 +50,7 @@ const projectTemplateName = 'AGENTS.template.md';
 const defaultProjectTemplate = '# Project instructions\n\n{{ blocks }}\n';
 const internalUpgradeRefreshCommand = '__skillshop_upgrade_refresh';
 const internalUpgradeRefreshToken = 'skillshop-managed-upgrade-v1';
+const personalLibraryTemplateRoot = path.join(packageRoot, 'templates', 'skillshop-library');
 const globalAgentsTargets = [
   path.join('.codex', 'AGENTS.md'),
   path.join('.agents', 'AGENTS.md'),
@@ -46,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' },
@@ -129,9 +222,16 @@ function printHelp() {
   skillshop update [name]
   skillshop update --push
   skillshop migrate [root ...]
+  skillshop library init [directory]
+  skillshop library list
+  skillshop download @<owner>/<skill> [--force]
+  skillshop install @<owner>/<skill> [--global]
+  skillshop sync
   skillshop list
 
 Install, uninstall, and update skills from the local registry.
+Personal folder libraries are the source of truth for user-authored skills. Initialize or select one with skillshop library init [directory], list it with skillshop library list, download a source with skillshop download @owner/skill, and install it with skillshop install @owner/skill. Bare names install from the selected library.
+skillshop sync propagates personal source edits and removals without fetching upstream. It can also adopt tracked legacy bundled copies into the selected library when all surviving copies agree; init itself never migrates.
 
 Agent instructions:
   skillshop agents init creates a neutral .agents/instructions/AGENTS.template.md and renders it into a separate managed region in the project-root AGENTS.md. Existing text and prior managed guidance are preserved. Edit the template and sibling *.block.md sources, not the generated region.
@@ -332,19 +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 || 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;
 }
 
@@ -388,22 +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, {
-        version: entry.version,
-        author: entry.author,
-        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() {
@@ -474,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}`);
     }
@@ -515,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)) {
@@ -656,15 +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 || 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;
 }
@@ -685,18 +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, { 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) {
@@ -709,7 +831,12 @@ function repairTrackedSkills(root, lock) {
       delete lock.skills[name];
       continue;
     }
+    if (root && entry.source?.kind === 'personal-library') {
+      entry.paths = targets.map((target) => relativePath(root, target));
+      continue;
+    }
     for (const target of targets) {
+      if (!root && entry.copies?.[target]?.source?.kind === 'personal-library') continue;
       const manifestPath = path.join(target, 'SKILL.md');
       assertLocalDestination(root ?? os.homedir(), manifestPath, `manifest for ${name}`);
       const installation = root ? entry : entry.copies?.[target] ?? {};
@@ -736,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);
@@ -753,35 +880,480 @@ function reconcileCurrentRepository() {
 
 function replaceSkillDirectory(sourceDir, targetDir) {
   const temporaryDir = `${targetDir}.skillshop-tmp-${process.pid}`;
+  const backupDir = `${targetDir}.skillshop-backup-${process.pid}`;
   fs.mkdirSync(path.dirname(targetDir), { recursive: true });
   fs.rmSync(temporaryDir, { recursive: true, force: true });
+  fs.rmSync(backupDir, { recursive: true, force: true });
   fs.cpSync(sourceDir, temporaryDir, { recursive: true, force: true });
-  fs.rmSync(targetDir, { recursive: true, force: true });
-  fs.renameSync(temporaryDir, targetDir);
+  const hadTarget = fs.existsSync(targetDir);
+  try {
+    if (hadTarget) fs.renameSync(targetDir, backupDir);
+    fs.renameSync(temporaryDir, targetDir);
+    fs.rmSync(backupDir, { recursive: true, force: true });
+  } catch (error) {
+    if (hadTarget && !fs.existsSync(targetDir) && fs.existsSync(backupDir)) fs.renameSync(backupDir, targetDir);
+    throw error;
+  } finally {
+    fs.rmSync(temporaryDir, { recursive: true, force: true });
+  }
+}
+
+function personalTreeSnapshot(root, label) {
+  const entries = [];
+  const visit = (directory, relative = '') => {
+    const stat = fs.lstatSync(directory);
+    if (stat.isSymbolicLink()) throw new CliError(`${label} contains a symlink: ${directory}`);
+    if (stat.isDirectory()) {
+      entries.push({ path: relative, kind: 'directory', mode: stat.mode & 0o777 });
+      for (const name of fs.readdirSync(directory).sort()) {
+        visit(path.join(directory, name), relative ? `${relative}/${name}` : name);
+      }
+      return;
+    }
+    if (!stat.isFile()) throw new CliError(`${label} contains a non-regular entry: ${directory}`);
+    entries.push({
+      path: relative,
+      kind: 'file',
+      mode: stat.mode & 0o777,
+      contents: fs.readFileSync(directory).toString('base64')
+    });
+  };
+  visit(root);
+  return entries;
+}
+
+function replaceSyncedSkillDirectory(sourceDir, targetDir) {
+  const parent = path.dirname(targetDir);
+  const transaction = fs.mkdtempSync(path.join(parent, `.skillshop-sync-${process.pid}-`));
+  const staged = path.join(transaction, 'skill');
+  const backup = path.join(transaction, 'previous-skill');
+  let backedUp = false;
+  let installed = false;
+  try {
+    fs.cpSync(sourceDir, staged, { recursive: true, errorOnExist: true, force: false });
+    personalTreeSnapshot(staged, 'staged personal skill');
+    fs.renameSync(targetDir, backup);
+    backedUp = true;
+    fs.renameSync(staged, targetDir);
+    installed = true;
+  } catch (error) {
+    if (installed) fs.rmSync(targetDir, { recursive: true, force: true });
+    if (backedUp && fs.existsSync(backup)) fs.renameSync(backup, targetDir);
+    throw error;
+  } finally {
+    // Once the new directory is installed, backup cleanup cannot invalidate
+    // that successful replacement or remove its only surviving content.
+    try { fs.rmSync(transaction, { recursive: true, force: true }); } catch {}
+  }
+}
+
+function recordedPersonalSkill(name, source) {
+  try {
+    const resolved = resolveRecordedPersonalSkill(source);
+    if (!resolved) throw new CliError(`recorded personal source for ${name} is missing from ${source.root}`);
+    return resolved;
+  } catch (error) {
+    if (/personal skill .* does not exist|\/SKILL\.md is missing/.test(error.message)) {
+      throw new CliError(`recorded personal source for ${name} is missing from ${source.root}`);
+    }
+    throw error;
+  }
+}
+
+function isLegacyBundleSource(source) {
+  return source == null || ['bundle', 'bundled'].includes(source.kind);
+}
+
+function syncPersonalCopy(name, source, target, boundary) {
+  assertNoManagedSymlink(boundary, target, `sync destination for ${name}`);
+  assertInstallPathsDoNotOverlap(source.sourceDir, target);
+  let targetStat;
+  try {
+    targetStat = fs.lstatSync(target);
+  } catch (error) {
+    if (error.code === 'ENOENT') return 'missing';
+    throw error;
+  }
+  if (!targetStat.isDirectory() || targetStat.isSymbolicLink()) {
+    throw new CliError(`sync destination for ${name} is not a regular skill directory: ${target}`);
+  }
+  const sourceTree = personalTreeSnapshot(source.sourceDir, `personal source for ${name}`);
+  const targetTree = personalTreeSnapshot(target, `sync destination for ${name}`);
+  if (JSON.stringify(sourceTree) === JSON.stringify(targetTree)) return 'current';
+  replaceSyncedSkillDirectory(source.sourceDir, target);
+  return 'updated';
+}
+
+function syncPersonalCopies(cwd) {
+  const failures = [];
+  const roots = new Map();
+  const currentRoot = findLockRoot(cwd, { required: false });
+  if (currentRoot) roots.set(canonicalPath(currentRoot), canonicalPath(currentRoot));
+  let ownershipComplete = true;
+  try {
+    for (const registeredRoot of readRegistry().repositories) {
+      const canonical = canonicalPath(registeredRoot);
+      roots.set(canonical, canonical);
+    }
+  } catch (error) {
+    failures.push(`project registry: ${error.message}`);
+    ownershipComplete = false;
+  }
+
+  const contexts = [];
+  for (const root of roots.values()) {
+    if (!hasLock(root)) continue;
+    try {
+      const lock = readLock(root);
+      contexts.push({ kind: 'project', root, lock, original: JSON.stringify(lock) });
+    } catch (error) {
+      failures.push(`project ${root}: ${error.message}`);
+      ownershipComplete = false;
+    }
+  }
+  let globalLock = null;
+  try {
+    globalLock = readGlobalSkills();
+  } catch (error) {
+    failures.push(`global manifest: ${error.message}`);
+    ownershipComplete = false;
+  }
+  if (globalLock) contexts.push({ kind: 'global', lock: globalLock, original: JSON.stringify(globalLock) });
+
+  let updated = 0;
+  let current = 0;
+  let pruned = 0;
+  let selectedRoot = null;
+  try {
+    selectedRoot = selectedLibraryRoot(skillshopHome());
+  } catch (error) {
+    failures.push(`selected personal library: ${error.message}`);
+  }
+  const libraryInfo = new Map();
+  const getLibrarySkill = (name) => {
+    if (!selectedRoot) return null;
+    if (!libraryInfo.has(name)) {
+      libraryInfo.set(name, resolvePersonalSkill(name, skillshopHome(), selectedRoot));
+    }
+    return libraryInfo.get(name);
+  };
+  const isUnknownSource = (source) => source != null && source.kind !== 'personal-library' && !isLegacyBundleSource(source);
+  const legacyGroups = new Map();
+  const personalItems = [];
+  const unknownSourceNames = new Set();
+
+  for (const context of contexts) {
+    for (const [name, entry] of Object.entries(context.lock.skills)) {
+      if (context.kind === 'project') {
+        let targets;
+        try { targets = lockedTargets(context.root, name, entry); }
+        catch (error) { failures.push(`project ${name}: ${error.message}`); ownershipComplete = false; continue; }
+        if (entry.source?.kind === 'personal-library') {
+          personalItems.push({ kind: 'project', context, name, entry, sourceRecord: entry.source, targets });
+        } else if (isLegacyBundleSource(entry.source)) {
+          legacyGroups.set(name, [...(legacyGroups.get(name) ?? []), { kind: 'project', context, name, entry, targets }]);
+        } else if (isUnknownSource(entry.source)) unknownSourceNames.add(name);
+        continue;
+      }
+
+      let targets;
+      try { targets = globalTargets(name, entry); }
+      catch (error) { failures.push(`global ${name}: ${error.message}`); ownershipComplete = false; continue; }
+      for (const target of targets) {
+        const copy = entry.copies?.[target] ?? {};
+        const sourceRecord = copy.source ?? entry.source;
+        if (sourceRecord?.kind === 'personal-library') {
+          personalItems.push({ kind: 'global', context, name, entry, copy, target, sourceRecord });
+        } else if (isLegacyBundleSource(sourceRecord)) {
+          legacyGroups.set(name, [...(legacyGroups.get(name) ?? []), { kind: 'global', context, name, entry, copy, target }]);
+        } else if (isUnknownSource(sourceRecord)) unknownSourceNames.add(name);
+      }
+    }
+  }
+
+  const updateLocalOwnership = (context, name, entry, source, targets) => {
+    const kept = targets.filter((target) => target.present).map(({ target }) => relativePath(context.root, target)).sort();
+    if (!kept.length) {
+      delete context.lock.skills[name];
+      return;
+    }
+    entry.paths = kept;
+    entry.source = source.source;
+    if (typeof source.author === 'string') entry.author = source.author;
+    else delete entry.author;
+    if (typeof source.version === 'string') entry.version = source.version;
+    else delete entry.version;
+  };
+  const updateGlobalOwnership = (entry, copy, target, source) => {
+    copy.source = source.source;
+    if (typeof source.author === 'string') copy.author = source.author;
+    else delete copy.author;
+    if (typeof source.version === 'string') copy.version = source.version;
+    else delete copy.version;
+    entry.copies ??= {};
+    entry.copies[target] = copy;
+  };
+  const pruneMissing = (item) => {
+    pruned += 1;
+    if (item.kind === 'project') {
+      const targets = lockedTargets(item.context.root, item.name, item.entry).filter((target) => target !== item.target);
+      if (targets.length) item.entry.paths = targets.map((target) => relativePath(item.context.root, target));
+      else delete item.context.lock.skills[item.name];
+      console.log(`Pruned missing project copy ${item.target}`);
+    } else {
+      delete item.entry.copies[item.target];
+      const paths = item.entry.paths.filter((target) => target !== item.target);
+      if (paths.length) item.entry.paths = paths;
+      else delete item.context.lock.skills[item.name];
+      console.log(`Pruned missing global copy ${item.target}`);
+    }
+  };
+
+  for (const item of personalItems) {
+    const { name, sourceRecord } = item;
+    let source;
+    try { source = recordedPersonalSkill(name, sourceRecord); }
+    catch (error) { failures.push(`${item.kind} ${name}: ${error.message}`); continue; }
+    const targets = item.kind === 'project' ? item.targets : [item.target];
+    const prepared = [];
+    let failed = false;
+    for (const target of targets) {
+      try {
+        const boundary = item.kind === 'project' ? item.context.root : os.homedir();
+        assertNoManagedSymlink(boundary, target, `sync destination for ${name}`);
+        assertInstallPathsDoNotOverlap(source.sourceDir, target);
+        let stat;
+        try { stat = fs.lstatSync(target); }
+        catch (error) { if (error.code === 'ENOENT') { prepared.push({ target, present: false }); continue; } throw error; }
+        if (!stat.isDirectory() || stat.isSymbolicLink()) throw new CliError(`sync destination for ${name} is not a regular skill directory: ${target}`);
+        personalTreeSnapshot(target, `sync destination for ${name}`);
+        prepared.push({ target, present: true });
+      } catch (error) { failures.push(`${item.kind} ${name} at ${target}: ${error.message}`); failed = true; }
+    }
+    if (failed) continue;
+    for (const target of prepared) {
+      if (!target.present) { pruneMissing({ ...item, target: target.target }); continue; }
+      try {
+        const result = syncPersonalCopy(name, source, target.target, item.kind === 'project' ? item.context.root : os.homedir());
+        if (result === 'updated') { updated += 1; console.log(`Synced ${item.kind} copy ${target.target}`); }
+        else current += 1;
+      } catch (error) { failures.push(`${item.kind} ${name} at ${target.target}: ${error.message}`); failed = true; }
+    }
+    if (failed) continue;
+    if (item.kind === 'project') updateLocalOwnership(item.context, name, item.entry, source, prepared);
+    else updateGlobalOwnership(item.entry, item.copy, item.target, source);
+  }
+
+  for (const [name, group] of legacyGroups) {
+    const root = selectedRoot;
+    if (!root) {
+      failures.push(`${name}: select a personal library with "skillshop library init" before adopting legacy copies`);
+      continue;
+    }
+    let source;
+    try { source = getLibrarySkill(name); }
+    catch (error) { failures.push(`${name}: selected library source is unsafe or invalid: ${error.message}`); continue; }
+    if (!source && unknownSourceNames.has(name)) {
+      failures.push(`${name}: an ownership record has an unknown source kind; legacy copies were left unchanged`);
+      continue;
+    }
+
+    const prepared = [];
+    let failed = false;
+    for (const item of group) {
+      const boundary = item.kind === 'project' ? item.context.root : os.homedir();
+      const target = item.kind === 'project' ? item.targets : [item.target];
+      for (const destination of target) {
+        try {
+          assertNoManagedSymlink(boundary, destination, `legacy copy for ${name}`);
+          if (source) assertInstallPathsDoNotOverlap(source.sourceDir, destination);
+          else assertInstallPathsDoNotOverlap(destination, path.join(root, 'skills', name));
+          let stat;
+          try { stat = fs.lstatSync(destination); }
+          catch (error) { if (error.code === 'ENOENT') { prepared.push({ item, target: destination, present: false }); continue; } throw error; }
+          if (!stat.isDirectory() || stat.isSymbolicLink()) throw new CliError(`legacy copy for ${name} is not a regular skill directory: ${destination}`);
+          validatePersonalSkillDirectory(boundary, destination, name);
+          const snapshot = personalTreeSnapshot(destination, `legacy copy for ${name}`);
+          prepared.push({ item, target: destination, present: true, snapshot });
+        } catch (error) { failures.push(`${name} at ${destination}: ${error.message}`); failed = true; }
+      }
+    }
+    if (failed) continue;
+
+    const present = prepared.filter(({ present: exists }) => exists);
+    if (!present.length) {
+      for (const item of group) {
+        if (item.kind === 'project') {
+          const existing = item.targets.filter((target) => fs.existsSync(target));
+          const missing = item.targets.filter((target) => !fs.existsSync(target));
+          for (const target of missing) {
+            pruned += 1;
+            console.log(`Pruned missing project copy ${target}`);
+          }
+          if (missing.length) {
+            item.entry.paths = existing.map((target) => relativePath(item.context.root, target));
+            if (!existing.length) delete item.context.lock.skills[name];
+          }
+        } else if (!fs.existsSync(item.target)) pruneMissing(item);
+      }
+      continue;
+    }
+
+    if (!source) {
+      if (!ownershipComplete) {
+        failures.push(`${name}: cannot import a missing source because one or more ownership manifests could not be read`);
+        continue;
+      }
+      const expected = JSON.stringify(present[0].snapshot);
+      if (present.some(({ snapshot }) => JSON.stringify(snapshot) !== expected)) {
+        failures.push(`${name}: tracked legacy copies diverge; resolve them before adoption`);
+        continue;
+      }
+      try {
+        const skillDirectory = path.join(inspectPersonalLibrary(root).skillsDirectory, name);
+        for (const copy of present) assertInstallPathsDoNotOverlap(copy.target, skillDirectory);
+        importTrackedPersonalSkill(root, present[0].target, name);
+        source = resolvePersonalSkill(name, skillshopHome(), root);
+      } catch (error) { failures.push(`${name}: could not import agreeing legacy copies: ${error.message}`); continue; }
+      for (const copy of present.slice(1)) {
+        if (JSON.stringify(copy.snapshot) !== JSON.stringify(present[0].snapshot)) {
+          failures.push(`${name}: tracked legacy copies changed during adoption`);
+          failed = true;
+          break;
+        }
+      }
+      if (failed) continue;
+      console.log(`Adopted ${name} from ${present.length} agreeing tracked copy/copies into ${root}`);
+    }
+
+    const localEntryResults = new Map();
+    for (const copy of prepared) {
+      if (!copy.present) { pruneMissing({ ...copy.item, target: copy.target }); continue; }
+      let result;
+      try {
+        result = source ? syncPersonalCopy(name, source, copy.target, copy.item.kind === 'project' ? copy.item.context.root : os.homedir()) : 'current';
+      } catch (error) {
+        failures.push(`${copy.item.kind} ${name} at ${copy.target}: ${error.message}`);
+        failed = true;
+        if (copy.item.kind === 'project') {
+          const state = localEntryResults.get(copy.item) ?? { successes: [], failed: false };
+          state.failed = true;
+          localEntryResults.set(copy.item, state);
+        }
+        continue;
+      }
+      if (result === 'updated') { updated += 1; console.log(`Synced adopted ${name} copy ${copy.target}`); }
+      else current += 1;
+      if (copy.item.kind === 'project') {
+        const state = localEntryResults.get(copy.item) ?? { successes: [], failed: false };
+        state.successes.push(copy.target);
+        localEntryResults.set(copy.item, state);
+      } else updateGlobalOwnership(copy.item.entry, copy.item.copy, copy.target, source);
+    }
+    for (const [item, state] of localEntryResults) {
+      if (state.failed) continue;
+      if (!state.successes.length) continue;
+      item.entry.source = source.source;
+      if (typeof source.author === 'string') item.entry.author = source.author;
+      else delete item.entry.author;
+      if (typeof source.version === 'string') item.entry.version = source.version;
+      else delete item.entry.version;
+      item.entry.paths = state.successes.map((target) => relativePath(item.context.root, target)).sort();
+    }
+  }
+
+  for (const context of contexts) {
+    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 || fs.existsSync(path.join(skillshopHome(), globalSkillsFileName)))) {
+    try { writeGlobalSkills(globalLock); }
+    catch (error) { failures.push(`global state: ${error.message}`); }
+  }
+  console.log(`Personal sync: ${updated} updated, ${current} current, ${pruned} missing destination(s) pruned.`);
+  if (failures.length) {
+    for (const failure of failures) console.error(`skillshop: ${failure}`);
+    throw new CliError(`sync completed with ${failures.length} failure(s); ${updated} copy/copies updated, ${current} current, ${pruned} missing destination(s) pruned`);
+  }
 }
 
-function installAt(name, requestedVersion, targetDir) {
-  const metadata = skillMetadata(name);
+function installAt(name, requestedVersion, targetDir, metadata = skillMetadata(name), boundary = path.dirname(targetDir)) {
   if (requestedVersion && requestedVersion !== metadata.version) {
-    throw new CliError(
-      `${name}@${requestedVersion} is unavailable; local registry provides ${name}@${metadata.version}`
-    );
+    throw new CliError(metadata.kind === 'personal'
+      ? `${name}@${requestedVersion} is unavailable in the personal library${metadata.version ? `; library version is ${metadata.version}` : ''}`
+      : `${name}@${requestedVersion} is unavailable; local registry provides ${name}@${metadata.version}`);
   }
 
+  if (metadata.kind === 'personal') {
+    assertNoManagedSymlink(boundary, targetDir, `install destination for ${name}`);
+    assertInstallPathsDoNotOverlap(metadata.sourceDir, targetDir);
+  }
   const updating = fs.existsSync(targetDir);
   replaceSkillDirectory(metadata.sourceDir, targetDir);
   return { ...metadata, targetDir, updating };
 }
 
+function assertInstallPathsDoNotOverlap(sourceDir, targetDir) {
+  const source = path.resolve(sourceDir);
+  const target = path.resolve(targetDir);
+  const within = (parent, child) => {
+    const relative = path.relative(parent, child);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+  };
+  if (within(source, target) || within(target, source)) {
+    throw new CliError(`install destination overlaps personal source directory: ${source}`);
+  }
+}
+
 function lockEntry(root, results) {
   const [result] = results;
   return {
-    version: result.version,
-    author: result.author,
+    ...(typeof result.version === 'string' ? { version: result.version } : {}),
+    ...(typeof result.author === 'string' ? { author: result.author } : {}),
+    ...(result.source ? { source: result.source } : {}),
     paths: results.map(({ targetDir }) => relativePath(root, targetDir)).sort()
   };
 }
 
+function resolvedInstallSource(name, stateHome, { existing = null, requested = false, selectedRoot = undefined, personalOnly = false } = {}) {
+  const allRecordedSources = [existing?.source, ...Object.values(existing?.copies ?? {}).map((copy) => copy?.source)]
+    .filter((source) => source != null);
+  if (personalOnly && allRecordedSources.some((source) => source.kind !== 'personal-library' && !isLegacyBundleSource(source))) {
+    throw new CliError(`${name} has an ownership record with an unknown source kind; refusing to replace it`);
+  }
+  const recordedSources = allRecordedSources
+    .filter((source) => source?.kind === 'personal-library');
+  if (requested) {
+    const selected = resolvePersonalSkill(name, stateHome, selectedRoot ?? null);
+    if (selected) {
+      if (recordedSources.some((source) => path.resolve(source.root) !== path.resolve(selected.source.root) || source.skillDirectory !== selected.source.skillDirectory)) {
+        throw new CliError(`${name} is already owned by a different personal library; uninstall it before changing sources`);
+      }
+      return selected;
+    }
+    if (personalOnly && selectedRoot && !recordedSources.length) {
+      throw new CliError(`${name} is not present in the selected personal library`);
+    }
+  }
+  if (recordedSources.length) {
+    const identities = new Set(recordedSources.map((source) => `${path.resolve(source.root)}\0${source.skillDirectory ?? ''}\0${source.skill ?? name}`));
+    if (identities.size !== 1) throw new CliError(`${name} has multiple personal library sources; refusing to choose one implicitly`);
+    const source = recordedSources[0];
+    const recorded = recordedPersonalSkill(name, source);
+    if (recorded.name !== name) throw new CliError(`recorded personal source for ${name} is unavailable`);
+    return recorded;
+  }
+  if (requested && selectedRoot === undefined) {
+    const selected = resolvePersonalSkill(name, stateHome);
+    if (selected) return selected;
+  }
+  if (personalOnly) throw new CliError(`${name} is not present in the selected or recorded personal library`);
+  return skillMetadata(name);
+}
+
 function installGlobal(name, requestedVersion) {
   const config = readConfig();
   const skillDirectories = config
@@ -789,16 +1361,39 @@ function installGlobal(name, requestedVersion) {
     : [path.join(os.homedir(), '.agents', 'skills')];
 
   const globalSkills = readGlobalSkills();
-  for (const skillDirectory of skillDirectories) {
+  const selectedRoot = selectedLibraryRoot(skillshopHome());
+  const existing = globalSkills.skills[name];
+  const recordedPersonal = [existing?.source, ...Object.values(existing?.copies ?? {}).map((copy) => copy?.source)]
+    .some((source) => source?.kind === 'personal-library');
+  const personalOnly = Boolean(selectedRoot) || recordedPersonal;
+  const metadata = resolvedInstallSource(name, skillshopHome(), { existing, requested: true, selectedRoot, personalOnly });
+  const managedTargets = existing ? new Set(globalTargets(name, existing).map(canonicalDestination)) : new Set();
+  const targetPairs = skillDirectories.map((skillDirectory) => {
     const targetDir = path.join(skillDirectory, name);
     assertLocalDestination(os.homedir(), targetDir, `global installation for ${name}`);
-    const result = installAt(name, requestedVersion, targetDir);
+    if (metadata.kind === 'personal') {
+      assertNoManagedSymlink(os.homedir(), targetDir, `global install destination for ${name}`);
+      assertInstallPathsDoNotOverlap(metadata.sourceDir, 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) {
+    const result = installAt(name, requestedVersion, targetDir, metadata, os.homedir());
     const entry = globalSkills.skills[name] ?? { paths: [], copies: {} };
     entry.paths = [...new Set([...entry.paths, targetDir])];
-    entry.copies[targetDir] = { author: result.author, version: result.version };
+    entry.copies[targetDir] = {
+      ...(typeof result.author === 'string' ? { author: result.author } : {}),
+      ...(typeof result.version === 'string' ? { version: result.version } : {}),
+      ...(result.source ? { source: result.source } : {})
+    };
     globalSkills.skills[name] = entry;
     writeGlobalSkills(globalSkills);
-    console.log(`${result.updating ? 'Updated' : 'Installed'} ${name}@${result.version} at ${targetDir}`);
+    console.log(`${result.updating ? 'Updated' : 'Installed'} ${name}@${result.version ?? 'personal'} at ${targetDir}`);
   }
 }
 
@@ -1004,10 +1599,22 @@ function installLocal(name, requestedVersion, cwd) {
   const root = findLockRoot(cwd) ?? projectRoot(cwd);
   const lock = readLock(root);
   const config = readConfig();
+  const selectedRoot = selectedLibraryRoot(skillshopHome());
   const skillDirectories = localSkillDirectories(root, lock, cwd);
-  const names = [...new Set([...Object.keys(lock.skills), name, 'skillshop'])].sort();
+  const existing = lock.skills[name];
+  const recordedPersonal = existing?.source?.kind === 'personal-library';
+  const personalOnly = Boolean(selectedRoot) || recordedPersonal;
+  if (personalOnly && existing?.source && existing.source.kind !== 'personal-library' && !isLegacyBundleSource(existing.source)) {
+    throw new CliError(`${name} has an ownership record with an unknown source kind; refusing to replace it`);
+  }
+  const names = personalOnly ? [name] : [...new Set([...Object.keys(lock.skills), name, 'skillshop'])].sort();
   const installs = names.map((skillName) => {
-    const metadata = skillMetadata(skillName);
+    const metadata = resolvedInstallSource(skillName, skillshopHome(), {
+      existing: lock.skills[skillName],
+      requested: skillName === name,
+      selectedRoot,
+      personalOnly: skillName === name && personalOnly
+    });
     const targetDirs = config || !lock.skills[skillName]
       ? skillDirectories.map((directory) => path.join(directory, skillName))
       : lockedTargets(root, skillName, lock.skills[skillName]);
@@ -1019,54 +1626,55 @@ function installLocal(name, requestedVersion, cwd) {
   const requestedMetadata = installs.find(({ metadata }) => metadata.name === name).metadata;
   if (requestedVersion && requestedVersion !== requestedMetadata.version) {
     throw new CliError(
-      `${name}@${requestedVersion} is unavailable; local registry provides ${name}@${requestedMetadata.version}`
+      `${name}@${requestedVersion} is unavailable; personal skills must declare that exact version or use a bundled skill`
     );
   }
   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}`);
+        assertInstallPathsDoNotOverlap(metadata.sourceDir, targetDir);
+      }
+    }
   }
 
   for (const { metadata, targetDirs, previousTargets } of installs) {
     const version = metadata.name === name ? requestedVersion : null;
-    const results = targetDirs.map((targetDir) => installAt(metadata.name, version, targetDir));
+    const results = targetDirs.map((targetDir) => installAt(metadata.name, version, targetDir, metadata, root));
     for (const staleTarget of staleTargets(previousTargets, targetDirs)) {
       fs.rmSync(staleTarget, { recursive: true, force: true });
     }
     lock.skills[metadata.name] = lockEntry(root, results);
     for (const result of results) {
       console.log(
-        `${result.updating ? 'Updated' : 'Installed'} ${result.name}@${result.version} at ${result.targetDir}`
+        `${result.updating ? 'Updated' : 'Installed'} ${result.name}@${result.version ?? 'personal'} at ${result.targetDir}`
       );
     }
   }
 
   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) {
@@ -1085,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 = {}) {
@@ -1102,7 +1710,10 @@ function updateLocal(requestedName, cwd, options = {}) {
   const skillDirectories = localSkillDirectories(root, lock, cwd);
 
   const updates = [...new Set(names)].sort().map((name) => {
-    const metadata = skillMetadata(name);
+    let metadata;
+    if (lock.skills[name]?.source?.kind === 'personal-library') {
+      metadata = recordedPersonalSkill(name, lock.skills[name].source);
+    } else metadata = skillMetadata(name);
     const targetDirs = config
       ? skillDirectories.map((directory) => path.join(directory, name))
       : lockedTargets(root, name, lock.skills[name]);
@@ -1110,23 +1721,29 @@ 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}`);
+        assertInstallPathsDoNotOverlap(metadata.sourceDir, targetDir);
+      }
+    }
   }
 
   for (const { metadata, targetDirs, previousTargets } of updates) {
-    const results = targetDirs.map((targetDir) => installAt(metadata.name, null, targetDir));
+    const results = targetDirs.map((targetDir) => installAt(metadata.name, null, targetDir, metadata, root));
     for (const staleTarget of staleTargets(previousTargets, targetDirs)) {
       fs.rmSync(staleTarget, { recursive: true, force: true });
     }
     lock.skills[metadata.name] = lockEntry(root, results);
     for (const result of results) {
-      console.log(`Updated ${result.name}@${result.version} at ${result.targetDir}`);
+      console.log(`Updated ${result.name}@${result.version ?? 'personal'} at ${result.targetDir}`);
     }
   }
 
   writeLock(root, lock);
   maintainRepository(root, lock, options);
-  console.log(`Updated ${path.join(root, lockFileName)}`);
+  console.log(`Updated installation manifests for ${root}`);
 }
 
 function updateAllRepositories() {
@@ -1238,8 +1855,18 @@ function refreshManagedLock(root, lock, { global = false, summary }) {
   for (const name of Object.keys(lock.skills).sort()) {
     const entry = lock.skills[name];
     try {
+      if (root && entry.source?.kind === 'personal-library') {
+        summary.unchanged += (Array.isArray(entry.paths) ? entry.paths.length : 1);
+        continue;
+      }
+      if (global && entry.paths?.length && entry.paths.every((target) => entry.copies?.[target]?.source?.kind === 'personal-library')) {
+        summary.unchanged += entry.paths.length;
+        continue;
+      }
       const metadata = skillMetadata(name);
-      const targets = global ? globalTargets(name, entry) : lockedTargets(root, name, entry);
+      const allTargets = global ? globalTargets(name, entry) : lockedTargets(root, name, entry);
+      const personalTargets = global ? allTargets.filter((target) => entry.copies?.[target]?.source?.kind === 'personal-library') : [];
+      const targets = global ? allTargets.filter((target) => !personalTargets.includes(target)) : allTargets;
       const base = global ? os.homedir() : root;
       const existingTargets = [];
       for (const target of targets) {
@@ -1248,8 +1875,13 @@ function refreshManagedLock(root, lock, { global = false, summary }) {
       }
 
       if (!existingTargets.length) {
-        delete lock.skills[name];
-        changed = true;
+        if (personalTargets.length) {
+          entry.paths = personalTargets;
+          changed = true;
+        } else {
+          delete lock.skills[name];
+          changed = true;
+        }
         continue;
       }
 
@@ -1273,7 +1905,7 @@ function refreshManagedLock(root, lock, { global = false, summary }) {
       }
 
       if (global) {
-        const keptTargets = skillFailed ? targets : successfulTargets;
+        const keptTargets = [...personalTargets, ...(skillFailed ? targets : successfulTargets)];
         entry.paths = keptTargets;
         entry.copies ??= {};
         for (const target of successfulTargets) {
@@ -1318,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}`);
@@ -1326,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}`);
@@ -1337,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}`);
@@ -1379,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;
@@ -1498,6 +2140,12 @@ function parseArgs(argv) {
 }
 
 function listSkills() {
+  const personalRoot = selectedLibraryRoot(skillshopHome());
+  if (personalRoot) {
+    const library = inspectPersonalLibrary(personalRoot);
+    for (const skill of library.skills) console.log(`${skill.name} — ${skill.description}`);
+    return;
+  }
   for (const name of availableSkills()) {
     const metadata = skillMetadata(name);
     console.log(`${name}@${metadata.version} — ${metadata.author}`);
@@ -1638,8 +2286,13 @@ async function main(argv) {
     return;
   }
 
-  const { positional, globalInstall, pushUpdate, requestedVersion, selectedProject, checkProject, agentsTargets } = parseArgs(argv);
+  const forceCount = argv.filter((argument) => argument === '--force').length;
+  if (forceCount > 1) throw new CliError('--force may only be specified once');
+  const parsedArgv = forceCount ? argv.filter((argument) => argument !== '--force') : argv;
+  const { positional, globalInstall, pushUpdate, requestedVersion, selectedProject, checkProject, agentsTargets } = parseArgs(parsedArgv);
   const command = positional[0];
+  const forceDownload = forceCount === 1;
+  if (forceDownload && command !== 'download') throw new CliError('--force is only valid with download');
 
   if ((selectedProject || checkProject) && command !== 'agents') {
     throw new CliError('--project and --check are only valid with agents');
@@ -1681,6 +2334,53 @@ async function main(argv) {
     return;
   }
 
+  if (command === 'library') {
+    if (requestedVersion || globalInstall || pushUpdate || agentsTargets.length) {
+      throw new CliError('library commands do not accept install or update options');
+    }
+    if (positional[1] === 'init' && positional.length <= 3) {
+      const directory = positional[2] ? path.resolve(process.cwd(), positional[2]) : undefined;
+      const result = initPersonalLibrary(directory, skillshopHome(), personalLibraryTemplateRoot);
+      console.log(`Initialized personal skill library at ${result.root}`);
+      console.log(`Skills directory: ${result.skillsDirectory}`);
+      return;
+    }
+    if (positional[1] === 'list' && positional.length === 2) {
+      const result = listPersonalSkills(skillshopHome());
+      console.log(`Personal skill library: ${result.root}`);
+      if (!result.skills.length) console.log('No personal skills found.');
+      for (const skill of result.skills) console.log(`${skill.name}: ${skill.description}`);
+      return;
+    }
+    throw new CliError('use "skillshop library init [directory]" or "skillshop library list"');
+  }
+
+  if (command === 'download') {
+    if (positional.length !== 2 || requestedVersion || globalInstall || pushUpdate || selectedProject || checkProject || agentsTargets.length) {
+      throw new CliError('download expects @<owner>/<skill> [--force] and does not accept install or update options');
+    }
+    const result = downloadPersonalSkill(positional[1], {
+      stateHome: skillshopHome(),
+      templateRoot: personalLibraryTemplateRoot,
+      force: forceDownload
+    });
+    if (result.alreadyPresent) {
+      console.log(`${result.name} is already downloaded from ${result.origin.repository} at ${result.root}`);
+    } else {
+      console.log(`Downloaded ${positional[1]} from ${result.origin.repository} at ${result.origin.commit}`);
+      console.log(`Personal source: ${result.target}`);
+    }
+    return;
+  }
+
+  if (command === 'sync') {
+    if (positional.length !== 1 || requestedVersion || globalInstall || pushUpdate || selectedProject || checkProject || agentsTargets.length) {
+      throw new CliError('sync does not accept a skill name or install options');
+    }
+    syncPersonalCopies(process.cwd());
+    return;
+  }
+
   if (command === 'upgrade') {
     if (positional.length !== 1 || requestedVersion || globalInstall || pushUpdate || agentsTargets.length) {
       throw new CliError('upgrade does not accept arguments or options');
@@ -1763,6 +2463,17 @@ async function main(argv) {
   }
   if (pushUpdate) throw new CliError('--push is only valid with update');
 
+  if (installAliases.has(command) && (spec.includes('/') || spec.startsWith('@'))) {
+    if (requestedVersion) throw new CliError('qualified GitHub installs do not accept --version');
+    const result = downloadPersonalSkill(spec, {
+      stateHome: skillshopHome(),
+      templateRoot: personalLibraryTemplateRoot
+    });
+    if (globalInstall) installGlobal(result.name, null);
+    else installLocal(result.name, null, process.cwd());
+    return;
+  }
+
   const { name, version } = parseSkillSpec(spec, requestedVersion);
   validateSkillName(name);
   if (globalInstall) installGlobal(name, version);
@@ -1799,10 +2510,54 @@ function isUpgradeFlowInvocation(argv) {
   }
 }
 
+function isPersonalLibraryInvocation(argv) {
+  if (argv[0] === '--help' || argv[0] === '-h') return false;
+  try {
+    const args = argv.filter((argument) => argument !== '--help' && argument !== '-h' && argument !== '--force');
+    const positional = parseArgs(args).positional;
+    const command = positional[0];
+    if (command === 'library' || command === 'download' || command === 'sync') return true;
+    const remoteInstall = ['install', 'i', 'add'].includes(command) && positional.length === 2 &&
+      (positional[1].includes('/') || positional[1].startsWith('@'));
+    // Remote-reference attempts may download before installing. Do not reconcile
+    // unrelated project/global state around that operation: a failed fetch
+    // or validation error must leave those managed copies untouched as well.
+    if (remoteInstall) return true;
+    const stateHome = skillshopHome();
+    const selectionPath = path.join(stateHome, librarySelectionFileName);
+    let selectionIntent = false;
+    try {
+      // A saved selection expresses personal-mode intent even when the file is
+      // malformed, symlinked, or points at a library that has since vanished.
+      // main() remains responsible for reporting the validation error.
+      fs.lstatSync(selectionPath);
+      selectionIntent = true;
+    } catch (error) {
+      if (error.code !== 'ENOENT') selectionIntent = true;
+    }
+    if (selectionIntent && (
+      (['list', 'ls'].includes(command) && positional.length === 1) ||
+      (['install', 'i', 'add'].includes(command) && positional.length === 2)
+    )) return true;
+    const activePersonalRoot = selectedLibraryRoot(stateHome);
+    if (!activePersonalRoot && !selectionIntent) return false;
+    if (['list', 'ls'].includes(command) && positional.length === 1) return true;
+    if (['install', 'i', 'add'].includes(command) && positional.length === 2) return true;
+    const legacyCommands = new Set([
+      'init', 'config', 'list', 'ls', 'upgrade', 'update', 'up', 'uninstall', 'remove', 'rm',
+      'agents', 'migrate', 'library', 'download', 'sync', 'help'
+    ]);
+    return positional.length === 1 && !legacyCommands.has(command);
+  } catch {
+    return false;
+  }
+}
+
 export async function runLegacyCli(argv) {
   const isolatedAgentsCommand = isIsolatedAgentsInvocation(argv);
   const upgradeFlow = isUpgradeFlowInvocation(argv);
-  const skipLegacyReconciliation = isolatedAgentsCommand || upgradeFlow;
+  const isolatedLibraryCommand = isPersonalLibraryInvocation(argv);
+  const skipLegacyReconciliation = isolatedAgentsCommand || upgradeFlow || isolatedLibraryCommand;
   try {
     if (!skipLegacyReconciliation) reconcileCurrentRepository();
     try {
@@ -1811,7 +2566,7 @@ export async function runLegacyCli(argv) {
       if (!skipLegacyReconciliation) reconcileCurrentRepository();
     }
   } catch (error) {
-    if (!(error instanceof CliError) && !(error instanceof AgentsInstructionsError)) throw error;
+    if (!(error instanceof CliError) && !(error instanceof AgentsInstructionsError) && !(error instanceof PersonalLibraryError) && !(error instanceof GitHubLibraryError)) throw error;
     console.error(`skillshop: ${error.message}`);
     process.exitCode = 1;
   }