@skaile/workspaces 5.2.0 → 5.4.0

package/dist/cli/index.js

@@ -1,22 +1,24 @@
 #!/usr/bin/env node
-import { makeProvidersCommand, loadRegistryView, addProviderEntry, ProviderRegistryWriteError } from '../chunk-6OWIEFZ2.js';
-import { makeSourceCommand, syncProjectSources } from '../chunk-TVJBJLXR.js';
-import { AI_RESOURCES } from '../chunk-JPR7EPIM.js';
-import { getStoreConfig, storeFetch, deviceLogin, loadStoreAuthConfig, logout, hasStoredAuth, isStoreAuthenticated, getStoreToken, getStoreIdentity, refFor, assetEntryRef } from '../chunk-S6KNDUAU.js';
-import { makeInstallCommand, makeCheckCommand, makeCleanCommand, reportInstalledSoftDeps } from '../chunk-EOGNW74K.js';
-import { openCatalogSource, openLibraryManager, openLibrary } from '../chunk-R3QW7CA5.js';
-import { logErr, S, logOk, logInfo, logWarn, TARGET_DEFAULT_HINT, warnLegacyClaudeCopies, kindColorPad, kindColor, colorRef, formatSoftDepSection, bareSoftDepName, formatSoftDepHint, formatRelativeTime, formatSoftDepRemovePreview, formatSoftDepAddPreview, fitWidth, KIND_COL_WIDTH } from '../chunk-77GKEZ2R.js';
-import { createFullRegistry } from '../chunk-BZXR6SW5.js';
-import { LocalSecretsProvider } from '../chunk-EB6OPURC.js';
-import { runAgentChat, loadSessionById, loadSession, listSessions, setCurrentSession, deleteSession, clearSession, loadAgentManifest, compileComposition, MarkdownStreamer, resolveMixin } from '../chunk-ZSFTCMZL.js';
-import { buildClaudePluginFiles } from '../chunk-XIYXBHLN.js';
-import '../chunk-2MEMXBLC.js';
-import '../chunk-FJTC5YFO.js';
+import { makeProvidersCommand, loadRegistryView, addProviderEntry, ProviderRegistryWriteError } from '../chunk-OANSNVCP.js';
+import { makeSourceCommand, syncProjectSources } from '../chunk-QK756IRJ.js';
+import { AI_RESOURCES } from '../chunk-ZUZ5LLZ2.js';
+import { checkSkillManifest } from '../chunk-UKDFOOEG.js';
+import { getStoreConfig, storeFetch, deviceLogin, loadStoreAuthConfig, logout, hasStoredAuth, isStoreAuthenticated, getStoreToken, getStoreIdentity, assetEntryRef, refFor } from '../chunk-A67BHJCH.js';
+import { makeInstallCommand, makeCheckCommand, makeCleanCommand, reportInstalledSoftDeps } from '../chunk-7KITVWXK.js';
+import { createSpinner } from '../chunk-NESV47MF.js';
+import { openCatalogSource, openLibraryManager, openLibrary } from '../chunk-JF26V3BC.js';
+import { logErr, S, logOk, logInfo, logWarn, TARGET_DEFAULT_HINT, warnLegacyClaudeCopies, kindColorPad, kindColor, colorRef, formatSoftDepSection, bareSoftDepName, formatSoftDepHint, formatRelativeTime, formatSoftDepRemovePreview, formatSoftDepAddPreview, fitWidth, KIND_COL_WIDTH } from '../chunk-JEA32KB6.js';
+import { createFullRegistry } from '../chunk-5NH3U6N5.js';
+import { LocalSecretsProvider } from '../chunk-HTKZ4AOW.js';
+import { runAgentChat, loadSessionById, loadSession, listSessions, setCurrentSession, deleteSession, clearSession, loadAgentManifest, compileComposition, MarkdownStreamer, resolveMixin } from '../chunk-VETH6MDG.js';
+import { buildClaudePluginFiles } from '../chunk-DTV7HL5R.js';
+import '../chunk-BHUHGLNS.js';
+import '../chunk-XMQAV6T3.js';
 import '../chunk-R6O6YWU7.js';
-import '../chunk-BJQUSAGB.js';
-import '../chunk-7Y43UXKA.js';
+import '../chunk-GCYD4EGY.js';
+import '../chunk-JELTQ4H7.js';
 import '../chunk-4ZTPYIBE.js';
-import '../chunk-DD3OZLRD.js';
+import '../chunk-OXE5A6H6.js';
 import '../chunk-X5YPJV4N.js';
 import '../chunk-O7SG5PC2.js';
 import '../chunk-7QBNJTTQ.js';
@@ -25,53 +27,53 @@ import '../chunk-5LKOAX7I.js';
 import '../chunk-32NA4TVC.js';
 import '../chunk-W3UDISS2.js';
 import '../chunk-HCYS7GFP.js';
-import { runFlow, resumeFlow } from '../chunk-IOUIC2ZD.js';
+import { runFlow, resumeFlow } from '../chunk-SQBPE66C.js';
 import '../chunk-4R6DROGN.js';
-import { validateFlowVersions, parseSkillFrontmatter } from '../chunk-ANWHAGM7.js';
-import '../chunk-XOTJVCJB.js';
+import { validateFlowVersions, parseSkillFrontmatter } from '../chunk-JAJG4G5E.js';
+import '../chunk-JKWU6ULI.js';
 import '../chunk-CT6NQSA4.js';
-import '../chunk-MGHUSFYQ.js';
+import '../chunk-ONWTPXVU.js';
 import '../chunk-QMWMSZQ4.js';
-import '../chunk-UDBN3LZU.js';
-import '../chunk-OFNXRI4L.js';
-import '../chunk-2QZG5VJQ.js';
+import '../chunk-RD6GE4HU.js';
+import '../chunk-IDUGP4V7.js';
+import '../chunk-LAI7X6I2.js';
 import '../chunk-EINLFFP6.js';
 import '../chunk-LOO5CB5M.js';
 import '../chunk-BNUZEYC3.js';
-import '../chunk-BUNBKRJZ.js';
+import '../chunk-LUBS5DXY.js';
 import '../chunk-XBSQ4KMC.js';
 import '../chunk-YROR332M.js';
-import { getProviderPreset, AI_PROVIDER_PRESETS } from '../chunk-3E2TIPBZ.js';
+import { getProviderPreset, AI_PROVIDER_PRESETS } from '../chunk-AE42DHSH.js';
 import '../chunk-6E6PKKAD.js';
 import '../chunk-IFGTRL2I.js';
-import { projectAiAssetsRoots, loadFlow, loadAllFlowEntries, findFlowFileInRoots } from '../chunk-RXPC4KBW.js';
+import { projectAiAssetsRoots, loadFlow, loadAllFlowEntries, findFlowFileInRoots } from '../chunk-UAAAERXI.js';
 import '../chunk-37FTLYFP.js';
 import '../chunk-QZLWJETK.js';
 import '../chunk-XUUYAS3Z.js';
 import { nodeLabel, nodeSkillAsset, nodeIsInert, nodeIsOptional, nodeRunKind, flowSkillVersionPins } from '../chunk-NFGRW3L7.js';
 import '../chunk-QCI6D7E4.js';
 import '../chunk-K2K7OF4P.js';
-import { AssetManager, NON_DEPLOYABLE_KINDS, MissingManifestError, parseRefTolerant, normalizeRepoUrl, FACTORY_SOURCE_URL } from '../chunk-L257BENF.js';
-import { cloneOrInitGitRepo, ensureGitRepo, stampManifestPublisher, upsertManifestAsset, syncManifestWithDisk, isGitRepo, assertManifestEditable, installLibraryAsset, missingRootAssets, getStoreManifestsDir, getDefaultValue, isSecretPlaceholder } from '../chunk-B4J4RGNY.js';
-import '../chunk-LZ5RH6LD.js';
-import '../chunk-4YE7OYTB.js';
+import { AssetManager, NON_DEPLOYABLE_KINDS, MissingManifestError, parseRefTolerant, normalizeRepoUrl, FACTORY_SOURCE_URL } from '../chunk-BATL2CWI.js';
+import { cloneOrInitGitRepo, ensureGitRepo, setManifestPublisher, syncManifestWithDisk, isGitRepo, assertManifestEditable, installLibraryAsset, missingRootAssets, stampManifestPublisher, upsertManifestAsset, getStoreManifestsDir, getDefaultValue, isSecretPlaceholder } from '../chunk-Y5OCUOXF.js';
+import { parseManifestFile } from '../chunk-Y7UBRRKG.js';
+import '../chunk-VKSA2CDJ.js';
 import '../chunk-R7FOF242.js';
 import '../chunk-ZDKJHQY2.js';
-import '../chunk-KGGT6MUM.js';
+import '../chunk-37DN45RR.js';
 import '../chunk-CGYEHQOX.js';
-import { resolveSettings, globalSettingsPath, projectSettingsPath, loadSettings, saveSettings, WorkspaceYamlEditor, resolveLibraryDir, checkAgentSkillConformance, readLock, workspaceProviderRegistryPath, userProviderRegistryPath, loadProviderRegistryFile, aiResourceRoots } from '../chunk-BIMEKYOE.js';
+import { resolveSettings, globalSettingsPath, projectSettingsPath, loadSettings, saveSettings, WorkspaceYamlEditor, resolveLibraryDir, checkAgentSkillConformance, globalInstallDir, GLOBAL_INSTALL_DIR_NAME, readLock, workspaceProviderRegistryPath, userProviderRegistryPath, loadProviderRegistryFile, aiResourceRoots } from '../chunk-QEXEHXX5.js';
 import '../chunk-4GY63JU6.js';
-import { factoryAssetRoots } from '../chunk-PU5VY7KF.js';
-import '../chunk-U6K3I3AX.js';
+import { factoryAssetRoots } from '../chunk-JCATNLY3.js';
+import '../chunk-XGIS325V.js';
 import { DEFAULT_DRIVER_ID, DRIVER_DEFAULTS } from '../chunk-5BEFNLOR.js';
 import { findKindDirs } from '../chunk-A2ULN3KX.js';
-import { sourceCacheKey, getGlobalCacheDir, resolveAgentDir, AgentRefResolutionError, matchPin, coerceVersion, loadSkWorkspaceConfig, resolveSkWorkspaceConfig, storeManifestSlug, isWorkspaceConfigFilename } from '../chunk-P2EM6FNQ.js';
-import { globalCacheRoot, globalSkaileDir } from '../chunk-TLKM4M47.js';
+import { sourceCacheKey, getGlobalCacheDir, resolveAgentDir, AgentRefResolutionError, matchPin, coerceVersion, loadSkWorkspaceConfig, resolveSkWorkspaceConfig, storeManifestSlug, isWorkspaceConfigFilename } from '../chunk-6IGFSUTE.js';
+import { globalCacheRoot, globalSkaileDir, userConfigPath } from '../chunk-MFHKHXDE.js';
 import { SUPPORTED_DRIVER_TARGETS } from '../chunk-TOSHZX4C.js';
-import { loadSkPublishManifest, SKAILE_MANIFEST_FILENAME, decodeSkaileManifest } from '../chunk-YRF5CYHR.js';
+import { loadSkPublishManifest, SKAILE_MANIFEST_FILENAME, decodeSkaileManifest } from '../chunk-SR4RFKHM.js';
 import { pluginTitle } from '../chunk-RVRB27AN.js';
-import { parseFrontmatter, scanDirectory } from '../chunk-YANDJSMN.js';
-import { parseAssetRef, ASSET_KINDS, isValidAssetName, slugifyAssetName, ASSET_NAME_HINT, assetRefToStr } from '../chunk-OABIGSUY.js';
+import { parseFrontmatter, scanDirectory } from '../chunk-LFMX2UEF.js';
+import { parseAssetRef, ASSET_KINDS, isValidAssetName, slugifyAssetName, ASSET_NAME_HINT, assetRefToStr } from '../chunk-WX74MVNA.js';
 import { portableSpawn, portableSpawnSync } from '../chunk-ICSCSM5D.js';
 import { openSqlite } from '../chunk-JMKB7IB4.js';
 import { parseModelRef, resolveEntryBaseUrl } from '../chunk-MJHSLODD.js';
@@ -80,22 +82,22 @@ import '../chunk-BOFL7GIF.js';
 import '../chunk-KTBKW2FI.js';
 import '../chunk-UQ6LFBPZ.js';
 import '../chunk-TNWXGHLD.js';
-import { validatePreset, SKILL_BODY_PLACEHOLDER } from '../chunk-5CYEWBPB.js';
+import { validatePreset } from '../chunk-5CYEWBPB.js';
 import '../chunk-NSBPE2FW.js';
-import * as fs11 from 'fs';
-import fs11__default, { readFileSync, existsSync, mkdirSync, writeFileSync, lstatSync, rmSync, readdirSync, statSync } from 'fs';
-import * as path35 from 'path';
-import path35__default, { resolve, join } from 'path';
+import * as fs12 from 'fs';
+import fs12__default, { readFileSync, existsSync, mkdirSync, writeFileSync, lstatSync, rmSync, readdirSync, statSync } from 'fs';
+import * as path36 from 'path';
+import path36__default, { resolve, join } from 'path';
 import { fileURLToPath } from 'url';
 import { Help, Command, Option } from 'commander';
 import { rcompare } from 'semver';
-import * as p5 from '@clack/prompts';
+import * as p4 from '@clack/prompts';
 import pc5 from 'picocolors';
-import * as os from 'os';
 import { parse, stringify, parseDocument } from 'yaml';
+import * as os from 'os';
 import * as readline from 'readline';
 import { createInterface } from 'readline';
-import fs5 from 'fs/promises';
+import fs6 from 'fs/promises';
 import { parse as parse$1, stringify as stringify$1 } from 'smol-toml';
 import { execSync, spawnSync } from 'child_process';
 import * as readline2 from 'readline/promises';
@@ -132,10 +134,14 @@ async function runSearch(kind, query, opts) {
     query = kind;
     kind = void 0;
   }
+  if (kind && query === void 0 && !ASSET_KINDS.includes(kind)) {
+    query = kind;
+    kind = void 0;
+  }
   const showLocal = !opts.store;
   const showStore = !opts.local;
   const { resolveConfig } = await import('../library/index.js');
-  const airGapped = resolveConfig({ projectDir: path35__default.resolve(opts.projectDir) }).catalog.cache_ttl === 0;
+  const airGapped = resolveConfig({ projectDir: path36__default.resolve(opts.projectDir) }).catalog.cache_ttl === 0;
   if (showLocal) {
     await searchLocal(query, kind, opts, showStore, airGapped);
   }
