@skaile/workspaces 1.5.0 → 1.6.1

package/dist/cli/index.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import { AI_RESOURCES, aiResourceRoots } from '../chunk-2ZMO4CFG.js';
-import { getStoreConfig, storeFetch, deviceLogin, loadStoreAuthConfig, logout, hasStoredAuth, isStoreAuthenticated, getStoreToken } from '../chunk-J5TI55E7.js';
-import { makeSourceCommand, syncProjectSources } from '../chunk-WYGXYGJH.js';
-import { openCatalogSource, openLibraryManager, createFullRegistry, openLibrary } from '../chunk-RSYV7XEN.js';
-import { logErr, S, logOk, logInfo, colorRef, logWarn, kindColorPad, kindColor, formatSoftDepSection, bareSoftDepName, formatSoftDepHint, formatRelativeTime, fitWidth, formatSoftDepRemovePreview, formatSoftDepAddPreview } from '../chunk-KMY7HVQ6.js';
+import { AI_RESOURCES, aiResourceRoots } from '../chunk-VK24PIAB.js';
+import { getStoreConfig, storeFetch, deviceLogin, loadStoreAuthConfig, logout, hasStoredAuth, isStoreAuthenticated, getStoreToken } from '../chunk-Y5B5272E.js';
+import { makeSourceCommand, syncProjectSources } from '../chunk-NTYCGPZ3.js';
+import { openCatalogSource, openLibraryManager, createFullRegistry, openLibrary } from '../chunk-X7G2CCW4.js';
+import { logErr, S, logOk, logInfo, colorRef, logWarn, kindColorPad, kindColor, formatSoftDepSection, bareSoftDepName, formatSoftDepHint, formatRelativeTime, formatSoftDepRemovePreview, formatSoftDepAddPreview, fitWidth } from '../chunk-SH55Z5QA.js';
 import { LocalSecretsProvider } from '../chunk-6BEGKO2Q.js';
-import { runFlow, resumeFlow } from '../chunk-CNSNN7N6.js';
+import { runFlow, resumeFlow } from '../chunk-HIATVS2E.js';
 import '../chunk-4R6DROGN.js';
 import { validateFlowVersions, parseSkillFrontmatter } from '../chunk-GXC3TYMQ.js';
-import { runAgentChat, loadSessionById, loadSession, listSessions, setCurrentSession, deleteSession, clearSession, loadAgentManifest, compileComposition, MarkdownStreamer, resolveMixin } from '../chunk-BGIC25VK.js';
-import { buildClaudePluginFiles } from '../chunk-RDYOU6N6.js';
+import { runAgentChat, loadSessionById, loadSession, listSessions, setCurrentSession, deleteSession, clearSession, loadAgentManifest, compileComposition, MarkdownStreamer, resolveMixin } from '../chunk-M4UKIJ5K.js';
+import { buildClaudePluginFiles } from '../chunk-EA73UA42.js';
 import '../chunk-X5YPJV4N.js';
 import '../chunk-O7SG5PC2.js';
 import '../chunk-7QBNJTTQ.js';
@@ -24,27 +24,27 @@ import '../chunk-BMQKMOQY.js';
 import '../chunk-GAH4YRCI.js';
 import '../chunk-TNSCHS4I.js';
 import '../chunk-LV2HPH3C.js';
-import '../chunk-DMG6NJH7.js';
-import '../chunk-KEQ4GLVM.js';
+import '../chunk-NRWDQBZ7.js';
+import '../chunk-OJ7G56I7.js';
 import '../chunk-6E6PKKAD.js';
 import { loadFlow, loadAllFlows } from '../chunk-4N5XR5DQ.js';
 import '../chunk-DEYYRFQU.js';
 import '../chunk-IFGTRL2I.js';
 import '../chunk-PK7Q7MC7.js';
-import { AssetManager, NON_DEPLOYABLE_KINDS, MissingManifestError, normalizeRepoUrl, FACTORY_SOURCE_URL } from '../chunk-3CHARYD4.js';
-import { resolveLibraryDir, getStoreManifestsDir, getDefaultValue, isSecretPlaceholder } from '../chunk-FDE7XRQA.js';
+import { AssetManager, NON_DEPLOYABLE_KINDS, MissingManifestError, normalizeRepoUrl, FACTORY_SOURCE_URL } from '../chunk-MY7TSVO7.js';
+import { resolveLibraryDir, getStoreManifestsDir, getDefaultValue, isSecretPlaceholder } from '../chunk-MWE7DEGC.js';
 import '../chunk-MZV6WCF3.js';
 import '../chunk-JXT46QFC.js';
 import '../chunk-UKJMQZV6.js';
 import '../chunk-R7FOF242.js';
-import '../chunk-6NR2BEIY.js';
+import '../chunk-STQOPWPS.js';
 import '../chunk-CGYEHQOX.js';
-import { readLock, resolveSettings, globalSettingsPath, projectSettingsPath, loadSettings, saveSettings, portableSpawn, portableSpawnSync, WorkspaceYamlEditor, checkAgentSkillConformance } from '../chunk-HY33RMEA.js';
+import { readLock, resolveSettings, globalSettingsPath, projectSettingsPath, loadSettings, saveSettings, portableSpawn, portableSpawnSync, WorkspaceYamlEditor, checkAgentSkillConformance } from '../chunk-5NZ56R63.js';
 import { assetSearchDirs, detectDomains } from '../chunk-ZAP2BDHG.js';
-import { factoryAssetRoots } from '../chunk-ZBZQC5R7.js';
-import { globalCacheRoot, sourceCacheKey, getGlobalCacheDir, resolveAgentDir, loadSkWorkspaceConfig, resolveSkWorkspaceConfig, storeManifestSlug } from '../chunk-UQKYT4V6.js';
+import { factoryAssetRoots } from '../chunk-7J7LQP6T.js';
+import { globalCacheRoot, sourceCacheKey, getGlobalCacheDir, resolveAgentDir, matchPin, coerceVersion, loadSkWorkspaceConfig, resolveSkWorkspaceConfig, storeManifestSlug } from '../chunk-ISA7R7PK.js';
 import { SKAILE_MANIFEST_FILENAME, decodeSkaileManifest, loadSkPublishManifest, saveSkPublishManifest } from '../chunk-P4VHQA4N.js';
-import { parseFrontmatter } from '../chunk-BQCGFPHW.js';
+import { parseFrontmatter, scanDirectory } from '../chunk-BQCGFPHW.js';
 import { parseAssetRef, ASSET_KINDS, isValidAssetName, slugifyAssetName, ASSET_NAME_HINT, assetRefToStr } from '../chunk-GEEW6SY2.js';
 import '../chunk-F3HNW354.js';
 import { SUPPORTED_DRIVER_TARGETS } from '../chunk-MENCWIHW.js';
@@ -55,12 +55,13 @@ import '../chunk-UQ6LFBPZ.js';
 import '../chunk-IEX5YV4R.js';
 import { validatePreset } from '../chunk-IRORTHGA.js';
 import '../chunk-NSBPE2FW.js';
-import * as fs12 from 'fs';
-import fs12__default, { readFileSync, existsSync, mkdirSync, writeFileSync, lstatSync, rmSync, readdirSync, statSync } from 'fs';
+import * as fs13 from 'fs';
+import fs13__default, { readFileSync, existsSync, mkdirSync, writeFileSync, lstatSync, rmSync, readdirSync, statSync } from 'fs';
 import * as path14 from 'path';
 import path14__default, { resolve, join } from 'path';
 import { fileURLToPath } from 'url';
 import { Help, Command, Option } from 'commander';
+import { rcompare } from 'semver';
 import * as p6 from '@clack/prompts';
 import pc5 from 'picocolors';
 import * as os from 'os';
