@skaile/workspaces 5.9.0 → 5.11.0

package/dist/{chunk-4MQS7CAF.js → chunk-2F5AWQX5.js}

@@ -1,16 +1,16 @@
-import { readManifestSourceConfig, discoverAssetsInTree, barePublisher, createDefaultKindRegistry, sharesItsFolder, SEMVER_RE, parseManifestFile } from './chunk-Y7QA2OLD.js';
-import { installFromManifest, assertSafeManifestPath } from './chunk-CKQEIY43.js';
-import { PresetManifestSchema } from './chunk-B6GIW55K.js';
-import { defaultLibraryDir, resolveLibraryDir, GLOBAL_INSTALL_DIR_NAME, readLock, buildLibraryLockEntries, writeLock, mergeLockFile, buildLockFile, ManifestYamlEditor } from './chunk-36AFURKZ.js';
-import { getGlobalCacheDir, storeManifestSlug, resolveSourcePublisher } from './chunk-JAKOMFC6.js';
+import { readManifestSourceConfig, discoverAssetsInTree, barePublisher, createDefaultKindRegistry, sharesItsFolder, SEMVER_RE, parseManifestFile } from './chunk-J4RBUFGM.js';
+import { installFromManifest, assertSafeManifestPath } from './chunk-COH6FQAG.js';
+import { PresetManifestSchema } from './chunk-ZCAJZ4B2.js';
+import { defaultLibraryDir, resolveLibraryDir, GLOBAL_INSTALL_DIR_NAME, readLock, buildLibraryLockEntries, writeLock, mergeLockFile, buildLockFile, ManifestYamlEditor } from './chunk-PBBPZYVG.js';
+import { getGlobalCacheDir, storeManifestSlug, resolveSourcePublisher } from './chunk-ALEYHUC5.js';
 import { userConfigPath, globalSkaileDir, mergeLegacyEntriesInto, migrateLegacyDir, globalCacheRoot } from './chunk-L5VSIPQD.js';
-import { encodeSkaileManifest, loadSkPublishManifest, SKAILE_MANIFEST_FILENAME } from './chunk-BTE2V4IW.js';
-import { scanDirectory } from './chunk-GTILM2CI.js';
-import { parseAssetRef, assetRefToStr } from './chunk-QVNRCDTV.js';
+import { encodeSkaileManifest, loadSkPublishManifest, SKAILE_MANIFEST_FILENAME } from './chunk-ZPWTOUTK.js';
+import { scanDirectory } from './chunk-SBSA3IQA.js';
+import { parseAssetRef, assetRefToStr } from './chunk-BNMZVPYA.js';
 import { __export } from './chunk-NSBPE2FW.js';
-import * as fs10 from 'fs';
+import * as fs11 from 'fs';
 import { existsSync, mkdirSync, symlinkSync, copyFileSync, cpSync } from 'fs';
-import * as path15 from 'path';
+import * as path16 from 'path';
 import { resolve, relative, sep, join, dirname } from 'path';
 import { stringify, parse, parseDocument } from 'yaml';
 import * as z3 from 'zod';