@@ -144,7 +150,7 @@ async function runSearch(kind, query, opts) {
   }
 }
 async function searchIndex(query, kind) {
-  const { openLibrary: openLibrary2 } = await import('../open-library-4IJTBVTR.js');
+  const { openLibrary: openLibrary2 } = await import('../open-library-NVG3CZUO.js');
   const library = await openLibrary2();
   try {
     const defs = await library.listAssetDefs(kind ? { kind } : {});
@@ -176,8 +182,8 @@ async function searchIndex(query, kind) {
   }
 }
 async function searchFactory(projectDir, query, kind) {
-  const prefixes = factoryAssetRoots().map((r) => r.endsWith(path35__default.sep) ? r : r + path35__default.sep);
-  const isFactoryPath = (p7) => prefixes.some((fp) => p7 === fp.slice(0, -1) || p7.startsWith(fp));
+  const prefixes = factoryAssetRoots().map((r) => r.endsWith(path36__default.sep) ? r : r + path36__default.sep);
+  const isFactoryPath = (p6) => prefixes.some((fp) => p6 === fp.slice(0, -1) || p6.startsWith(fp));
   try {
     const entries = await new AssetManager({ projectDir }).search(query, kind);
     return entries.filter((e) => isFactoryPath(e.source));
@@ -193,11 +199,11 @@ function unionEntries(indexed, factory) {
   return [...indexed, ...factory.filter((e) => !seen.has(entryDedupKey(e)))];
 }
 async function searchLocal(query, kind, opts, showStore, airGapped) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const factory = await searchFactory(projectDir, query, kind);
   let entries = unionEntries(await searchIndex(query, kind), factory);
   if (entries.length === 0 && !query && !kind && !airGapped) {
-    const { autoSyncForSearch } = await import('../source-LJOI5AXU.js');
+    const { autoSyncForSearch } = await import('../source-HTT6CXUP.js');
     if (await autoSyncForSearch(projectDir)) {
       entries = unionEntries(await searchIndex(query, kind), factory);
     }
@@ -216,31 +222,70 @@ async function searchLocal(query, kind, opts, showStore, airGapped) {
   }
   printLocalEntries(entries);
 }
+var MIN_LOCAL_DESCRIPTION_WIDTH = 10;
+function layoutLocalTable(rows, width, style = {}) {
+  const styleRef = style.ref ?? ((s) => s);
+  const styleVer = style.version ?? ((s) => s);
+  const gap = COLUMN_GAP.length;
+  const indent = 2;
+  const pad = " ".repeat(indent);
+  const nameW = Math.max(4, ...rows.map((r) => r.ref.length));
+  const verW = Math.max(0, ...rows.map((r) => r.version.length));
+  const verSpan = verW > 0 ? gap + verW : 0;
+  const refCell = (ref) => styleRef(ref) + " ".repeat(nameW - ref.length);
+  const lines = [];
+  const descW = width - (indent + nameW + gap + verSpan);
+  if (descW >= MIN_LOCAL_DESCRIPTION_WIDTH) {
+    for (const r of rows) {
+      const desc = truncateText(r.description, descW);
+      const descCell = verW > 0 ? desc.padEnd(descW) : desc;
+      lines.push(
+        `${pad}${refCell(r.ref)}${COLUMN_GAP}${descCell}${r.version ? `${COLUMN_GAP}${styleVer(r.version)}` : ""}`
+      );
+    }
+    return { ruleWidth: nameW + gap + descW + verSpan, lines };
+  }
+  if (indent + nameW + verSpan <= width) {
+    for (const r of rows) {
+      lines.push(
+        verW > 0 ? `${pad}${refCell(r.ref)}${r.version ? `${COLUMN_GAP}${styleVer(r.version)}` : ""}` : `${pad}${styleRef(r.ref)}`
+      );
+    }
+    return { ruleWidth: nameW + verSpan, lines };
+  }
+  const subPad = " ".repeat(indent + 2);
+  const subDescW = width - (indent + 2) - verSpan;
+  for (const r of rows) {
+    lines.push(`${pad}${styleRef(r.ref)}`);
+    const desc = subDescW >= MIN_LOCAL_DESCRIPTION_WIDTH ? truncateText(r.description, subDescW) : "";
+    const descCell = r.version && desc ? desc.padEnd(subDescW) : desc;
+    const parts = [descCell, r.version ? styleVer(r.version) : ""].filter((s) => s !== "");
+    if (parts.length > 0) lines.push(`${subPad}${parts.join(COLUMN_GAP)}`);
+  }
+  return { ruleWidth: Math.max(1, Math.min(nameW, width - indent)), lines };
+}
 function printLocalEntries(entries, width = terminalWidth()) {
   const byKind = /* @__PURE__ */ new Map();
   for (const e of entries) {
     if (!byKind.has(e.kind)) byKind.set(e.kind, []);
     byKind.get(e.kind).push(e);
   }
-  const verOf = (e) => e.version ? `v${e.version}` : "";
   for (const [k, items] of byKind) {
-    const nameW = Math.max(4, ...items.map((e) => localEntryRef(e).length));
-    const verW = Math.max(0, ...items.map((e) => verOf(e).length));
-    const fixed = 2 + nameW + COLUMN_GAP.length + (verW > 0 ? COLUMN_GAP.length + verW : 0);
-    const descW = Math.max(MIN_DESCRIPTION_WIDTH, width - fixed);
+    const { ruleWidth, lines } = layoutLocalTable(
+      items.map((e) => ({
+        ref: localEntryRef(e),
+        description: e.description,
+        version: e.version ? `v${e.version}` : ""
+      })),
+      width,
+      { ref: S.cmd, version: S.dim }
+    );
     console.log();
     console.log(
       `  ${kindColor(k)} ${S.heading(`${k.toUpperCase()}S`)} ${S.dim(`(${items.length})`)}`
     );
-    console.log(`  ${S.rule(fixed - 2 + descW)}`);
-    for (const e of items) {
-      const desc = truncateText(e.description, descW);
-      const ver = verOf(e);
-      const descCell = ver ? desc.padEnd(descW) : desc;
-      console.log(
-        `  ${S.cmd(localEntryRef(e).padEnd(nameW))}${COLUMN_GAP}${descCell}${ver ? `${COLUMN_GAP}${S.dim(ver)}` : ""}`
-      );
-    }
+    console.log(`  ${S.rule(Math.max(1, Math.min(ruleWidth, width - 2)))}`);
+    for (const line of lines) console.log(line);
   }
   console.log(`
   ${S.dim(`${entries.length} total`)}
@@ -267,9 +312,9 @@ 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-4IJTBVTR.js');
+  const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError } = await import('../open-library-NVG3CZUO.js');
   try {
-    const remote = await openCatalogSource2({ projectDir: path35__default.resolve(opts.projectDir) });
+    const remote = await openCatalogSource2({ projectDir: path36__default.resolve(opts.projectDir) });
     const assets = await remote.listAssets(kind ? { kind } : {});
     const results = filterCatalogAssets(assets, query);
     if (results.length > 0) {
@@ -293,7 +338,7 @@ async function searchStore(query, kind, opts, airGapped) {
   }
 }
 function makeSearchCommand() {
-  return new Command("search").description("Search across all repos").argument("[kind]", "Filter by asset kind").argument("[query]", "Search query").option("--project-dir <path>", "Project directory", process.cwd()).option("--store", "Search only the store").option("--local", "Search only local repos").action(async (kind, query, opts) => {
+  return new Command("search").description("Search across all repos").argument("[kind]", "Filter by asset kind (a single non-kind argument is the query)").argument("[query]", "Search query").option("--project-dir <path>", "Project directory", process.cwd()).option("--store", "Search only the store").option("--local", "Search only local repos").action(async (kind, query, opts) => {
     await runSearch(kind, query, opts);
   });
 }
@@ -385,23 +430,27 @@ function makeAddCommand() {
     }
     const harnesses = parseHarnessFilter(opts.harness);
     const am2 = new AssetManager({
-      projectDir: path35__default.resolve(opts.projectDir),
+      projectDir: path36__default.resolve(opts.projectDir),
       global: opts.global || harnesses !== void 0,
       harnesses,
       driverTarget: opts.target
     });
-    const spinner4 = p5.spinner();
-    spinner4.start(`Adding ${ref}`);
+    const spinner = createSpinner();
+    spinner.start(`Adding ${ref}`);
     try {
-      const added = await am2.add(ref, { link: opts.link });
-      spinner4.stop("Done");
+      const libraryOf = /* @__PURE__ */ new Map();
+      const added = await am2.add(ref, {
+        link: opts.link,
+        onLibraryOrigin: (deployedRef, library) => libraryOf.set(deployedRef, library)
+      });
+      spinner.stop("Done");
       await promptSoftDepAdds(am2, ref, {
         isTTY: !!process.stdin.isTTY,
         link: opts.link,
         withSoftDeps: opts.withSoftDeps,
         noSoftDeps: opts.softDeps === false,
-        confirm: (message) => p5.confirm({ message, initialValue: false }),
-        isCancel: p5.isCancel,
+        confirm: (message) => p4.confirm({ message, initialValue: false }),
+        isCancel: p4.isCancel,
         onAdded: logOk,
         onError: logErr,
         onHint: (line) => logInfo(S.dim(line))
@@ -413,10 +462,15 @@ function makeAddCommand() {
             `Recorded in skaile.yaml${kind === "mcp-server" ? " (bytes fetched + verified into .skaile/cache/store)" : ""}. ${kind} assets are not deployed into the driver target \u2014 they are wired when skaile runs the agent.`
           );
         else logInfo("Nothing to deploy (already up to date).");
-      } else for (const a of added) logOk(a);
+      } else {
+        for (const a of added) {
+          const library = libraryOf.get(a);
+          logOk(library ? `${a} (library ${library})` : a);
+        }
+      }
       await reportBundleMembership(am2, ref, (line) => logInfo(S.dim(line)));
     } catch (err) {
-      spinner4.stop("Failed");
+      spinner.stop("Failed");
       logErr(String(err));
       process.exit(1);
     }
@@ -429,7 +483,7 @@ function makeRemoveCommand() {
   ).option("--target <agent>", `Driver target (${TARGET_DEFAULT_HINT})`).option("--no-soft-deps", "skip the orphaned-soft-dep prompt (don't remove, don't report)").action(async (ref, opts) => {
     const harnesses = parseHarnessFilter(opts.harness);
     const am2 = new AssetManager({
-      projectDir: path35__default.resolve(opts.projectDir),
+      projectDir: path36__default.resolve(opts.projectDir),
       global: opts.global || harnesses !== void 0,
       harnesses,
       driverTarget: opts.target
@@ -443,8 +497,8 @@ function makeRemoveCommand() {
     await promptSoftDepRemovals(am2, ref, {
       isTTY: !!process.stdin.isTTY,
       noSoftDeps: opts.softDeps === false,
-      confirm: (message) => p5.confirm({ message, initialValue: false }),
-      isCancel: p5.isCancel,
+      confirm: (message) => p4.confirm({ message, initialValue: false }),
+      isCancel: p4.isCancel,
       onRemoved: logOk,
       onHint: (line) => logInfo(S.dim(line))
     });
@@ -471,7 +525,7 @@ function makeListCommand() {
       return;
     }
     const am2 = new AssetManager({
-      projectDir: path35__default.resolve(opts.projectDir),
+      projectDir: path36__default.resolve(opts.projectDir),
       driverTarget: opts.target
     });
     let declared;
@@ -518,7 +572,7 @@ function makeListCommand() {
 }
 function runGlobalList(kind, opts, harnesses) {
   const am2 = new AssetManager({
-    projectDir: path35__default.resolve(opts.projectDir),
+    projectDir: path36__default.resolve(opts.projectDir),
     global: true,
     harnesses
   });
@@ -589,7 +643,7 @@ async function resolveInfoEntry(am2, ref, opts) {
     return { entry: match ?? deployed };
   }
   const lookup = opts.storeLookup ?? (async (filter) => {
-    const { resolveCatalogSource } = await import('../open-library-4IJTBVTR.js');
+    const { resolveCatalogSource } = await import('../open-library-NVG3CZUO.js');
     const { source, close } = await resolveCatalogSource({ projectDir: opts.projectDir });
     try {
       return await source.listAssets(filter);
@@ -605,7 +659,7 @@ async function resolveInfoEntry(am2, ref, opts) {
     );
     return { entry: hit ? catalogAssetToEntry(hit) : null };
   } catch (err) {
-    const { LocalCatalogDisabledError } = await import('../open-library-4IJTBVTR.js');
+    const { LocalCatalogDisabledError } = await import('../open-library-NVG3CZUO.js');
     const storeNote = err instanceof Error ? err.message : String(err);
     const disabled = err instanceof LocalCatalogDisabledError || /catalog\.url/i.test(storeNote);
     return { entry: null, storeNote, ...disabled ? { storeDisabled: true } : {} };
@@ -616,12 +670,12 @@ function infoNotFoundHint(ref, lookup) {
   if (!lookup.storeNote)
     return `'${ref}' not found in local sources, deployed assets, or the store. ${sync}, or ${S.cmd("skaile search --store")} to browse the store.`;
   if (lookup.storeDisabled)
-    return `'${ref}' not found in local sources or deployed assets, and the remote store is disabled (${lookup.storeNote}). ${sync}, or set ${S.cmd("catalog.url")} in ~/.skaile/config.yaml to query the store.`;
+    return `'${ref}' not found in local sources or deployed assets, and the remote store is disabled (${lookup.storeNote}). ${sync}, or set ${S.cmd("catalog.url")} in ${userConfigPath()} to query the store.`;
   return `'${ref}' not found locally and the store could not be queried (${lookup.storeNote}). ${sync}, or retry when the store is reachable.`;
 }
 function makeInfoCommand() {
   return new Command("info").description("Show asset metadata, deps, deploy status").argument("<ref>", "Asset reference (kind:name)").option("--project-dir <path>", "Project directory", process.cwd()).action(async (ref, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const am2 = new AssetManager({ projectDir });
     const lookup = await resolveInfoEntry(am2, ref, { projectDir });
     const entry = lookup.entry;
@@ -657,7 +711,7 @@ function makeCreateCommand() {
     new Option("-k, --kind <kind>", "Asset kind").default("skill").choices([...ASSET_KINDS])
   ).option("-d, --dir <dir>", "Target directory (default: cwd)").action((name, opts) => {
     const am2 = new AssetManager({ projectDir: process.cwd() });
-    const destDir = opts.dir ? path35__default.resolve(opts.dir) : process.cwd();
+    const destDir = opts.dir ? path36__default.resolve(opts.dir) : process.cwd();
     const result = am2.create(name, opts.kind, destDir);
     if (result.ok) logOk(`Created ${kindColor(opts.kind)}: ${pc5.dim(result.path)}`);
     else {
@@ -668,7 +722,7 @@ function makeCreateCommand() {
 }
 function makeDoctorCommand() {
   return new Command("doctor").description("Scan for missing dependency chains").argument("[name]", "Check a specific asset (kind:name)").option("--project-dir <path>", "Project directory", process.cwd()).action(async (name, opts) => {
-    const am2 = new AssetManager({ projectDir: path35__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path36__default.resolve(opts.projectDir) });
     const issues = await am2.doctor();
     if (issues.length === 0) {
       logOk("No missing dependencies.");
@@ -690,27 +744,145 @@ function makeDoctorCommand() {
     console.log();
   });
 }
+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 resolveLibraryPublisherDetailed(lib, opts, storeIdentity) {
+  const bare = (p6) => p6.startsWith("@") ? p6.slice(1) : p6;
+  if (opts.publisher?.trim()) return { publisher: bare(opts.publisher.trim()), source: "flag" };
+  const declared = loadSkPublishManifest(lib.path)?.publisher?.trim();
+  if (declared) return { publisher: bare(declared), source: "manifest" };
+  const identity = (storeIdentity?.githubLogin ?? storeIdentity?.username)?.trim();
+  if (identity) return { publisher: identity, source: "identity" };
+  try {
+    return { publisher: slugifyAssetName(lib.name), source: "library-name" };
+  } catch {
+    return { publisher: "library", source: "library-name" };
+  }
+}
+function resolveLibraryPublisher(lib, opts, storeIdentity) {
+  return resolveLibraryPublisherDetailed(lib, opts, storeIdentity).publisher;
+}
+function stampAssetPublisher(assetDir, publisher) {
+  const markers = ["SKILL.md", "AGENT.md", "CONTRACT.md"];
+  let markerFile;
+  for (const m of markers) {
+    if (fs12.existsSync(path36.join(assetDir, m))) {
+      markerFile = path36.join(assetDir, m);
+      break;
+    }
+  }
+  if (!markerFile) {
+    const promptMd = fs12.readdirSync(assetDir).find((f) => f.endsWith(".prompt.md"));
+    if (promptMd) markerFile = path36.join(assetDir, promptMd);
+  }
+  if (!markerFile) return;
+  try {
+    const { data, body } = parseFrontmatter(fs12.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();
+    fs12.writeFileSync(markerFile, `---
+${fm}
+---
+
+${body}
+`, "utf8");
+  } catch {
+  }
+}
+async function registerLibraryAsset(lib, index, input) {
+  const { publisher, source } = resolveLibraryPublisherDetailed(
+    lib,
+    { publisher: input.publisher },
+    getStoreIdentity()
+  );
+  if (source === "library-name") {
+    logWarn(
+      `No publisher given and not signed in \u2014 using the library name "${publisher}" as the publisher. Pass --publisher <name> or run \`skaile store login\`; change it later with \`skaile library set ${lib.name} publisher=<name>\`.`
+    );
+  }
+  stampAssetPublisher(input.assetDir, publisher);
+  stampManifestPublisher(lib.path, publisher);
+  upsertManifestAsset(lib.path, {
+    kind: input.kind,
+    name: input.name,
+    root: path36.relative(lib.path, input.assetDir) || input.name,
+    version: input.version,
+    publisher
+  });
+  const idx = await indexLibrary(lib, index);
+  for (const e of idx.errors) logWarn(e);
+  return { publisher, ref: refFor(input.kind, publisher, input.name, input.version) };
+}
+var LIBRARY_UPGRADE_DOCS = "https://github.com/skaile-ai/workspaces/blob/main/docs/sections/cli/commands/library.md#upgrading-a-4x-library";
+var DOMAIN_REMOVED_HINT = `Domains were removed in 5.0 \u2014 delete DOMAIN.md files; group assets with .claude-plugin/marketplace.json. See ${LIBRARY_UPGRADE_DOCS}`;
+function countDomainFiles(root) {
+  let count = 0;
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs12.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+          walk(path36.join(dir, entry.name));
+        }
+      } else if (entry.name === "DOMAIN.md") {
+        count++;
+      }
+    }
+  };
+  walk(root);
+  return count;
+}
+function warnIgnoredDomainFiles(root) {
+  const count = countDomainFiles(root);
+  if (count > 0) {
+    logWarn(
+      `${count} DOMAIN.md file(s) are ignored since 5.0 (domains were removed) \u2014 delete them; group assets with .claude-plugin/marketplace.json. See ${LIBRARY_UPGRADE_DOCS}`
+    );
+  }
+  return count;
+}
 var DEFAULT_IMPORT_VERSION = "0.1.0";
 var DEFAULT_IMPORT_STAGE = "alpha";
 function claudeSkillRoots() {
   const roots = [];
   const override = process.env.SKAILE_CLAUDE_SKILLS_DIR;
   if (override) roots.push(override);
-  roots.push(path35.join(os.homedir(), ".claude", "skills"));
+  roots.push(path36.join(os.homedir(), ".claude", "skills"));
   return roots;
 }
 function resolveImportSource(nameOrPath) {
-  const asPath = path35.resolve(nameOrPath);
-  if (fs11.existsSync(asPath)) {
-    const dir = fs11.statSync(asPath).isDirectory() ? asPath : path35.dirname(asPath);
-    const skillFile = path35.join(dir, "SKILL.md");
-    if (fs11.existsSync(skillFile)) return { dir, skillFile, via: "path" };
+  const asPath = path36.resolve(nameOrPath);
+  if (fs12.existsSync(asPath)) {
+    const dir = fs12.statSync(asPath).isDirectory() ? asPath : path36.dirname(asPath);
+    const skillFile = path36.join(dir, "SKILL.md");
+    if (fs12.existsSync(skillFile)) return { dir, skillFile, via: "path" };
   }
-  if (!nameOrPath.includes(path35.sep) && !nameOrPath.startsWith(".")) {
+  if (!nameOrPath.includes(path36.sep) && !nameOrPath.startsWith(".")) {
     for (const root of claudeSkillRoots()) {
-      const dir = path35.join(root, nameOrPath);
-      const skillFile = path35.join(dir, "SKILL.md");
-      if (fs11.existsSync(skillFile)) return { dir, skillFile, via: "claude-skills" };
+      const dir = path36.join(root, nameOrPath);
+      const skillFile = path36.join(dir, "SKILL.md");
+      if (fs12.existsSync(skillFile)) return { dir, skillFile, via: "claude-skills" };
     }
   }
   return null;
@@ -740,9 +912,9 @@ function normalizeSkillContent(raw, opts = {}) {
     notes.push(`stamped metadata.stage: ${existingMeta.stage}`);
   }
   if (existingMeta.tags == null) {
-    const keywords = Array.isArray(data.keywords) ? data.keywords : [];
-    existingMeta.tags = keywords.filter((k) => typeof k === "string");
-    if (existingMeta.tags.length > 0) {
+    const keywords = Array.isArray(data.keywords) ? data.keywords.filter((k) => typeof k === "string") : [];
+    if (keywords.length > 0) {
+      existingMeta.tags = keywords;
       notes.push("promoted top-level keywords \u2192 metadata.tags");
     }
   }
@@ -787,9 +959,21 @@ async function resolveDefByRef(library, ref, opts) {
 function withCanonicalRef(def) {
   return { ref: catalogAssetRef(def), ...def };
 }
+function resolveLibraryOption(opts) {
+  if (opts.library && opts.to && opts.library !== opts.to) {
+    logErr(
+      `Conflicting options: --library "${opts.library}" and --to "${opts.to}". Use --library.`
+    );
+    process.exit(1);
+  }
+  return opts.library ?? opts.to;
+}
 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("--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(
+  cmd.command("import <name-or-path>").description("Import + skailify an existing coding-agent skill into a library").option("--library <library>", "Target library (default: auto / personal)").addOption(new Option("--to <library>", "Alias for --library").hideHelp()).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(
+    "--publisher <name>",
+    "Publisher for the imported skill (default: the library's, else your store login)"
+  ).option("--commit", "Auto-commit in git-backed libraries", false).action(
     async (nameOrPath, opts) => {
       const src = resolveImportSource(nameOrPath);
       if (!src) {
@@ -799,18 +983,19 @@ function makeAssetCommand() {
         process.exit(1);
       }
       logInfo(`Source: ${S.dim(src.dir)} (${src.via})`);
-      const { manager, close } = await openLibraryManager();
+      const libraryName = resolveLibraryOption(opts);
+      const { manager, library, close } = await openLibraryManager();
       try {
         let target;
-        if (opts.to) {
-          target = await manager.requireLibrary(opts.to);
+        if (libraryName) {
+          target = await manager.requireLibrary(libraryName);
         } else {
           const found = await manager.findDefaultLibrary();
           const def = found && found.ownership !== "reader" ? found : void 0;
           target = def ?? (await manager.ensurePersonalLibrary(resolveLibraryDir())).library;
         }
         if (target.ownership === "reader") {
-          logErr(`Library "${target.name}" is read-only (ownership=reader). Choose --to.`);
+          logErr(`Library "${target.name}" is read-only (ownership=reader). Choose --library.`);
           process.exit(1);
         }
         try {
@@ -819,40 +1004,37 @@ function makeAssetCommand() {
           logErr(err instanceof Error ? err.message : String(err));
           process.exit(1);
         }
-        const rawSkill = fs11.readFileSync(src.skillFile, "utf8");
+        const rawSkill = fs12.readFileSync(src.skillFile, "utf8");
         const norm = opts.normalize ? normalizeSkillContent(rawSkill, {
-          fallbackName: path35.basename(src.dir),
+          fallbackName: path36.basename(src.dir),
           version: opts.version,
           stage: opts.stage
-        }) : { content: rawSkill, name: path35.basename(src.dir), changed: false, notes: [] };
+        }) : { content: rawSkill, name: path36.basename(src.dir), changed: false, notes: [] };
         if (!opts.normalize && !isValidAssetName(norm.name)) {
           logWarn(
             `Name "${norm.name}" is not canonical (kebab-case); \`skaile validate\` will reject this manifest entry. Drop --no-normalize to slugify it.`
           );
         }
-        const destDir = path35.join(target.path, norm.name);
-        if (fs11.existsSync(destDir)) {
+        const destDir = path36.join(target.path, norm.name);
+        if (fs12.existsSync(destDir)) {
           logErr(`Destination already exists: ${destDir}`);
           process.exit(1);
         }
-        fs11.cpSync(src.dir, destDir, { recursive: true });
-        fs11.writeFileSync(path35.join(destDir, "SKILL.md"), norm.content, "utf8");
+        fs12.cpSync(src.dir, destDir, { recursive: true });
+        fs12.writeFileSync(path36.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;
-        const description = typeof descRaw === "string" ? descRaw.trim() : void 0;
         for (const f of checkAgentSkillConformance(fm, { dirName: norm.name })) {
           logWarn(`conformance: ${f.field} \u2014 ${f.message}`);
         }
-        const root = path35.relative(target.path, destDir);
-        const up = upsertManifestAsset(target.path, {
+        const fmVersion = fm.metadata?.version;
+        const { ref } = await registerLibraryAsset(target, library, {
           kind: "skill",
           name: norm.name,
-          root,
-          version: opts.version,
-          description
+          assetDir: destDir,
+          version: fmVersion != null ? String(fmVersion) : opts.version ?? DEFAULT_IMPORT_VERSION,
+          publisher: opts.publisher
         });
-        logOk(`${up.added ? "Added" : "Updated"} manifest entry skill:${norm.name}`);
         if (target.backend === "git" && opts.commit) {
           const { spawnSync: spawnSync2 } = await import('child_process');
           spawnSync2("git", ["add", "--", destDir], { cwd: target.path, stdio: "inherit" });
@@ -864,28 +1046,30 @@ function makeAssetCommand() {
             logWarn("Nothing committed (working tree clean or commit aborted).");
           }
         }
-        logOk(`Imported ${S.cmd(norm.name)} \u2192 ${target.name}`);
+        logOk(`Imported ${S.cmd(ref)} \u2192 ${target.name}`);
+        logInfo(`Indexed \u2014 add it with ${S.cmd(`skaile add ${ref}`)}`);
         logInfo(`Verify: ${S.cmd(`skaile validate ${target.path}`)}`);
       } finally {
         close();
       }
     }
   );
-  cmd.command("migrate <path>").description("Move/copy/link a workspace asset into a library").option("--to <library>", "Target library (default: auto)").option("--mode <mode>", "copy | move | link", "copy").option("--commit", "Auto-commit in git-backed libraries", false).action(
+  cmd.command("migrate <path>").description("Move/copy/link a workspace asset into a library").option("--library <library>", "Target library (default: auto)").addOption(new Option("--to <library>", "Alias for --library").hideHelp()).option("--mode <mode>", "copy | move | link", "copy").option("--commit", "Auto-commit in git-backed libraries", false).action(
     async (srcPath, opts) => {
       if (!["copy", "move", "link"].includes(opts.mode)) {
         logErr(`Invalid --mode "${opts.mode}". Expected: copy | move | link.`);
         process.exit(1);
       }
-      if (!fs11.existsSync(srcPath)) {
+      if (!fs12.existsSync(srcPath)) {
         logErr(`Source path does not exist: ${srcPath}`);
         process.exit(1);
       }
+      const libraryName = resolveLibraryOption(opts);
       const { manager, close } = await openLibraryManager();
       try {
         let target;
-        if (opts.to) {
-          target = await manager.requireLibrary(opts.to);
+        if (libraryName) {
+          target = await manager.requireLibrary(libraryName);
         } else {
           const found = await manager.findDefaultLibrary();
           const def = found && found.ownership !== "reader" ? found : void 0;
@@ -898,27 +1082,27 @@ function makeAssetCommand() {
         }
         if (target.ownership === "reader") {
           logErr(
-            `Library "${target.name}" is read-only (ownership=reader). Choose another with --to.`
+            `Library "${target.name}" is read-only (ownership=reader). Choose another with --library.`
           );
           process.exit(1);
         }
-        const basename2 = path35.basename(srcPath);
+        const basename2 = path36.basename(srcPath);
         const destDir = target.path;
-        fs11.mkdirSync(destDir, { recursive: true });
-        const destPath = path35.join(destDir, basename2);
-        if (fs11.existsSync(destPath)) {
+        fs12.mkdirSync(destDir, { recursive: true });
+        const destPath = path36.join(destDir, basename2);
+        if (fs12.existsSync(destPath)) {
           logErr(`Destination already exists: ${destPath}`);
           process.exit(1);
         }
         switch (opts.mode) {
           case "copy":
-            fs11.cpSync(srcPath, destPath, { recursive: true });
+            fs12.cpSync(srcPath, destPath, { recursive: true });
             break;
           case "move":
-            fs11.renameSync(srcPath, destPath);
+            fs12.renameSync(srcPath, destPath);
             break;
           case "link":
-            fs11.symlinkSync(path35.resolve(srcPath), destPath);
+            fs12.symlinkSync(path36.resolve(srcPath), destPath);
             break;
         }
         if (target.backend === "git" && opts.commit) {
@@ -992,7 +1176,7 @@ function makeAssetCommand() {
     }
   );
   cmd.addCommand(makeListCommand());
-  cmd.command("show <ref>").description("Show details for an asset by canonical ref").action(async (ref) => {
+  cmd.command("show <ref>").description("Show details for an asset by canonical ref (prints JSON)").option("--json", "Print JSON (the default and only output format)").action(async (ref, _opts) => {
     const { library, close } = await openLibraryManager();
     try {
       const def = await resolveDefByRef(library, ref);
@@ -1048,14 +1232,14 @@ function makeAuthCommand() {
 }
 function collectCacheTargets(scope) {
   const out = [];
-  out.push(path35__default.join(scope.projectDir, ".skaile", "cache"));
-  out.push(path35__default.join(scope.projectDir, ".skaile", "store-cache"));
-  out.push(path35__default.join(scope.projectDir, ".skaile", "repos"));
+  out.push(path36__default.join(scope.projectDir, ".skaile", "cache"));
+  out.push(path36__default.join(scope.projectDir, ".skaile", "store-cache"));
+  out.push(path36__default.join(scope.projectDir, ".skaile", "repos"));
   if (scope.global) {
     out.push(globalCacheRoot());
     const home = globalSkaileDir();
-    out.push(path35__default.join(home, "repos"));
-    out.push(path35__default.join(home, "catalog-cache"));
+    out.push(path36__default.join(home, "repos"));
+    out.push(path36__default.join(home, "catalog-cache"));
   }
   return out;
 }
@@ -1069,7 +1253,7 @@ function dirSize(target) {
 function dirSizeOfDir(dir) {
   let total = 0;
   for (const ent of readdirSync(dir, { withFileTypes: true })) {
-    const child = path35__default.join(dir, ent.name);
+    const child = path36__default.join(dir, ent.name);
     if (ent.isSymbolicLink()) continue;
     if (ent.isDirectory()) total += dirSizeOfDir(child);
     else if (ent.isFile()) total += statSync(child).size;
@@ -1095,7 +1279,7 @@ function makeCacheCommand() {
   const cmd = new Command("cache").description("Inspect and reclaim the re-derivable cache");
   cmd.command("clean").description("Remove the project cache (.skaile/cache); --global also clears ~/.skaile/cache").option("--global", "Also clear the global cache (sources + catalog) and legacy dirs").option("--dry-run", "Show what would be removed without doing it").option("-y, --yes", "Skip confirmation prompt").option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {
     const targets = collectCacheTargets({
-      projectDir: path35__default.resolve(opts.projectDir),
+      projectDir: path36__default.resolve(opts.projectDir),
       global: opts.global
     }).filter((t) => existsSync(t));
     if (targets.length === 0) {
@@ -1112,10 +1296,10 @@ function makeCacheCommand() {
       return;
     }
     if (!opts.yes) {
-      const ok = await p5.confirm({
+      const ok = await p4.confirm({
         message: opts.global ? "Clear project AND global cache?" : "Clear project cache?"
       });
-      if (p5.isCancel(ok) || !ok) {
+      if (p4.isCancel(ok) || !ok) {
         logInfo("Cancelled.");
         return;
       }
@@ -1125,12 +1309,12 @@ function makeCacheCommand() {
     for (const r of removed) logOk(`Removed ${r}`);
   });
   cmd.command("dir").description("Print the resolved cache roots").option("--global", "Include the global cache root").option("--project-dir <path>", "Project directory", process.cwd()).action((opts) => {
-    console.log(path35__default.join(path35__default.resolve(opts.projectDir), ".skaile", "cache"));
+    console.log(path36__default.join(path36__default.resolve(opts.projectDir), ".skaile", "cache"));
     if (opts.global) console.log(globalCacheRoot());
   });
   cmd.command("size").description("Show cache disk usage per directory").option("--global", "Include the global cache").option("--project-dir <path>", "Project directory", process.cwd()).action((opts) => {
     const targets = collectCacheTargets({
-      projectDir: path35__default.resolve(opts.projectDir),
+      projectDir: path36__default.resolve(opts.projectDir),
       global: opts.global
     });
     console.log();
@@ -1146,7 +1330,7 @@ function makeCatalogCommand() {
   const catalog = new Command("catalog").description("Catalog source health and configuration");
   catalog.command("test").description("Probe the configured catalog source and report status").option("--project-dir <path>", "Project directory (for project-level config overlay)").option("--url <url>", "Override the catalog URL for this probe").option("--force", "Probe the network even in air-gapped mode (cache_ttl: 0)").action(async (opts) => {
     const { resolveConfig, isLocalCatalogUrl, trpcGetUrl } = await import('../library/index.js');
-    const projectDir = opts.projectDir ? path35__default.resolve(opts.projectDir) : void 0;
+    const projectDir = opts.projectDir ? path36__default.resolve(opts.projectDir) : void 0;
     const cfg = resolveConfig({ projectDir });
     const baseUrl = opts.url ?? cfg.catalog.url;
     if (isLocalCatalogUrl(baseUrl)) {
@@ -1164,7 +1348,7 @@ function makeCatalogCommand() {
   });
   catalog.command("info").description("Print the resolved catalog configuration (url, framing, cacheTtlMs)").option("--project-dir <path>", "Project directory (for project-level config overlay)").action(async (opts) => {
     const { resolveConfig } = await import('../library/index.js');
-    const projectDir = opts.projectDir ? path35__default.resolve(opts.projectDir) : void 0;
+    const projectDir = opts.projectDir ? path36__default.resolve(opts.projectDir) : void 0;
     const cfg = resolveConfig({ projectDir });
     console.log(`url: ${cfg.catalog.url}`);
     console.log(`framing: ${cfg.catalog.framing}`);
@@ -1173,7 +1357,7 @@ function makeCatalogCommand() {
   return catalog;
 }
 async function runLocalCatalogTest(projectDir) {
-  const { resolveCatalogSource } = await import('../open-library-4IJTBVTR.js');
+  const { resolveCatalogSource } = await import('../open-library-NVG3CZUO.js');
   let resolved;
   try {
     resolved = await resolveCatalogSource({ projectDir });
@@ -1215,11 +1399,11 @@ async function runRemoteCatalogProbe(baseUrl, probeUrl) {
       logErr(`${probeUrl} responded ${res.status} ${res.statusText} (${ms}ms)`);
       if (res.status === 404) {
         logInfo(
-          "Got 404 from catalog.listKinds. Check the URL prefix in ~/.skaile/config.yaml \u2014 Skaile mirrors must expose `/trpc/catalog.*` at the configured baseUrl."
+          `Got 404 from catalog.listKinds. Check the URL prefix in ${userConfigPath()} \u2014 Skaile mirrors must expose \`/trpc/catalog.*\` at the configured baseUrl.`
         );
       } else {
         logInfo(
-          "Verify the URL in ~/.skaile/config.yaml and any auth requirements on private mirrors."
+          `Verify the URL in ${userConfigPath()} and any auth requirements on private mirrors.`
         );
       }
       process.exitCode = 1;
@@ -1243,7 +1427,7 @@ async function runRemoteCatalogProbe(baseUrl, probeUrl) {
     } else {
       logErr(`Could not reach ${probeUrl}: ${err instanceof Error ? err.message : String(err)}`);
     }
-    logInfo("Verify the URL in ~/.skaile/config.yaml and that the catalog backend is deployed.");
+    logInfo(`Verify the URL in ${userConfigPath()} and that the catalog backend is deployed.`);
     process.exitCode = 1;
   } finally {
     clearTimeout(timeout);
@@ -1317,8 +1501,8 @@ async function scanLibraryFlowEntries() {
     const indexPath = resolveIndexPath();
     if (!existsSync(indexPath)) return entries;
     const [{ authoringLibraries }, { createFullRegistry: createFullRegistry2 }] = await Promise.all([
-      import('../open-library-4IJTBVTR.js'),
-      import('../open-registry-G5DI4RPU.js')
+      import('../open-library-NVG3CZUO.js'),
+      import('../open-registry-IYH6W6CN.js')
     ]);
     const index = new LocalIndex({ indexPath });
     try {
@@ -1375,11 +1559,11 @@ function findSkills() {
   return deduped;
 }
 function walkSkills(dir, out) {
-  for (const entry of fs11__default.readdirSync(dir, { withFileTypes: true })) {
-    const full = path35__default.join(dir, entry.name);
+  for (const entry of fs12__default.readdirSync(dir, { withFileTypes: true })) {
+    const full = path36__default.join(dir, entry.name);
     if (entry.isDirectory()) {
-      const skillMd = path35__default.join(full, "SKILL.md");
-      if (fs11__default.existsSync(skillMd)) {
+      const skillMd = path36__default.join(full, "SKILL.md");
+      if (fs12__default.existsSync(skillMd)) {
         out.push({ name: entry.name, path: full, skillPath: skillMd });
       } else {
         walkSkills(full, out);
@@ -1400,10 +1584,10 @@ function resolveFlowIds() {
   }
 }
 function resolveSessionIds(projectDir) {
-  const sessionsDir = path35__default.join(projectDir, ".skaile", "sessions");
-  if (!fs11__default.existsSync(sessionsDir)) return [];
+  const sessionsDir = path36__default.join(projectDir, ".skaile", "sessions");
+  if (!fs12__default.existsSync(sessionsDir)) return [];
   try {
-    return fs11__default.readdirSync(sessionsDir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
+    return fs12__default.readdirSync(sessionsDir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
   } catch {
     return [];
   }
@@ -1460,12 +1644,12 @@ var API_KEY_PREFIX = "apiKey.";
 function collectWorkspaceDefaults(projectDir) {
   const wsDefaults = {};
   const ws = resolveSkWorkspaceConfig(projectDir);
-  const p7 = ws.agent_config?.default ?? {};
-  if (p7.driver) wsDefaults.driver = p7.driver;
-  if (p7.model) wsDefaults.model = p7.model;
-  if (p7.skills_dir) wsDefaults.skills_dir = p7.skills_dir;
-  if (p7.agents_dir) wsDefaults.agents_dir = p7.agents_dir;
-  if (p7.prompts_dir) wsDefaults.prompts_dir = p7.prompts_dir;
+  const p6 = ws.agent_config?.default ?? {};
+  if (p6.driver) wsDefaults.driver = p6.driver;
+  if (p6.model) wsDefaults.model = p6.model;
+  if (p6.skills_dir) wsDefaults.skills_dir = p6.skills_dir;
+  if (p6.agents_dir) wsDefaults.agents_dir = p6.agents_dir;
+  if (p6.prompts_dir) wsDefaults.prompts_dir = p6.prompts_dir;
   for (const [role, target] of Object.entries(ws.roles ?? {})) {
     wsDefaults[`@${role}`] = target;
   }
@@ -1542,7 +1726,7 @@ function printResolvedPathsSection(config) {
   console.log(`  ${S.label("prompts:".padEnd(16))} ${config.promptsDir ?? paths.promptsDir}`);
 }
 async function showConfig(opts) {
-  const projectDir = opts.projectDir ? path35__default.resolve(opts.projectDir) : process.cwd();
+  const projectDir = opts.projectDir ? path36__default.resolve(opts.projectDir) : process.cwd();
   let config;
   let wsDefaults;
   try {
@@ -1587,13 +1771,13 @@ function makeConfigCommand() {
   const cmd = new Command("config").description("Manage personal config (.skaile/settings.json)");
   cmd.command("show").description("Show effective config with sources").option("--project-dir <path>", "Project directory").action((opts) => showConfig(opts));
   cmd.command("get <key>").description("Get an effective config value").option("--project-dir <path>", "Project directory").action(async (key, opts) => {
-    const projectDir = opts.projectDir ? path35__default.resolve(opts.projectDir) : process.cwd();
+    const projectDir = opts.projectDir ? path36__default.resolve(opts.projectDir) : process.cwd();
     const config = await resolveSettings(projectDir);
     const value = config[key];
     console.log(value ?? S.dim("(not set)"));
   });
   cmd.command("set <key> <value>").description("Set a personal config value (driver, model, apiKey.<provider>)").option("--project-dir <path>", "Project directory").option("--global", "Write to ~/.skaile/settings.json instead of project-local").action(async (key, value, opts) => {
-    const projectDir = opts.projectDir ? path35__default.resolve(opts.projectDir) : process.cwd();
+    const projectDir = opts.projectDir ? path36__default.resolve(opts.projectDir) : process.cwd();
     if (key === "provider" || key === "cloud" || key === "cloudConfig") {
       logErr(
         `'${key}' is no longer a setting \u2014 an endpoint is an AI provider registry entry and a session selects one with a model reference.
@@ -1933,8 +2117,8 @@ function makeConnectorCommand() {
     async (driver, opts) => {
       const { installNpmPackages } = await import('../connectors/index.js');
       const { scanDirectory: scanDirectory2, factoryAssetRoots: factoryAssetRoots2, WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-      const projectDir = path35__default.resolve(opts.projectDir);
-      const yamlPath = path35__default.join(projectDir, "skaile.yaml");
+      const projectDir = path36__default.resolve(opts.projectDir);
+      const yamlPath = path36__default.join(projectDir, "skaile.yaml");
       if (!existsSync(yamlPath)) {
         logErr("No skaile.yaml found in current directory. Run 'skaile init' first.");
         process.exit(1);
@@ -1994,8 +2178,8 @@ ${installResult.output}`);
   );
   cmd.command("remove <id>").option("--project-dir <path>", "Workspace directory", process.cwd()).description("Remove a connector from skaile.yaml by its instance ID").action(async (id, opts) => {
     const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-    const projectDir = path35__default.resolve(opts.projectDir);
-    const yamlPath = path35__default.join(projectDir, "skaile.yaml");
+    const projectDir = path36__default.resolve(opts.projectDir);
+    const yamlPath = path36__default.join(projectDir, "skaile.yaml");
     if (!existsSync(yamlPath)) {
       logErr("No skaile.yaml found in current directory.");
       process.exit(1);
@@ -2012,7 +2196,7 @@ ${installResult.output}`);
   cmd.command("status [id]").option("--project-dir <path>", "Workspace directory", process.cwd()).description("Connect and report health status for one or all connectors").action(async (id, opts) => {
     const res = await import('../connectors/index.js');
     res.registerBuiltinConnectors();
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const declarations = res.loadConnectorDeclarations(projectDir);
     if (declarations.length === 0) {
       console.log("No connectors configured in skaile.yaml.");
@@ -2036,7 +2220,7 @@ ${installResult.output}`);
     await manager.disconnectAll();
   });
   cmd.command("list").description("List all configured connectors").option("--project-dir <path>", "Workspace directory", process.cwd()).action(async (opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       console.log(JSON.stringify(manager.listConnectors(), null, 2));
@@ -2045,7 +2229,7 @@ ${installResult.output}`);
     }
   });
   cmd.command("sync [id]").description("Re-sync a filesystem-face connector or all of them (git pull, S3 refresh, etc.)").option("--all", "Sync all connectors").option("--project-dir <path>", "Workspace directory", process.cwd()).action(async (id, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       if (opts.all) {
@@ -2069,7 +2253,7 @@ ${installResult.output}`);
     }
   });
   cmd.command("ops <id>").description("List available operations for a connector").option("--project-dir <path>", "Workspace directory", process.cwd()).action(async (id, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       if (!manager.has(id)) {
@@ -2084,7 +2268,7 @@ ${installResult.output}`);
     }
   });
   cmd.command("read <id> <resource-path>").description("Read content from a connector").option("--project-dir <path>", "Workspace directory", process.cwd()).action(async (id, resourcePath, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const content = await manager.read(id, resourcePath);
@@ -2094,7 +2278,7 @@ ${installResult.output}`);
     }
   });
   cmd.command("write <id> <resource-path> <content>").description("Write content to a connector at a path").option("--project-dir <path>", "Workspace directory", process.cwd()).action(async (id, resourcePath, content, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       await manager.write(id, resourcePath, { data: content });
@@ -2104,7 +2288,7 @@ ${installResult.output}`);
     }
   });
   cmd.command("entries <id> [resource-path]").description("List entries in a connector (files, keys, rows, etc)").option("--project-dir <path>", "Workspace directory", process.cwd()).option("--recursive", "Include nested entries").option("--limit <n>", "Maximum entries to return", parsePositiveIntOption).action(async (id, resourcePath, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const entries = await manager.list(id, resourcePath, {
@@ -2117,7 +2301,7 @@ ${installResult.output}`);
     }
   });
   cmd.command("search <id> <query>").description("Search within a connector for matching content").option("--project-dir <path>", "Workspace directory", process.cwd()).action(async (id, query, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const results = await manager.search(id, query);
@@ -2127,7 +2311,7 @@ ${installResult.output}`);
     }
   });
   cmd.command("delete <id> <resource-path>").description("Delete an entry from a connector").option("--project-dir <path>", "Workspace directory", process.cwd()).action(async (id, resourcePath, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const ok = await manager.delete(id, resourcePath);
@@ -2137,7 +2321,7 @@ ${installResult.output}`);
     }
   });
   cmd.command("run <id> <op> [args...]").description("Run a custom adapter operation (e.g. git log, sqlite query)").option("--project-dir <path>", "Workspace directory", process.cwd()).allowUnknownOption().action(async (id, op, args, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       if (!manager.has(id)) {
@@ -2246,7 +2430,7 @@ function envRecord() {
 async function buildDeployContext(projectDir) {
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const config = resolveSkWorkspaceConfig2(projectDir);
-  const workspaceId = config.name ?? path35__default.basename(projectDir);
+  const workspaceId = config.name ?? path36__default.basename(projectDir);
   let log;
   try {
     const { createLogger } = await import('../core/logging.js');
@@ -2278,13 +2462,13 @@ 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-QENDYZ63.js');
+    const { ensurePluginsLoaded } = await import('../plugin-store-2DTEIJTG.js');
     const result = await ensurePluginsLoaded(projectDir, config.plugins, pluginRegistry);
     for (const f of result.failed) logWarn(f.error);
   }
 }
 async function runUp(opts) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   await ensureTargetsRegistered(projectDir);
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const { resolveDeployTarget, pluginRegistry } = await import('../plugin-registry/index.js');
@@ -2352,7 +2536,7 @@ async function restoreFromHandle(projectDir) {
   return { target, handle, ctx };
 }
 async function runDown(opts) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const restored = await restoreFromHandle(projectDir);
   if (!restored) return;
   await restored.handle.stop();
@@ -2361,7 +2545,7 @@ async function runDown(opts) {
   logOk(`Stopped ${S.cmd(restored.target.id)} and cleared the handle.`);
 }
 async function runStatus(opts) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const restored = await restoreFromHandle(projectDir);
   if (!restored) return;
   const health = await restored.handle.health();
@@ -2375,7 +2559,7 @@ async function runStatus(opts) {
   console.log();
 }
 async function runLogs(opts) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const restored = await restoreFromHandle(projectDir);
   if (!restored) return;
   if (!restored.handle.logs) {
@@ -2399,7 +2583,7 @@ function makeDeployCommand() {
 }
 function makeDiffCommand() {
   return new Command("diff").description("Show changes between deployed and source versions").argument("<ref>", "Asset reference (kind:name)").option("--project-dir <path>", "Project directory", process.cwd()).action(async (ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path35__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path36__default.resolve(opts.projectDir) });
     const result = await am2.diff(ref);
     switch (result.status) {
       case "not-found":
@@ -2421,7 +2605,7 @@ function makeDiffCommand() {
 function makeFlowCommand() {
   const cmd = new Command("flow").description("Manage flows");
   cmd.command("list").description("List available flows").option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {
-    const flows = await discoverFlowsWithLibraries(path35__default.resolve(opts.projectDir));
+    const flows = await discoverFlowsWithLibraries(path36__default.resolve(opts.projectDir));
     if (flows.length === 0) {
       logInfo("No flows found.");
       return;
@@ -2436,7 +2620,7 @@ function makeFlowCommand() {
     console.log();
   });
   cmd.command("show <id>").description("Show flow details and node graph").option("--project-dir <path>", "Project directory", process.cwd()).action(async (id, opts) => {
-    const flows = await discoverFlowsWithLibraries(path35__default.resolve(opts.projectDir));
+    const flows = await discoverFlowsWithLibraries(path36__default.resolve(opts.projectDir));
     const flow = flows.find((f) => f.id === id);
     if (!flow) {
       logErr(`Flow not found: ${id}`);
@@ -2468,7 +2652,7 @@ function makeFlowCommand() {
 function makeHistoryCommand() {
   const cmd = new Command("history").description("Show recent add/remove/update actions");
   cmd.argument("[limit]", "Number of entries to show", "20").option("--project-dir <path>", "Project directory", process.cwd()).action((limitStr, opts) => {
-    const am2 = new AssetManager({ projectDir: path35__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path36__default.resolve(opts.projectDir) });
     const limit = parseInt(limitStr, 10) || 20;
     const entries = am2.history(limit);
     if (entries.length === 0) {
@@ -2488,7 +2672,7 @@ function makeHistoryCommand() {
     console.log();
   });
   cmd.command("clear").description("Clear action history").option("--project-dir <path>", "Project directory", process.cwd()).action((opts) => {
-    const am2 = new AssetManager({ projectDir: path35__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path36__default.resolve(opts.projectDir) });
     am2.clearHistory();
     logOk("History cleared.");
   });
@@ -2501,12 +2685,12 @@ var MCP_SERVER_ENTRY = {
   env: {}
 };
 function pluginDir(projectDir) {
-  return path35__default.join(projectDir, ".claude", "plugins", "skaile");
+  return path36__default.join(projectDir, ".claude", "plugins", "skaile");
 }
-async function readJsonStrict(p7) {
+async function readJsonStrict(p6) {
   let raw;
   try {
-    raw = await fs5.readFile(p7, "utf-8");
+    raw = await fs6.readFile(p6, "utf-8");
   } catch {
     return null;
   }
@@ -2514,37 +2698,37 @@ async function readJsonStrict(p7) {
     return JSON.parse(raw);
   } catch (e) {
     throw new Error(
-      `cannot parse ${p7}: ${e instanceof Error ? e.message : String(e)}; please fix or remove`
+      `cannot parse ${p6}: ${e instanceof Error ? e.message : String(e)}; please fix or remove`
     );
   }
 }
-async function writeJson(p7, value) {
-  await fs5.mkdir(path35__default.dirname(p7), { recursive: true });
-  await fs5.writeFile(p7, `${JSON.stringify(value, null, 2)}
+async function writeJson(p6, value) {
+  await fs6.mkdir(path36__default.dirname(p6), { recursive: true });
+  await fs6.writeFile(p6, `${JSON.stringify(value, null, 2)}
 `);
 }
 async function copyDir(src, dest) {
-  await fs5.mkdir(dest, { recursive: true });
-  const entries = await fs5.readdir(src, { withFileTypes: true });
+  await fs6.mkdir(dest, { recursive: true });
+  const entries = await fs6.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path35__default.join(src, entry.name);
-    const destPath = path35__default.join(dest, entry.name);
+    const srcPath = path36__default.join(src, entry.name);
+    const destPath = path36__default.join(dest, entry.name);
     if (entry.isDirectory()) await copyDir(srcPath, destPath);
-    else await fs5.copyFile(srcPath, destPath);
+    else await fs6.copyFile(srcPath, destPath);
   }
 }
 async function install(projectDir, opts) {
   return opts?.full ? installFullPlugin(projectDir) : installMcp(projectDir);
 }
 async function installMcp(projectDir) {
-  const mcpPath = path35__default.join(projectDir, ".claude", "mcp.json");
+  const mcpPath = path36__default.join(projectDir, ".claude", "mcp.json");
   const existing = await readJsonStrict(mcpPath) ?? {};
   const mcpServers = { ...existing.mcpServers ?? {} };
   const previous = mcpServers[SKAILE_MCP_NAME];
   const matches = previous && JSON.stringify(previous) === JSON.stringify(MCP_SERVER_ENTRY);
   let warning;
   if (previous && !matches) {
-    warning = `overwrote existing ${SKAILE_MCP_NAME} entry in ${path35__default.relative(projectDir, mcpPath)}`;
+    warning = `overwrote existing ${SKAILE_MCP_NAME} entry in ${path36__default.relative(projectDir, mcpPath)}`;
   }
   mcpServers[SKAILE_MCP_NAME] = MCP_SERVER_ENTRY;
   await writeJson(mcpPath, { ...existing, mcpServers });
@@ -2553,15 +2737,15 @@ async function installMcp(projectDir) {
 async function installFullPlugin(projectDir) {
   const dir = pluginDir(projectDir);
   for (const [rel, content] of Object.entries(buildClaudePluginFiles())) {
-    const dest = path35__default.join(dir, rel);
-    await fs5.mkdir(path35__default.dirname(dest), { recursive: true });
-    await fs5.writeFile(dest, content);
+    const dest = path36__default.join(dir, rel);
+    await fs6.mkdir(path36__default.dirname(dest), { recursive: true });
+    await fs6.writeFile(dest, content);
   }
-  const projectSkillsDir = path35__default.join(projectDir, ".skaile", "skills");
+  const projectSkillsDir = path36__default.join(projectDir, ".skaile", "skills");
   if (existsSync(projectSkillsDir)) {
-    await copyDir(projectSkillsDir, path35__default.join(dir, "skills"));
+    await copyDir(projectSkillsDir, path36__default.join(dir, "skills"));
   }
-  const settingsPath = path35__default.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path36__default.join(projectDir, ".claude", "settings.json");
   const settings = await readJsonStrict(settingsPath) ?? {};
   const plugins = settings.plugins ?? [];
   if (!plugins.includes(dir)) plugins.push(dir);
@@ -2569,13 +2753,13 @@ async function installFullPlugin(projectDir) {
   return { changed: true, method: "plugin" };
 }
 async function uninstall(projectDir) {
-  const settingsPath = path35__default.join(projectDir, ".claude", "settings.json");
-  const mcpPath = path35__default.join(projectDir, ".claude", "mcp.json");
+  const settingsPath = path36__default.join(projectDir, ".claude", "settings.json");
+  const mcpPath = path36__default.join(projectDir, ".claude", "mcp.json");
   const dir = pluginDir(projectDir);
   let changed = false;
   const settings = await readJsonStrict(settingsPath);
   if (settings && Array.isArray(settings.plugins)) {
-    const next = settings.plugins.filter((p7) => p7 !== dir);
+    const next = settings.plugins.filter((p6) => p6 !== dir);
     if (next.length !== settings.plugins.length) {
       changed = true;
       const updated = { ...settings, plugins: next };
@@ -2584,7 +2768,7 @@ async function uninstall(projectDir) {
     }
   }
   if (existsSync(dir)) {
-    await fs5.rm(dir, { recursive: true, force: true });
+    await fs6.rm(dir, { recursive: true, force: true });
     changed = true;
   }
   const mcp = await readJsonStrict(mcpPath);
@@ -2594,7 +2778,7 @@ async function uninstall(projectDir) {
     const updated = { ...mcp, mcpServers: rest };
     if (Object.keys(rest).length === 0) delete updated.mcpServers;
     if (Object.keys(updated).length === 0) {
-      await fs5.unlink(mcpPath);
+      await fs6.unlink(mcpPath);
     } else {
       await writeJson(mcpPath, updated);
     }
@@ -2604,12 +2788,12 @@ async function uninstall(projectDir) {
 async function detectInstall(projectDir) {
   const dir = pluginDir(projectDir);
   const settings = await readJsonStrict(
-    path35__default.join(projectDir, ".claude", "settings.json")
+    path36__default.join(projectDir, ".claude", "settings.json")
   );
-  if (existsSync(path35__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir)) {
+  if (existsSync(path36__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir)) {
     return { method: "plugin", pluginPath: dir };
   }
-  const mcp = await readJsonStrict(path35__default.join(projectDir, ".claude", "mcp.json"));
+  const mcp = await readJsonStrict(path36__default.join(projectDir, ".claude", "mcp.json"));
   if (mcp?.mcpServers && SKAILE_MCP_NAME in mcp.mcpServers) {
     return { method: "mcp" };
   }
@@ -2618,11 +2802,11 @@ async function detectInstall(projectDir) {
 async function enable(projectDir) {
   const detected = await detectInstall(projectDir);
   if (!detected) throw new Error("plugin not installed for claude-code");
-  const settingsPath = path35__default.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path36__default.join(projectDir, ".claude", "settings.json");
   const settings = await readJsonStrict(settingsPath) ?? {};
   if (detected.method === "plugin") {
     const disabled2 = settings.disabledPlugins ?? [];
-    const next2 = disabled2.filter((p7) => p7 !== detected.pluginPath);
+    const next2 = disabled2.filter((p6) => p6 !== detected.pluginPath);
     if (next2.length === disabled2.length) return { changed: false };
     const updated2 = { ...settings, disabledPlugins: next2 };
     if (next2.length === 0) delete updated2.disabledPlugins;
@@ -2640,7 +2824,7 @@ async function enable(projectDir) {
 async function disable(projectDir) {
   const detected = await detectInstall(projectDir);
   if (!detected) throw new Error("plugin not installed for claude-code");
-  const settingsPath = path35__default.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path36__default.join(projectDir, ".claude", "settings.json");
   const settings = await readJsonStrict(settingsPath) ?? {};
   if (detected.method === "plugin") {
     const list2 = settings.disabledPlugins ?? [];
@@ -2660,12 +2844,12 @@ async function disable(projectDir) {
   return { changed: true };
 }
 async function status(projectDir) {
-  const settingsPath = path35__default.join(projectDir, ".claude", "settings.json");
-  const mcpPath = path35__default.join(projectDir, ".claude", "mcp.json");
+  const settingsPath = path36__default.join(projectDir, ".claude", "settings.json");
+  const mcpPath = path36__default.join(projectDir, ".claude", "mcp.json");
   const dir = pluginDir(projectDir);
   const settings = await readJsonStrict(settingsPath);
   const mcp = await readJsonStrict(mcpPath);
-  const pluginInstalled = !!(existsSync(path35__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir));
+  const pluginInstalled = !!(existsSync(path36__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir));
   const mcpInstalled = !!(mcp?.mcpServers && SKAILE_MCP_NAME in mcp.mcpServers);
   if (!pluginInstalled && !mcpInstalled) {
     return {
@@ -2683,7 +2867,7 @@ async function status(projectDir) {
       installed: "yes",
       enabled: disabled2 ? "no" : "yes",
       method: "plugin",
-      location: path35__default.relative(projectDir, dir)
+      location: path36__default.relative(projectDir, dir)
     };
   }
   const disabled = settings?.disabledMcpjsonServers?.includes(SKAILE_MCP_NAME) ?? false;
@@ -2692,7 +2876,7 @@ async function status(projectDir) {
     installed: "yes",
     enabled: disabled ? "no" : "yes",
     method: "mcp",
-    location: path35__default.relative(projectDir, mcpPath)
+    location: path36__default.relative(projectDir, mcpPath)
   };
 }
 var SKAILE_MCP_NAME2 = "skaile-workspace";
@@ -2703,10 +2887,10 @@ function buildEntry(projectDir) {
     env: { SKAILE_PROJECT_DIR: projectDir }
   };
 }
-async function readConfig(p7) {
+async function readConfig(p6) {
   let raw;
   try {
-    raw = await fs5.readFile(p7, "utf-8");
+    raw = await fs6.readFile(p6, "utf-8");
   } catch {
     return null;
   }
@@ -2714,41 +2898,41 @@ async function readConfig(p7) {
     return parse$1(raw);
   } catch (e) {
     throw new Error(
-      `cannot parse ${p7}: ${e instanceof Error ? e.message : String(e)}; please fix or remove`
+      `cannot parse ${p6}: ${e instanceof Error ? e.message : String(e)}; please fix or remove`
     );
   }
 }
-async function writeConfig(p7, value) {
-  await fs5.mkdir(path35__default.dirname(p7), { recursive: true });
+async function writeConfig(p6, value) {
+  await fs6.mkdir(path36__default.dirname(p6), { recursive: true });
   const cleaned = {};
   for (const [k, v] of Object.entries(value)) {
     if (v === void 0) continue;
     cleaned[k] = v;
   }
-  await fs5.writeFile(p7, stringify$1(cleaned));
+  await fs6.writeFile(p6, stringify$1(cleaned));
 }
 function configPath(projectDir) {
-  return path35__default.join(projectDir, ".codex", "config.toml");
+  return path36__default.join(projectDir, ".codex", "config.toml");
 }
 async function install2(projectDir) {
-  const p7 = configPath(projectDir);
-  const cfg = await readConfig(p7) ?? {};
+  const p6 = configPath(projectDir);
+  const cfg = await readConfig(p6) ?? {};
   const next = buildEntry(projectDir);
   const servers = { ...cfg.mcp_servers ?? {} };
   const previous = servers[SKAILE_MCP_NAME2];
   const matches = previous && JSON.stringify(previous) === JSON.stringify(next);
   let warning;
   if (previous && !matches) {
-    warning = `overwrote existing ${SKAILE_MCP_NAME2} entry in ${path35__default.relative(projectDir, p7)}`;
+    warning = `overwrote existing ${SKAILE_MCP_NAME2} entry in ${path36__default.relative(projectDir, p6)}`;
   }
   if (matches) return { changed: false, method: "toml" };
   servers[SKAILE_MCP_NAME2] = next;
-  await writeConfig(p7, { ...cfg, mcp_servers: servers });
+  await writeConfig(p6, { ...cfg, mcp_servers: servers });
   return { changed: true, method: "toml", warning };
 }
 async function uninstall2(projectDir) {
-  const p7 = configPath(projectDir);
-  const cfg = await readConfig(p7);
+  const p6 = configPath(projectDir);
+  const cfg = await readConfig(p6);
   if (!cfg?.mcp_servers || !(SKAILE_MCP_NAME2 in cfg.mcp_servers)) {
     return { changed: false };
   }
@@ -2756,15 +2940,15 @@ async function uninstall2(projectDir) {
   const updated = { ...cfg, mcp_servers: rest };
   if (Object.keys(rest).length === 0) delete updated.mcp_servers;
   if (Object.keys(updated).length === 0) {
-    await fs5.unlink(p7);
+    await fs6.unlink(p6);
   } else {
-    await writeConfig(p7, updated);
+    await writeConfig(p6, updated);
   }
   return { changed: true };
 }
 async function status2(projectDir) {
-  const p7 = configPath(projectDir);
-  const cfg = await readConfig(p7);
+  const p6 = configPath(projectDir);
+  const cfg = await readConfig(p6);
   const installed = !!(cfg?.mcp_servers && SKAILE_MCP_NAME2 in cfg.mcp_servers);
   if (!installed) {
     return {
@@ -2780,43 +2964,43 @@ async function status2(projectDir) {
     installed: "yes",
     enabled: "n/a",
     method: "mcp",
-    location: path35__default.relative(projectDir, p7)
+    location: path36__default.relative(projectDir, p6)
   };
 }
 async function install3(projectDir) {
-  const extDir = path35__default.join(projectDir, ".omp", "extensions");
-  const extPath = path35__default.join(extDir, "skaile.ts");
-  await fs5.mkdir(extDir, { recursive: true });
+  const extDir = path36__default.join(projectDir, ".omp", "extensions");
+  const extPath = path36__default.join(extDir, "skaile.ts");
+  await fs6.mkdir(extDir, { recursive: true });
   const { WorkspacePlugin } = await import('../workspace-plugin/index.js');
   const plugin = new WorkspacePlugin({ projectDir });
   const nextSrc = await plugin.buildOmpExtensionSource();
   let prevSrc = null;
   try {
-    prevSrc = await fs5.readFile(extPath, "utf-8");
+    prevSrc = await fs6.readFile(extPath, "utf-8");
   } catch {
   }
   if (prevSrc === nextSrc) return { changed: false, method: "generated" };
-  await fs5.writeFile(extPath, nextSrc);
+  await fs6.writeFile(extPath, nextSrc);
   return { changed: true, method: "generated" };
 }
 async function uninstall3(projectDir) {
-  const extPath = path35__default.join(projectDir, ".omp", "extensions", "skaile.ts");
+  const extPath = path36__default.join(projectDir, ".omp", "extensions", "skaile.ts");
   try {
-    await fs5.unlink(extPath);
+    await fs6.unlink(extPath);
     return { changed: true };
   } catch {
     return { changed: false };
   }
 }
 async function status3(projectDir) {
-  const extPath = path35__default.join(projectDir, ".omp", "extensions", "skaile.ts");
+  const extPath = path36__default.join(projectDir, ".omp", "extensions", "skaile.ts");
   if (existsSync(extPath)) {
     return {
       harness: "omp",
       installed: "yes",
       enabled: "n/a",
       method: "extension",
-      location: path35__default.relative(projectDir, extPath)
+      location: path36__default.relative(projectDir, extPath)
     };
   }
   return {
@@ -2879,7 +3063,7 @@ async function installCodex(projectDir) {
   console.log(`  ${S.dim("\u2192")} Restart Codex CLI to pick up the change.`);
 }
 async function runInstall(opts) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const targets = resolveDriver(opts.driver);
   let exitCode = 0;
   if (targets.includes("claude-code")) {
@@ -2913,7 +3097,7 @@ async function uninstallCodex(projectDir) {
   else logInfo(`codex: not installed`);
 }
 async function runUninstall(opts) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const targets = resolveDriver(opts.driver);
   let exitCode = 0;
   if (targets.includes("claude-code")) {
@@ -2956,7 +3140,7 @@ async function toggleTarget(t, projectDir, action3) {
   });
 }
 async function runToggle(opts, action3) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const requestedAll = opts.driver === "all";
   const targets = resolveDriver(opts.driver);
   const usageError = checkToggleSupported(targets, requestedAll, action3);
@@ -2968,7 +3152,7 @@ async function runToggle(opts, action3) {
   return exitCode;
 }
 async function runStatus2(opts) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const targets = resolveDriver(opts.driver);
   const rows = [];
   let exitCode = 0;
@@ -2997,7 +3181,7 @@ function printStatusTable(rows) {
   const widths = cols.map(
     (c) => Math.max(c.header.length, ...rows.map((r) => String(r[c.key] ?? "").length))
   );
-  const fmtRow = (parts) => parts.map((p7, i) => p7.padEnd(widths[i] ?? p7.length)).join("  ");
+  const fmtRow = (parts) => parts.map((p6, i) => p6.padEnd(widths[i] ?? p6.length)).join("  ");
   console.log();
   console.log(`  ${S.heading(fmtRow(cols.map((c) => c.header)))}`);
   for (const r of rows) {
@@ -3039,7 +3223,7 @@ async function runHook(event) {
     await plugin.shutdown();
     return;
   }
-  const store = new PluginStore(path35__default.join(projectDir, ".skaile", "plugin-state.json"));
+  const store = new PluginStore(path36__default.join(projectDir, ".skaile", "plugin-state.json"));
   await store.load();
   const status4 = store.get("connector:status");
   if (status4 && typeof status4 === "object" && Object.keys(status4).length > 0) {
@@ -3099,37 +3283,6 @@ function makeIntegrationCommand() {
   cmd.action(() => cmd.help());
   return cmd;
 }
-
-// cli/src/commands/library-index.ts
-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 resolveLibraryPublisher(lib, opts, storeIdentity) {
-  if (opts.publisher?.trim()) return opts.publisher.trim();
-  const declared = loadSkPublishManifest(lib.path)?.publisher?.trim();
-  if (declared) return declared.startsWith("@") ? declared.slice(1) : declared;
-  const identity = (storeIdentity?.githubLogin ?? storeIdentity?.username)?.trim();
-  if (identity) return identity;
-  try {
-    return slugifyAssetName(lib.name);
-  } catch {
-    return "library";
-  }
-}
-
-// cli/src/commands/library-cmd.ts
 function exitOnSyncError(err) {
   logErr(err instanceof Error ? err.message : String(err));
   process.exit(1);
@@ -3143,10 +3296,42 @@ function assertManifestEditableOrExit(libraryPath) {
 }
 async function assertLibraryPathFree(manager, dir, exceptId) {
   const clash = (await manager.listLibraries()).find(
-    (l) => l.id !== exceptId && path35.resolve(l.path) === dir
+    (l) => l.id !== exceptId && path36.resolve(l.path) === dir
   );
   if (clash) throw new Error(`${dir} is already registered as library "${clash.name}".`);
 }
+function canonicalDir(dir) {
+  const abs = path36.resolve(dir);
+  return fs12.existsSync(abs) ? fs12.realpathSync(abs) : abs;
+}
+function refuseGlobalInstallFolder(name, dir) {
+  const reserved = globalInstallDir();
+  const rel = path36.relative(canonicalDir(reserved), canonicalDir(dir));
+  const inside = rel === "" || !rel.startsWith("..") && !path36.isAbsolute(rel);
+  if (name === GLOBAL_INSTALL_DIR_NAME || inside) {
+    logErr(
+      `"${GLOBAL_INSTALL_DIR_NAME}" is reserved: ${reserved} holds assets from \`skaile install\`, not a library you author.`
+    );
+    process.exit(1);
+  }
+}
+function readOriginTracking(dir) {
+  if (!isGitRepo(dir)) return null;
+  const origin = spawnSync("git", ["remote", "get-url", "origin"], { cwd: dir, encoding: "utf-8" });
+  const url = origin.status === 0 ? origin.stdout.trim() : "";
+  if (!url) return null;
+  const head = spawnSync("git", ["symbolic-ref", "--short", "HEAD"], {
+    cwd: dir,
+    encoding: "utf-8"
+  });
+  return { url, branch: head.status === 0 && head.stdout.trim() || "main" };
+}
+function requireGitBackend(lib, verb) {
+  if (lib.backend !== "git") {
+    logErr(`\`library ${verb}\` only applies to git-backed libraries.`);
+    process.exit(1);
+  }
+}
 function scaffoldLibraryFiles(dir, name) {
   const readme = `# ${name}
 
@@ -3176,9 +3361,9 @@ by the same ref.
   ];
   const written = [];
   for (const [file, content] of files) {
-    const target = path35.join(dir, file);
-    if (fs11.existsSync(target)) continue;
-    fs11.writeFileSync(target, content, "utf8");
+    const target = path36.join(dir, file);
+    if (fs12.existsSync(target)) continue;
+    fs12.writeFileSync(target, content, "utf8");
     written.push(file);
   }
   return written;
@@ -3253,12 +3438,13 @@ function makeLibraryCommand() {
         );
         process.exit(1);
       }
-      const libPath = opts.path ? path35.resolve(opts.path) : path35.join(resolveLibraryDir(), name);
-      if (fs11.existsSync(libPath) && !fs11.statSync(libPath).isDirectory()) {
+      const libPath = opts.path ? path36.resolve(opts.path) : path36.join(resolveLibraryDir(), name);
+      refuseGlobalInstallFolder(name, libPath);
+      if (fs12.existsSync(libPath) && !fs12.statSync(libPath).isDirectory()) {
         logErr(`${libPath} exists and is not a directory.`);
         process.exit(1);
       }
-      const { manager, close } = await openLibraryManager();
+      const { manager, library, close } = await openLibraryManager();
       try {
         if (await manager.getLibrary(name)) {
           logErr(`A library named "${name}" is already registered.`);
@@ -3268,6 +3454,7 @@ function makeLibraryCommand() {
         const hasDefault = (await manager.listLibraries()).some((l) => l.isDefault);
         let backend = "local";
         let backendConfig;
+        let adoptedOrigin = false;
         if (opts.git) {
           const { branch, reason } = cloneOrInitGitRepo(libPath, opts.git, "main");
           if (reason) {
@@ -3278,9 +3465,16 @@ function makeLibraryCommand() {
           backend = "git";
           backendConfig = { url: opts.git, branch, authHint: "ssh" };
         } else {
-          fs11.mkdirSync(libPath, { recursive: true });
+          const origin = readOriginTracking(libPath);
+          if (origin) {
+            backend = "git";
+            backendConfig = { url: origin.url, branch: origin.branch, authHint: "ssh" };
+            adoptedOrigin = true;
+          } else {
+            fs12.mkdirSync(libPath, { recursive: true });
+          }
         }
-        const blank = fs11.readdirSync(libPath).every((entry) => entry === ".git");
+        const blank = fs12.readdirSync(libPath).every((entry) => entry === ".git");
         const isDefault = !hasDefault && ownership !== "reader";
         await manager.addLibrary({
           name,
@@ -3295,6 +3489,16 @@ function makeLibraryCommand() {
           `Library "${name}" ${blank ? "created" : "registered"} at ${libPath}${isDefault ? " (default)" : ""}`
         );
         if (scaffolded.length > 0) logInfo(`Scaffolded ${scaffolded.join(", ")}.`);
+        if (adoptedOrigin && backendConfig) {
+          logInfo(`Adopted existing git clone as a git library tracking ${backendConfig.url}.`);
+        }
+        if (!blank) {
+          const lib = await manager.requireLibrary(name);
+          const res = await indexLibrary(lib, library);
+          for (const e of res.errors) logWarn(e);
+          logOk(`Indexed ${res.assetsUpdated} asset(s) from ${name}.`);
+          warnIgnoredDomainFiles(libPath);
+        }
       } catch (err) {
         exitOnSyncError(err);
       } finally {
@@ -3326,7 +3530,7 @@ function makeLibraryCommand() {
   });
   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)").option(
     "--description <text>",
-    "Description for the manifest \u2014 say what it does and when to use it (default: a TODO placeholder `skaile validate` rejects)"
+    "Description for the asset's frontmatter \u2014 say what it does and when to use it (default: a TODO placeholder `skaile validate` rejects)"
   ).action(
     async (kind, name, opts) => {
       if (!ASSET_KINDS.includes(kind)) {
@@ -3346,7 +3550,7 @@ function makeLibraryCommand() {
         assertManifestEditableOrExit(target.path);
         const effectiveKind = opts.kind ?? kind;
         const am2 = new AssetManager({ projectDir: process.cwd() });
-        const destDir = opts.dir ? path35.join(target.path, opts.dir) : target.path;
+        const destDir = opts.dir ? path36.join(target.path, opts.dir) : target.path;
         const res = am2.create(name, effectiveKind, destDir, { description: opts.description });
         if (!res.ok) {
           logErr(res.path);
@@ -3358,21 +3562,14 @@ function makeLibraryCommand() {
             "Description is a TODO placeholder \u2014 edit it (what the skill does and when to use it) or `skaile validate` will fail."
           );
         }
-        const publisher = resolveLibraryPublisher(target, opts, getStoreIdentity());
-        stampAssetPublisher(res.path, publisher);
-        stampManifestPublisher(target.path, publisher);
-        upsertManifestAsset(target.path, {
+        const { ref } = await registerLibraryAsset(target, library, {
           kind: effectiveKind,
           name,
-          root: path35.relative(target.path, res.path) || name,
+          assetDir: res.path,
           version: "0.1.0",
-          publisher
+          publisher: opts.publisher
         });
-        const idx = await indexLibrary(target, library);
-        for (const e of idx.errors) logWarn(e);
-        logOk(
-          `Indexed \u2014 add it with \`skaile add ${refFor(effectiveKind, publisher, name, "0.1.0")}\``
-        );
+        logOk(`Indexed \u2014 add it with \`skaile add ${ref}\``);
       } finally {
         close();
       }
@@ -3402,34 +3599,59 @@ function makeLibraryCommand() {
     const { manager, close } = await openLibraryManager();
     try {
       const lib = await manager.requireLibrary(oldName);
-      const parent = path35.dirname(lib.path);
-      const newPath = path35.join(parent, newName);
-      if (fs11.existsSync(newPath)) {
+      const parent = path36.dirname(lib.path);
+      const newPath = path36.join(parent, newName);
+      refuseGlobalInstallFolder(newName, newPath);
+      if (fs12.existsSync(newPath)) {
         logErr(`Target directory already exists: ${newPath}`);
         process.exit(1);
       }
-      fs11.renameSync(lib.path, newPath);
+      fs12.renameSync(lib.path, newPath);
       await manager.updateLibrary(lib.id, { name: newName, path: newPath });
       logOk(`Renamed ${oldName} \u2192 ${newName}`);
     } finally {
       close();
     }
   });
-  cmd.command("set <name> <field=value>").description("Update a single library field (ownership, isDefault, path, backendConfig.<key>)").action(async (name, expr) => {
+  cmd.command("set <name> <field=value>").description(
+    "Update a single library field (ownership, isDefault, path, publisher, backendConfig.<key>)"
+  ).action(async (name, expr) => {
     const [field, ...rest] = expr.split("=");
     const value = rest.join("=");
-    const { manager, close } = await openLibraryManager();
+    const { manager, library, close } = await openLibraryManager();
     try {
       const lib = await manager.requireLibrary(name);
+      if (field === "publisher") {
+        const publisher = value.trim().replace(/^@/, "");
+        if (!/^[^\s/#@]+$/.test(publisher)) {
+          logErr(
+            `Invalid publisher "${value}": expected a bare name like "acme" (no @, /, # or spaces).`
+          );
+          process.exit(1);
+        }
+        if (lib.ownership === "reader") {
+          logErr(
+            `Library "${lib.name}" is read-only (ownership=reader); its publisher is not yours to set.`
+          );
+          process.exit(1);
+        }
+        assertManifestEditableOrExit(lib.path);
+        setManifestPublisher(lib.path, publisher);
+        const res = await indexLibrary(lib, library);
+        for (const e of res.errors) logWarn(e);
+        logOk(`Updated ${name}.publisher \u2192 ${publisher}`);
+        return;
+      }
       const patch = {};
       if (field === "ownership") patch.ownership = value;
       else if (field === "isDefault") patch.isDefault = value === "true";
       else if (field === "path") {
-        const dir = path35.resolve(value);
-        if (!fs11.existsSync(dir) || !fs11.statSync(dir).isDirectory()) {
+        const dir = path36.resolve(value);
+        if (!fs12.existsSync(dir) || !fs12.statSync(dir).isDirectory()) {
           logErr(`Directory does not exist: ${dir}. \`library set path=\` does not move files.`);
           process.exit(1);
         }
+        refuseGlobalInstallFolder(null, dir);
         await assertLibraryPathFree(manager, dir, lib.id);
         patch.path = dir;
       } else if (field.startsWith("backendConfig.")) {
@@ -3458,11 +3680,11 @@ function makeLibraryCommand() {
     const { manager, close } = await openLibraryManager();
     try {
       if (!opts.yes) {
-        const confirmed = await p5.confirm({
+        const confirmed = await p4.confirm({
           message: `Remove library "${name}"${opts.purge ? " AND delete its directory" : ""}?`,
           initialValue: false
         });
-        if (!confirmed || p5.isCancel(confirmed)) {
+        if (!confirmed || p4.isCancel(confirmed)) {
           logInfo("Cancelled.");
           return;
         }
@@ -3477,10 +3699,11 @@ function makeLibraryCommand() {
     const { manager, close } = await openLibraryManager();
     try {
       const lib = await manager.requireLibrary(name);
+      requireGitBackend(lib, "sync");
       const drv = manager.driverFor(lib.backend);
       const pull = await drv.pull(lib);
       logInfo(`Pulled: applied=${pull.applied}, conflicts=${pull.conflicts.length}`);
-      if (lib.ownership === "owner" && lib.backend !== "local") {
+      if (lib.ownership === "owner") {
         const push = await drv.push(lib);
         logInfo(`Pushed: ${push.pushed}`);
       }
@@ -3507,8 +3730,14 @@ function makeLibraryCommand() {
         logInfo(`Removed manifest entry ${ref} (root ${a.root} is gone)`);
       }
       const res = await indexLibrary(lib, library);
-      for (const e of res.errors) logWarn(e);
+      const unparsable = res.errors.filter((e) => e.includes("ManifestSchemaError:"));
+      for (const e of res.errors) (unparsable.includes(e) ? logErr : logWarn)(e);
       logOk(`Indexed ${res.assetsUpdated} asset(s) from ${name}.`);
+      warnIgnoredDomainFiles(lib.path);
+      if (unparsable.length > 0) {
+        logErr(`${unparsable.length} asset(s) skipped: manifest could not be parsed.`);
+        process.exitCode = 1;
+      }
     } finally {
       close();
     }
@@ -3517,6 +3746,7 @@ function makeLibraryCommand() {
     const { manager, close } = await openLibraryManager();
     try {
       const lib = await manager.requireLibrary(name);
+      requireGitBackend(lib, "pull");
       const res = await manager.driverFor(lib.backend).pull(lib);
       if (res.conflicts.length > 0) {
         logWarn(`Conflicts: ${res.conflicts.map((c) => c.path).join(", ")}`);
@@ -3533,6 +3763,7 @@ function makeLibraryCommand() {
     const { manager, close } = await openLibraryManager();
     try {
       const lib = await manager.requireLibrary(name);
+      requireGitBackend(lib, "push");
       const res = await manager.driverFor(lib.backend).push(lib, { force: opts.force });
       logOk(`Pushed (${res.pushed}).`);
     } catch (err) {
@@ -3557,10 +3788,7 @@ function makeLibraryCommand() {
     const { manager, close } = await openLibraryManager();
     try {
       const lib = await manager.requireLibrary(name);
-      if (lib.backend !== "git") {
-        logErr("`library commit` only applies to git-backed libraries.");
-        process.exit(1);
-      }
+      requireGitBackend(lib, "commit");
       if (!isGitRepo(lib.path)) {
         logErr(
           `${lib.path} is not a git repository. Run \`skaile library link ${name} <url>\` to initialise it.`
@@ -3597,6 +3825,10 @@ function makeLibraryCommand() {
       close();
     }
   });
+  cmd.command("domain", { hidden: true }).description("Removed in 5.0 (domains were removed)").allowUnknownOption().allowExcessArguments().argument("[args...]").action(() => {
+    logErr(DOMAIN_REMOVED_HINT);
+    process.exit(1);
+  });
   cmd.command("git <name> [args...]").description("Pass-through: run arbitrary git commands inside the library").allowUnknownOption().passThroughOptions().action(async (name, rawArgs) => {
     const args = rawArgs[0] === "--" ? rawArgs.slice(1) : rawArgs;
     const { manager, close } = await openLibraryManager();
@@ -3617,16 +3849,16 @@ function makeLibraryCommand() {
     "With --create-repo: create the repo private (the store only accepts public repos)"
   ).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-RIP6NBYA.js');
+      const { runLibraryPublish } = await import('../library-publish-62RFU74A.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-RIP6NBYA.js');
+    const { runLibraryRegister } = await import('../library-publish-62RFU74A.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-RIP6NBYA.js');
+    const { runLibraryYank } = await import('../library-publish-62RFU74A.js');
     await withStoreErrorHandling(() => runLibraryYank(lib, opts));
   });
   return cmd;
@@ -3639,36 +3871,6 @@ async function withStoreErrorHandling(fn) {
     process.exit(1);
   }
 }
-function stampAssetPublisher(assetDir, publisher) {
-  const markers = ["SKILL.md", "AGENT.md", "CONTRACT.md"];
-  let markerFile;
-  for (const m of markers) {
-    if (fs11.existsSync(path35.join(assetDir, m))) {
-      markerFile = path35.join(assetDir, m);
-      break;
-    }
-  }
-  if (!markerFile) {
-    const promptMd = fs11.readdirSync(assetDir).find((f) => f.endsWith(".prompt.md"));
-    if (promptMd) markerFile = path35.join(assetDir, promptMd);
-  }
-  if (!markerFile) return;
-  try {
-    const { data, body } = parseFrontmatter(fs11.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();
-    fs11.writeFileSync(markerFile, `---
-${fm}
----
-
-${body}
-`, "utf8");
-  } catch {
-  }
-}
 async function printPerLibraryStatus(name, asJson) {
   const { manager, close } = await openLibraryManager();
   try {
@@ -3707,9 +3909,9 @@ async function printOverallStatus(projectDir, asJson) {
     } catch {
       secretsStrategy = "unavailable";
     }
-    const resolvedProjectDir = path35.resolve(projectDir);
-    const hasWorkspaceConfig = existsSync(path35.join(resolvedProjectDir, "skaile.yaml"));
-    const hasLockFile = existsSync(path35.join(resolvedProjectDir, "skaile.lock.yaml"));
+    const resolvedProjectDir = path36.resolve(projectDir);
+    const hasWorkspaceConfig = existsSync(path36.join(resolvedProjectDir, "skaile.yaml"));
+    const hasLockFile = existsSync(path36.join(resolvedProjectDir, "skaile.lock.yaml"));
     let assignments = [];
     if (hasWorkspaceConfig) {
       try {
@@ -4316,7 +4518,7 @@ function scheduleSoftDepPreview() {
 }
 async function loadAssets() {
   softDepPreviewCache.clear();
-  const { gatherAssetFeeds } = await import('../asset-feeds-WDIB3E6H.js');
+  const { gatherAssetFeeds } = await import('../asset-feeds-3MVRNS5U.js');
   const { entries, notes } = await gatherAssetFeeds(am, am.projectDir);
   if (notes.length > 0) {
     state.message = notes.map((n) => `[${n.feed}] ${n.message}`).join(" \u2022 ");
@@ -4336,7 +4538,7 @@ function rebuildSourceTree() {
   rebuildVisibleSources();
 }
 function sourceOrgRepo(s) {
-  const parts = s.path.split(path35__default.sep).filter(Boolean);
+  const parts = s.path.split(path36__default.sep).filter(Boolean);
   if (parts.length < 2) return null;
   return { org: parts[parts.length - 2], repo: parts[parts.length - 1] };
 }
@@ -4483,13 +4685,13 @@ function reconcileCollapsedSets(rows) {
 async function loadSourcesAndLibraries() {
   try {
     const [{ openLibraryManager: openLibraryManager2 }, { getGlobalCacheDir: getGlobalCacheDir2, globalSkaileDir: globalSkaileDir2 }] = await Promise.all([
-      import('../open-library-4IJTBVTR.js'),
+      import('../open-library-NVG3CZUO.js'),
       import('../core/index.js')
     ]);
     const { manager, library, close } = await openLibraryManager2();
     try {
       const newRoot = getGlobalCacheDir2();
-      const legacyRoot = path35__default.join(globalSkaileDir2(), "sources");
+      const legacyRoot = path36__default.join(globalSkaileDir2(), "sources");
       const isSourceRow = (l) => l.path.startsWith(newRoot) || l.path.startsWith(legacyRoot);
       const libs = await manager.listLibraries();
       const defs = await library.listAssetDefs();
@@ -5425,13 +5627,13 @@ async function run(projectDir) {
 }
 function makeManageCommand() {
   return new Command("manage").description("Interactive TUI for managing assets, sources, and libraries").option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {
-    await run(path35__default.resolve(opts.projectDir));
+    await run(path36__default.resolve(opts.projectDir));
   });
 }
 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 path38 = await import('path');
-    const projectDir = path38.default.resolve(opts.projectDir);
+    const path39 = await import('path');
+    const projectDir = path39.default.resolve(opts.projectDir);
     const { LogStore, StdoutSink, registerLogStore } = await import('../core/logging.js');
     registerLogStore(
       new LogStore({
@@ -5601,7 +5803,7 @@ function workspaceConfigFiles(dir) {
   } catch {
     return [];
   }
-  return names.filter((name) => isWorkspaceConfigFilename(name)).sort().map((name) => path35__default.join(dir, name));
+  return names.filter((name) => isWorkspaceConfigFilename(name)).sort().map((name) => path36__default.join(dir, name));
 }
 function readAgentConfigBlock(raw) {
   const key = AGENT_CONFIG_KEYS.find((candidate) => raw[candidate] !== void 0);
@@ -5613,7 +5815,7 @@ function readAgentConfigBlock(raw) {
   return flat ? { key, profiles: { default: profiles }, flat } : { key, profiles, flat };
 }
 function planProviderMigration(options) {
-  const projectDir = path35__default.resolve(options.projectDir);
+  const projectDir = path36__default.resolve(options.projectDir);
   const registryPath = options.workspace ? workspaceProviderRegistryPath(projectDir) : userProviderRegistryPath();
   const plan = {
     registryPath,
@@ -5629,7 +5831,7 @@ function planProviderMigration(options) {
       raw = parseDocument(readFileSync(file, "utf-8")).toJS() ?? {};
     } catch (error) {
       plan.warnings.push(
-        `${path35__default.basename(file)}: not valid YAML (${error instanceof Error ? error.message : String(error)}) \u2014 skipped`
+        `${path36__default.basename(file)}: not valid YAML (${error instanceof Error ? error.message : String(error)}) \u2014 skipped`
       );
       continue;
     }
@@ -5678,7 +5880,7 @@ function planProviderMigration(options) {
       });
       if (!model) {
         plan.warnings.push(
-          `${path35__default.basename(file)}: profile '${profile}' had no model: \u2014 it now resolves against registry order. Pin it with 'model: ${providerId}/<modelId>'.`
+          `${path36__default.basename(file)}: profile '${profile}' had no model: \u2014 it now resolves against registry order. Pin it with 'model: ${providerId}/<modelId>'.`
         );
       }
       touched = true;
@@ -5745,7 +5947,7 @@ function printPlan(plan) {
   for (const entry of plan.entries) {
     const base = entry.entry.base_url ?? S.dim("(transport-derived)");
     console.log(
-      `  ${S.label(`${path35__default.basename(entry.file)} ${entry.profile}`)} provider: ${entry.legacy.provider}, cloud: ${entry.legacy.cloud}`
+      `  ${S.label(`${path36__default.basename(entry.file)} ${entry.profile}`)} provider: ${entry.legacy.provider}, cloud: ${entry.legacy.cloud}`
     );
     console.log(`    \u2192 providers.yml ${S.bold(entry.providerId)}  ${base}`);
     console.log(
@@ -5761,7 +5963,7 @@ function printPlan(plan) {
   console.log();
 }
 async function runMigrateProviders(opts) {
-  const projectDir = opts.projectDir ? path35__default.resolve(opts.projectDir) : process.cwd();
+  const projectDir = opts.projectDir ? path36__default.resolve(opts.projectDir) : process.cwd();
   const plan = planProviderMigration({ projectDir, workspace: opts.workspace });
   for (const warning of plan.warnings) logWarn(warning);
   if (plan.entries.length === 0 && Object.keys(plan.providers).length === 0) {
@@ -5821,8 +6023,8 @@ function makeNpxCommand() {
   skills.command("add <url>").description(
     "Clone a repo, register it in the project's skaile.yaml sources[], and install a skill from it"
   ).requiredOption("--skill <name>", "Skill name to install from the repo").option("--project-dir <path>", "Project directory", process.cwd()).option("--target <agent>", `Agent framework (${TARGET_DEFAULT_HINT})`).option("--global", "Deploy globally").action(async (url, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
-    const projYaml = path35__default.join(projectDir, "skaile.yaml");
+    const projectDir = path36__default.resolve(opts.projectDir);
+    const projYaml = path36__default.join(projectDir, "skaile.yaml");
     if (!existsSync(projYaml)) {
       logErr(`No skaile.yaml in ${projectDir} \u2014 run \`skaile init\` first.`);
       process.exit(1);
@@ -5833,18 +6035,18 @@ function makeNpxCommand() {
       );
       process.exit(1);
     }
-    const spinner4 = p5.spinner();
+    const spinner = createSpinner();
     const key = sourceCacheKey(url);
-    const clonePath = path35__default.join(getGlobalCacheDir(), key);
-    spinner4.start(`Cloning ${url}`);
+    const clonePath = path36__default.join(getGlobalCacheDir(), key);
+    spinner.start(`Cloning ${url}`);
     try {
       if (!existsSync(clonePath)) {
-        mkdirSync(path35__default.dirname(clonePath), { recursive: true });
+        mkdirSync(path36__default.dirname(clonePath), { recursive: true });
         execSync(`git clone ${url} ${clonePath}`, { stdio: "ignore" });
       }
-      spinner4.stop(`Cloned to ${key}`);
+      spinner.stop(`Cloned to ${key}`);
     } catch (err) {
-      spinner4.stop("Clone failed");
+      spinner.stop("Clone failed");
       logErr(err instanceof Error ? err.message : String(err));
       process.exit(1);
     }
@@ -5864,10 +6066,10 @@ function makeNpxCommand() {
     }
     const skillRef = `skill:@${publisher}/${skillName}`;
     const am2 = new AssetManager({ projectDir, global: opts.global, driverTarget: opts.target });
-    spinner4.start(`Installing ${skillRef}`);
+    spinner.start(`Installing ${skillRef}`);
     try {
       const added = await am2.add(skillRef);
-      spinner4.stop("Done");
+      spinner.stop("Done");
       if (added.length === 0) {
         logInfo(`${opts.skill} already deployed or not found in source.`);
       } else {
@@ -5875,7 +6077,7 @@ function makeNpxCommand() {
       }
       logInfo(`Source registered in skaile.yaml \u2014 manage via ${S.cmd("skaile source")}.`);
     } catch (err) {
-      spinner4.stop("Failed");
+      spinner.stop("Failed");
       logErr(err.message);
       process.exit(1);
     }
@@ -5885,7 +6087,7 @@ function makeNpxCommand() {
   return npx;
 }
 function resolvePublisher(clonePath, url) {
-  const manifestPath = path35__default.join(clonePath, SKAILE_MANIFEST_FILENAME);
+  const manifestPath = path36__default.join(clonePath, SKAILE_MANIFEST_FILENAME);
   if (existsSync(manifestPath)) {
     try {
       const { manifest } = decodeSkaileManifest(readFileSync(manifestPath, "utf8"));
@@ -5898,12 +6100,12 @@ function resolvePublisher(clonePath, url) {
   return url.match(/github\.com[/:]([^/]+)\/[^/]+/)?.[1];
 }
 function resolveSkillName(clonePath, requested) {
-  const skillsDir = path35__default.join(clonePath, "skills");
-  if (existsSync(path35__default.join(skillsDir, requested, "SKILL.md"))) return requested;
+  const skillsDir = path36__default.join(clonePath, "skills");
+  if (existsSync(path36__default.join(skillsDir, requested, "SKILL.md"))) return requested;
   if (!existsSync(skillsDir)) return requested;
   for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const md = path35__default.join(skillsDir, entry.name, "SKILL.md");
+    const md = path36__default.join(skillsDir, entry.name, "SKILL.md");
     if (!existsSync(md)) continue;
     try {
       const { data } = parseFrontmatter(readFileSync(md, "utf8"));
@@ -5933,7 +6135,7 @@ function makeOutdatedCommand() {
     )
   ).action(async (filter, opts) => {
     const am2 = new AssetManager({
-      projectDir: path35__default.resolve(opts.projectDir),
+      projectDir: path36__default.resolve(opts.projectDir),
       driverTarget: opts.target
     });
     const entries = await am2.outdated();
@@ -5951,19 +6153,24 @@ function makeOutdatedCommand() {
     console.log(S.heading("  Outdated Assets"));
     console.log(`  ${S.rule(refW + 34)}`);
     for (const e of filtered) {
-      const status4 = e.library !== void 0 ? `${e.currentVersion} \u2192 ${e.latestVersion} ${S.dim(`(library ${e.library})`)}` : `${e.behind} commit(s) behind`;
+      const status4 = e.problem !== void 0 ? e.problem : e.library !== void 0 ? `${e.currentVersion} \u2192 ${e.latestVersion} ${S.dim(`(library ${e.library})`)}` : `${e.behind} commit(s) behind`;
       console.log(
-        `  ${colorRef(outdatedRef(e))}${" ".repeat(refW - outdatedRef(e).length)}  ${pc5.yellow(status4)}`
+        `  ${colorRef(outdatedRef(e))}${" ".repeat(refW - outdatedRef(e).length)}  ${e.problem !== void 0 ? pc5.red(status4) : pc5.yellow(status4)}`
       );
     }
     console.log();
-    logWarn(`Run ${S.cmd("skaile update")} to re-deploy.`);
+    if (filtered.some((e) => e.problem === void 0)) {
+      logWarn(`Run ${S.cmd("skaile update")} to re-deploy.`);
+    }
+    if (filtered.some((e) => e.problem !== void 0)) {
+      logWarn(`Run ${S.cmd("skaile install")} to restore or re-lock the broken assets.`);
+    }
   });
 }
 function makePatchCommand() {
   const cmd = new Command("patch").description("Patch workflow for skill improvement");
   cmd.command("extract <ref>").alias("start").description("Extract asset for local editing").option("--project-dir <path>", "Project directory", process.cwd()).action(async (ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path35__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path36__default.resolve(opts.projectDir) });
     try {
       const dest = await am2.patch(ref);
       logOk(`Extracted to ${S.dim(dest)}`);
@@ -5974,7 +6181,7 @@ function makePatchCommand() {
     }
   });
   cmd.command("commit <ref>").description("Generate .patch file from edits").option("--project-dir <path>", "Project directory", process.cwd()).action(async (ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path35__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path36__default.resolve(opts.projectDir) });
     try {
       const patchFile = await am2.patchCommit(ref);
       logOk(`Patch saved to ${S.dim(patchFile)}`);
@@ -5985,7 +6192,7 @@ function makePatchCommand() {
     }
   });
   cmd.command("submit <ref>").description("Apply patch to repo clone and prepare for PR").option("--project-dir <path>", "Project directory", process.cwd()).action(async (ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path35__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path36__default.resolve(opts.projectDir) });
     try {
       await am2.patchSubmit(ref);
       logOk("Patch applied to repo clone and committed.");
@@ -5998,7 +6205,7 @@ function makePatchCommand() {
     }
   });
   cmd.command("remove <ref>").description("Remove local patch after upstream merge").option("--project-dir <path>", "Project directory", process.cwd()).action((ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path35__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path36__default.resolve(opts.projectDir) });
     am2.patchRemove(ref);
     logOk(`Patch removed for ${ref}`);
   });
@@ -6016,7 +6223,7 @@ function action2(fn) {
   };
 }
 async function reconcileAndReport(projectDir, plugins) {
-  const { reconcilePlugins } = await import('../plugin-store-QENDYZ63.js');
+  const { reconcilePlugins } = await import('../plugin-store-2DTEIJTG.js');
   if (plugins.length === 0) {
     logInfo("No plugins declared \u2014 nothing to reconcile.");
     return;
@@ -6030,10 +6237,10 @@ async function reconcileAndReport(projectDir, plugins) {
   }
 }
 async function runInstall2(spec, opts) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-  const { specName } = await import('../plugin-store-QENDYZ63.js');
-  const yamlPath = path35__default.join(projectDir, "skaile.yaml");
+  const { specName } = await import('../plugin-store-2DTEIJTG.js');
+  const yamlPath = path36__default.join(projectDir, "skaile.yaml");
   const editor = WorkspaceYamlEditor2.load(yamlPath);
   const replaced = editor.addPlugin(spec, specName);
   editor.save();
@@ -6042,10 +6249,10 @@ async function runInstall2(spec, opts) {
   await reconcileAndReport(projectDir, editor.getPlugins());
 }
 async function runRemove(name, opts) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-  const { specName } = await import('../plugin-store-QENDYZ63.js');
-  const yamlPath = path35__default.join(projectDir, "skaile.yaml");
+  const { specName } = await import('../plugin-store-2DTEIJTG.js');
+  const yamlPath = path36__default.join(projectDir, "skaile.yaml");
   const editor = WorkspaceYamlEditor2.load(yamlPath);
   const removed = editor.removePlugin(name, specName);
   if (!removed) {
@@ -6057,7 +6264,7 @@ async function runRemove(name, opts) {
   await reconcileAndReport(projectDir, editor.getPlugins());
 }
 async function runList(opts) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const config = resolveSkWorkspaceConfig2(projectDir);
   const declared = config.plugins ?? [];
@@ -6072,7 +6279,7 @@ async function runList(opts) {
   const registry = createPluginRegistry();
   if (declared.length > 0) {
     try {
-      const { loadPlugins } = await import('../plugin-store-QENDYZ63.js');
+      const { loadPlugins } = await import('../plugin-store-2DTEIJTG.js');
       const result = await loadPlugins(projectDir, declared, registry);
       for (const f of result.failed) logWarn(f.error);
     } catch (err) {
@@ -6247,7 +6454,7 @@ function neededSources(config, lock) {
 }
 function sourcesWithSidecar(sources) {
   const dir = getStoreManifestsDir();
-  return sources.filter((s) => existsSync(path35.join(dir, `${storeManifestSlug(s.url)}.yaml`))).map((s) => s.url);
+  return sources.filter((s) => existsSync(path36.join(dir, `${storeManifestSlug(s.url)}.yaml`))).map((s) => s.url);
 }
 function compact(obj) {
   const out = {};
@@ -6339,8 +6546,8 @@ function redactSecrets(preset, findings) {
   }
   return { preset: next, keys };
 }
-function placeholderKey(itemId, path38) {
-  return `${itemId}_${path38}`.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+function placeholderKey(itemId, path39) {
+  return `${itemId}_${path39}`.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
 }
 function setAtPath(root, segments, value) {
   let node = root;
@@ -6363,7 +6570,7 @@ function makePresetCommand() {
   cmd.command("init [name]").description("Scaffold a new .preset.yaml file").option("--dir <path>", "Output directory", process.cwd()).action(async (name, opts) => {
     const presetName = name ?? "my-preset";
     const filename = `${presetName}.preset.yaml`;
-    const outPath = path35__default.join(path35__default.resolve(opts.dir), filename);
+    const outPath = path36__default.join(path36__default.resolve(opts.dir), filename);
     if (existsSync(outPath)) {
       logErr(`File already exists: ${outPath}`);
       logInfo("Choose a different name or remove the existing file.");
@@ -6396,7 +6603,7 @@ function makePresetCommand() {
   return cmd;
 }
 async function runPresetExport(name, opts) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const file = loadSkWorkspaceConfig(projectDir);
   if (!file) {
     logErr(`No skaile.yaml found in ${projectDir}`);
@@ -6406,7 +6613,7 @@ async function runPresetExport(name, opts) {
   const presetName = name ?? file.config.name ?? "my-preset";
   let lock = null;
   try {
-    lock = readLock(path35__default.join(projectDir, "skaile.lock.yaml"));
+    lock = readLock(path36__default.join(projectDir, "skaile.lock.yaml"));
   } catch {
     lock = null;
   }
@@ -6447,7 +6654,7 @@ async function runPresetExport(name, opts) {
   const contents = header ? `${header}
 ${body}` : body;
   if (opts.out && opts.dir !== process.cwd()) logWarn("--dir is ignored when --out is set.");
-  const outPath = opts.out ? path35__default.resolve(opts.out) : path35__default.join(path35__default.resolve(opts.dir), `${presetName}.preset.yaml`);
+  const outPath = opts.out ? path36__default.resolve(opts.out) : path36__default.join(path36__default.resolve(opts.dir), `${presetName}.preset.yaml`);
   if (existsSync(outPath) && !opts.force) {
     logErr(`File already exists: ${outPath}`);
     logInfo("Pass --force to overwrite, or choose a different --out/--dir.");
@@ -6459,7 +6666,7 @@ ${body}` : body;
     logErr(`Failed to write ${outPath}: ${e.message}`);
     process.exit(1);
   }
-  logOk(`Exported ${S.brand(path35__default.basename(outPath))}`);
+  logOk(`Exported ${S.brand(path36__default.basename(outPath))}`);
   logInfo(`Path: ${outPath}`);
   if (unresolved.length > 0) {
     console.error(S.err("This file is NOT safe to share."));
@@ -6500,13 +6707,13 @@ function collectInput(value, acc) {
   return acc;
 }
 async function runPresetApply(filePath, opts) {
-  const projectDir = path35__default.resolve(opts.projectDir);
+  const projectDir = path36__default.resolve(opts.projectDir);
   const file = loadSkWorkspaceConfig(projectDir);
   if (!file) {
     logErr("No skaile.yaml \u2014 run `skaile init` first");
     process.exit(1);
   }
-  const resolved = path35__default.resolve(filePath);
+  const resolved = path36__default.resolve(filePath);
   if (!existsSync(resolved)) {
     logErr(`File not found: ${resolved}`);
     process.exit(1);
@@ -6722,7 +6929,7 @@ async function reportNestedPresetRefs(preset) {
 }
 async function checkPresetCycles(preset, resolved) {
   const { detectCycles } = await import('../discovery/index.js');
-  const presetRef = path35__default.basename(resolved, ".preset.yaml");
+  const presetRef = path36__default.basename(resolved, ".preset.yaml");
   const edges = [];
   for (const item of preset.items) {
     if (item.ref) {
@@ -6774,7 +6981,7 @@ function printPresetSummary(preset, placeholderCount, hasWarnings) {
   }
 }
 async function runPresetValidate(filePath) {
-  const resolved = path35__default.resolve(filePath);
+  const resolved = path36__default.resolve(filePath);
   const preset = await loadPresetForValidation(resolved);
   await reportNestedPresetRefs(preset);
   await checkPresetCycles(preset, resolved);
@@ -6824,11 +7031,11 @@ items:
 }
 function makeRebuildCommand() {
   return new Command("rebuild").description("Re-snapshot inline-snapshot composition items and bump prompt version").argument("[agent]", "Agent name or path (defaults to current project agent)").option("--project-dir <dir>", "Project directory", process.cwd()).action(async (agentArg, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     let agentDir;
     if (agentArg) {
       if (agentArg.includes("/") || agentArg.includes("\\")) {
-        agentDir = path35__default.resolve(projectDir, agentArg);
+        agentDir = path36__default.resolve(projectDir, agentArg);
       } else {
         let resolved;
         try {
@@ -6837,7 +7044,7 @@ function makeRebuildCommand() {
           if (!(err instanceof AgentRefResolutionError)) throw err;
           logWarn(`${err.message} \u2014 using "${agentArg}"`);
         }
-        agentDir = resolved ?? path35__default.resolve(projectDir, agentArg);
+        agentDir = resolved ?? path36__default.resolve(projectDir, agentArg);
       }
     } else {
       let resolved;
@@ -6938,7 +7145,7 @@ function makeFlowEventHandler() {
 }
 function makeRunCommand() {
   const cmd = new Command("run").description("Start a flow or run a single-shot text prompt").argument("[flow-id-or-text...]", "Flow ID or text prompt").option("--project-dir <path>", "Project directory", process.cwd()).option("--driver <name>", "Harness to run (claude-sdk, codex, omp)").option("--model <name>", "Model override").option("--label <label>", "Human-readable session label").option("--dry-run", "Print plan without executing").option("--skill <name>", "Skill name (for single-shot mode)").action(async (positional, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const cliDriver = opts.driver;
     const dryRun = opts.dryRun ?? false;
     let flowId = positional[0];
@@ -6948,7 +7155,7 @@ function makeRunCommand() {
         logErr("No flows available.");
         process.exit(1);
       }
-      const selected = await p5.select({
+      const selected = await p4.select({
         message: "Select a flow to run",
         options: flows.map((f) => ({
           value: f.id,
@@ -6956,8 +7163,8 @@ function makeRunCommand() {
           hint: f.description
         }))
       });
-      if (p5.isCancel(selected)) {
-        p5.cancel("Cancelled.");
+      if (p4.isCancel(selected)) {
+        p4.cancel("Cancelled.");
         process.exit(0);
       }
       flowId = selected;
@@ -7039,7 +7246,7 @@ function makeRunCommand() {
 }
 function makeResumeCommand() {
   const cmd = new Command("resume").description("Resume current session").option("--project-dir <path>", "Project directory", process.cwd()).option("--session <run-id>", "Target session by runId").option("--dry-run", "Print plan without executing").action(async (opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const sessionId = opts.session;
     const dryRun = opts.dryRun ?? false;
     const session = sessionId ? await loadSessionById(projectDir, sessionId) : await loadSession(projectDir);
@@ -7066,7 +7273,7 @@ function makeResumeCommand() {
 }
 function makeStatusCommand() {
   return new Command("status").description("Show current session state").option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const session = await loadSession(projectDir);
     if (!session) {
       logInfo("No active session.");
@@ -7091,7 +7298,7 @@ function makeStatusCommand() {
 }
 function makeClearCommand() {
   return new Command("clear").description("Unset current session pointer").option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     await clearSession(projectDir);
     logOk("Session cleared.");
   });
@@ -7101,7 +7308,7 @@ function makeReplCommand() {
     const { findWorkspaceRoot } = await import('../core/index.js');
     const { startRepl } = await import('../tui/index.js');
     const os2 = await import('os');
-    const userCwd = path35__default.resolve(opts.projectDir ?? process.cwd());
+    const userCwd = path36__default.resolve(opts.projectDir ?? process.cwd());
     const workspaceRoot = findWorkspaceRoot(userCwd);
     let projectDir;
     let agentCwd;
@@ -7116,20 +7323,20 @@ function makeReplCommand() {
       console.log();
       logWarn(`No skaile.yaml found in ${S.cmd(userCwd)} or any parent directory.`);
       console.log();
-      const shouldCreate = await p5.confirm({
+      const shouldCreate = await p4.confirm({
         message: "Create a temporary workspace? (session state in /tmp/)"
       });
-      if (p5.isCancel(shouldCreate) || !shouldCreate) {
-        p5.cancel("Cancelled.");
+      if (p4.isCancel(shouldCreate) || !shouldCreate) {
+        p4.cancel("Cancelled.");
         process.exit(0);
       }
-      const tmpDir = fs11__default.mkdtempSync(path35__default.join(os2.tmpdir(), "skaile-repl-"));
+      const tmpDir = fs12__default.mkdtempSync(path36__default.join(os2.tmpdir(), "skaile-repl-"));
       projectDir = tmpDir;
       agentCwd = userCwd;
       logOk(`Temporary workspace: ${S.cmd(tmpDir)}`);
       if (!driverOverride) {
-        const claudeDir = path35__default.join(os2.homedir(), ".claude");
-        if (fs11__default.existsSync(claudeDir)) {
+        const claudeDir = path36__default.join(os2.homedir(), ".claude");
+        if (fs12__default.existsSync(claudeDir)) {
           driverOverride = "claude-sdk";
           logInfo(`Detected ${S.cmd("~/.claude")} \u2192 using ${S.cmd("claude-sdk")} harness`);
         } else {
@@ -7201,12 +7408,12 @@ function makeServeCommand() {
   );
 }
 async function ensurePluginsLoadedForServe(projectDir) {
-  const { logInfo: logInfo2, logWarn: logWarn2 } = await import('../helpers-ZGK4R5MZ.js');
+  const { logInfo: logInfo2, logWarn: logWarn2 } = await import('../helpers-F2RFRT5D.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-QENDYZ63.js');
+    const { ensurePluginsLoaded } = await import('../plugin-store-2DTEIJTG.js');
     const { pluginRegistry } = await import('../plugin-registry/index.js');
     const result = await ensurePluginsLoaded(projectDir, config.plugins, pluginRegistry);
     if (result.loaded.length > 0) {
@@ -7220,21 +7427,21 @@ async function ensurePluginsLoadedForServe(projectDir) {
   }
 }
 async function runCompileTest(opts) {
-  const { logOk: logOk2, logErr: logErr2, logInfo: logInfo2, S: S2 } = await import('../helpers-ZGK4R5MZ.js');
+  const { logOk: logOk2, logErr: logErr2, logInfo: logInfo2, S: S2 } = await import('../helpers-F2RFRT5D.js');
   const { tmpdir } = await import('os');
-  const { dirname: dirname3, join: join6, resolve: resolve5 } = await import('path');
+  const { dirname: dirname3, join: join7, resolve: resolve5 } = await import('path');
   const { fileURLToPath: fileURLToPath2 } = await import('url');
-  const { unlinkSync, existsSync: existsSync15 } = await import('fs');
+  const { unlinkSync, existsSync: existsSync16 } = await import('fs');
   const { spawn } = await import('child_process');
   const { portableSpawnSync: portableSpawnSync2 } = await import('../core/index.js');
-  const { MONOREPO_ROOT } = await import('../paths-L5XLUC3D.js');
+  const { MONOREPO_ROOT } = await import('../paths-STQO4FYF.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(dirname3(__thisFile), "..", "index.ts");
   logInfo2(`Building compiled binary...`);
@@ -7289,7 +7496,7 @@ async function runCompileTest(opts) {
     } catch {
     }
     try {
-      if (existsSync15(outfile)) unlinkSync(outfile);
+      if (existsSync16(outfile)) unlinkSync(outfile);
     } catch {
     }
   }
@@ -7710,7 +7917,7 @@ function resolveMode(opts) {
   if (opts.forceLocal && opts.forceRemote) {
     throw new Error("Cannot use both --local and --remote");
   }
-  const startDir = path35__default.resolve(opts.projectDir ?? process.cwd());
+  const startDir = path36__default.resolve(opts.projectDir ?? process.cwd());
   const localDb = findLogsDb(startDir);
   if (opts.forceLocal) {
     if (!localDb) {
@@ -7743,14 +7950,14 @@ function resolveMode(opts) {
 function findLogsDb(startDir) {
   let dir = startDir;
   for (let i = 0; i < MAX_WALK_LEVELS; i++) {
-    const candidate = path35__default.join(dir, ".skaile", "logs.db");
+    const candidate = path36__default.join(dir, ".skaile", "logs.db");
     if (existsSync(candidate)) {
       try {
         if (statSync(candidate).isFile()) return candidate;
       } catch {
       }
     }
-    const parent = path35__default.dirname(dir);
+    const parent = path36__default.dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -7925,7 +8132,7 @@ function parsePositiveInt(value, flag) {
 function makeSessionCommand() {
   const cmd = new Command("session").description("Manage sessions");
   cmd.command("list").description("List all sessions for a project").option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const sessions = await listSessions(projectDir);
     const current = await loadSession(projectDir);
     if (sessions.length === 0) {
@@ -7953,7 +8160,7 @@ function makeSessionCommand() {
     console.log();
   });
   cmd.command("show <run-id>").description("Show a specific session").option("--project-dir <path>", "Project directory", process.cwd()).action(async (runId, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     const session = await loadSessionById(projectDir, runId);
     if (!session) {
       logErr(`Session not found: ${runId}`);
@@ -7962,12 +8169,12 @@ function makeSessionCommand() {
     console.log(JSON.stringify(session, null, 2));
   });
   cmd.command("switch <run-id>").description("Switch the current session").option("--project-dir <path>", "Project directory", process.cwd()).action(async (runId, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     await setCurrentSession(projectDir, runId);
     logOk(`Switched to session: ${S.dim(runId.slice(0, 8))}`);
   });
   cmd.command("delete <run-id>").description("Delete a session").option("--project-dir <path>", "Project directory", process.cwd()).action(async (runId, opts) => {
-    const projectDir = path35__default.resolve(opts.projectDir);
+    const projectDir = path36__default.resolve(opts.projectDir);
     await deleteSession(projectDir, runId);
     logOk(`Deleted session: ${S.dim(runId.slice(0, 8))}`);
   });
@@ -8021,12 +8228,12 @@ function showOverview(am2) {
 }
 async function showAsset(am2, kind, name) {
   const entry = await am2.info(`${kind}:${name}`);
-  if (entry?.source && fs11__default.existsSync(entry.source)) {
+  if (entry?.source && fs12__default.existsSync(entry.source)) {
     console.log();
     console.log(`  ${kindColor(entry.kind)} ${S.heading(entry.name)}`);
     console.log(`  ${S.rule(40)}`);
     console.log();
-    console.log(fs11__default.readFileSync(entry.source, "utf-8"));
+    console.log(fs12__default.readFileSync(entry.source, "utf-8"));
     return;
   }
   logErr(`Asset not found: ${kind}:${name}`);
@@ -8035,7 +8242,7 @@ async function showAsset(am2, kind, name) {
 function makeShowCommand() {
   return new Command("show").description("Show deployed assets overview, or print asset content").argument("[kind]", "Asset kind (skill, agent, prompt, flow, bundle, contract)").argument("[name]", "Asset name").option("--project-dir <path>", "Project directory", process.cwd()).option("--target <agent>", `Agent framework (${TARGET_DEFAULT_HINT})`).action(async (kind, name, opts) => {
     const am2 = new AssetManager({
-      projectDir: path35__default.resolve(opts.projectDir),
+      projectDir: path36__default.resolve(opts.projectDir),
       driverTarget: opts.target
     });
     if (!kind) {
@@ -8098,14 +8305,14 @@ function makeStoreCommand() {
   });
   store.command("mode <auto|local|remote>").description("Set the catalog resolution mode (not yet wired)").action((_mode) => {
     logErr(
-      "`skaile store mode` is scaffolded but not yet wired. Store config lives at ~/.skaile/store/config.yaml."
+      `\`skaile store mode\` is scaffolded but not yet wired. Store config lives at ${path36__default.join(globalSkaileDir(), "store", "config.yaml")}.`
     );
     process.exit(2);
   });
   store.command("search <query>").description("Search the AI Asset Store catalog by name, description, or publisher").option("--kind <kind>", "Filter by asset kind (skill, agent, prompt, flow, \u2026)").option("-C, --project-dir <dir>", "Project directory (catalog config overlay)", process.cwd()).action(async (query, opts) => {
-    const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError } = await import('../open-library-4IJTBVTR.js');
+    const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError } = await import('../open-library-NVG3CZUO.js');
     try {
-      const remote = await openCatalogSource2({ projectDir: path35__default.resolve(opts.projectDir) });
+      const remote = await openCatalogSource2({ projectDir: path36__default.resolve(opts.projectDir) });
       const assets = await remote.listAssets(opts.kind ? { kind: opts.kind } : {});
       const results = filterCatalogAssets(assets, query);
       if (results.length === 0) {
@@ -8122,7 +8329,7 @@ function makeStoreCommand() {
     } catch (e) {
       if (e instanceof LocalCatalogDisabledError) {
         logErr(
-          "Remote catalog disabled (catalog.url: local). Set `catalog.url: https://skaile.store` in ~/.skaile/config.yaml."
+          `Remote catalog disabled (catalog.url: local). Set \`catalog.url: https://skaile.store\` in ${userConfigPath()}.`
         );
       } else {
         logErr(`Store search failed: ${e.message}`);
@@ -8131,10 +8338,10 @@ function makeStoreCommand() {
     }
   });
   store.command("show <ref>").description("Show a store asset's details + provenance (source, files, integrity)").option("-C, --project-dir <dir>", "Project directory (catalog config overlay)", process.cwd()).action(async (ref, opts) => {
-    const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError } = await import('../open-library-4IJTBVTR.js');
-    const { supportsInstallManifest } = await import('../project-4INCIIZI.js');
+    const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError } = await import('../open-library-NVG3CZUO.js');
+    const { supportsInstallManifest } = await import('../project-44LM6SRV.js');
     try {
-      const remote = await openCatalogSource2({ projectDir: path35__default.resolve(opts.projectDir) });
+      const remote = await openCatalogSource2({ projectDir: path36__default.resolve(opts.projectDir) });
       const asset = await remote.resolve(ref);
       if (!asset) {
         logErr(`Not found in store: ${ref} (try a full ref, e.g. skill:@publisher/name#version)`);
@@ -8184,7 +8391,7 @@ function makeStoreCommand() {
     } catch (e) {
       if (e instanceof LocalCatalogDisabledError) {
         logErr(
-          "Remote catalog disabled (catalog.url: local). Set `catalog.url: https://skaile.store` in ~/.skaile/config.yaml."
+          `Remote catalog disabled (catalog.url: local). Set \`catalog.url: https://skaile.store\` in ${userConfigPath()}.`
         );
       } else {
         logErr(`Store show failed: ${e.message}`);
@@ -8256,7 +8463,7 @@ function printTree(node, prefix = "", isLast = true) {
 }
 function makeTreeCommand() {
   return new Command("tree").description("Show full dependency tree").option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {
-    const am2 = new AssetManager({ projectDir: path35__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path36__default.resolve(opts.projectDir) });
     const root = am2.tree();
     if (root.children.length === 0) {
       logInfo("No dependencies in lock file. Run `skaile install` first.");
@@ -8279,10 +8486,10 @@ function makeUpdateCommand() {
   return new Command("update").description("Refresh the Catalog cache and re-deploy outdated assets in the current project").argument("[name]", "Update a specific asset (kind:name)").option("--project-dir <path>", "Project directory", process.cwd()).option("--no-catalog", "Skip refreshing the catalog cache").option("--catalog-only", "Refresh the catalog cache only; do not re-deploy assets").option("--no-sync", "Skip syncing sources from upstream before re-deploying").option("-y, --yes", "Sync sources without the confirmation prompt").action(
     async (_name, opts) => {
       if (opts.catalog !== false) {
-        const catalogSpinner = p5.spinner();
+        const catalogSpinner = createSpinner();
         catalogSpinner.start("Refreshing catalog cache");
         try {
-          const remote = await openCatalogSource({ projectDir: path35__default.resolve(opts.projectDir) });
+          const remote = await openCatalogSource({ projectDir: path36__default.resolve(opts.projectDir) });
           const result2 = await remote.refresh();
           catalogSpinner.stop(
             `Catalog refreshed: ${S.heading(String(result2.assetsCached))} assets cached`
@@ -8295,9 +8502,9 @@ function makeUpdateCommand() {
         }
       }
       if (opts.catalogOnly) return;
-      const projectDir = path35__default.resolve(opts.projectDir);
+      const projectDir = path36__default.resolve(opts.projectDir);
       if (await shouldSyncSources(opts)) {
-        const syncSpinner = p5.spinner();
+        const syncSpinner = createSpinner();
         syncSpinner.start("Syncing sources");
         const { total, synced, failed } = await syncProjectSources(projectDir);
         syncSpinner.stop(
@@ -8305,10 +8512,10 @@ function makeUpdateCommand() {
         );
       }
       const am2 = new AssetManager({ projectDir });
-      const spinner4 = p5.spinner();
-      spinner4.start("Re-deploying assets");
+      const spinner = createSpinner();
+      spinner.start("Re-deploying assets");
       const result = await am2.install();
-      spinner4.stop("Done");
+      spinner.stop("Done");
       if (result.deployed.length > 0) {
         for (const d of result.deployed) logOk(`Updated ${d}`);
       } else {
@@ -8320,12 +8527,12 @@ function makeUpdateCommand() {
 async function shouldSyncSources(opts) {
   if (opts.sync === false) return false;
   if (opts.yes || !process.stdin.isTTY) return true;
-  const answer = await p5.confirm({
+  const answer = await p4.confirm({
     message: "Sync sources from upstream before re-deploying?",
     initialValue: true
   });
-  if (p5.isCancel(answer)) {
-    p5.cancel("Cancelled.");
+  if (p4.isCancel(answer)) {
+    p4.cancel("Cancelled.");
     process.exit(130);
   }
   return answer;
@@ -8351,12 +8558,12 @@ function findManifestCandidates(rootPath) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs11__default.readdirSync(dir, { withFileTypes: true });
+      entries = fs12__default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path35__default.join(dir, entry.name);
+      const fullPath = path36__default.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) walk(fullPath);
       } else if (entry.isFile()) {
@@ -8372,11 +8579,6 @@ function findManifestCandidates(rootPath) {
   walk(rootPath);
   return candidates;
 }
-function parseMdFrontmatter(content) {
-  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?/);
-  if (!fmMatch) return null;
-  return { frontmatter: parse(fmMatch[1]), body: content.slice(fmMatch[0].length).trim() };
-}
 function checkManifestIdentity(kind, parsed) {
   if (parsed === null || typeof parsed !== "object") return null;
   const obj = parsed;
@@ -8397,25 +8599,20 @@ function checkManifestIdentity(kind, parsed) {
   return null;
 }
 function parseManifestCandidate(c, absRoot) {
-  const content = fs11__default.readFileSync(c.filePath, "utf-8");
-  if (c.filePath.endsWith(".md")) {
-    const md = parseMdFrontmatter(content);
-    if (md === null) {
-      return { kind: "skip" };
-    }
-    return { kind: "value", parsed: md.frontmatter, body: md.body };
-  }
-  try {
-    const parsed = c.filePath.endsWith(".json") ? JSON.parse(content) : parse(content);
-    return { kind: "value", parsed };
-  } catch (e) {
-    const relPath = path35__default.relative(absRoot, c.filePath);
-    logErr(`${relPath} \u2014 parse error: ${e instanceof Error ? e.message : String(e)}`);
+  const content = fs12__default.readFileSync(c.filePath, "utf-8");
+  const res = parseManifestFile(c.filePath, content);
+  if (!res.ok) {
+    logErr(`${path36__default.relative(absRoot, c.filePath)} [${c.kind}] \u2014 parse error: ${res.reason}`);
     return { kind: "error" };
   }
+  return {
+    kind: "value",
+    parsed: res.data,
+    body: c.filePath.endsWith(".md") ? parseFrontmatter(content).body : void 0
+  };
 }
 function validateManifestCandidate(c, parsed, body, absRoot, registry, strictConformance) {
-  const relPath = path35__default.relative(absRoot, c.filePath);
+  const relPath = path36__default.relative(absRoot, c.filePath);
   let errors = 0;
   let warnings = 0;
   const identityError = checkManifestIdentity(c.kind, parsed);
@@ -8424,11 +8621,10 @@ function validateManifestCandidate(c, parsed, body, absRoot, registry, strictCon
     errors++;
   }
   if (c.kind === "skill" && parsed && typeof parsed === "object") {
-    const dirName = path35__default.basename(path35__default.dirname(c.filePath));
-    const findings = checkAgentSkillConformance(parsed, { dirName });
-    for (const f of findings) {
-      const line = `${relPath} [skill conformance] \u2014 ${f.field}: ${f.message}`;
-      if (strictConformance) {
+    const dirName = path36__default.basename(path36__default.dirname(c.filePath));
+    for (const f of checkSkillManifest(parsed, body, dirName)) {
+      const line = `${relPath} [${f.tag}] \u2014 ${f.text}`;
+      if (f.conformance && strictConformance) {
         logErr(line);
         errors++;
       } else {
@@ -8437,10 +8633,6 @@ function validateManifestCandidate(c, parsed, body, absRoot, registry, strictCon
       }
     }
   }
-  if (c.kind === "skill" && body?.replace(/^#[^\n]*\n+/, "") === SKILL_BODY_PLACEHOLDER) {
-    logWarn(`${relPath} [skill] \u2014 body is still the scaffold placeholder; write the skill prompt`);
-    warnings++;
-  }
   const provider = registry.getProvider(c.kind);
   if (!provider) {
     logWarn(`${relPath} [${c.kind}] \u2014 kind "${c.kind}" is not registered, skipping validation`);
@@ -8456,8 +8648,8 @@ function validateManifestCandidate(c, parsed, body, absRoot, registry, strictCon
   return { errors, warnings };
 }
 function validateManifests(rootPath, strictConformance) {
-  const absRoot = path35__default.resolve(rootPath);
-  if (!fs11__default.existsSync(absRoot)) {
+  const absRoot = path36__default.resolve(rootPath);
+  if (!fs12__default.existsSync(absRoot)) {
     logErr(`Path does not exist: ${absRoot}`);
     return { total: 0, errors: 1, warnings: 0 };
   }
@@ -8467,7 +8659,6 @@ function validateManifests(rootPath, strictConformance) {
   let warnings = 0;
   for (const c of candidates) {
     const parseResult = parseManifestCandidate(c, absRoot);
-    if (parseResult.kind === "skip") continue;
     if (parseResult.kind === "error") {
       errors++;
       continue;
@@ -8490,12 +8681,12 @@ function findWorkspaceManifests(rootPath) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs11__default.readdirSync(dir, { withFileTypes: true });
+      entries = fs12__default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path35__default.join(dir, entry.name);
+      const full = path36__default.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) walk(full);
       } else if (entry.isFile() && /(^|\.)skaile\.yaml$/.test(entry.name)) {
@@ -8558,14 +8749,14 @@ function validateWorkspaceAssets(parsed, relPath) {
   return errors;
 }
 function validateWorkspaceManifests(rootPath) {
-  const absRoot = path35__default.resolve(rootPath);
+  const absRoot = path36__default.resolve(rootPath);
   const files = findWorkspaceManifests(absRoot);
   let errors = 0;
   for (const file of files) {
-    const relPath = path35__default.relative(absRoot, file);
+    const relPath = path36__default.relative(absRoot, file);
     let parsed;
     try {
-      parsed = parse(fs11__default.readFileSync(file, "utf-8")) ?? {};
+      parsed = parse(fs12__default.readFileSync(file, "utf-8")) ?? {};
     } catch (e) {
       logErr(`${relPath} \u2014 parse error: ${e instanceof Error ? e.message : String(e)}`);
       errors++;
@@ -8577,7 +8768,7 @@ function validateWorkspaceManifests(rootPath) {
   return { total: files.length, errors };
 }
 function validatePublishManifestRoots(rootPath) {
-  const absRoot = path35__default.resolve(rootPath);
+  const absRoot = path36__default.resolve(rootPath);
   const manifest = loadSkPublishManifest(absRoot);
   if (!manifest) return 0;
   const missing = missingRootAssets(absRoot, manifest);
@@ -8589,8 +8780,8 @@ function validatePublishManifestRoots(rootPath) {
   return missing.length;
 }
 var EXCLUDED_PATHS = ["skaileup-shared/", "external/", "docs/"];
-function toPosix(p7) {
-  return p7.split(path35__default.sep).join("/");
+function toPosix(p6) {
+  return p6.split(path36__default.sep).join("/");
 }
 function isExcludedPath(relPath) {
   const rel = toPosix(relPath);
@@ -8598,9 +8789,9 @@ function isExcludedPath(relPath) {
 }
 function collectAssetVersions() {
   const assets = [];
-  if (!fs11__default.existsSync(AI_RESOURCES)) return assets;
+  if (!fs12__default.existsSync(AI_RESOURCES)) return assets;
   const kindDirs = (kindDirName) => findKindDirs(AI_RESOURCES, kindDirName).filter(
-    (dir) => !isExcludedPath(path35__default.relative(AI_RESOURCES, dir))
+    (dir) => !isExcludedPath(path36__default.relative(AI_RESOURCES, dir))
   );
   for (const dir of kindDirs("skills")) collectSkillVersions(dir, assets);
   for (const dir of kindDirs("agents")) collectAgentVersions(dir, assets);
@@ -8610,10 +8801,10 @@ function collectAssetVersions() {
   return assets.filter((a) => !seen.has(a.filePath) && seen.add(a.filePath));
 }
 function collectFlowVersions(dir, out) {
-  for (const f of fs11__default.readdirSync(dir)) {
+  for (const f of fs12__default.readdirSync(dir)) {
     if (!f.endsWith(".flow.yaml")) continue;
-    const fp = path35__default.join(dir, f);
-    const content = fs11__default.readFileSync(fp, "utf-8");
+    const fp = path36__default.join(dir, f);
+    const content = fs12__default.readFileSync(fp, "utf-8");
     const parsed = parse(content);
     out.push({
       kind: "flow",
@@ -8624,10 +8815,10 @@ function collectFlowVersions(dir, out) {
   }
 }
 function collectPromptVersions(dir, out) {
-  for (const f of fs11__default.readdirSync(dir)) {
+  for (const f of fs12__default.readdirSync(dir)) {
     if (!f.endsWith(".prompt.md")) continue;
-    const fp = path35__default.join(dir, f);
-    const content = fs11__default.readFileSync(fp, "utf-8");
+    const fp = path36__default.join(dir, f);
+    const content = fs12__default.readFileSync(fp, "utf-8");
     const fm = parseSkillFrontmatter(content);
     out.push({
       kind: "prompt",
@@ -8638,12 +8829,12 @@ function collectPromptVersions(dir, out) {
   }
 }
 function collectSkillVersions(dir, out) {
-  for (const entry of fs11__default.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs12__default.readdirSync(dir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const full = path35__default.join(dir, entry.name);
-    const skillMd = path35__default.join(full, "SKILL.md");
-    if (fs11__default.existsSync(skillMd)) {
-      const content = fs11__default.readFileSync(skillMd, "utf-8");
+    const full = path36__default.join(dir, entry.name);
+    const skillMd = path36__default.join(full, "SKILL.md");
+    if (fs12__default.existsSync(skillMd)) {
+      const content = fs12__default.readFileSync(skillMd, "utf-8");
       const fm = parseSkillFrontmatter(content);
       out.push({
         kind: "skill",
@@ -8657,11 +8848,11 @@ function collectSkillVersions(dir, out) {
   }
 }
 function collectAgentVersions(dir, out) {
-  for (const entry of fs11__default.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs12__default.readdirSync(dir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const agentYaml = path35__default.join(dir, entry.name, "agent.yaml");
-    if (!fs11__default.existsSync(agentYaml)) continue;
-    const content = fs11__default.readFileSync(agentYaml, "utf-8");
+    const agentYaml = path36__default.join(dir, entry.name, "agent.yaml");
+    if (!fs12__default.existsSync(agentYaml)) continue;
+    const content = fs12__default.readFileSync(agentYaml, "utf-8");
     const parsed = parse(content);
     out.push({
       kind: "agent",
@@ -8672,15 +8863,15 @@ function collectAgentVersions(dir, out) {
   }
 }
 function assetLocation(a) {
-  return toPosix(path35__default.relative(AI_RESOURCES, a.filePath));
+  return toPosix(path36__default.relative(AI_RESOURCES, a.filePath));
 }
 function findChangelogUnit(assetRelPath, root) {
-  let dir = path35__default.posix.dirname(toPosix(assetRelPath));
+  let dir = path36__default.posix.dirname(toPosix(assetRelPath));
   for (; ; ) {
     const candidate = dir === "." ? "CHANGELOG.md" : `${dir}/CHANGELOG.md`;
-    if (fs11__default.existsSync(path35__default.join(root, candidate))) return candidate;
+    if (fs12__default.existsSync(path36__default.join(root, candidate))) return candidate;
     if (dir === ".") return null;
-    dir = path35__default.posix.dirname(dir);
+    dir = path36__default.posix.dirname(dir);
   }
 }
 function checkChangelogUnits(modifiedFiles, root) {
@@ -8718,7 +8909,7 @@ function filterToChangedAssets(assets) {
       encoding: "utf-8"
     });
     const changedFiles = new Set(
-      diffOutput.trim().split("\n").filter(Boolean).map((f) => path35__default.resolve(AI_RESOURCES, f))
+      diffOutput.trim().split("\n").filter(Boolean).map((f) => path36__default.resolve(AI_RESOURCES, f))
     );
     return assets.filter((a) => changedFiles.has(a.filePath));
   } catch {
@@ -8746,7 +8937,7 @@ function checkVersionBumps(assets) {
   let warnings = 0;
   for (const a of assets) {
     if (!a.version) continue;
-    const relPath = path35__default.relative(AI_RESOURCES, a.filePath);
+    const relPath = path36__default.relative(AI_RESOURCES, a.filePath);
     try {
       const headContent = execSync(`git show HEAD:${relPath}`, {
         cwd: AI_RESOURCES,
@@ -8778,7 +8969,7 @@ function checkFlowVersionPins(assets) {
       pins = flowSkillVersionPins(loadFlow(f.filePath));
     } catch (err) {
       logWarn(
-        `flow:${f.name} (${path35__default.relative(AI_RESOURCES, f.filePath)}) \u2014 could not be read: ${err instanceof Error ? err.message : err}`
+        `flow:${f.name} (${path36__default.relative(AI_RESOURCES, f.filePath)}) \u2014 could not be read: ${err instanceof Error ? err.message : err}`
       );
       warnings++;
       continue;
@@ -8828,7 +9019,7 @@ function makeValidateCommand() {
     "--strict-conformance",
     "Treat Agent Skills (agentskills.io) standard findings as errors"
   ).action((targetPath, opts) => {
-    const absPath = path35__default.resolve(targetPath);
+    const absPath = path36__default.resolve(targetPath);
     logInfo(`Validating manifests in ${absPath}`);
     const { total, errors, warnings } = validateManifests(
       absPath,
@@ -8838,6 +9029,7 @@ function makeValidateCommand() {
     const rootErrors = validatePublishManifestRoots(absPath);
     const totalErrors = errors + ws.errors + rootErrors;
     console.log();
+    warnIgnoredDomainFiles(absPath);
     logInfo(`Scanned ${total} asset manifest(s) and ${ws.total} skaile.yaml file(s)`);
     if (warnings > 0) logWarn(`${warnings} warning(s)`);
     if (totalErrors === 0) {
@@ -8970,7 +9162,7 @@ function whyEmptyMessage(ref, declared) {
 }
 function makeWhyCommand() {
   return new Command("why").description("Show why an asset is installed (dependency chain)").argument("<ref>", "Asset reference (kind:name)").option("--project-dir <path>", "Project directory", process.cwd()).action(async (ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path35__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path36__default.resolve(opts.projectDir) });
     const chain = am2.why(ref);
     if (chain.length === 0) {
       let declared;
@@ -9004,7 +9196,7 @@ function makeWhyCommand() {
 var _defaultFormatHelp = Help.prototype.formatHelp;
 var pkg = JSON.parse(
   readFileSync(
-    path35__default.resolve(path35__default.dirname(fileURLToPath(import.meta.url)), "../../package.json"),
+    path36__default.resolve(path36__default.dirname(fileURLToPath(import.meta.url)), "../../package.json"),
     "utf-8"
   )
 );
@@ -9126,7 +9318,7 @@ program.command("init [project-dir]").description("Initialize a project director
   (projectDir, opts) => runInit(projectDir, opts)
 );
 async function runInit(projectDir, opts) {
-  const { mkdirSync: mkdirSync4, writeFileSync: writeFileSync5 } = await import('fs');
+  const { mkdirSync: mkdirSync4, writeFileSync: writeFileSync6 } = await import('fs');
   const { stringify: stringify2 } = await import('yaml');
   const { DRIVER_TARGETS, SUPPORTED_DRIVER_TARGETS: SUPPORTED_DRIVER_TARGETS2 } = await import('../core/index.js');
   const harness = opts.harness;
@@ -9135,32 +9327,32 @@ async function runInit(projectDir, opts) {
     process.exitCode = 1;
     return;
   }
-  const resolved = path35__default.resolve(projectDir ?? ".");
-  const projectName = path35__default.basename(resolved);
+  const resolved = path36__default.resolve(projectDir ?? ".");
+  const projectName = path36__default.basename(resolved);
   const created = [];
-  const { existsSync: existsSync15 } = await import('fs');
-  if (!existsSync15(resolved)) {
+  const { existsSync: existsSync16 } = await import('fs');
+  if (!existsSync16(resolved)) {
     mkdirSync4(resolved, { recursive: true });
     created.push(".");
   }
-  const skaileDir = path35__default.join(resolved, ".skaile");
-  if (!existsSync15(skaileDir)) {
-    mkdirSync4(path35__default.join(skaileDir, "sessions"), { recursive: true });
+  const skaileDir = path36__default.join(resolved, ".skaile");
+  if (!existsSync16(skaileDir)) {
+    mkdirSync4(path36__default.join(skaileDir, "sessions"), { recursive: true });
     created.push(".skaile/");
   }
-  const settingsPath = path35__default.join(skaileDir, "settings.json");
-  if (!existsSync15(settingsPath)) {
-    writeFileSync5(settingsPath, "{}\n");
+  const settingsPath = path36__default.join(skaileDir, "settings.json");
+  if (!existsSync16(settingsPath)) {
+    writeFileSync6(settingsPath, "{}\n");
     created.push(".skaile/settings.json");
   }
-  const wsConfigPath = path35__default.join(resolved, "skaile.yaml");
-  if (!existsSync15(wsConfigPath)) {
-    writeFileSync5(wsConfigPath, stringify2(buildInitWorkspaceConfig(projectName, harness)));
+  const wsConfigPath = path36__default.join(resolved, "skaile.yaml");
+  if (!existsSync16(wsConfigPath)) {
+    writeFileSync6(wsConfigPath, stringify2(buildInitWorkspaceConfig(projectName, harness)));
     created.push("skaile.yaml");
   }
   for (const dir of new Set(Object.values(DRIVER_TARGETS[harness].local))) {
-    const full = path35__default.join(resolved, dir);
-    if (!existsSync15(full)) {
+    const full = path36__default.join(resolved, dir);
+    if (!existsSync16(full)) {
       mkdirSync4(full, { recursive: true });
       created.push(`${dir}/`);
     }
@@ -9190,8 +9382,8 @@ function buildInitWorkspaceConfig(projectName, harness) {
 }
 async function initGitScaffold(resolved, created) {
   const { execSync: execSync3 } = await import('child_process');
-  const { existsSync: existsSync15, readFileSync: readFileSync9, writeFileSync: writeFileSync5 } = await import('fs');
-  const gitignorePath = path35__default.join(resolved, ".gitignore");
+  const { existsSync: existsSync16, readFileSync: readFileSync9, writeFileSync: writeFileSync6 } = await import('fs');
+  const gitignorePath = path36__default.join(resolved, ".gitignore");
   const entries = [
     "node_modules/",
     ".skaile/sessions/",
@@ -9208,16 +9400,16 @@ async function initGitScaffold(resolved, created) {
     ".env",
     ".env.local"
   ];
-  const existing = existsSync15(gitignorePath) ? readFileSync9(gitignorePath, "utf-8") : "";
+  const existing = existsSync16(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" : "";
-    writeFileSync5(gitignorePath, `${existing + prefix}${append.join("\n")}
+    writeFileSync6(gitignorePath, `${existing + prefix}${append.join("\n")}
 `);
     if (!existing) created.push(".gitignore");
   }
-  if (!existsSync15(path35__default.join(resolved, ".git"))) {
+  if (!existsSync16(path36__default.join(resolved, ".git"))) {
     try {
       execSync3("git init", { cwd: resolved, stdio: "pipe" });
       created.push(".git/");
@@ -9229,10 +9421,10 @@ async function initGitScaffold(resolved, created) {
 }
 async function bootstrapUserConfig() {
   try {
-    const fs12 = await import('fs');
-    const { userConfigPath, saveConfig, getConfigDefaults } = await import('../library/index.js');
-    const userCfgPath = userConfigPath();
-    if (!fs12.existsSync(userCfgPath)) {
+    const fs13 = await import('fs');
+    const { userConfigPath: userConfigPath2, saveConfig, getConfigDefaults } = await import('../library/index.js');
+    const userCfgPath = userConfigPath2();
+    if (!fs13.existsSync(userCfgPath)) {
       const defaults = getConfigDefaults();
       saveConfig(userCfgPath, {
         catalog: { url: defaults.catalog.url, cache_ttl: defaults.catalog.cache_ttl }
@@ -9247,7 +9439,7 @@ async function bootstrapUserConfig() {
 }
 async function hydrateInitSources(resolved, created) {
   try {
-    const { ensureSourcesCloned } = await import('../ensure-sources-VCPA762L.js');
+    const { ensureSourcesCloned } = await import('../ensure-sources-Z3KKLEM6.js');
     const hydrate = ensureSourcesCloned(resolved, { quiet: true });
     for (const n of hydrate.cloned) created.push(`~/.skaile/cache/sources/${n}/`);
     if (hydrate.failed.length > 0) {
@@ -9263,7 +9455,7 @@ function printInitSummary(resolved, projectDir, created) {
   logOk(`Initialized project at ${S.heading(resolved)}`);
   console.log();
   console.log(S.heading("  Next steps:"));
-  const isCurrentDir = resolved === path35__default.resolve(".");
+  const isCurrentDir = resolved === path36__default.resolve(".");
   let step = 1;
   if (!isCurrentDir) {
     console.log(`  ${S.dim(`${step}.`)} ${S.cmd(`cd ${projectDir}`)}`);
@@ -9287,7 +9479,7 @@ function printInitSummary(resolved, projectDir, created) {
   console.log();
 }
 program.command("setup").description("Interactive provider setup wizard").action(async () => {
-  const { cmdSetup } = await import('../setup-RG4PJJUW.js');
+  const { cmdSetup } = await import('../setup-4BV5ZWOZ.js');
   await cmdSetup([], { projectDir: process.cwd() });
 });
 program.addCommand(makeInstallCommand());
@@ -9340,13 +9532,34 @@ program.addCommand(makeSourceCommand());
 program.addCommand(makeLibraryCommand());
 program.addCommand(makeAssetCommand());
 program.addCommand(makePresetCommand());
-program.command("path").description("Show resolved paths").action(() => {
+program.command("path").description("Show resolved paths (honours SKAILE_HOME and the per-path overrides)").action(async () => {
+  const { globalCacheRoot: globalCacheRoot2, globalSkaileDir: globalSkaileDir2, resolveLibraryDir: resolveLibraryDir2, userConfigPath: userConfigPath2 } = await import('../core/index.js');
+  const { getStoreRoot, resolveIndexPath } = await import('../library/index.js');
+  const rows = [
+    ["skaile-home", globalSkaileDir2()],
+    ["config", userConfigPath2()],
+    ["index", resolveIndexPath()],
+    ["libraries", resolveLibraryDir2()],
+    ["store", getStoreRoot()],
+    ["cache", globalCacheRoot2()],
+    ["ai-assets", AI_RESOURCES],
+    ["patches-dir", ".skaile/patches/"]
+  ];
+  const width = Math.max(...rows.map(([label]) => label.length));
   console.log();
-  console.log(`  ${S.dim("ai-assets")}    ${S.heading(AI_RESOURCES)}`);
-  console.log(`  ${S.dim("patches-dir")}  ${S.heading(".skaile/patches/")}`);
+  for (const [label, value] of rows) {
+    console.log(`  ${S.dim(label.padEnd(width))}  ${S.heading(value)}`);
+  }
   console.log();
 });
 program.addCommand(makeCompleteCommand(program));
-await program.parseAsync();
+try {
+  await program.parseAsync();
+} catch (err) {
+  const { LibrarySyncError } = await import('../library/index.js');
+  if (!(err instanceof LibrarySyncError)) throw err;
+  logErr(err.message);
+  process.exit(1);
+}
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map