@@ -104,7 +105,7 @@ async function runSearch(kind, query, opts) {
   }
 }
 async function searchIndex(query, kind) {
-  const { openLibrary: openLibrary2 } = await import('../open-library-4HMIDK3N.js');
+  const { openLibrary: openLibrary2 } = await import('../open-library-ODW2PJ2J.js');
   const library = await openLibrary2();
   try {
     const defs = await library.listAssetDefs(kind ? { kind } : {});
@@ -156,7 +157,7 @@ async function searchLocal(query, kind, opts, showStore, airGapped) {
   const factory = searchFactory(projectDir, query, kind);
   let entries = unionEntries(await searchIndex(query, kind), factory);
   if (entries.length === 0 && !query && !kind && !airGapped) {
-    const { autoSyncForSearch } = await import('../source-LOAM7IIQ.js');
+    const { autoSyncForSearch } = await import('../source-KPH66TXY.js');
     if (await autoSyncForSearch(projectDir)) {
       entries = unionEntries(await searchIndex(query, kind), factory);
     }
@@ -210,7 +211,7 @@ async function searchStore(query, kind, opts, airGapped) {
     logInfo("air-gapped (cache_ttl: 0) \u2014 local sources only");
     return;
   }
-  const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError } = await import('../open-library-4HMIDK3N.js');
+  const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError } = await import('../open-library-ODW2PJ2J.js');
   try {
     const remote = await openCatalogSource2({ projectDir: path14__default.resolve(opts.projectDir) });
     const assets = await remote.listAssets(kind ? { kind } : {});
@@ -575,16 +576,16 @@ function claudeSkillRoots() {
 }
 function resolveImportSource(nameOrPath) {
   const asPath = path14.resolve(nameOrPath);
-  if (fs12.existsSync(asPath)) {
-    const dir = fs12.statSync(asPath).isDirectory() ? asPath : path14.dirname(asPath);
+  if (fs13.existsSync(asPath)) {
+    const dir = fs13.statSync(asPath).isDirectory() ? asPath : path14.dirname(asPath);
     const skillFile = path14.join(dir, "SKILL.md");
-    if (fs12.existsSync(skillFile)) return { dir, skillFile, via: "path" };
+    if (fs13.existsSync(skillFile)) return { dir, skillFile, via: "path" };
   }
   if (!nameOrPath.includes(path14.sep) && !nameOrPath.startsWith(".")) {
     for (const root of claudeSkillRoots()) {
       const dir = path14.join(root, nameOrPath);
       const skillFile = path14.join(dir, "SKILL.md");
-      if (fs12.existsSync(skillFile)) return { dir, skillFile, via: "claude-skills" };
+      if (fs13.existsSync(skillFile)) return { dir, skillFile, via: "claude-skills" };
     }
   }
   return null;
@@ -652,17 +653,17 @@ function ensureDomain(libraryPath, domain, opts = {}) {
   const dir = path14.join(libraryPath, domain);
   const domainFile = path14.join(dir, "DOMAIN.md");
   const publisher = opts.publisher ?? slugifyAssetName(domain);
-  if (fs12.existsSync(domainFile)) {
+  if (fs13.existsSync(domainFile)) {
     return { dir, publisher, created: false };
   }
-  fs12.mkdirSync(dir, { recursive: true });
+  fs13.mkdirSync(dir, { recursive: true });
   const description = opts.description ?? `The ${domain} domain.`;
-  fs12.writeFileSync(domainFile, DOMAIN_TEMPLATE(domain, publisher, description), "utf8");
+  fs13.writeFileSync(domainFile, DOMAIN_TEMPLATE(domain, publisher, description), "utf8");
   return { dir, publisher, created: true };
 }
 function listDomains(libraryPath) {
-  if (!fs12.existsSync(libraryPath)) return [];
-  return fs12.readdirSync(libraryPath, { withFileTypes: true }).filter((e) => e.isDirectory() && fs12.existsSync(path14.join(libraryPath, e.name, "DOMAIN.md"))).map((e) => e.name).sort();
+  if (!fs13.existsSync(libraryPath)) return [];
+  return fs13.readdirSync(libraryPath, { withFileTypes: true }).filter((e) => e.isDirectory() && fs13.existsSync(path14.join(libraryPath, e.name, "DOMAIN.md"))).map((e) => e.name).sort();
 }
 function upsertManifestAsset(libraryPath, input) {
   const manifest = loadSkPublishManifest(libraryPath) ?? { assets: [] };
@@ -684,6 +685,25 @@ function upsertManifestAsset(libraryPath, input) {
 }
 
 // cli/src/commands/asset-cmd.ts
+async function resolveDefByRef(library, ref, opts) {
+  const inScope = (d) => !opts?.fromLibraryId || d.libraryId === opts.fromLibraryId;
+  const direct = await library.getAssetDef(ref);
+  if (direct && inScope(direct)) return direct;
+  let parsed;
+  try {
+    parsed = parseAssetRef(ref);
+  } catch {
+    return null;
+  }
+  const wantPublisher = parsed.publisher?.replace(/^@/, "");
+  const defs = await library.listAssetDefs({ kind: parsed.kind });
+  const matches = defs.filter(
+    (d) => d.name === parsed.name && inScope(d) && (wantPublisher === void 0 || d.publisher.replace(/^@/, "") === wantPublisher) && matchPin(parsed.pin, d.version)
+  );
+  if (matches.length === 0) return null;
+  matches.sort((a, b) => rcompare(coerceVersion(a.version), coerceVersion(b.version)));
+  return matches[0];
+}
 function makeAssetCommand() {
   const cmd = new Command("asset").description("Author and install AI assets");
   cmd.command("import <name-or-path>").description("Import + skailify an existing coding-agent skill into a library").option("--to <library>", "Target library (default: auto / personal)").option("--domain <name>", "Place under this domain's skills/ (created if missing)").option("--version <semver>", "Version to stamp when the skill ships none").option("--stage <stage>", "Lifecycle stage to stamp (default: alpha)").option("--no-normalize", "Copy verbatim \u2014 skip frontmatter normalization").option("--commit", "Auto-commit in git-backed libraries", false).action(
@@ -712,7 +732,7 @@ function makeAssetCommand() {
           logErr(`Library "${target.name}" is read-only (ownership=reader). Choose --to.`);
           process.exit(1);
         }
-        const rawSkill = fs12.readFileSync(src.skillFile, "utf8");
+        const rawSkill = fs13.readFileSync(src.skillFile, "utf8");
         const norm = opts.normalize ? normalizeSkillContent(rawSkill, {
           fallbackName: path14.basename(src.dir),
           version: opts.version,
@@ -731,14 +751,14 @@ function makeAssetCommand() {
           destParent = path14.join(dom.dir, "skills");
           publisher = dom.publisher;
         }
-        fs12.mkdirSync(destParent, { recursive: true });
+        fs13.mkdirSync(destParent, { recursive: true });
         const destDir = path14.join(destParent, norm.name);
-        if (fs12.existsSync(destDir)) {
+        if (fs13.existsSync(destDir)) {
           logErr(`Destination already exists: ${destDir}`);
           process.exit(1);
         }
-        fs12.cpSync(src.dir, destDir, { recursive: true });
-        fs12.writeFileSync(path14.join(destDir, "SKILL.md"), norm.content, "utf8");
+        fs13.cpSync(src.dir, destDir, { recursive: true });
+        fs13.writeFileSync(path14.join(destDir, "SKILL.md"), norm.content, "utf8");
         for (const note of norm.notes) logInfo(`  \u2022 ${note}`);
         const fm = parseFrontmatter(norm.content).data;
         const descRaw = fm.description;
@@ -780,7 +800,7 @@ function makeAssetCommand() {
         logErr(`Invalid --mode "${opts.mode}". Expected: copy | move | link.`);
         process.exit(1);
       }
-      if (!fs12.existsSync(srcPath)) {
+      if (!fs13.existsSync(srcPath)) {
         logErr(`Source path does not exist: ${srcPath}`);
         process.exit(1);
       }
@@ -809,21 +829,21 @@ function makeAssetCommand() {
         }
         const basename2 = path14.basename(srcPath);
         const destDir = target.structure === "domain" && opts.domain ? path14.join(target.path, opts.domain) : target.path;
-        fs12.mkdirSync(destDir, { recursive: true });
+        fs13.mkdirSync(destDir, { recursive: true });
         const destPath = path14.join(destDir, basename2);
-        if (fs12.existsSync(destPath)) {
+        if (fs13.existsSync(destPath)) {
           logErr(`Destination already exists: ${destPath}`);
           process.exit(1);
         }
         switch (opts.mode) {
           case "copy":
-            fs12.cpSync(srcPath, destPath, { recursive: true });
+            fs13.cpSync(srcPath, destPath, { recursive: true });
             break;
           case "move":
-            fs12.renameSync(srcPath, destPath);
+            fs13.renameSync(srcPath, destPath);
             break;
           case "link":
-            fs12.symlinkSync(path14.resolve(srcPath), destPath);
+            fs13.symlinkSync(path14.resolve(srcPath), destPath);
             break;
         }
         if (target.backend === "git" && opts.commit) {
@@ -858,7 +878,16 @@ function makeAssetCommand() {
       }
       const { manager, library, close } = await openLibraryManager();
       try {
-        const def = await library.getAssetDef(ref);
+        let fromLibraryId;
+        if (opts.from) {
+          const match = (await manager.listLibraries()).find((l) => l.name === opts.from);
+          if (!match) {
+            logErr(`Unknown library "${opts.from}". Run \`skaile library list\`.`);
+            process.exit(1);
+          }
+          fromLibraryId = match.id;
+        }
+        const def = await resolveDefByRef(library, ref, { fromLibraryId });
         if (!def) {
           logErr(`No asset found for ref "${ref}". Try \`skaile search\`.`);
           process.exit(1);
@@ -869,22 +898,19 @@ function makeAssetCommand() {
           logErr(`Asset has no associated library; install path unknown.`);
           process.exit(1);
         }
-        if (opts.from && lib.name !== opts.from) {
-          logWarn(`Asset belongs to "${lib.name}", but --from=${opts.from} was specified.`);
-        }
         const manifestPath = def.manifest.path;
         const candidateSubpath = typeof manifestPath === "string" && manifestPath.length > 0 ? manifestPath : def.name;
         const srcPath = path14.join(lib.path, candidateSubpath);
-        if (!fs12.existsSync(srcPath)) {
+        if (!fs13.existsSync(srcPath)) {
           logErr(`Asset path not found: ${srcPath}`);
           process.exit(1);
         }
         const destPath = path14.join(target, candidateSubpath);
-        fs12.mkdirSync(path14.dirname(destPath), { recursive: true });
+        fs13.mkdirSync(path14.dirname(destPath), { recursive: true });
         if (opts.mode === "copy") {
-          fs12.cpSync(srcPath, destPath, { recursive: true });
+          fs13.cpSync(srcPath, destPath, { recursive: true });
         } else {
-          fs12.symlinkSync(path14.resolve(srcPath), destPath);
+          fs13.symlinkSync(path14.resolve(srcPath), destPath);
         }
         logOk(`Installed ${ref} \u2192 ${destPath} (${opts.mode})`);
       } finally {
@@ -896,7 +922,7 @@ function makeAssetCommand() {
   cmd.command("show <ref>").description("Show details for an asset by canonical ref").action(async (ref) => {
     const { library, close } = await openLibraryManager();
     try {
-      const def = await library.getAssetDef(ref);
+      const def = await resolveDefByRef(library, ref);
       if (!def) {
         logErr(`Not found: ${ref}`);
         process.exit(1);
@@ -1074,7 +1100,7 @@ function makeCatalogCommand() {
   return catalog;
 }
 async function runLocalCatalogTest(projectDir) {
-  const { resolveCatalogSource } = await import('../open-library-4HMIDK3N.js');
+  const { resolveCatalogSource } = await import('../open-library-ODW2PJ2J.js');
   let resolved;
   try {
     resolved = await resolveCatalogSource({ projectDir });
@@ -1208,7 +1234,7 @@ function findFlowFile(flowId, priorityRoots = []) {
     for (const { dir } of assetSearchDirs(root, "flows")) {
       for (const ext of [".flow.yaml", ".flow.json", ".json"]) {
         const candidate = path14__default.join(dir, `${flowId}${ext}`);
-        if (fs12__default.existsSync(candidate)) return candidate;
+        if (fs13__default.existsSync(candidate)) return candidate;
       }
     }
   }
@@ -1218,7 +1244,7 @@ function findSkills(domain) {
   const found = [];
   for (const root of aiResourceRoots()) {
     for (const { dir, domain: dirDomain } of assetSearchDirs(root, "skills")) {
-      if (fs12__default.existsSync(dir)) walkSkills(dir, dirDomain, found);
+      if (fs13__default.existsSync(dir)) walkSkills(dir, dirDomain, found);
     }
   }
   const seen = /* @__PURE__ */ new Set();
@@ -1231,11 +1257,11 @@ function findSkills(domain) {
   return deduped;
 }
 function walkSkills(dir, domain, out) {
-  for (const entry of fs12__default.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs13__default.readdirSync(dir, { withFileTypes: true })) {
     const full = path14__default.join(dir, entry.name);
     if (entry.isDirectory()) {
       const skillMd = path14__default.join(full, "SKILL.md");
-      if (fs12__default.existsSync(skillMd)) {
+      if (fs13__default.existsSync(skillMd)) {
         out.push({ name: entry.name, path: full, skillPath: skillMd, domain });
       } else {
         walkSkills(full, domain, out);
@@ -1264,9 +1290,9 @@ function resolveFlowIds() {
 }
 function resolveSessionIds(projectDir) {
   const sessionsDir = path14__default.join(projectDir, ".skaile", "sessions");
-  if (!fs12__default.existsSync(sessionsDir)) return [];
+  if (!fs13__default.existsSync(sessionsDir)) return [];
   try {
-    return fs12__default.readdirSync(sessionsDir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
+    return fs13__default.readdirSync(sessionsDir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
   } catch {
     return [];
   }
@@ -1582,10 +1608,10 @@ function parsePositiveIntOption(value) {
   }
   return n;
 }
-function scanFactoryConnectors(scanDirectory, roots) {
+function scanFactoryConnectors(scanDirectory2, roots) {
   const byName = /* @__PURE__ */ new Map();
   for (const dir of roots) {
-    for (const e of scanDirectory(dir, "factory-assets")) {
+    for (const e of scanDirectory2(dir, "factory-assets")) {
       if (e.kind === "connector" && !byName.has(e.name)) byName.set(e.name, e);
     }
   }
@@ -1693,8 +1719,8 @@ async function promptField(field) {
 function makeConnectorCommand() {
   const cmd = new Command("connector").description("Operate on connectors in a workspace");
   cmd.command("catalog").description("List all available connector drivers and their dependencies").action(async () => {
-    const { scanDirectory, factoryAssetRoots: factoryAssetRoots2 } = await import('../core/index.js');
-    const entries = scanFactoryConnectors(scanDirectory, factoryAssetRoots2());
+    const { scanDirectory: scanDirectory2, factoryAssetRoots: factoryAssetRoots2 } = await import('../core/index.js');
+    const entries = scanFactoryConnectors(scanDirectory2, factoryAssetRoots2());
     if (entries.length === 0) {
       console.log("No connector descriptors found.");
       return;
@@ -1718,14 +1744,14 @@ function makeConnectorCommand() {
   cmd.command("add <driver>").option("--id <id>", "Connector instance ID (defaults to driver name)").option("--access <level>", "Access level: read-only | read-write", "read-only").option("--no-install", "Skip npm dependency installation").option("--project-dir <path>", "Workspace directory", process.cwd()).description("Add a connector to skaile.yaml and install its npm deps").action(
     async (driver, opts) => {
       const { installNpmPackages } = await import('../connectors/index.js');
-      const { scanDirectory, factoryAssetRoots: factoryAssetRoots2, WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
+      const { scanDirectory: scanDirectory2, factoryAssetRoots: factoryAssetRoots2, WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
       const projectDir = path14__default.resolve(opts.projectDir);
       const yamlPath = path14__default.join(projectDir, "skaile.yaml");
       if (!existsSync(yamlPath)) {
         logErr("No skaile.yaml found in current directory. Run 'skaile init' first.");
         process.exit(1);
       }
-      const entries = scanFactoryConnectors(scanDirectory, factoryAssetRoots2());
+      const entries = scanFactoryConnectors(scanDirectory2, factoryAssetRoots2());
       const entry = entries.find((e) => e.name === driver);
       if (!entry) {
         logErr(
@@ -2064,7 +2090,7 @@ async function ensureTargetsRegistered(projectDir) {
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const config = resolveSkWorkspaceConfig2(projectDir);
   if (config.plugins && config.plugins.length > 0) {
-    const { ensurePluginsLoaded } = await import('../plugin-store-S7OMGI7N.js');
+    const { ensurePluginsLoaded } = await import('../plugin-store-QMJ2B3VM.js');
     const result = await ensurePluginsLoaded(projectDir, config.plugins, pluginRegistry);
     for (const f of result.failed) logWarn(f.error);
   }
@@ -2869,6 +2895,46 @@ function makeIntegrationCommand() {
   cmd.action(() => cmd.help());
   return cmd;
 }
+async function indexLibrary(lib, index) {
+  const { LocalCatalogSource } = await import('../library/index.js');
+  const own = index ?? await openLibrary();
+  try {
+    const source = new LocalCatalogSource(own, lib.id, lib.path, createFullRegistry());
+    const res = await source.sync();
+    return {
+      assetsFound: res.assetsFound,
+      assetsUpdated: res.assetsUpdated,
+      errors: res.errors
+    };
+  } finally {
+    if (!index) own.close();
+  }
+}
+function domainPublisher(libraryPath, domain) {
+  const domainFile = path14.join(libraryPath, domain, "DOMAIN.md");
+  if (!fs13.existsSync(domainFile)) return void 0;
+  try {
+    const { data } = parseFrontmatter(fs13.readFileSync(domainFile, "utf8"));
+    const pub = data.publisher;
+    return typeof pub === "string" && pub.trim() ? pub.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveLibraryPublisher(lib, opts, domain) {
+  if (opts.publisher?.trim()) return opts.publisher.trim();
+  if (domain) {
+    const fromDomain = domainPublisher(lib.path, domain);
+    if (fromDomain) return fromDomain;
+  }
+  try {
+    return slugifyAssetName(lib.name);
+  } catch {
+    return "library";
+  }
+}
+
+// cli/src/commands/library-cmd.ts
 function makeLibraryCommand() {
   const cmd = new Command("library").description("Manage user authoring libraries (local / git)");
   cmd.command("list").description("List all registered libraries").option("--json", "Output as JSON").action(async (opts) => {
@@ -2931,7 +2997,7 @@ function makeLibraryCommand() {
       const { manager, close } = await openLibraryManager();
       try {
         if (opts.git) {
-          fs12.mkdirSync(libPath, { recursive: true });
+          fs13.mkdirSync(libPath, { recursive: true });
           await manager.addLibrary({
             name,
             path: libPath,
@@ -2940,7 +3006,7 @@ function makeLibraryCommand() {
             ownership
           });
         } else {
-          fs12.mkdirSync(libPath, { recursive: true });
+          fs13.mkdirSync(libPath, { recursive: true });
           await manager.addLibrary({
             name,
             path: libPath,
@@ -2974,13 +3040,13 @@ function makeLibraryCommand() {
       close();
     }
   });
-  cmd.command("create <kind> <name>").description("Scaffold a new asset inside the default (or named) library").addOption(new Option("--kind <kind>", "Asset kind override").choices([...ASSET_KINDS])).option("--library <name>", "Target library (default: the default-marked one)").option("--dir <dir>", "Target directory inside the library (default: library root)").action(
+  cmd.command("create <kind> <name>").description("Scaffold a new asset inside the default (or named) library").addOption(new Option("--kind <kind>", "Asset kind override").choices([...ASSET_KINDS])).option("--library <name>", "Target library (default: the default-marked one)").option("--dir <dir>", "Target directory inside the library (default: library root)").option("--publisher <name>", "Publisher for the new asset (default: the library's default)").action(
     async (kind, name, opts) => {
       if (!ASSET_KINDS.includes(kind)) {
         logErr(`Unknown asset kind "${kind}". Expected: ${ASSET_KINDS.join(", ")}.`);
         process.exit(1);
       }
-      const { manager, close } = await openLibraryManager();
+      const { manager, library, close } = await openLibraryManager();
       try {
         let target;
         if (opts.library) {
@@ -2996,15 +3062,28 @@ function makeLibraryCommand() {
           }
           target = def;
         }
+        const effectiveKind = opts.kind ?? kind;
         const am2 = new AssetManager({ projectDir: process.cwd() });
         const destDir = opts.dir ? path14.join(target.path, opts.dir) : target.path;
-        const res = am2.create(name, opts.kind ?? kind, destDir);
-        if (res.ok) {
-          logOk(`Created ${opts.kind ?? kind}: ${pc5.dim(res.path)}`);
-        } else {
+        const res = am2.create(name, effectiveKind, destDir);
+        if (!res.ok) {
           logErr(res.path);
           process.exit(1);
         }
+        logOk(`Created ${effectiveKind}: ${pc5.dim(res.path)}`);
+        const domain2 = opts.dir ? opts.dir.split(path14.sep)[0] : void 0;
+        const publisher = resolveLibraryPublisher(target, opts, domain2);
+        stampAssetPublisher(res.path, publisher);
+        ensureManifestPublisher(target.path, publisher);
+        upsertManifestAsset(target.path, {
+          kind: effectiveKind,
+          name,
+          root: path14.relative(target.path, res.path) || name,
+          version: "0.1.0"
+        });
+        const idx = await indexLibrary(target, library);
+        for (const e of idx.errors) logWarn(e);
+        logOk(`Indexed \u2014 add it with \`skaile add ${effectiveKind}:@${publisher}/${name}\``);
       } finally {
         close();
       }
@@ -3079,7 +3158,7 @@ function makeLibraryCommand() {
         logErr(`Domain "${name}" not found in "${target.name}" (no ${domainFile}).`);
         process.exit(1);
       }
-      console.log(fs12.readFileSync(domainFile, "utf8"));
+      console.log(fs13.readFileSync(domainFile, "utf8"));
     } finally {
       close();
     }
@@ -3099,11 +3178,11 @@ function makeLibraryCommand() {
       const lib = await manager.requireLibrary(oldName);
       const parent = path14.dirname(lib.path);
       const newPath = path14.join(parent, newName);
-      if (fs12.existsSync(newPath)) {
+      if (fs13.existsSync(newPath)) {
         logErr(`Target directory already exists: ${newPath}`);
         process.exit(1);
       }
-      fs12.renameSync(lib.path, newPath);
+      fs13.renameSync(lib.path, newPath);
       await manager.updateLibrary(lib.id, { name: newName, path: newPath });
       logOk(`Renamed ${oldName} \u2192 ${newName}`);
     } finally {
@@ -3169,6 +3248,18 @@ function makeLibraryCommand() {
       close();
     }
   });
+  cmd.command("index <name>").description("(Re)index a library's assets into the local index").action(async (name) => {
+    const { manager, library, close } = await openLibraryManager();
+    try {
+      const lib = await manager.requireLibrary(name);
+      syncManifestWithDisk(lib.path, lib.name);
+      const res = await indexLibrary(lib, library);
+      for (const e of res.errors) logWarn(e);
+      logOk(`Indexed ${res.assetsUpdated} asset(s) from ${name}.`);
+    } finally {
+      close();
+    }
+  });
   cmd.command("pull <name>").description("Pull from remote").action(async (name) => {
     const { manager, close } = await openLibraryManager();
     try {
@@ -3246,20 +3337,70 @@ function makeLibraryCommand() {
   });
   cmd.command("publish <lib>").description("Push + register the library's manifest atomically (needs git backend)").option("--asset <ref>", "Publish only the single asset matching this ref/name").option("--create-repo", "Provision + link a public github repo if the library has no remote").option("--ref <gitref>", "Git ref to ingest (default: the library branch or main)").option("--dry-run", "Print the plan; push nothing and call no store endpoint").action(
     async (lib, opts) => {
-      const { runLibraryPublish } = await import('../library-publish-K5IBE44D.js');
-      await runLibraryPublish(lib, opts);
+      const { runLibraryPublish } = await import('../library-publish-NQQFPOUY.js');
+      await withStoreErrorHandling(() => runLibraryPublish(lib, opts));
     }
   );
   cmd.command("register <lib>").description("Register the library's manifest without pushing (bytes already on github)").option("--asset <ref>", "Publish only the single asset matching this ref/name").option("--ref <gitref>", "Git ref to ingest (default: the library branch or main)").option("--dry-run", "Print the plan; call no store endpoint").action(async (lib, opts) => {
-    const { runLibraryRegister } = await import('../library-publish-K5IBE44D.js');
-    await runLibraryRegister(lib, opts);
+    const { runLibraryRegister } = await import('../library-publish-NQQFPOUY.js');
+    await withStoreErrorHandling(() => runLibraryRegister(lib, opts));
   });
   cmd.command("yank <lib>").description("Retract the library's published assets from the store").option("--asset <ref>", "Yank only the single asset matching this ref/name").action(async (lib, opts) => {
-    const { runLibraryYank } = await import('../library-publish-K5IBE44D.js');
-    await runLibraryYank(lib, opts);
+    const { runLibraryYank } = await import('../library-publish-NQQFPOUY.js');
+    await withStoreErrorHandling(() => runLibraryYank(lib, opts));
   });
   return cmd;
 }
+async function withStoreErrorHandling(fn) {
+  try {
+    await fn();
+  } catch (err) {
+    logErr(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+function stampAssetPublisher(assetDir, publisher) {
+  const markers = ["SKILL.md", "AGENT.md", "CONTRACT.md"];
+  let markerFile;
+  for (const m of markers) {
+    if (fs13.existsSync(path14.join(assetDir, m))) {
+      markerFile = path14.join(assetDir, m);
+      break;
+    }
+  }
+  if (!markerFile) {
+    const promptMd = fs13.readdirSync(assetDir).find((f) => f.endsWith(".prompt.md"));
+    if (promptMd) markerFile = path14.join(assetDir, promptMd);
+  }
+  if (!markerFile) return;
+  try {
+    const { data, body } = parseFrontmatter(fs13.readFileSync(markerFile, "utf8"));
+    const meta = data.metadata && typeof data.metadata === "object" && !Array.isArray(data.metadata) ? { ...data.metadata } : {};
+    if (meta.publisher != null) return;
+    meta.publisher = publisher;
+    data.metadata = meta;
+    const fm = stringify(data).trimEnd();
+    fs13.writeFileSync(markerFile, `---
+${fm}
+---
+
+${body}
+`, "utf8");
+  } catch {
+  }
+}
+function ensureManifestPublisher(libraryPath, publisher) {
+  const manifest = loadSkPublishManifest(libraryPath) ?? { assets: [] };
+  if (manifest.publisher) return;
+  saveSkPublishManifest(libraryPath, { ...manifest, publisher });
+}
+function syncManifestWithDisk(libraryPath, libraryName) {
+  const publisher = loadSkPublishManifest(libraryPath)?.publisher ?? slugifyAssetName(libraryName);
+  for (const e of scanDirectory(libraryPath, publisher)) {
+    const root = path14.relative(libraryPath, path14.dirname(e.source)) || e.name;
+    upsertManifestAsset(libraryPath, { kind: e.kind, name: e.name, root, version: e.version });
+  }
+}
 async function printPerLibraryStatus(name, asJson) {
   const { manager, close } = await openLibraryManager();
   try {
@@ -3514,6 +3655,7 @@ var srcKey = (origin, publisher) => `${origin}:${publisher}`;
 var domainKey = (origin, publisher, slug) => `${origin}:${publisher}:dom:${slug}`;
 var repoKey = (org, repo) => `${org}/${repo}`;
 var srcDomainKey = (org, repo, slug) => `${org}/${repo}:dom:${slug}`;
+var libDomainKey = (group, slug) => `${group}:dom:${slug}`;
 var NO_DOMAIN = "";
 var domainRegistry = /* @__PURE__ */ new Map();
 function relationBadge(relation) {
@@ -3544,6 +3686,8 @@ var state = {
   visibleRows: [],
   sourceTreeRows: [],
   visibleSourceRows: [],
+  libraryTreeRows: [],
+  visibleLibraryRows: [],
   pendingAdds: /* @__PURE__ */ new Set(),
   pendingRemoves: /* @__PURE__ */ new Set(),
   collapsedOrigins: /* @__PURE__ */ new Set(),
@@ -3556,6 +3700,10 @@ var state = {
   collapsedSourceDomains: /* @__PURE__ */ new Set(),
   expandedSourceDomainInfo: /* @__PURE__ */ new Set(),
   seenSourceDomains: /* @__PURE__ */ new Set(),
+  collapsedLibraryGroups: /* @__PURE__ */ new Set(),
+  collapsedLibraryDomains: /* @__PURE__ */ new Set(),
+  expandedLibraryDomainInfo: /* @__PURE__ */ new Set(),
+  seenLibraryDomains: /* @__PURE__ */ new Set(),
   seenOrigins: /* @__PURE__ */ new Set(),
   originFilter: null,
   message: "",
@@ -3663,6 +3811,59 @@ function sourceDomainRefs(rows, org, repo, slug) {
     )
   );
 }
+function buildLibraryTreeRows(assetRows, registered = []) {
+  const byGroup = /* @__PURE__ */ new Map();
+  const ensure = (group) => {
+    if (!byGroup.has(group)) byGroup.set(group, /* @__PURE__ */ new Map());
+    return byGroup.get(group);
+  };
+  for (const r of assetRows) {
+    if (!isAsset(r) || rowOrigin(r) !== "library") continue;
+    const group = rowGroup(r);
+    const slug = rowDomain(r);
+    const byDomain = ensure(group);
+    if (!byDomain.has(slug)) byDomain.set(slug, []);
+    byDomain.get(slug).push(r);
+  }
+  for (const group of registered) ensure(group);
+  if (byGroup.size === 0) return [];
+  const rows = [{ type: "library-root" }];
+  for (const group of [...byGroup.keys()].sort((a, b) => a.localeCompare(b))) {
+    rows.push({ type: "library-header", origin: "library", source: group });
+    const byDomain = byGroup.get(group);
+    const loose = byDomain.get(NO_DOMAIN);
+    if (loose) for (const a of loose) rows.push({ ...a });
+    for (const slug of sortedDomainSlugs([...byDomain.keys()])) {
+      const meta = domainRegistry.get(slug);
+      rows.push({ type: "domain-header", origin: "library", source: group, domainSlug: slug });
+      if (meta?.description) {
+        rows.push({ type: "domain-info", origin: "library", source: group, domainSlug: slug });
+      }
+      for (const a of byDomain.get(slug)) rows.push({ ...a });
+    }
+  }
+  return rows;
+}
+function buildVisibleLibraryRows(rows, collapsedGroups, collapsedDomains) {
+  return rows.filter((row) => {
+    if (row.type === "library-root" || row.type === "library-header") return true;
+    const group = row.source ?? rowGroup(row);
+    if (collapsedGroups.has(group)) return false;
+    if (row.type === "domain-header") return true;
+    if (row.type === "domain-info") {
+      return !collapsedDomains.has(libDomainKey(group, row.domainSlug ?? NO_DOMAIN));
+    }
+    if (row.underDomain) {
+      return !collapsedDomains.has(libDomainKey(rowGroup(row), rowDomain(row)));
+    }
+    return true;
+  });
+}
+function libraryGroupRefs(rows, group) {
+  return refsOf(
+    rows.filter((r) => isAsset(r) && rowOrigin(r) === "library" && rowGroup(r) === group)
+  );
+}
 function isAsset(r) {
   return r.type === "asset";
 }
@@ -3786,7 +3987,7 @@ async function previewSoftDepsUnderCursor() {
 }
 async function loadAssets() {
   softDepPreviewCache.clear();
-  const { gatherAssetFeeds } = await import('../asset-feeds-T35ELX2O.js');
+  const { gatherAssetFeeds } = await import('../asset-feeds-PTZBWJEL.js');
   const { entries, domains, notes } = await gatherAssetFeeds(am, am.projectDir);
   if (notes.length > 0) {
     state.message = notes.map((n) => `[${n.feed}] ${n.message}`).join(" \u2022 ");
@@ -3799,6 +4000,7 @@ async function loadAssets() {
   reconcileCollapsedSets(rows);
   rebuildVisible();
   rebuildSourceTree();
+  rebuildLibraryTree();
 }
 function rebuildSourceTree() {
   const registered = state.sourceRows.map((s) => sourceOrgRepo(s)).filter((x) => x !== null);
@@ -3848,6 +4050,44 @@ function rebuildVisibleSources() {
   );
   clampCursor();
 }
+function rebuildLibraryTree() {
+  state.libraryTreeRows = buildLibraryTreeRows(
+    state.assetRows,
+    state.libraryRows.map((l) => l.name)
+  );
+  reconcileLibraryCollapsedSets(state.libraryTreeRows);
+  rebuildVisibleLibraries();
+}
+function reconcileLibraryCollapsedSets(rows) {
+  const groupKeys = new Set(rows.filter((r) => r.type === "library-header").map((r) => r.source));
+  const domainKeys = new Set(
+    rows.filter((r) => r.type === "domain-header").map((r) => libDomainKey(r.source, r.domainSlug ?? NO_DOMAIN))
+  );
+  for (const k of state.collapsedLibraryGroups)
+    if (!groupKeys.has(k)) state.collapsedLibraryGroups.delete(k);
+  for (const k of domainKeys) {
+    if (!state.seenLibraryDomains.has(k)) {
+      state.collapsedLibraryDomains.add(k);
+      state.seenLibraryDomains.add(k);
+    }
+  }
+  for (const k of state.collapsedLibraryDomains) {
+    if (!domainKeys.has(k)) state.collapsedLibraryDomains.delete(k);
+  }
+  for (const k of state.expandedLibraryDomainInfo) {
+    if (!domainKeys.has(k)) state.expandedLibraryDomainInfo.delete(k);
+  }
+  for (const k of state.seenLibraryDomains)
+    if (!domainKeys.has(k)) state.seenLibraryDomains.delete(k);
+}
+function rebuildVisibleLibraries() {
+  state.visibleLibraryRows = buildVisibleLibraryRows(
+    state.libraryTreeRows,
+    state.collapsedLibraryGroups,
+    state.collapsedLibraryDomains
+  );
+  clampCursor();
+}
 function groupEntriesByOriginPublisherDomain(entries) {
   const byOrigin = /* @__PURE__ */ new Map();
   for (const { origin, entry, group } of entries) {
@@ -3917,7 +4157,7 @@ function reconcileCollapsedSets(rows) {
   const presentOrigins = new Set(rows.filter((r) => r.type === "origin-header").map(rowOrigin));
   for (const o of presentOrigins) {
     if (!state.seenOrigins.has(o)) {
-      if (o === "store") state.collapsedOrigins.add(o);
+      if (o !== "factory") state.collapsedOrigins.add(o);
       state.seenOrigins.add(o);
     }
   }
@@ -3953,7 +4193,7 @@ function reconcileCollapsedSets(rows) {
 async function loadSourcesAndLibraries() {
   try {
     const [{ openLibraryManager: openLibraryManager2 }, { skaileHomeDir }, { getGlobalCacheDir: getGlobalCacheDir2 }] = await Promise.all([
-      import('../open-library-4HMIDK3N.js'),
+      import('../open-library-ODW2PJ2J.js'),
       import('../library/index.js'),
       import('../core/index.js')
     ]);
@@ -3990,6 +4230,7 @@ async function loadSourcesAndLibraries() {
     state.libraryRows = [];
   }
   rebuildSourceTree();
+  rebuildLibraryTree();
 }
 function rebuildVisible() {
   state.visibleRows = buildVisibleRows(
@@ -4033,11 +4274,11 @@ var TABS = {
   },
   libraries: {
     label: "Libraries",
-    rowCount: () => state.libraryRows.length,
-    selectableCount: () => state.libraryRows.length,
+    rowCount: () => state.visibleLibraryRows.length,
+    selectableCount: () => state.libraryTreeRows.filter(isAsset).length,
     emptyMsg: "  No libraries registered. Run `skaile library init <name>` from the shell to author your own.",
-    renderRow: (i, sel) => renderLibraryRow(state.libraryRows[i], sel),
-    footer: "  \u2191\u2193 navigate  Tab switch  q quit  (use `skaile library \u2026` from the shell for CRUD)"
+    renderRow: (i, sel) => renderLibraryTreeRow(state.visibleLibraryRows[i], sel),
+    footer: "  \u2191\u2193/jk nav  \u2190/\u2192 collapse/expand  [space/+/-] select  [a/\u21B5] apply  [d] domain info  [i] info  Tab  [q] quit"
   },
   pending: {
     label: "Pending",
@@ -4246,6 +4487,57 @@ function renderSourceTreeRow(row, selected) {
   }
   return renderAssetLeaf(row, selected, 7);
 }
+function renderLibraryTreeRow(row, selected) {
+  if (row.type === "library-root") {
+    const total = state.libraryTreeRows.filter(isAsset).length;
+    const meta = ORIGIN_META.library;
+    const line = ` \u25BC ${meta.icon} ${pc5.bold(pc5.cyan(meta.label))}  (${total} assets)`;
+    return selected ? pc5.bgWhite(pc5.black(`${line} `.padEnd(state.cols))) : line;
+  }
+  if (row.type === "library-header") {
+    const group = row.source;
+    return renderHeaderLine({
+      indent: " ".repeat(3),
+      collapsed: state.collapsedLibraryGroups.has(group),
+      match: (r) => isAsset(r) && rowOrigin(r) === "library" && rowGroup(r) === group,
+      refs: libraryGroupRefs(state.libraryTreeRows, group),
+      label: pc5.bold(pc5.cyan(group)),
+      selected,
+      rows: state.libraryTreeRows
+    });
+  }
+  if (row.type === "domain-header") {
+    const group = row.source;
+    const slug = row.domainSlug ?? NO_DOMAIN;
+    const meta = domainRegistry.get(slug);
+    const title = meta?.title || slug || "(no domain)";
+    const badge = relationBadge(meta?.relation);
+    const label = `${pc5.magenta("\u25C8")} ${pc5.bold(title)}${badge ? ` ${badge}` : ""}`;
+    return renderHeaderLine({
+      indent: " ".repeat(5),
+      collapsed: state.collapsedLibraryDomains.has(libDomainKey(group, slug)),
+      match: (r) => isAsset(r) && inDomain(r, "library", group, slug),
+      refs: domainAssetRefs(state.libraryTreeRows, "library", group, slug),
+      label,
+      selected,
+      rows: state.libraryTreeRows
+    });
+  }
+  if (row.type === "domain-info") {
+    const group = row.source;
+    const slug = row.domainSlug ?? NO_DOMAIN;
+    const meta = domainRegistry.get(slug);
+    const members = domainAssetRefs(state.libraryTreeRows, "library", group, slug).length;
+    const key = libDomainKey(group, slug);
+    const line = renderSourceDomainInfoLine(
+      meta,
+      members,
+      state.expandedLibraryDomainInfo.has(key)
+    );
+    return selected ? pc5.inverse(line.padEnd(state.cols)) : line;
+  }
+  return renderAssetLeaf(row, selected, 5);
+}
 function renderSourceDomainInfoLine(meta, members, expanded) {
   const indent = " ".repeat(9);
   const desc = meta?.description ?? "";
@@ -4279,11 +4571,6 @@ function renderDomainInfoLine(meta, origin, publisher, slug, expanded) {
   const shown = full.length > budget ? `${full.slice(0, Math.max(0, budget - 1))}\u2026` : full;
   return pc5.dim(`${indent}\u24D8 ${shown}`);
 }
-function renderLibraryRow(row, selected) {
-  const mark = row.isDefault ? pc5.green("\u25B8") : " ";
-  const line = `${mark} ${S.cmd(fitWidth(row.name, 16))}  ${pc5.dim(row.backend.padEnd(7))}  ${pc5.dim(row.ownership.padEnd(12))}  ${pc5.dim(`${row.assetCount} assets`)}`;
-  return selected ? pc5.inverse(line.padEnd(state.cols)) : line;
-}
 function computeMaxBodyRows() {
   const pendingLines = state.pendingAdds.size > 0 || state.pendingRemoves.size > 0 ? 1 + (state.pendingAdds.size > 0 ? 1 : 0) + (state.pendingRemoves.size > 0 ? 1 : 0) : 0;
   const msgLines = state.message ? 2 : 0;
@@ -4401,14 +4688,9 @@ async function syncAll() {
     "Sync is not yet driven from the manage TUI. Run `skaile source sync` (sources) or `skaile library sync <name>` (git-backed libraries) from the shell."
   );
 }
-function libraryShellHint(action3) {
-  state.message = pc5.yellow(
-    `${action3} is a shell command. Run \`skaile library \u2026\` from the shell.`
-  );
-}
 async function showInfo() {
-  const rows = state.tab === "sources" ? state.visibleSourceRows : state.visibleRows;
-  if (state.tab !== "assets" && state.tab !== "sources") return;
+  const rows = state.tab === "sources" ? state.visibleSourceRows : state.tab === "libraries" ? state.visibleLibraryRows : state.visibleRows;
+  if (state.tab !== "assets" && state.tab !== "sources" && state.tab !== "libraries") return;
   const row = rows[state.cursor];
   if (row?.type !== "asset") return;
   const e = row.entry;
@@ -4646,6 +4928,97 @@ function toggleSourceDomainInfoUnderCursor() {
   else state.expandedSourceDomainInfo.add(key);
   rebuildVisibleSources();
 }
+function actOnLibraryHeader(row, action3) {
+  if (row.type === "library-header") {
+    bulkSelection(libraryGroupRefs(state.libraryTreeRows, row.source), action3);
+    return true;
+  }
+  return row.type === "library-root" || row.type === "domain-header" || row.type === "domain-info";
+}
+function selectLibraryUnderCursor(action3) {
+  const row = state.visibleLibraryRows[state.cursor];
+  if (!row) return;
+  if (actOnLibraryHeader(row, action3)) return;
+  const ref = assetRefOf(row);
+  if (!ref) return;
+  if (action3 === "toggle") {
+    setSelection(ref, "toggle");
+  } else if (action3 === "add") {
+    setSelection(ref, state.pendingAdds.has(ref) ? "clear" : "add");
+  } else {
+    setSelection(ref, state.pendingRemoves.has(ref) ? "clear" : "remove");
+  }
+}
+function expandLibraryUnderCursor() {
+  const row = state.visibleLibraryRows[state.cursor];
+  if (!row) return;
+  if (row.type === "library-header" && state.collapsedLibraryGroups.has(row.source)) {
+    state.collapsedLibraryGroups.delete(row.source);
+    rebuildVisibleLibraries();
+  } else if (row.type === "domain-header") {
+    const k = libDomainKey(row.source, row.domainSlug ?? NO_DOMAIN);
+    if (state.collapsedLibraryDomains.has(k)) {
+      state.collapsedLibraryDomains.delete(k);
+      rebuildVisibleLibraries();
+    }
+  }
+}
+function collapseOrJumpLibraryUnderCursor() {
+  const row = state.visibleLibraryRows[state.cursor];
+  if (!row) return;
+  if (row.type === "library-header") {
+    if (!state.collapsedLibraryGroups.has(row.source)) {
+      state.collapsedLibraryGroups.add(row.source);
+      rebuildVisibleLibraries();
+    } else {
+      const idx2 = findLastIndex(
+        state.visibleLibraryRows,
+        state.cursor,
+        (r) => r.type === "library-root"
+      );
+      if (idx2 >= 0) state.cursor = idx2;
+    }
+    return;
+  }
+  if (row.type === "domain-header") {
+    const k = libDomainKey(row.source, row.domainSlug ?? NO_DOMAIN);
+    if (!state.collapsedLibraryDomains.has(k)) {
+      state.collapsedLibraryDomains.add(k);
+      rebuildVisibleLibraries();
+    } else {
+      const idx2 = findLastIndex(
+        state.visibleLibraryRows,
+        state.cursor,
+        (r) => r.type === "library-header"
+      );
+      if (idx2 >= 0) state.cursor = idx2;
+    }
+    return;
+  }
+  const idx = findLastIndex(
+    state.visibleLibraryRows,
+    state.cursor,
+    (r) => r.type === "domain-header" || r.type === "library-header"
+  );
+  if (idx >= 0) state.cursor = idx;
+}
+function toggleLibraryDomainInfoUnderCursor() {
+  const row = state.visibleLibraryRows[state.cursor];
+  if (!row) return;
+  let key = null;
+  if (row.type === "domain-header" || row.type === "domain-info") {
+    key = libDomainKey(row.source, row.domainSlug ?? NO_DOMAIN);
+  } else if (row.type === "asset" && row.underDomain) {
+    key = libDomainKey(rowGroup(row), rowDomain(row));
+  }
+  if (!key) {
+    state.message = pc5.dim("No domain here \u2014 [d] opens a domain's info region.");
+    return;
+  }
+  if (state.expandedLibraryDomainInfo.has(key)) state.expandedLibraryDomainInfo.delete(key);
+  else state.expandedLibraryDomainInfo.add(key);
+  rebuildVisibleLibraries();
+}
 function findLastIndex(arr, endExclusive, pred) {
   for (let i = Math.min(endExclusive, arr.length) - 1; i >= 0; i--) {
     if (pred(arr[i])) return i;
@@ -4691,6 +5064,9 @@ var KEYMAP = [
   // Collapse / expand — sources tab
   { keys: ["\x1B[C"], when: TAB_SOURCES, run: expandSourceUnderCursor },
   { keys: ["\x1B[D"], when: TAB_SOURCES, run: collapseOrJumpSourceUnderCursor },
+  // Collapse / expand — libraries tab
+  { keys: ["\x1B[C"], when: TAB_LIBRARIES, run: expandLibraryUnderCursor },
+  { keys: ["\x1B[D"], when: TAB_LIBRARIES, run: collapseOrJumpLibraryUnderCursor },
   // + : assets → bulk-add or single-add toggle
   {
     keys: ["+"],
@@ -4712,23 +5088,13 @@ var KEYMAP = [
   { keys: ["a", "\r", "\n"], when: TAB_SOURCES, run: applyChanges },
   { keys: ["i"], when: TAB_SOURCES, run: showInfo },
   { keys: ["d"], when: TAB_SOURCES, run: toggleSourceDomainInfoUnderCursor },
-  // Libraries tab: +/-/n/r/x/d/enter map to shell hints in the minimal scaffold.
-  {
-    keys: ["+", "n", "a"],
-    when: TAB_LIBRARIES,
-    run: () => libraryShellHint("Adding a library")
-  },
-  {
-    keys: ["-", "r", "x"],
-    when: TAB_LIBRARIES,
-    run: () => libraryShellHint("Removing a library")
-  },
-  {
-    keys: ["d"],
-    when: TAB_LIBRARIES,
-    run: () => libraryShellHint("Setting the default library")
-  },
-  { keys: ["\r", "\n"], when: TAB_LIBRARIES, run: () => libraryShellHint("Library actions") },
+  // Libraries tab: + / - / space select (asset leaf or library bulk header).
+  { keys: ["+"], when: TAB_LIBRARIES, run: () => selectLibraryUnderCursor("add") },
+  { keys: ["-"], when: TAB_LIBRARIES, run: () => selectLibraryUnderCursor("remove") },
+  { keys: [" "], when: TAB_LIBRARIES, run: () => selectLibraryUnderCursor("toggle") },
+  { keys: ["a", "\r", "\n"], when: TAB_LIBRARIES, run: applyChanges },
+  { keys: ["i"], when: TAB_LIBRARIES, run: showInfo },
+  { keys: ["d"], when: TAB_LIBRARIES, run: toggleLibraryDomainInfoUnderCursor },
   // - : assets → bulk-remove or single-remove toggle
   {
     keys: ["-"],
@@ -4822,8 +5188,8 @@ function makeManageCommand() {
 }
 function makeMcpServerCommand() {
   return new Command("mcp-server").description("Start skaile workspace MCP server (stdio transport)").option("--project-dir <path>", "Project directory (default: cwd)", process.cwd()).action(async (opts) => {
-    const path37 = await import('path');
-    const projectDir = path37.default.resolve(opts.projectDir);
+    const path38 = await import('path');
+    const projectDir = path38.default.resolve(opts.projectDir);
     const { LogStore, StdoutSink, registerLogStore } = await import('../core/logging.js');
     registerLogStore(
       new LogStore({
@@ -5039,7 +5405,7 @@ function action2(fn) {
   };
 }
 async function reconcileAndReport(projectDir, plugins) {
-  const { reconcilePlugins } = await import('../plugin-store-S7OMGI7N.js');
+  const { reconcilePlugins } = await import('../plugin-store-QMJ2B3VM.js');
   if (plugins.length === 0) {
     logInfo("No plugins declared \u2014 nothing to reconcile.");
     return;
@@ -5055,7 +5421,7 @@ async function reconcileAndReport(projectDir, plugins) {
 async function runInstall2(spec, opts) {
   const projectDir = path14__default.resolve(opts.projectDir);
   const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-  const { specName } = await import('../plugin-store-S7OMGI7N.js');
+  const { specName } = await import('../plugin-store-QMJ2B3VM.js');
   const yamlPath = path14__default.join(projectDir, "skaile.yaml");
   const editor = WorkspaceYamlEditor2.load(yamlPath);
   const replaced = editor.addPlugin(spec, specName);
@@ -5067,7 +5433,7 @@ async function runInstall2(spec, opts) {
 async function runRemove(name, opts) {
   const projectDir = path14__default.resolve(opts.projectDir);
   const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-  const { specName } = await import('../plugin-store-S7OMGI7N.js');
+  const { specName } = await import('../plugin-store-QMJ2B3VM.js');
   const yamlPath = path14__default.join(projectDir, "skaile.yaml");
   const editor = WorkspaceYamlEditor2.load(yamlPath);
   const removed = editor.removePlugin(name, specName);
@@ -5095,7 +5461,7 @@ async function runList(opts) {
   const registry = createPluginRegistry();
   if (declared.length > 0) {
     try {
-      const { loadPlugins } = await import('../plugin-store-S7OMGI7N.js');
+      const { loadPlugins } = await import('../plugin-store-QMJ2B3VM.js');
       const result = await loadPlugins(projectDir, declared, registry);
       for (const f of result.failed) logWarn(f.error);
     } catch (err) {
@@ -5292,7 +5658,7 @@ async function runRefInstall(ref, opts) {
   const spinner5 = p6.spinner();
   spinner5.start(`Installing ${ref}`);
   try {
-    const { openCatalogSource: openCatalogSource2, openLibrary: openLibrary2 } = await import('../open-library-4HMIDK3N.js');
+    const { openCatalogSource: openCatalogSource2, openLibrary: openLibrary2 } = await import('../open-library-ODW2PJ2J.js');
     const catalog = await openCatalogSource2({ projectDir: path14__default.resolve(opts.projectDir) });
     if (!supportsInstallManifest(catalog)) {
       throw new Error(
@@ -5332,7 +5698,7 @@ async function runYamlInstall(opts) {
     return;
   }
   try {
-    const { ensureSourcesCloned } = await import('../ensure-sources-QDVFUIUP.js');
+    const { ensureSourcesCloned } = await import('../ensure-sources-ORACQA4I.js');
     const hydrate = ensureSourcesCloned(projectDir, { quiet: true });
     if (hydrate.cloned.length > 0) {
       logOk(`Cloned source(s): ${hydrate.cloned.join(", ")}`);
@@ -5633,8 +5999,8 @@ function redactSecrets(preset, findings) {
   }
   return { preset: next, keys };
 }
-function placeholderKey(itemId, path37) {
-  return `${itemId}_${path37}`.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+function placeholderKey(itemId, path38) {
+  return `${itemId}_${path38}`.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
 }
 function setAtPath(root, segments, value) {
   let node = root;
@@ -6247,7 +6613,7 @@ function makeRunCommand() {
     let dir = projectDir;
     for (let i = 0; i < 6; i++) {
       const candidate = path14__default.join(dir, "ai-assets");
-      if (fs12__default.existsSync(candidate)) {
+      if (fs13__default.existsSync(candidate)) {
         priorityRoots.push(candidate);
         break;
       }
@@ -6406,13 +6772,13 @@ function makeReplCommand() {
         p6.cancel("Cancelled.");
         process.exit(0);
       }
-      const tmpDir = fs12__default.mkdtempSync(path14__default.join(os2.tmpdir(), "skaile-repl-"));
+      const tmpDir = fs13__default.mkdtempSync(path14__default.join(os2.tmpdir(), "skaile-repl-"));
       projectDir = tmpDir;
       agentCwd = userCwd;
       logOk(`Temporary workspace: ${S.cmd(tmpDir)}`);
       if (!driverOverride) {
         const claudeDir = path14__default.join(os2.homedir(), ".claude");
-        if (fs12__default.existsSync(claudeDir)) {
+        if (fs13__default.existsSync(claudeDir)) {
           driverOverride = "claude-sdk";
           logInfo(`Detected ${S.cmd("~/.claude")} \u2192 using ${S.cmd("claude-sdk")} backend`);
         } else {
@@ -6458,12 +6824,12 @@ function makeServeCommand() {
   );
 }
 async function ensurePluginsLoadedForServe(projectDir) {
-  const { logInfo: logInfo2, logWarn: logWarn2 } = await import('../helpers-TF7GCBRQ.js');
+  const { logInfo: logInfo2, logWarn: logWarn2 } = await import('../helpers-SXGIHFCF.js');
   try {
     const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
     const config = resolveSkWorkspaceConfig2(projectDir);
     if (!config.plugins || config.plugins.length === 0) return;
-    const { ensurePluginsLoaded } = await import('../plugin-store-S7OMGI7N.js');
+    const { ensurePluginsLoaded } = await import('../plugin-store-QMJ2B3VM.js');
     const { pluginRegistry } = await import('../plugin-registry/index.js');
     const result = await ensurePluginsLoaded(projectDir, config.plugins, pluginRegistry);
     if (result.loaded.length > 0) {
@@ -6477,21 +6843,21 @@ async function ensurePluginsLoadedForServe(projectDir) {
   }
 }
 async function runCompileTest(opts) {
-  const { logOk: logOk2, logErr: logErr2, logInfo: logInfo2, S: S2 } = await import('../helpers-TF7GCBRQ.js');
+  const { logOk: logOk2, logErr: logErr2, logInfo: logInfo2, S: S2 } = await import('../helpers-SXGIHFCF.js');
   const { tmpdir } = await import('os');
-  const { dirname: dirname4, join: join6, resolve: resolve5 } = await import('path');
+  const { dirname: dirname4, join: join7, resolve: resolve5 } = await import('path');
   const { fileURLToPath: fileURLToPath2 } = await import('url');
-  const { unlinkSync, existsSync: existsSync14 } = await import('fs');
+  const { unlinkSync, existsSync: existsSync15 } = await import('fs');
   const { spawn } = await import('child_process');
   const { portableSpawnSync: portableSpawnSync2 } = await import('../core/index.js');
-  const { MONOREPO_ROOT } = await import('../paths-P3DWFUPS.js');
+  const { MONOREPO_ROOT } = await import('../paths-KOKCMBL5.js');
   if (MONOREPO_ROOT === null) {
     logErr2("--compile-test is only available inside the skaile-dev workspace.");
     logInfo2("Run it from a checkout of skaile-ai/skaile-dev (the monorepo shell).");
     process.exitCode = 2;
     return;
   }
-  const outfile = join6(tmpdir(), `skaile-compile-test-${Date.now()}`);
+  const outfile = join7(tmpdir(), `skaile-compile-test-${Date.now()}`);
   const __thisFile = fileURLToPath2(import.meta.url);
   const entryPoint = resolve5(dirname4(__thisFile), "..", "index.ts");
   logInfo2(`Building compiled binary...`);
@@ -6543,7 +6909,7 @@ async function runCompileTest(opts) {
     } catch {
     }
     try {
-      if (existsSync14(outfile)) unlinkSync(outfile);
+      if (existsSync15(outfile)) unlinkSync(outfile);
     } catch {
     }
   }
@@ -7265,12 +7631,12 @@ function showOverview(am2) {
 }
 function showAsset(am2, kind, name) {
   const entry = am2.info(`${kind}:${name}`);
-  if (entry?.source && fs12__default.existsSync(entry.source)) {
+  if (entry?.source && fs13__default.existsSync(entry.source)) {
     console.log();
     console.log(`  ${kindColor(entry.kind)} ${S.heading(entry.name)}`);
     console.log(`  ${S.rule(40)}`);
     console.log();
-    console.log(fs12__default.readFileSync(entry.source, "utf-8"));
+    console.log(fs13__default.readFileSync(entry.source, "utf-8"));
     return;
   }
   logErr(`Asset not found: ${kind}:${name}`);
@@ -7497,7 +7863,7 @@ function findManifestCandidates(rootPath) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs12__default.readdirSync(dir, { withFileTypes: true });
+      entries = fs13__default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -7543,7 +7909,7 @@ function checkManifestIdentity(kind, parsed) {
   return null;
 }
 function parseManifestCandidate(c, absRoot) {
-  const content = fs12__default.readFileSync(c.filePath, "utf-8");
+  const content = fs13__default.readFileSync(c.filePath, "utf-8");
   if (c.filePath.endsWith(".md")) {
     const parsed = parseMdFrontmatter(content);
     if (parsed === null) {
@@ -7599,7 +7965,7 @@ function validateManifestCandidate(c, parsed, absRoot, registry, strictConforman
 }
 function validateManifests(rootPath, strictConformance) {
   const absRoot = path14__default.resolve(rootPath);
-  if (!fs12__default.existsSync(absRoot)) {
+  if (!fs13__default.existsSync(absRoot)) {
     logErr(`Path does not exist: ${absRoot}`);
     return { total: 0, errors: 1, warnings: 0 };
   }
@@ -7631,7 +7997,7 @@ function findWorkspaceManifests(rootPath) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs12__default.readdirSync(dir, { withFileTypes: true });
+      entries = fs13__default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -7706,7 +8072,7 @@ function validateWorkspaceManifests(rootPath) {
     const relPath = path14__default.relative(absRoot, file);
     let parsed;
     try {
-      parsed = parse(fs12__default.readFileSync(file, "utf-8")) ?? {};
+      parsed = parse(fs13__default.readFileSync(file, "utf-8")) ?? {};
     } catch (e) {
       logErr(`${relPath} \u2014 parse error: ${e instanceof Error ? e.message : String(e)}`);
       errors++;
@@ -7720,34 +8086,34 @@ function validateWorkspaceManifests(rootPath) {
 var EXCLUDED_DOMAINS = /* @__PURE__ */ new Set(["skaileup-shared", "external", "docs"]);
 function collectAssetVersions() {
   const assets = [];
-  if (!fs12__default.existsSync(AI_RESOURCES)) return assets;
-  const domains = fs12__default.readdirSync(AI_RESOURCES, { withFileTypes: true }).filter((d) => d.isDirectory() && !EXCLUDED_DOMAINS.has(d.name));
+  if (!fs13__default.existsSync(AI_RESOURCES)) return assets;
+  const domains = fs13__default.readdirSync(AI_RESOURCES, { withFileTypes: true }).filter((d) => d.isDirectory() && !EXCLUDED_DOMAINS.has(d.name));
   for (const d of domains) {
     const domainDir = path14__default.join(AI_RESOURCES, d.name);
     const skillsDir = path14__default.join(domainDir, "skills");
-    if (fs12__default.existsSync(skillsDir)) {
+    if (fs13__default.existsSync(skillsDir)) {
       collectSkillVersions(skillsDir, d.name, assets);
     }
     const agentsDir = path14__default.join(domainDir, "agents");
-    if (fs12__default.existsSync(agentsDir)) {
+    if (fs13__default.existsSync(agentsDir)) {
       collectAgentVersions(agentsDir, d.name, assets);
     }
     const flowsDir = path14__default.join(domainDir, "flows");
-    if (fs12__default.existsSync(flowsDir)) {
+    if (fs13__default.existsSync(flowsDir)) {
       collectFlowVersions(flowsDir, d.name, assets);
     }
     const promptsDir = path14__default.join(domainDir, "prompts");
-    if (fs12__default.existsSync(promptsDir)) {
+    if (fs13__default.existsSync(promptsDir)) {
       collectPromptVersions(promptsDir, d.name, assets);
     }
   }
   return assets;
 }
 function collectFlowVersions(dir, domain, out) {
-  for (const f of fs12__default.readdirSync(dir)) {
+  for (const f of fs13__default.readdirSync(dir)) {
     if (!f.endsWith(".flow.yaml")) continue;
     const fp = path14__default.join(dir, f);
-    const content = fs12__default.readFileSync(fp, "utf-8");
+    const content = fs13__default.readFileSync(fp, "utf-8");
     const parsed = parse(content);
     out.push({
       kind: "flow",
@@ -7759,10 +8125,10 @@ function collectFlowVersions(dir, domain, out) {
   }
 }
 function collectPromptVersions(dir, domain, out) {
-  for (const f of fs12__default.readdirSync(dir)) {
+  for (const f of fs13__default.readdirSync(dir)) {
     if (!f.endsWith(".prompt.md")) continue;
     const fp = path14__default.join(dir, f);
-    const content = fs12__default.readFileSync(fp, "utf-8");
+    const content = fs13__default.readFileSync(fp, "utf-8");
     const fm = parseSkillFrontmatter(content);
     out.push({
       kind: "prompt",
@@ -7774,12 +8140,12 @@ function collectPromptVersions(dir, domain, out) {
   }
 }
 function collectSkillVersions(dir, domain, out) {
-  for (const entry of fs12__default.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs13__default.readdirSync(dir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const full = path14__default.join(dir, entry.name);
     const skillMd = path14__default.join(full, "SKILL.md");
-    if (fs12__default.existsSync(skillMd)) {
-      const content = fs12__default.readFileSync(skillMd, "utf-8");
+    if (fs13__default.existsSync(skillMd)) {
+      const content = fs13__default.readFileSync(skillMd, "utf-8");
       const fm = parseSkillFrontmatter(content);
       out.push({
         kind: "skill",
@@ -7794,11 +8160,11 @@ function collectSkillVersions(dir, domain, out) {
   }
 }
 function collectAgentVersions(dir, domain, out) {
-  for (const entry of fs12__default.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs13__default.readdirSync(dir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const agentYaml = path14__default.join(dir, entry.name, "agent.yaml");
-    if (!fs12__default.existsSync(agentYaml)) continue;
-    const content = fs12__default.readFileSync(agentYaml, "utf-8");
+    if (!fs13__default.existsSync(agentYaml)) continue;
+    const content = fs13__default.readFileSync(agentYaml, "utf-8");
     const parsed = parse(content);
     out.push({
       kind: "agent",
@@ -7881,7 +8247,7 @@ function checkFlowVersionPins(assets) {
   }
   let errors = 0;
   for (const f of flows) {
-    const content = fs12__default.readFileSync(f.filePath, "utf-8");
+    const content = fs13__default.readFileSync(f.filePath, "utf-8");
     const parsed = parse(content);
     const nodes = (parsed?.nodes ?? []).filter((n) => n.type === "skill" && n.data?.version).map((n) => ({
       nodeId: n.id,
@@ -8242,7 +8608,7 @@ program.command("init [project-dir]").description("Initialize a project director
   (projectDir, opts) => runInit(projectDir, opts)
 );
 async function runInit(projectDir, opts) {
-  const { mkdirSync: mkdirSync5, writeFileSync: writeFileSync4 } = await import('fs');
+  const { mkdirSync: mkdirSync5, writeFileSync: writeFileSync5 } = await import('fs');
   const { stringify: stringify2 } = await import('yaml');
   const { DRIVER_TARGETS, SUPPORTED_DRIVER_TARGETS: SUPPORTED_DRIVER_TARGETS2 } = await import('../core/index.js');
   const backend = opts.backend;
@@ -8254,29 +8620,29 @@ async function runInit(projectDir, opts) {
   const resolved = path14__default.resolve(projectDir ?? ".");
   const projectName = path14__default.basename(resolved);
   const created = [];
-  const { existsSync: existsSync14 } = await import('fs');
-  if (!existsSync14(resolved)) {
+  const { existsSync: existsSync15 } = await import('fs');
+  if (!existsSync15(resolved)) {
     mkdirSync5(resolved, { recursive: true });
     created.push(".");
   }
   const skaileDir = path14__default.join(resolved, ".skaile");
-  if (!existsSync14(skaileDir)) {
+  if (!existsSync15(skaileDir)) {
     mkdirSync5(path14__default.join(skaileDir, "sessions"), { recursive: true });
     created.push(".skaile/");
   }
   const settingsPath = path14__default.join(skaileDir, "settings.json");
-  if (!existsSync14(settingsPath)) {
-    writeFileSync4(settingsPath, "{}\n");
+  if (!existsSync15(settingsPath)) {
+    writeFileSync5(settingsPath, "{}\n");
     created.push(".skaile/settings.json");
   }
   const wsConfigPath = path14__default.join(resolved, "skaile.yaml");
-  if (!existsSync14(wsConfigPath)) {
-    writeFileSync4(wsConfigPath, stringify2(buildInitWorkspaceConfig(projectName, backend)));
+  if (!existsSync15(wsConfigPath)) {
+    writeFileSync5(wsConfigPath, stringify2(buildInitWorkspaceConfig(projectName, backend)));
     created.push("skaile.yaml");
   }
   for (const dir of new Set(Object.values(DRIVER_TARGETS[backend].local))) {
     const full = path14__default.join(resolved, dir);
-    if (!existsSync14(full)) {
+    if (!existsSync15(full)) {
       mkdirSync5(full, { recursive: true });
       created.push(`${dir}/`);
     }
@@ -8307,7 +8673,7 @@ function buildInitWorkspaceConfig(projectName, backend) {
 }
 async function initGitScaffold(resolved, created) {
   const { execSync: execSync3 } = await import('child_process');
-  const { existsSync: existsSync14, readFileSync: readFileSync8, writeFileSync: writeFileSync4 } = await import('fs');
+  const { existsSync: existsSync15, readFileSync: readFileSync9, writeFileSync: writeFileSync5 } = await import('fs');
   const gitignorePath = path14__default.join(resolved, ".gitignore");
   const entries = [
     "node_modules/",
@@ -8323,16 +8689,16 @@ async function initGitScaffold(resolved, created) {
     ".env",
     ".env.local"
   ];
-  const existing = existsSync14(gitignorePath) ? readFileSync8(gitignorePath, "utf-8") : "";
+  const existing = existsSync15(gitignorePath) ? readFileSync9(gitignorePath, "utf-8") : "";
   const have = new Set(existing.split("\n").map((l) => l.trim()));
   const append = entries.filter((e) => !have.has(e));
   if (append.length > 0) {
     const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
-    writeFileSync4(gitignorePath, `${existing + prefix}${append.join("\n")}
+    writeFileSync5(gitignorePath, `${existing + prefix}${append.join("\n")}
 `);
     if (!existing) created.push(".gitignore");
   }
-  if (!existsSync14(path14__default.join(resolved, ".git"))) {
+  if (!existsSync15(path14__default.join(resolved, ".git"))) {
     try {
       execSync3("git init", { cwd: resolved, stdio: "pipe" });
       created.push(".git/");
@@ -8344,10 +8710,10 @@ async function initGitScaffold(resolved, created) {
 }
 async function bootstrapUserConfig() {
   try {
-    const fs13 = await import('fs');
+    const fs14 = await import('fs');
     const { userConfigPath, saveConfig, getConfigDefaults } = await import('../library/index.js');
     const userCfgPath = userConfigPath();
-    if (!fs13.existsSync(userCfgPath)) {
+    if (!fs14.existsSync(userCfgPath)) {
       const defaults = getConfigDefaults();
       saveConfig(userCfgPath, {
         catalog: { url: defaults.catalog.url, cache_ttl: defaults.catalog.cache_ttl }
@@ -8362,7 +8728,7 @@ async function bootstrapUserConfig() {
 }
 async function hydrateInitSources(resolved, created) {
   try {
-    const { ensureSourcesCloned } = await import('../ensure-sources-QDVFUIUP.js');
+    const { ensureSourcesCloned } = await import('../ensure-sources-ORACQA4I.js');
     const hydrate = ensureSourcesCloned(resolved, { quiet: true });
     for (const n of hydrate.cloned) created.push(`~/.skaile/cache/sources/${n}/`);
     if (hydrate.failed.length > 0) {
@@ -8402,7 +8768,7 @@ function printInitSummary(resolved, projectDir, created) {
   console.log();
 }
 program.command("setup").description("Interactive provider setup wizard").action(async () => {
-  const { cmdSetup } = await import('../setup-2CCS63L6.js');
+  const { cmdSetup } = await import('../setup-ETGRXSZG.js');
   await cmdSetup([], { projectDir: process.cwd() });
 });
 program.addCommand(makeInstallCommand());