@@ -103,10 +103,10 @@ var SkaileConfigSchema = z3.object({
   library: LibraryConfigSchema.optional()
 });
 function defaultIndexPath() {
-  return path15.join(globalSkaileDir(), "index.db");
+  return path16.join(globalSkaileDir(), "index.db");
 }
 function resolveIndexPath() {
-  if (process.env.SKAILE_INDEX_PATH) return path15.resolve(process.env.SKAILE_INDEX_PATH);
+  if (process.env.SKAILE_INDEX_PATH) return path16.resolve(process.env.SKAILE_INDEX_PATH);
   return defaultIndexPath();
 }
 function getConfigDefaults() {
@@ -117,12 +117,12 @@ function getConfigDefaults() {
 }
 var CONFIG_FILENAME = "config.yaml";
 function projectConfigPath(projectDir) {
-  return path15.join(projectDir, ".skaile", CONFIG_FILENAME);
+  return path16.join(projectDir, ".skaile", CONFIG_FILENAME);
 }
 function loadConfigFile(filePath) {
-  if (!fs10.existsSync(filePath)) return null;
+  if (!fs11.existsSync(filePath)) return null;
   try {
-    const content = fs10.readFileSync(filePath, "utf-8");
+    const content = fs11.readFileSync(filePath, "utf-8");
     const raw = parse(content);
     if (!raw || typeof raw !== "object") return null;
     return SkaileConfigSchema.partial().parse(raw);
@@ -170,11 +170,11 @@ function resolveConfig(opts) {
   return resolved;
 }
 function saveConfig(filePath, config) {
-  const dir = path15.dirname(filePath);
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
+  const dir = path16.dirname(filePath);
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
-  fs10.writeFileSync(filePath, stringify(config, { indent: 2 }), "utf-8");
+  fs11.writeFileSync(filePath, stringify(config, { indent: 2 }), "utf-8");
 }
 var KnowledgeManifestSchema = z3.looseObject({
   name: z3.string().optional(),
@@ -200,11 +200,11 @@ function validateKnowledge(data) {
 
 // library/src/knowledge/knowledge-kind-provider.ts
 function collectDirRecursive(baseDir, relativeDir) {
-  const full = path15.join(baseDir, relativeDir);
-  if (!fs10.existsSync(full) || !fs10.statSync(full).isDirectory()) return [];
+  const full = path16.join(baseDir, relativeDir);
+  if (!fs11.existsSync(full) || !fs11.statSync(full).isDirectory()) return [];
   const results = [];
-  for (const entry of fs10.readdirSync(full, { withFileTypes: true })) {
-    const rel = path15.posix.join(relativeDir, entry.name);
+  for (const entry of fs11.readdirSync(full, { withFileTypes: true })) {
+    const rel = path16.posix.join(relativeDir, entry.name);
     if (entry.isDirectory()) {
       results.push(...collectDirRecursive(baseDir, rel));
     } else if (entry.isFile()) {
@@ -231,8 +231,8 @@ var knowledgeKindProvider = {
     return validateKnowledge(data);
   },
   defaultFileFilter(manifestPath) {
-    const dir = path15.dirname(manifestPath);
-    const manifestName = path15.basename(manifestPath);
+    const dir = path16.dirname(manifestPath);
+    const manifestName = path16.basename(manifestPath);
     const files = [manifestName];
     files.push(...collectDirRecursive(dir, "documents"));
     files.sort();
@@ -311,30 +311,30 @@ var assignments = sqliteTable("assignments", {
   assignedAt: text("assigned_at").notNull()
 });
 function isClone(dir) {
-  return fs10.existsSync(path15.join(dir, ".git"));
+  return fs11.existsSync(path16.join(dir, ".git"));
 }
 function getSidecarRoot() {
   const home = globalSkaileDir();
-  const sidecars = path15.join(home, "sidecars");
-  const legacy = path15.join(home, "sources");
+  const sidecars = path16.join(home, "sidecars");
+  const legacy = path16.join(home, "sources");
   mergeLegacyEntriesInto(getGlobalCacheDir(), legacy, isClone);
   mergeLegacyEntriesInto(sidecars, legacy, (p) => !isClone(p));
   return sidecars;
 }
 function resolveSidecarPaths(slug) {
   const rootDir = getSidecarRoot();
-  const sidecarDir = path15.join(rootDir, slug);
+  const sidecarDir = path16.join(rootDir, slug);
   return {
     rootDir,
     sidecarDir,
-    manifestFile: path15.join(sidecarDir, "skaile.manifest.yaml"),
-    readmeFile: path15.join(sidecarDir, "README.md"),
-    lockFile: path15.join(sidecarDir, "skaile.manifest.lock.json")
+    manifestFile: path16.join(sidecarDir, "skaile.manifest.yaml"),
+    readmeFile: path16.join(sidecarDir, "README.md"),
+    lockFile: path16.join(sidecarDir, "skaile.manifest.lock.json")
   };
 }
 function deriveSlug(sourceConfig, sourcePath, existingSlugs) {
   const fromConfig = sourceConfig && typeof sourceConfig.name === "string" ? sourceConfig.name : void 0;
-  const base = fromConfig && fromConfig.length > 0 ? slugify(fromConfig) : slugify(path15.basename(sourcePath || "")) || "unnamed-source";
+  const base = fromConfig && fromConfig.length > 0 ? slugify(fromConfig) : slugify(path16.basename(sourcePath || "")) || "unnamed-source";
   const taken = new Set(existingSlugs);
   if (!taken.has(base)) return base;
   for (let i = 2; i < 1e3; i++) {
@@ -345,9 +345,9 @@ function deriveSlug(sourceConfig, sourcePath, existingSlugs) {
 }
 function listSidecarSlugsOnDisk() {
   const root = getSidecarRoot();
-  if (!fs10.existsSync(root)) return [];
+  if (!fs11.existsSync(root)) return [];
   const out = [];
-  for (const entry of fs10.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs11.readdirSync(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
     out.push(entry.name);
@@ -360,28 +360,28 @@ function slugify(input) {
 
 // library/src/local/store-paths.ts
 function getStoreRoot() {
-  return path15.join(globalSkaileDir(), "store");
+  return path16.join(globalSkaileDir(), "store");
 }
 function getStoreManifestsDir() {
-  return path15.join(getStoreRoot(), "manifests");
+  return path16.join(getStoreRoot(), "manifests");
 }
 function curatedManifestOverlay(sourceUrl) {
-  const file = path15.join(getStoreManifestsDir(), `${storeManifestSlug(sourceUrl)}.yaml`);
-  return fs10.existsSync(file) ? file : void 0;
+  const file = path16.join(getStoreManifestsDir(), `${storeManifestSlug(sourceUrl)}.yaml`);
+  return fs11.existsSync(file) ? file : void 0;
 }
 function migratedMarkerPath() {
-  return path15.join(getStoreRoot(), ".migrated");
+  return path16.join(getStoreRoot(), ".migrated");
 }
 function collectSidecarMigrationCandidates(sidecarRoot) {
   const candidates = [];
-  if (fs10.existsSync(sidecarRoot)) {
-    for (const entry of fs10.readdirSync(sidecarRoot, { withFileTypes: true })) {
+  if (fs11.existsSync(sidecarRoot)) {
+    for (const entry of fs11.readdirSync(sidecarRoot, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
-      const sidecarDir = path15.join(sidecarRoot, entry.name);
-      const current = path15.join(sidecarDir, "skaile.manifest.yaml");
-      const legacy = path15.join(sidecarDir, ".skaile-source.yaml");
-      const src = fs10.existsSync(current) ? current : fs10.existsSync(legacy) ? legacy : void 0;
+      const sidecarDir = path16.join(sidecarRoot, entry.name);
+      const current = path16.join(sidecarDir, "skaile.manifest.yaml");
+      const legacy = path16.join(sidecarDir, ".skaile-source.yaml");
+      const src = fs11.existsSync(current) ? current : fs11.existsSync(legacy) ? legacy : void 0;
       if (src) candidates.push({ src, slug: entry.name });
     }
   }
@@ -390,10 +390,10 @@ function collectSidecarMigrationCandidates(sidecarRoot) {
 function moveSidecarManifests(candidates, manifestsDir) {
   let migrated = 0;
   for (const { src, slug } of candidates) {
-    const dest = path15.join(manifestsDir, `${slug}.yaml`);
-    if (fs10.existsSync(dest)) continue;
+    const dest = path16.join(manifestsDir, `${slug}.yaml`);
+    if (fs11.existsSync(dest)) continue;
     try {
-      fs10.renameSync(src, dest);
+      fs11.renameSync(src, dest);
       migrated++;
     } catch (err) {
       process.stderr.write(
@@ -405,11 +405,11 @@ function moveSidecarManifests(candidates, manifestsDir) {
   return migrated;
 }
 function initStoreGitRepo(storeRoot) {
-  if (fs10.existsSync(path15.join(storeRoot, ".git"))) return;
+  if (fs11.existsSync(path16.join(storeRoot, ".git"))) return;
   try {
     spawnSync("git", ["init", "--quiet"], { cwd: storeRoot, stdio: "ignore" });
-    fs10.writeFileSync(
-      path15.join(storeRoot, ".gitignore"),
+    fs11.writeFileSync(
+      path16.join(storeRoot, ".gitignore"),
       "# Remote-store cache \u2014 local to this machine.\nremote-cache/\n",
       "utf8"
     );
@@ -419,14 +419,14 @@ function initStoreGitRepo(storeRoot) {
 function migrateSidecarsToStoreIfNeeded() {
   const storeRoot = getStoreRoot();
   const marker = migratedMarkerPath();
-  if (fs10.existsSync(marker)) return { migrated: 0, storeRoot };
+  if (fs11.existsSync(marker)) return { migrated: 0, storeRoot };
   const sidecarRoot = getSidecarRoot();
   const manifestsDir = getStoreManifestsDir();
   const candidates = collectSidecarMigrationCandidates(sidecarRoot);
-  fs10.mkdirSync(manifestsDir, { recursive: true });
+  fs11.mkdirSync(manifestsDir, { recursive: true });
   const migrated = moveSidecarManifests(candidates, manifestsDir);
   initStoreGitRepo(storeRoot);
-  fs10.writeFileSync(marker, (/* @__PURE__ */ new Date()).toISOString(), "utf8");
+  fs11.writeFileSync(marker, (/* @__PURE__ */ new Date()).toISOString(), "utf8");
   return { migrated, storeRoot };
 }
 
@@ -507,7 +507,7 @@ async function librariesPresent(client) {
   return rs.rows.length > 0;
 }
 function slugify2(p) {
-  const base = path15.basename(p) || "lib";
+  const base = path16.basename(p) || "lib";
   return base.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-|-$/g, "") || "lib";
 }
 async function runLibrariesMigration(client) {
@@ -671,23 +671,23 @@ async function purgeOrphanedAssetDefinitions(client) {
   await client.execute(`PRAGMA user_version = ${ORPHAN_PURGE_VERSION}`);
 }
 function assertNoLegacyLibDb(newDbPath) {
-  if (fs10.existsSync(newDbPath)) return;
-  const parent = path15.dirname(newDbPath);
+  if (fs11.existsSync(newDbPath)) return;
+  const parent = path16.dirname(newDbPath);
   const skaileHome = globalSkaileDir();
-  const defaultIndexPath2 = path15.join(skaileHome, "index.db");
+  const defaultIndexPath2 = path16.join(skaileHome, "index.db");
   const candidates = [];
-  if (path15.basename(newDbPath) === "index.db") {
-    candidates.push(path15.join(parent, "lib.db"));
+  if (path16.basename(newDbPath) === "index.db") {
+    candidates.push(path16.join(parent, "lib.db"));
   }
   if (newDbPath === defaultIndexPath2) {
-    candidates.push(path15.join(skaileHome, "libraries", "lib.db"));
-    candidates.push(path15.join(skaileHome, "library", "lib.db"));
+    candidates.push(path16.join(skaileHome, "libraries", "lib.db"));
+    candidates.push(path16.join(skaileHome, "library", "lib.db"));
   }
-  if (path15.basename(parent) === "libraries") {
-    candidates.push(path15.join(path15.dirname(parent), "library", "lib.db"));
+  if (path16.basename(parent) === "libraries") {
+    candidates.push(path16.join(path16.dirname(parent), "library", "lib.db"));
   }
   for (const legacy of candidates) {
-    if (!fs10.existsSync(legacy)) continue;
+    if (!fs11.existsSync(legacy)) continue;
     throw new Error(
       `Found legacy index database at ${legacy}. The lib.db \u2192 index.db relocation ran for one release and has been removed. Move the file manually to ${newDbPath} (and any -wal / -shm siblings), then retry.`
     );
@@ -846,26 +846,26 @@ var LocalIndex = class {
     let dbPath;
     if (typeof optionsOrDir === "string") {
       dir = optionsOrDir;
-      dbPath = path15.join(dir, "index.db");
+      dbPath = path16.join(dir, "index.db");
     } else if (optionsOrDir?.indexPath) {
       dbPath = optionsOrDir.indexPath;
       dir = optionsOrDir.libraryDir ?? resolveLibraryDir();
       this._kindRegistry = optionsOrDir.kindRegistry;
     } else if (optionsOrDir?.libraryDir) {
       dir = optionsOrDir.libraryDir;
-      dbPath = path15.join(dir, "index.db");
+      dbPath = path16.join(dir, "index.db");
       this._kindRegistry = optionsOrDir.kindRegistry;
     } else {
       dir = resolveLibraryDir();
       dbPath = resolveIndexPath();
       this._kindRegistry = optionsOrDir?.kindRegistry;
     }
-    if (!fs10.existsSync(dir)) {
-      fs10.mkdirSync(dir, { recursive: true });
+    if (!fs11.existsSync(dir)) {
+      fs11.mkdirSync(dir, { recursive: true });
     }
-    const dbParent = path15.dirname(dbPath);
-    if (!fs10.existsSync(dbParent)) {
-      fs10.mkdirSync(dbParent, { recursive: true });
+    const dbParent = path16.dirname(dbPath);
+    if (!fs11.existsSync(dbParent)) {
+      fs11.mkdirSync(dbParent, { recursive: true });
     }
     this.libraryDir = dir;
     this.dbPath = dbPath;
@@ -990,7 +990,7 @@ var LocalIndex = class {
    * Delete this library's cached asset defs whose ref is not in `keepRefs`.
    * Makes a sync authoritative: a def re-keyed under a new publisher (e.g.
    * `@skills/x` → `@acme/x`) leaves no stale duplicate behind. Returns the
-   * number of rows removed.
+   * ids of the rows removed.
    *
    * Not on the IAssetIndex interface — used by catalog sources.
    */
@@ -1004,7 +1004,7 @@ var LocalIndex = class {
         and(eq(assetDefinitions.libraryId, libraryId), eq(assetDefinitions.id, id))
       ).run();
     }
-    return stale.length;
+    return stale;
   }
   async getAssetDef(ref) {
     const db = await this.ensureDb();
@@ -1085,7 +1085,7 @@ var LocalIndex = class {
    * @returns The created Instance plus its on-disk install path.
    */
   async install(manifest, opts) {
-    const libraryRoot = opts?.libraryRoot ?? path15.join(this.libraryDir, GLOBAL_INSTALL_DIR_NAME);
+    const libraryRoot = opts?.libraryRoot ?? path16.join(this.libraryDir, GLOBAL_INSTALL_DIR_NAME);
     const { installPath } = await installFromManifest({
       manifest,
       libraryRoot,
@@ -1206,6 +1206,113 @@ var LocalIndex = class {
     return (await db.select().from(assignments).where(eq(assignments.instanceId, instanceId)).all()).map(rowToAssignment);
   }
 };
+var UNREGISTERED_FILE = ".unregistered-libraries";
+function libraryDirMissing(lib) {
+  try {
+    return !fs11.statSync(lib.path).isDirectory();
+  } catch {
+    return true;
+  }
+}
+function missingLibraryDirMessage(lib) {
+  return `library "${lib.name}" is registered but its directory ${lib.path} is missing - run skaile library init ${lib.name} --path <dir> or skaile library remove ${lib.name}`;
+}
+function realDir(dir) {
+  try {
+    return fs11.realpathSync(dir);
+  } catch {
+    return path16.resolve(dir);
+  }
+}
+function unregisteredLibraryNames() {
+  try {
+    return new Set(
+      fs11.readFileSync(path16.join(resolveLibraryDir(), UNREGISTERED_FILE), "utf8").split("\n").map((l) => l.trim()).filter(Boolean)
+    );
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function markLibraryUnregistered(lib) {
+  if (realDir(path16.dirname(lib.path)) !== realDir(resolveLibraryDir())) return;
+  const known = unregisteredLibraryNames();
+  const add = [.../* @__PURE__ */ new Set([lib.name, path16.basename(lib.path)])].filter((n) => !known.has(n));
+  if (add.length === 0) return;
+  fs11.mkdirSync(resolveLibraryDir(), { recursive: true });
+  fs11.appendFileSync(
+    path16.join(resolveLibraryDir(), UNREGISTERED_FILE),
+    `${add.join("\n")}
+`,
+    "utf8"
+  );
+}
+function clearLibraryUnregistered(lib) {
+  const known = unregisteredLibraryNames();
+  if (known.size === 0) return;
+  const drop = /* @__PURE__ */ new Set([lib.name]);
+  if (realDir(path16.dirname(lib.path)) === realDir(resolveLibraryDir())) {
+    drop.add(path16.basename(lib.path));
+  }
+  const keep = [...known].filter((n) => !drop.has(n));
+  if (keep.length === known.size) return;
+  const file = path16.join(resolveLibraryDir(), UNREGISTERED_FILE);
+  if (keep.length === 0) fs11.rmSync(file, { force: true });
+  else fs11.writeFileSync(file, `${keep.join("\n")}
+`, "utf8");
+}
+var RENAMED_FILE = ".renamed-libraries";
+function readRenames() {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    for (const line of fs11.readFileSync(path16.join(resolveLibraryDir(), RENAMED_FILE), "utf8").split("\n")) {
+      const [from, to] = line.split("	").map((s) => s.trim());
+      if (from && to && from !== to) out.set(from, to);
+    }
+  } catch {
+  }
+  return out;
+}
+function writeRenames(renames) {
+  const file = path16.join(resolveLibraryDir(), RENAMED_FILE);
+  if (renames.size === 0) {
+    fs11.rmSync(file, { force: true });
+    return;
+  }
+  fs11.mkdirSync(resolveLibraryDir(), { recursive: true });
+  fs11.writeFileSync(
+    file,
+    `${[...renames].map(([from, to]) => `${from}	${to}`).join("\n")}
+`,
+    "utf8"
+  );
+}
+function recordLibraryRename(from, to) {
+  if (from === to) return;
+  const renames = readRenames();
+  for (const [k, v] of renames) if (v === from) renames.set(k, to);
+  renames.delete(to);
+  renames.set(from, to);
+  for (const [k, v] of renames) if (k === v) renames.delete(k);
+  writeRenames(renames);
+}
+function renamedLibraryName(name) {
+  return readRenames().get(name);
+}
+function clearLibraryRenamed(name) {
+  const renames = readRenames();
+  if (renames.delete(name)) writeRenames(renames);
+}
+function dropLibraryRenamesTo(name) {
+  const renames = readRenames();
+  let changed = false;
+  for (const [from, to] of renames) {
+    if (to === name) {
+      renames.delete(from);
+      changed = true;
+    }
+  }
+  if (changed) writeRenames(renames);
+}
 
 // library/src/user-library.ts
 var LIBRARY_BACKENDS = ["local", "git"];
@@ -1242,7 +1349,7 @@ function git(cwd, args) {
   return spawnSync("git", args, { cwd, encoding: "utf-8" });
 }
 function isGitRepo(libPath) {
-  return existsSync(path15.join(libPath, ".git"));
+  return existsSync(path16.join(libPath, ".git"));
 }
 function spawnGit(cwd, args, action) {
   const r = git(cwd, args);
@@ -1312,6 +1419,31 @@ function headCommit(cwd) {
   const r = git(cwd, ["rev-parse", "--verify", "--quiet", "HEAD"]);
   return r.status === 0 ? r.stdout.trim() : void 0;
 }
+function rebaseInProgress(cwd) {
+  for (const entry of ["rebase-merge", "rebase-apply"]) {
+    const p = git(cwd, ["rev-parse", "--git-path", entry]);
+    if (p.status === 0 && existsSync(path16.resolve(cwd, p.stdout.trim()))) return true;
+  }
+  return false;
+}
+var REBASE_IN_PROGRESS = "rebase in progress; finish it with git rebase --continue";
+var MERGE_IN_PROGRESS = "merge in progress; resolve the conflicts, then git commit";
+function mergeInProgress(cwd) {
+  const head = git(cwd, ["rev-parse", "--git-path", "MERGE_HEAD"]);
+  if (head.status === 0 && existsSync(path16.resolve(cwd, head.stdout.trim()))) return true;
+  const unmerged = git(cwd, ["ls-files", "--unmerged"]);
+  return unmerged.status === 0 && unmerged.stdout.trim() !== "";
+}
+function assertLibraryDir(lib) {
+  if (libraryDirMissing(lib)) {
+    throw new LibrarySyncError(missingLibraryDirMessage(lib), "library_dir_missing");
+  }
+}
+function assertNoRebase(lib) {
+  assertLibraryDir(lib);
+  if (rebaseInProgress(lib.path)) throw new LibrarySyncError(REBASE_IN_PROGRESS, "remote_error");
+  if (mergeInProgress(lib.path)) throw new LibrarySyncError(MERGE_IN_PROGRESS, "remote_error");
+}
 function ok(r, action) {
   if (r.status !== 0) {
     throw new LibrarySyncError(
@@ -1328,6 +1460,13 @@ var GitSyncDriver = class {
   backend = "git";
   async status(lib) {
     const cfg = gitCfg(lib);
+    if (libraryDirMissing(lib)) {
+      return {
+        reachable: false,
+        localChanges: { added: [], modified: [], deleted: [] },
+        notes: [missingLibraryDirMessage(lib)]
+      };
+    }
     const porcelain = git(lib.path, ["status", "--porcelain"]);
     if (porcelain.status !== 0) {
       return {
@@ -1369,6 +1508,7 @@ var GitSyncDriver = class {
     };
   }
   async pull(lib, opts) {
+    assertNoRebase(lib);
     const cfg = gitCfg(lib);
     const args = ["pull", "--ff-only", "origin", cfg.branch];
     if (opts?.rebase) args.splice(1, 1, "--rebase");
@@ -1398,6 +1538,14 @@ var GitSyncDriver = class {
           ]
         };
       }
+      if (/would be overwritten by (merge|checkout)|unstaged changes|uncommitted changes|commit your changes or stash/i.test(
+        r.stderr
+      )) {
+        throw new LibrarySyncError(
+          `uncommitted changes in ${lib.name}; commit or stash them first`,
+          "remote_error"
+        );
+      }
       throw new LibrarySyncError(`git pull failed: ${r.stderr.trim()}`, "remote_error");
     }
     const upstream = `refs/remotes/origin/${cfg.branch}`;
@@ -1411,11 +1559,27 @@ var GitSyncDriver = class {
         `library "${lib.name}" has ownership=${lib.ownership}; use \`propose\` instead`
       );
     }
+    assertNoRebase(lib);
     const cfg = gitCfg(lib);
     const args = ["push", "origin", cfg.branch];
     if (opts?.force) args.push("--force-with-lease");
+    const countRef = "refs/skaile/push-base";
+    const trackingRef = `refs/remotes/origin/${cfg.branch}`;
+    git(lib.path, ["update-ref", "-d", countRef]);
+    const fetched = spawnSync(
+      "git",
+      ["fetch", "--quiet", "origin", `+refs/heads/${cfg.branch}:${countRef}`],
+      {
+        cwd: lib.path,
+        encoding: "utf-8",
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+      }
+    );
+    const remoteHasNoBranch = /couldn't find remote ref/i.test(fetched.stderr ?? "");
+    const baseRef = fetched.status === 0 || remoteHasNoBranch ? countRef : trackingRef;
     const local = `refs/heads/${cfg.branch}`;
-    const pushed = countCommits(lib.path, `refs/remotes/origin/${cfg.branch}..${local}`) ?? countCommits(lib.path, local) ?? 0;
+    const pushed = countCommits(lib.path, `${baseRef}..${local}`) ?? countCommits(lib.path, local) ?? 0;
+    git(lib.path, ["update-ref", "-d", countRef]);
     const pushRes = git(lib.path, args);
     if (pushRes.status !== 0 && /non-fast-forward|fetch first|updates were rejected/i.test(pushRes.stderr)) {
       throw new LibrarySyncError(
@@ -1433,6 +1597,7 @@ var GitSyncDriver = class {
         `propose requires ownership=contributor; got ${lib.ownership}`
       );
     }
+    assertLibraryDir(lib);
     const cfg = gitCfg(lib);
     const branch = opts.branch ?? `skaile/${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "").slice(0, 14)}`;
     const remotes = ok(git(lib.path, ["remote"]), "remote-list").split("\n");
@@ -1528,7 +1693,13 @@ function rowToLibrary2(row) {
   };
 }
 var LIBRARY_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+var MAX_LIBRARY_NAME_LENGTH = 64;
 function assertValidLibraryName(name) {
+  if (name.length > MAX_LIBRARY_NAME_LENGTH) {
+    throw new Error(
+      `Invalid library name (${name.length} characters): at most ${MAX_LIBRARY_NAME_LENGTH} characters.`
+    );
+  }
   if (!LIBRARY_NAME_PATTERN.test(name)) {
     throw new Error(
       `Invalid library name "${name}": use letters, digits, "_" or "-", starting with a letter or digit.`
@@ -1573,6 +1744,8 @@ var LibraryManager = class {
       createdAt: now,
       updatedAt: now
     }).run();
+    clearLibraryUnregistered({ name: input.name, path: input.path });
+    clearLibraryRenamed(input.name);
     return this.requireLibrary(id);
   }
   async listLibraries() {
@@ -1593,6 +1766,19 @@ var LibraryManager = class {
     if (!lib) throw new UserLibraryNotFoundError(nameOrId);
     return lib;
   }
+  /**
+   * {@link requireLibrary}, then refuse a library whose registered directory is gone: one line
+   * that names the path and the two ways out. For every verb that reads or writes the files.
+   *
+   * @throws LibrarySyncError (`library_dir_missing`) when the directory does not exist.
+   */
+  async requireLibraryDir(nameOrId) {
+    const lib = await this.requireLibrary(nameOrId);
+    if (libraryDirMissing(lib)) {
+      throw new LibrarySyncError(missingLibraryDirMessage(lib), "library_dir_missing");
+    }
+    return lib;
+  }
   async updateLibrary(nameOrId, patch) {
     const lib = await this.requireLibrary(nameOrId);
     if (patch.name !== void 0 && patch.name !== lib.name) assertValidLibraryName(patch.name);
@@ -1610,6 +1796,9 @@ var LibraryManager = class {
     if (patch.isDefault !== void 0) updates.isDefault = patch.isDefault;
     if (patch.lastSyncAt !== void 0) updates.lastSyncAt = patch.lastSyncAt.toISOString();
     await db.update(libraries).set(updates).where(eq(libraries.id, lib.id)).run();
+    if (patch.name !== void 0 && patch.name !== lib.name) {
+      recordLibraryRename(lib.name, patch.name);
+    }
     return this.requireLibrary(lib.id);
   }
   /**
@@ -1635,9 +1824,11 @@ var LibraryManager = class {
   async removeLibrary(nameOrId, opts = {}) {
     const lib = await this.requireLibrary(nameOrId);
     await this.lib.removeSource(lib.id);
-    if (opts.purge && fs10.existsSync(lib.path)) {
-      fs10.rmSync(lib.path, { recursive: true, force: true });
+    if (opts.purge && fs11.existsSync(lib.path)) {
+      fs11.rmSync(lib.path, { recursive: true, force: true });
     }
+    dropLibraryRenamesTo(lib.name);
+    if (!opts.purge) markLibraryUnregistered(lib);
   }
   /**
    * Idempotently ensure a `personal` library exists at `<librariesDir>/personal`.
@@ -1652,8 +1843,8 @@ var LibraryManager = class {
       (l) => l.isDefault && (l.ownership === "owner" || l.ownership === "contributor")
     );
     if (writableDefault) return { library: writableDefault, created: false };
-    const personalPath = path15.join(librariesDir, "personal");
-    fs10.mkdirSync(personalPath, { recursive: true });
+    const personalPath = path16.join(librariesDir, "personal");
+    fs11.mkdirSync(personalPath, { recursive: true });
     const lib = await this.addLibrary({
       name: "personal",
       path: personalPath,
@@ -1684,7 +1875,7 @@ function describeSyncError(err) {
   return parts.join(": ");
 }
 function scanLibraryRoot(rootPath, registry, scanOpts) {
-  const fallbackPublisher = resolveSourcePublisher(rootPath) ?? (path15.basename(rootPath) || "unknown");
+  const fallbackPublisher = resolveSourcePublisher(rootPath) ?? (path16.basename(rootPath) || "unknown");
   const opts = {
     registry,
     sidecarManifestFile: scanOpts?.sidecarManifestFile,
@@ -1783,7 +1974,9 @@ var LocalCatalogSource = class {
   async sync(syncOpts) {
     const result = this.scan(syncOpts);
     const exclude = syncOpts?.exclude;
-    const assets = exclude ? result.assets.filter((a) => !exclude(a)) : result.assets;
+    const only = syncOpts?.only;
+    const kept = exclude ? result.assets.filter((a) => !exclude(a)) : result.assets;
+    const assets = only ? kept.filter((a) => only.has(a.ref)) : kept;
     let assetsUpdated = 0;
     const errors = [];
     const softDepsByRef = /* @__PURE__ */ new Map();
@@ -1835,8 +2028,11 @@ var LocalCatalogSource = class {
       );
     }
     const keepRefs = assets.map((a) => a.ref);
-    if (result.assets.length > 0) await this.library.pruneAssetDefs(this.sourceId, keepRefs);
-    return { assetsFound: assets.length, assetsUpdated, errors, advisories };
+    let pruned = [];
+    if (!syncOpts?.only && result.assets.length > 0) {
+      pruned = await this.library.pruneAssetDefs(this.sourceId, keepRefs);
+    }
+    return { assetsFound: assets.length, assetsUpdated, errors, advisories, pruned };
   }
 };
 function defToCatalogAsset(def) {
@@ -1913,7 +2109,7 @@ function installLibraryAsset(opts) {
 }
 function authoringLibraries(libs) {
   const newRoot = getGlobalCacheDir();
-  const legacyRoot = path15.join(globalSkaileDir(), "sources");
+  const legacyRoot = path16.join(globalSkaileDir(), "sources");
   return libs.filter((l) => !l.path.startsWith(newRoot) && !l.path.startsWith(legacyRoot));
 }
 async function scanAuthoringLibraries(index, registry) {
@@ -1975,21 +2171,21 @@ var SidecarGit = class {
    * @docLink packages/library/concepts#sidecar-git
    */
   async ensureInitialized() {
-    if (!fs10.existsSync(this.rootDir)) {
-      fs10.mkdirSync(this.rootDir, { recursive: true });
+    if (!fs11.existsSync(this.rootDir)) {
+      fs11.mkdirSync(this.rootDir, { recursive: true });
     }
-    const gitDir = path15.join(this.rootDir, ".git");
-    const freshRepo = !fs10.existsSync(gitDir);
+    const gitDir = path16.join(this.rootDir, ".git");
+    const freshRepo = !fs11.existsSync(gitDir);
     if (freshRepo) {
       const init = this.spawn(["init", "-b", "main"]);
       if (init.exitCode !== 0) {
         throw new Error(`git init failed: ${init.stderr || init.stdout}`);
       }
     }
-    const attrsPath = path15.join(this.rootDir, ".gitattributes");
-    if (!fs10.existsSync(attrsPath)) fs10.writeFileSync(attrsPath, GITATTRIBUTES, "utf-8");
-    const readmePath = path15.join(this.rootDir, "README.md");
-    if (!fs10.existsSync(readmePath)) fs10.writeFileSync(readmePath, ROOT_README, "utf-8");
+    const attrsPath = path16.join(this.rootDir, ".gitattributes");
+    if (!fs11.existsSync(attrsPath)) fs11.writeFileSync(attrsPath, GITATTRIBUTES, "utf-8");
+    const readmePath = path16.join(this.rootDir, "README.md");
+    if (!fs11.existsSync(readmePath)) fs11.writeFileSync(readmePath, ROOT_README, "utf-8");
     if (!this.hasGlobalGitConfig("user.name")) {
       this.spawn(["config", "user.name", FALLBACK_USER_NAME]);
     }
@@ -2014,8 +2210,8 @@ var SidecarGit = class {
    */
   async commit(slug, message, opts) {
     if (opts?.skip) return;
-    const slugDir = path15.join(this.rootDir, slug);
-    if (fs10.existsSync(slugDir)) {
+    const slugDir = path16.join(this.rootDir, slug);
+    if (fs11.existsSync(slugDir)) {
       this.spawn(["add", "--", slug]);
     } else {
       this.spawn(["add", "-A"]);
@@ -2075,11 +2271,11 @@ ${result.stderr}`;
 };
 function migrateWorkspaceConfig(dir, opts) {
   const filename = opts?.filename ?? "skaile.yaml";
-  const filePath = path15.join(dir, filename);
-  if (!fs10.existsSync(filePath)) {
+  const filePath = path16.join(dir, filename);
+  if (!fs11.existsSync(filePath)) {
     return { migrated: false, version: 1, warnings: ["No skaile.yaml found"] };
   }
-  const content = fs10.readFileSync(filePath, "utf-8");
+  const content = fs11.readFileSync(filePath, "utf-8");
   const raw = parse(content);
   if (!raw || typeof raw !== "object") {
     return { migrated: false, version: 1, warnings: ["Invalid YAML content"] };
@@ -2111,7 +2307,7 @@ function migrateWorkspaceConfig(dir, opts) {
     } else {
       doc.set("version", 2);
     }
-    fs10.writeFileSync(filePath, doc.toString(), "utf-8");
+    fs11.writeFileSync(filePath, doc.toString(), "utf-8");
   }
   return {
     migrated: !opts?.dryRun,
@@ -2300,8 +2496,8 @@ function resolveTemplate(template, context) {
   });
   return { value: result, hasSecret: false };
 }
-function setNestedValue(obj, path17, value) {
-  const parts = path17.split(".");
+function setNestedValue(obj, path18, value) {
+  const parts = path18.split(".");
   let current = obj;
   for (let i = 0; i < parts.length - 1; i++) {
     const key = parts[i];
@@ -2906,8 +3102,8 @@ function deepEqual(a, b) {
 function defaultCatalogCacheDir() {
   const home = globalSkaileDir();
   return migrateLegacyDir(
-    path15.join(globalCacheRoot(), "catalog"),
-    path15.join(home, "catalog-cache")
+    path16.join(globalCacheRoot(), "catalog"),
+    path16.join(home, "catalog-cache")
   );
 }
 var INDEX_FILE = "index.json";
@@ -2916,11 +3112,13 @@ var CatalogCache = class {
   dir;
   ttlMs;
   nowFn;
+  scopePrefix;
   index = null;
   constructor(opts) {
     this.dir = opts.dir ?? defaultCatalogCacheDir();
     this.ttlMs = opts.ttlMs;
     this.nowFn = opts.now ?? Date.now;
+    this.scopePrefix = opts.scope === void 0 ? "" : `${scopeHash(opts.scope)}|`;
     this.ensureDir();
   }
   // ── public: resolve cache ───────────────────────────────────────────────
@@ -2931,8 +3129,7 @@ var CatalogCache = class {
    * regardless of `fetchedAt`.
    */
   getResolve(ref) {
-    const idx = this.loadIndex();
-    const entry = idx.resolve[ref];
+    const entry = this.lookupResolve(ref);
     if (!entry) return null;
     if (this.ttlMs === 0) return entry;
     if (this.nowFn() - entry.fetchedAt > this.ttlMs) return null;
@@ -2942,21 +3139,40 @@ var CatalogCache = class {
    * Return a stale resolve-cache entry regardless of TTL — for stale-while-revalidate.
    */
   getResolveStale(ref) {
-    const idx = this.loadIndex();
-    return idx.resolve[ref] ?? null;
+    return this.lookupResolve(ref);
   }
-  /** Persist a resolve-cache entry (use `null` to negatively cache misses). */
+  /**
+   * Persist a resolve-cache entry (use `null` to negatively cache misses). A found asset
+   * is stored under its canonical ref and shared by every catalog; a miss is only true
+   * of this catalog, so it is stored under the catalog scope.
+   */
   setResolve(ref, value) {
     const idx = this.loadIndex();
-    idx.resolve[ref] = { fetchedAt: this.nowFn(), value };
+    const entry = { fetchedAt: this.nowFn(), value };
+    if (value === null) {
+      idx.resolve[this.scopePrefix + ref] = entry;
+    } else {
+      idx.resolve[ref] = entry;
+      if (this.scopePrefix) delete idx.resolve[this.scopePrefix + ref];
+    }
     this.writeIndex(idx);
   }
+  /**
+   * A shared hit, else this catalog's own miss. An unscoped entry holding `null` was
+   * written before misses were scoped and may belong to another catalog: ignore it.
+   */
+  lookupResolve(ref) {
+    const idx = this.loadIndex();
+    const shared = idx.resolve[ref];
+    if (shared && shared.value !== null) return shared;
+    return idx.resolve[this.scopePrefix + ref] ?? null;
+  }
   // ── public: list cache ──────────────────────────────────────────────────
   /**
    * Return a fresh list-cache entry for `filter`, or `null` if absent / stale.
    */
   getList(filter) {
-    const key = filterKey(filter);
+    const key = this.scopePrefix + filterKey(filter);
     const idx = this.loadIndex();
     const entry = idx.list[key];
     if (!entry) return null;
@@ -2966,13 +3182,13 @@ var CatalogCache = class {
   }
   /** Return a stale list-cache entry regardless of TTL — for stale-while-revalidate. */
   getListStale(filter) {
-    const key = filterKey(filter);
+    const key = this.scopePrefix + filterKey(filter);
     const idx = this.loadIndex();
     return idx.list[key] ?? null;
   }
   /** Persist a list-cache entry. */
   setList(filter, items) {
-    const key = filterKey(filter);
+    const key = this.scopePrefix + filterKey(filter);
     const idx = this.loadIndex();
     idx.list[key] = { fetchedAt: this.nowFn(), items };
     this.writeIndex(idx);
@@ -2980,22 +3196,22 @@ var CatalogCache = class {
   // ── public: tarball cache ───────────────────────────────────────────────
   /** Absolute path where a tarball with `sha256` would be cached. */
   tarballPath(sha256) {
-    return path15.join(this.dir, TARBALL_DIR, `${sha256}.tgz`);
+    return path16.join(this.dir, TARBALL_DIR, `${sha256}.tgz`);
   }
   /** Read a cached tarball from disk if present, otherwise `null`. */
   readTarball(sha256) {
     const p = this.tarballPath(sha256);
-    if (!fs10.existsSync(p)) return null;
-    return fs10.readFileSync(p);
+    if (!fs11.existsSync(p)) return null;
+    return fs11.readFileSync(p);
   }
   /** Persist a tarball blob to disk (atomic write). */
   writeTarball(sha256, bytes) {
-    const dir = path15.join(this.dir, TARBALL_DIR);
-    if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
+    const dir = path16.join(this.dir, TARBALL_DIR);
+    if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
     const finalPath = this.tarballPath(sha256);
     const tmpPath = `${finalPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-    fs10.writeFileSync(tmpPath, bytes);
-    fs10.renameSync(tmpPath, finalPath);
+    fs11.writeFileSync(tmpPath, bytes);
+    fs11.renameSync(tmpPath, finalPath);
   }
   // ── public: invalidation ────────────────────────────────────────────────
   /**
@@ -3014,9 +3230,9 @@ var CatalogCache = class {
    */
   invalidateEverything() {
     this.invalidateAll();
-    const tarballDir = path15.join(this.dir, TARBALL_DIR);
-    if (fs10.existsSync(tarballDir)) {
-      fs10.rmSync(tarballDir, { recursive: true, force: true });
+    const tarballDir = path16.join(this.dir, TARBALL_DIR);
+    if (fs11.existsSync(tarballDir)) {
+      fs11.rmSync(tarballDir, { recursive: true, force: true });
     }
   }
   /** Return whether `ttlMs` is zero (air-gapped mode). */
@@ -3025,22 +3241,22 @@ var CatalogCache = class {
   }
   // ── private ─────────────────────────────────────────────────────────────
   ensureDir() {
-    if (!fs10.existsSync(this.dir)) fs10.mkdirSync(this.dir, { recursive: true });
-    const tarballDir = path15.join(this.dir, TARBALL_DIR);
-    if (!fs10.existsSync(tarballDir)) fs10.mkdirSync(tarballDir, { recursive: true });
+    if (!fs11.existsSync(this.dir)) fs11.mkdirSync(this.dir, { recursive: true });
+    const tarballDir = path16.join(this.dir, TARBALL_DIR);
+    if (!fs11.existsSync(tarballDir)) fs11.mkdirSync(tarballDir, { recursive: true });
   }
   indexPath() {
-    return path15.join(this.dir, INDEX_FILE);
+    return path16.join(this.dir, INDEX_FILE);
   }
   loadIndex() {
     if (this.index) return this.index;
     const p = this.indexPath();
-    if (!fs10.existsSync(p)) {
+    if (!fs11.existsSync(p)) {
       this.index = { version: 1, resolve: {}, list: {} };
       return this.index;
     }
     try {
-      const raw = JSON.parse(fs10.readFileSync(p, "utf-8"));
+      const raw = JSON.parse(fs11.readFileSync(p, "utf-8"));
       if (raw && typeof raw === "object" && raw.version === 1) {
         this.index = {
           version: 1,
@@ -3058,8 +3274,8 @@ var CatalogCache = class {
     this.index = idx;
     const p = this.indexPath();
     const tmp = `${p}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-    fs10.writeFileSync(tmp, JSON.stringify(idx, null, 2), "utf-8");
-    fs10.renameSync(tmp, p);
+    fs11.writeFileSync(tmp, JSON.stringify(idx, null, 2), "utf-8");
+    fs11.renameSync(tmp, p);
   }
 };
 function filterKey(filter) {
@@ -3072,6 +3288,9 @@ function filterKey(filter) {
   }
   return Object.keys(norm).length === 0 ? "__all__" : JSON.stringify(norm);
 }
+function scopeHash(scope) {
+  return crypto.createHash("sha256").update(scope.replace(/\/+$/, "")).digest("hex").slice(0, 16);
+}
 function sha256Hex(bytes) {
   const h = crypto.createHash("sha256");
   h.update(bytes);
@@ -3124,6 +3343,7 @@ var RemoteCatalogSource = class {
     this.cache = opts.cache ?? new CatalogCache({
       dir: opts.cacheDir,
       ttlMs: this.cacheTtlMs,
+      scope: this.baseUrl,
       now: opts.now
     });
   }
@@ -3564,6 +3784,7 @@ var RestCatalogSource = class {
     this.cache = opts.cache ?? new CatalogCache({
       dir: opts.cacheDir,
       ttlMs: this.cacheTtlMs,
+      scope: this.baseUrl,
       now: opts.now
     });
   }
@@ -3894,7 +4115,7 @@ var defaultFetch2 = async (url, init) => {
   });
 };
 function discoveredToAssetEntry(asset, repoPublisher, inheritPublisher) {
-  const root = path15.posix.dirname(asset.relativePath.replace(/\\/g, "/"));
+  const root = path16.posix.dirname(asset.relativePath.replace(/\\/g, "/"));
   const entry = {
     kind: asset.kind,
     name: asset.name,
@@ -3911,22 +4132,22 @@ function discoveredToAssetEntry(asset, repoPublisher, inheritPublisher) {
 }
 function writeCuratedManifest(input) {
   const manifestPath = input.manifestFile;
-  if (fs10.existsSync(manifestPath) && !input.force) {
+  if (fs11.existsSync(manifestPath) && !input.force) {
     return { wrote: false, manifestPath, assetCount: 0 };
   }
   const publisher = input.publisher.startsWith("@") ? input.publisher.slice(1) : input.publisher;
   const inheritPublisher = input.inheritPublisher ?? false;
   const assets = input.assets.map((a) => discoveredToAssetEntry(a, publisher, inheritPublisher)).sort((a, b) => `${a.kind}:${a.name}`.localeCompare(`${b.kind}:${b.name}`));
   const manifest = { publisher, assets };
-  fs10.mkdirSync(path15.dirname(manifestPath), { recursive: true });
-  fs10.writeFileSync(manifestPath, encodeSkaileManifest(manifest), "utf-8");
+  fs11.mkdirSync(path16.dirname(manifestPath), { recursive: true });
+  fs11.writeFileSync(manifestPath, encodeSkaileManifest(manifest), "utf-8");
   return { wrote: true, manifestPath, assetCount: assets.length };
 }
 function openManifest(libraryPath) {
-  const dir = path15.resolve(libraryPath);
-  const file = path15.join(dir, SKAILE_MANIFEST_FILENAME);
-  if (!fs10.existsSync(file)) {
-    fs10.mkdirSync(dir, { recursive: true });
+  const dir = path16.resolve(libraryPath);
+  const file = path16.join(dir, SKAILE_MANIFEST_FILENAME);
+  if (!fs11.existsSync(file)) {
+    fs11.mkdirSync(dir, { recursive: true });
     return { editor: ManifestYamlEditor.create(file), created: true };
   }
   const editor = ManifestYamlEditor.load(file);
@@ -3938,16 +4159,16 @@ function assertManifestEditable(libraryPath) {
   openManifest(libraryPath);
 }
 function conflictingAssetRoot(libraryPath, kind, name, root) {
-  const existing = loadSkPublishManifest(path15.resolve(libraryPath))?.assets?.find(
+  const existing = loadSkPublishManifest(path16.resolve(libraryPath))?.assets?.find(
     (a) => a.kind === kind && a.name === name
   );
   return existingRootConflict(libraryPath, existing, root);
 }
 function existingRootConflict(libraryPath, existing, root) {
   if (!existing?.root || existing.source) return void 0;
-  const existingAbs = path15.resolve(libraryPath, existing.root);
-  if (existingAbs === path15.resolve(libraryPath, root)) return void 0;
-  const stat = fs10.statSync(existingAbs, { throwIfNoEntry: false });
+  const existingAbs = path16.resolve(libraryPath, existing.root);
+  if (existingAbs === path16.resolve(libraryPath, root)) return void 0;
+  const stat = fs11.statSync(existingAbs, { throwIfNoEntry: false });
   return stat?.isDirectory() ? existing.root : void 0;
 }
 function upsertManifestAsset(libraryPath, input) {
@@ -3981,8 +4202,8 @@ function upsertManifestAsset(libraryPath, input) {
 function missingRootAssets(libraryPath, manifest) {
   return (manifest.assets ?? []).filter((a) => {
     if (a.source || manifest.source || !a.root) return false;
-    const dir = path15.resolve(libraryPath, a.root);
-    return !(fs10.existsSync(dir) && fs10.statSync(dir).isDirectory());
+    const dir = path16.resolve(libraryPath, a.root);
+    return !(fs11.existsSync(dir) && fs11.statSync(dir).isDirectory());
   });
 }
 function pruneMissingRootAssets(libraryPath) {
@@ -4021,18 +4242,19 @@ function setManifestPublisher(libraryPath, publisher) {
   editor.save();
   return true;
 }
-async function syncManifestWithDisk(libraryPath, defaultPublisher, registry) {
+async function syncManifestWithDisk(libraryPath, defaultPublisher, registry, opts = {}) {
   stampManifestPublisher(libraryPath, defaultPublisher);
   const knownKinds = new Set(registry.getAllKinds());
   const unknownKind = pruneUnknownKindAssets(libraryPath, knownKinds);
   const removed = pruneMissingRootAssets(libraryPath);
   const skipped = [];
+  const failed = [];
   const publisher = loadSkPublishManifest(libraryPath)?.publisher ?? defaultPublisher;
   const scanned = await scanDirectory(libraryPath, publisher, {
     knownKinds,
     keepDuplicates: true
   });
-  const rootOf = (e) => path15.relative(libraryPath, path15.dirname(e.source)) || e.name;
+  const rootOf = (e) => path16.relative(libraryPath, path16.dirname(e.source)) || e.name;
   const copiesOf = /* @__PURE__ */ new Map();
   for (const e of scanned) {
     const key = `${e.kind}:${e.name}`;
@@ -4045,6 +4267,9 @@ async function syncManifestWithDisk(libraryPath, defaultPublisher, registry) {
     );
     if (copies.length > 1 && !claimed) unclaimed.add(key);
   }
+  const listedAtStart = new Set(
+    (loadSkPublishManifest(libraryPath)?.assets ?? []).map((a) => `${a.kind}:${a.name}`)
+  );
   for (const e of scanned) {
     if (!isParsable(e.source)) {
       skipped.push({
@@ -4052,7 +4277,7 @@ async function syncManifestWithDisk(libraryPath, defaultPublisher, registry) {
         name: e.name,
         reason: "unparsable",
         detail: "manifest file could not be parsed",
-        file: path15.relative(libraryPath, e.source)
+        file: path16.relative(libraryPath, e.source)
       });
       continue;
     }
@@ -4062,7 +4287,7 @@ async function syncManifestWithDisk(libraryPath, defaultPublisher, registry) {
         name: e.name,
         reason: "invalid-version",
         detail: `version "${e.version}" is not valid semver`,
-        file: path15.relative(libraryPath, e.source)
+        file: path16.relative(libraryPath, e.source)
       });
       continue;
     }
@@ -4077,10 +4302,23 @@ async function syncManifestWithDisk(libraryPath, defaultPublisher, registry) {
         name: e.name,
         reason: "duplicate",
         detail: conflict,
-        file: path15.relative(libraryPath, e.source)
+        file: path16.relative(libraryPath, e.source)
       });
       continue;
     }
+    const findings = opts.check?.(e) ?? [];
+    const known = listedAtStart.has(`${e.kind}:${e.name}`);
+    const inManifest = known || !(findings.length > 0 && !e.version);
+    if (findings.length > 0) {
+      failed.push({
+        kind: e.kind,
+        name: e.name,
+        file: path16.relative(libraryPath, e.source),
+        findings,
+        inManifest
+      });
+    }
+    if (!inManifest) continue;
     upsertManifestAsset(libraryPath, {
       kind: e.kind,
       name: e.name,
@@ -4088,11 +4326,35 @@ async function syncManifestWithDisk(libraryPath, defaultPublisher, registry) {
       version: e.version
     });
   }
-  return { removed, unknownKind, skipped };
+  return { removed, unknownKind, skipped, failed };
+}
+async function scanUnlistedAssets(libraryPath, publisher, registry) {
+  const manifest = loadSkPublishManifest(libraryPath);
+  if (!manifest || manifest.source) return [];
+  const entries = manifest.assets ?? [];
+  const roots = entries.flatMap(
+    (a) => a.root && !a.source ? [path16.resolve(libraryPath, a.root)] : []
+  );
+  const scanned = await scanDirectory(libraryPath, manifest.publisher ?? publisher, {
+    knownKinds: new Set(registry.getAllKinds()),
+    keepDuplicates: true
+  });
+  const out = [];
+  for (const e of scanned) {
+    const file = path16.resolve(e.source);
+    if (roots.some((r) => file === r || file.startsWith(r + path16.sep))) continue;
+    const registered = entries.find((a) => a.kind === e.kind && a.name === e.name && a.root);
+    out.push({
+      entry: e,
+      root: path16.relative(libraryPath, path16.dirname(e.source)) || e.name,
+      ...registered?.root ? { registeredAt: registered.root } : {}
+    });
+  }
+  return out;
 }
 function isParsable(file) {
   try {
-    return parseManifestFile(file, fs10.readFileSync(file, "utf-8")).ok;
+    return parseManifestFile(file, fs11.readFileSync(file, "utf-8")).ok;
   } catch {
     return false;
   }
@@ -4149,33 +4411,33 @@ function parseWorkspaceV2(raw) {
   return WorkspaceConfigV2Schema.parse(raw);
 }
 function loadWorkspaceV2(dir, filename = "skaile.yaml") {
-  const filePath = path15.join(dir, filename);
-  if (!fs10.existsSync(filePath)) return null;
-  const content = fs10.readFileSync(filePath, "utf-8");
+  const filePath = path16.join(dir, filename);
+  if (!fs11.existsSync(filePath)) return null;
+  const content = fs11.readFileSync(filePath, "utf-8");
   const raw = parse(content);
   if (!raw || typeof raw !== "object") return null;
   return parseWorkspaceV2(raw);
 }
 function saveWorkspaceV2(dir, v2, filename = "skaile.yaml") {
-  const filePath = path15.join(dir, filename);
+  const filePath = path16.join(dir, filename);
   let existing = {};
-  if (fs10.existsSync(filePath)) {
-    const content = fs10.readFileSync(filePath, "utf-8");
+  if (fs11.existsSync(filePath)) {
+    const content = fs11.readFileSync(filePath, "utf-8");
     existing = parse(content) ?? {};
   }
   existing.version = 2;
   if (v2.library !== void 0) existing.library = v2.library;
   if (v2.presets_applied !== void 0) existing.presets_applied = v2.presets_applied;
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
-  fs10.writeFileSync(filePath, stringify(existing, { indent: 2 }), "utf-8");
+  fs11.writeFileSync(filePath, stringify(existing, { indent: 2 }), "utf-8");
 }
 var LOCK_FILENAME = "skaile.lock.yaml";
 function loadLockFile(dir) {
-  const filePath = path15.join(dir, LOCK_FILENAME);
-  if (!fs10.existsSync(filePath)) return null;
-  const content = fs10.readFileSync(filePath, "utf-8");
+  const filePath = path16.join(dir, LOCK_FILENAME);
+  if (!fs11.existsSync(filePath)) return null;
+  const content = fs11.readFileSync(filePath, "utf-8");
   const raw = parse(content);
   if (raw !== null && !("assignments" in raw) && "subscriptions" in raw) {
     const legacySubs = raw.subscriptions;
@@ -4191,11 +4453,11 @@ function loadLockFile(dir) {
   return LockFileSchema.parse(raw);
 }
 function saveLockFile(dir, lock) {
-  const filePath = path15.join(dir, LOCK_FILENAME);
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
+  const filePath = path16.join(dir, LOCK_FILENAME);
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
-  fs10.writeFileSync(
+  fs11.writeFileSync(
     filePath,
     `# Auto-generated by skaile. Do not edit manually.
 ${stringify(lock, { indent: 2 })}`,
@@ -4212,14 +4474,14 @@ function createEmptyLockFile() {
   };
 }
 function detectWorkspaceVersion(dir, filename = "skaile.yaml") {
-  const filePath = path15.join(dir, filename);
-  if (!fs10.existsSync(filePath)) return null;
-  const content = fs10.readFileSync(filePath, "utf-8");
+  const filePath = path16.join(dir, filename);
+  if (!fs11.existsSync(filePath)) return null;
+  const content = fs11.readFileSync(filePath, "utf-8");
   const raw = parse(content);
   if (!raw || typeof raw !== "object") return null;
   return raw.version === 2 ? 2 : 1;
 }
 
-export { AssignmentNotFoundError, CatalogCache, CatalogConfigSchema, CatalogHttpError, DuplicateAssignmentError, DuplicateLibraryNameError, GitSyncDriver, InstanceHasConsumersError, InstanceNotFoundError, InterpolationError, KnowledgeManifestSchema, LIBRARY_BACKENDS, LIBRARY_OWNERSHIPS, LOCAL_CATALOG_URL, LibraryConfigSchema, LibraryError, LibraryInstanceRefSchema, LibraryManager, LibrarySectionSchema, LibrarySyncError, LocalCatalogSource, LocalIndex, LocalSyncDriver, LockAssignmentSchema, LockFileSchema, OfflineError, OperationNotPermittedError, PIN_POLICIES, PinPolicySchema, PresetAppliedSchema, PresetExpandedSchema, RemoteCatalogSource, RequiresEdgeSchema, RestCatalogSource, SidecarGit, SkaileConfigSchema, SourceNotFoundError, TarballHashMismatchError, UserLibraryNotFoundError, WorkspaceConfigV2Schema, applyNonStructuralUpgrade, applyPreset, applyPresetFromData, assertManifestEditable, assertValidLibraryName, classifyRef, cloneOrInitGitRepo, conflictingAssetRoot, createEmptyLockFile, curatedManifestOverlay, deriveSlug, detectChanges, detectNestedPresetRefs, detectWorkspaceVersion, ensureGitRepo, evaluateUpgrade, extractLibraryInstanceId, extractReferencedKeys, filterKey, getConfigDefaults, getDefaultValue, getSidecarRoot, getStoreManifestsDir, getStoreRoot, hasInterpolationTokens, installLibraryAsset, interpolate, isGitRepo, isLocalCatalogUrl, isSecretPlaceholder, knowledgeKindProvider, listSidecarSlugsOnDisk, loadLockFile, loadWorkspaceV2, migrateSidecarsToStoreIfNeeded, migrateWorkspaceConfig, missingRootAssets, parsePreset, parsePresetYaml, parseWorkspaceV2, projectConfigPath, pruneMissingRootAssets, queryInstancePickerChoices, resolveAllItems, resolveConfig, resolveIndexPath, resolveItem, resolvePin, resolveSidecarPaths, saveConfig, saveLockFile, saveWorkspaceV2, scanAuthoringLibraries, scanLibraryRoot, setManifestPublisher, setOriginUrl, sha256Hex, stampManifestPublisher, storeSecrets, syncManifestWithDisk, trackOriginBranch, trpcGetUrl, upsertManifestAsset, validateAllPlaceholders, validateKnowledge, validateNestingDepth, validatePlaceholder, writeCuratedManifest };
-//# sourceMappingURL=chunk-4MQS7CAF.js.map
-//# sourceMappingURL=chunk-4MQS7CAF.js.map
+export { AssignmentNotFoundError, CatalogCache, CatalogConfigSchema, CatalogHttpError, DuplicateAssignmentError, DuplicateLibraryNameError, GitSyncDriver, InstanceHasConsumersError, InstanceNotFoundError, InterpolationError, KnowledgeManifestSchema, LIBRARY_BACKENDS, LIBRARY_OWNERSHIPS, LOCAL_CATALOG_URL, LibraryConfigSchema, LibraryError, LibraryInstanceRefSchema, LibraryManager, LibrarySectionSchema, LibrarySyncError, LocalCatalogSource, LocalIndex, LocalSyncDriver, LockAssignmentSchema, LockFileSchema, OfflineError, OperationNotPermittedError, PIN_POLICIES, PinPolicySchema, PresetAppliedSchema, PresetExpandedSchema, RemoteCatalogSource, RequiresEdgeSchema, RestCatalogSource, SidecarGit, SkaileConfigSchema, SourceNotFoundError, TarballHashMismatchError, UserLibraryNotFoundError, WorkspaceConfigV2Schema, applyNonStructuralUpgrade, applyPreset, applyPresetFromData, assertManifestEditable, assertValidLibraryName, classifyRef, cloneOrInitGitRepo, conflictingAssetRoot, createEmptyLockFile, curatedManifestOverlay, deriveSlug, detectChanges, detectNestedPresetRefs, detectWorkspaceVersion, ensureGitRepo, evaluateUpgrade, extractLibraryInstanceId, extractReferencedKeys, filterKey, getConfigDefaults, getDefaultValue, getSidecarRoot, getStoreManifestsDir, getStoreRoot, hasInterpolationTokens, installLibraryAsset, interpolate, isGitRepo, isLocalCatalogUrl, isSecretPlaceholder, knowledgeKindProvider, libraryDirMissing, listSidecarSlugsOnDisk, loadLockFile, loadWorkspaceV2, markLibraryUnregistered, migrateSidecarsToStoreIfNeeded, migrateWorkspaceConfig, missingLibraryDirMessage, missingRootAssets, parsePreset, parsePresetYaml, parseWorkspaceV2, projectConfigPath, pruneMissingRootAssets, queryInstancePickerChoices, recordLibraryRename, renamedLibraryName, resolveAllItems, resolveConfig, resolveIndexPath, resolveItem, resolvePin, resolveSidecarPaths, saveConfig, saveLockFile, saveWorkspaceV2, scanAuthoringLibraries, scanLibraryRoot, scanUnlistedAssets, setManifestPublisher, setOriginUrl, sha256Hex, stampManifestPublisher, storeSecrets, syncManifestWithDisk, trackOriginBranch, trpcGetUrl, unregisteredLibraryNames, upsertManifestAsset, validateAllPlaceholders, validateKnowledge, validateNestingDepth, validatePlaceholder, writeCuratedManifest };
+//# sourceMappingURL=chunk-2F5AWQX5.js.map
+//# sourceMappingURL=chunk-2F5AWQX5.js.map