@skaile/workspaces 5.6.1 → 5.7.0

package/dist/cli/index.js

@@ -1,24 +1,24 @@
 #!/usr/bin/env node
-import { makeProvidersCommand, loadRegistryView, addProviderEntry, ProviderRegistryWriteError } from '../chunk-QD772CGQ.js';
-import { makeSourceCommand, syncProjectSources } from '../chunk-D2V42LUE.js';
-import { AI_RESOURCES } from '../chunk-OGLDAJFL.js';
-import { checkSkillManifest } from '../chunk-2NYXQYHN.js';
-import { getStoreConfig, storeFetch, deviceLogin, loadStoreAuthConfig, logout, hasStoredAuth, isStoreAuthenticated, getStoreToken, getStoreIdentity, assetEntryRef, refFor } from '../chunk-65EYRFZJ.js';
-import { makeInstallCommand, makeCheckCommand, makeCleanCommand, reportInstalledSoftDeps } from '../chunk-WIHQWVWL.js';
+import { makeProvidersCommand, loadRegistryView, addProviderEntry, ProviderRegistryWriteError } from '../chunk-53MSCGR2.js';
+import { makeSourceCommand, syncProjectSources } from '../chunk-IZLQ4GDO.js';
+import { makeInstallCommand, makeCheckCommand, makeCleanCommand, REF_HINT, reportInstalledSoftDeps } from '../chunk-EU3Q5AQ4.js';
 import { createSpinner } from '../chunk-NESV47MF.js';
-import { openCatalogSource, openLibraryManager, openLibrary } from '../chunk-I4QBZLOR.js';
-import { logErr, S, logOk, logInfo, logWarn, TARGET_DEFAULT_HINT, deferredWarnings, warnLegacyClaudeCopies, kindColorPad, kindColor, colorRef, formatSoftDepSection, bareSoftDepName, formatSoftDepHint, formatRelativeTime, formatSoftDepRemovePreview, formatSoftDepAddPreview, fitWidth, KIND_COL_WIDTH } from '../chunk-VJENKWXF.js';
-import { getKindRegistry, getKnownKinds } from '../chunk-OLLAQLFJ.js';
-import { LocalSecretsProvider } from '../chunk-VSQFGU5D.js';
-import { runAgentChat, isCompositionError, loadSessionById, loadSession, listSessions, setCurrentSession, deleteSession, clearSession, loadAgentManifest, hashAgentFiles, createCompositionContentSource, compileComposition, instanceForSession, resolveAgentInstance, describeComposition, MarkdownStreamer } from '../chunk-RGXVQZOV.js';
-import { buildClaudePluginFiles } from '../chunk-4GNJELPH.js';
-import '../chunk-6NPINANG.js';
-import '../chunk-SX4UIDKT.js';
+import { AI_RESOURCES } from '../chunk-7FJQT3GT.js';
+import { findAssetManifestFile, declaredVersion, checkAssetManifest } from '../chunk-6C654TFI.js';
+import { getStoreConfig, storeFetch, deviceLogin, loadStoreAuthConfig, logout, hasStoredAuth, isStoreAuthenticated, getStoreToken, getStoreIdentity, assetEntryRef, refFor } from '../chunk-LXY4BUA3.js';
+import { openCatalogSource, LocalCatalogDisabledError, openLibraryManager, openLibrary } from '../chunk-GIC3G5YG.js';
+import { logErr, S, logOk, logInfo, logWarn, TARGET_DEFAULT_HINT, deferredWarnings, warnLegacyClaudeCopies, kindColorPad, kindColor, colorRef, formatSoftDepSection, bareSoftDepName, formatSoftDepHint, formatRelativeTime, formatSoftDepRemovePreview, formatSoftDepAddPreview, fitWidth, KIND_COL_WIDTH } from '../chunk-THEJJBOU.js';
+import { getKindRegistry, getKnownKinds } from '../chunk-WIEC3ZE4.js';
+import { LocalSecretsProvider } from '../chunk-ILFGVSTJ.js';
+import { runAgentChat, isCompositionError, loadSessionById, loadSession, listSessions, setCurrentSession, deleteSession, clearSession, loadAgentManifest, hashAgentFiles, createCompositionContentSource, compileComposition, instanceForSession, resolveAgentInstance, describeComposition, MarkdownStreamer } from '../chunk-VOOI7B2L.js';
+import { buildClaudePluginFiles } from '../chunk-N6FBTXQ5.js';
+import '../chunk-6UFFKMVC.js';
+import '../chunk-KM7XWC4Y.js';
 import '../chunk-R6O6YWU7.js';
-import '../chunk-KYXOGHY6.js';
-import '../chunk-45VFGT7A.js';
+import '../chunk-IUUYRXT6.js';
+import '../chunk-RNPHRRLG.js';
 import '../chunk-4ZTPYIBE.js';
-import '../chunk-2XFUXGV6.js';
+import '../chunk-NWQB7UTY.js';
 import '../chunk-X5YPJV4N.js';
 import '../chunk-O7SG5PC2.js';
 import '../chunk-7QBNJTTQ.js';
@@ -27,67 +27,67 @@ import '../chunk-5LKOAX7I.js';
 import '../chunk-32NA4TVC.js';
 import '../chunk-W3UDISS2.js';
 import '../chunk-HCYS7GFP.js';
-import { runFlow, resumeFlow } from '../chunk-7KLC4LZO.js';
+import { runFlow, resumeFlow } from '../chunk-MKLBK7HI.js';
 import '../chunk-4R6DROGN.js';
-import { validateFlowVersions, parseSkillFrontmatter } from '../chunk-ZBBM6O6P.js';
-import '../chunk-SDFROXSA.js';
+import { validateFlowVersions, parseSkillFrontmatter } from '../chunk-EB4XN3KE.js';
+import '../chunk-O4Z7MAW7.js';
 import '../chunk-CT6NQSA4.js';
-import '../chunk-UAP2XHRF.js';
+import '../chunk-SZWRPEF7.js';
 import '../chunk-FK6HPLQA.js';
-import '../chunk-2GRB5ITE.js';
-import '../chunk-VX3INFBA.js';
-import '../chunk-VBBBZDI7.js';
+import '../chunk-PSA6ONFB.js';
+import '../chunk-34C42MJX.js';
+import '../chunk-UX3K4RKE.js';
 import '../chunk-EINLFFP6.js';
 import '../chunk-LOO5CB5M.js';
 import '../chunk-NARITJS2.js';
-import '../chunk-27HS2DHB.js';
+import '../chunk-GWXFSLBK.js';
 import '../chunk-XBSQ4KMC.js';
 import '../chunk-YROR332M.js';
-import { getProviderPreset, AI_PROVIDER_PRESETS } from '../chunk-5B5IZVEP.js';
+import { getProviderPreset, AI_PROVIDER_PRESETS } from '../chunk-BTK7ECLH.js';
 import '../chunk-6E6PKKAD.js';
 import '../chunk-IFGTRL2I.js';
-import { projectAiAssetsRoots, loadFlow, loadAllFlowEntries, findFlowFileInRoots } from '../chunk-AOAZCSDI.js';
+import { projectAiAssetsRoots, loadFlow, loadAllFlowEntries, findFlowFileInRoots } from '../chunk-LBQ4BBX4.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-DMLDYFDS.js';
-import { AssetManager, MissingManifestError, parseRefTolerant, normalizeRepoUrl, FACTORY_SOURCE_URL } from '../chunk-PTO2YDDG.js';
-import { cloneOrInitGitRepo, ensureGitRepo, setManifestPublisher, syncManifestWithDisk, isGitRepo, assertManifestEditable, installLibraryAsset, missingRootAssets, stampManifestPublisher, upsertManifestAsset, getStoreManifestsDir, getDefaultValue, isSecretPlaceholder } from '../chunk-MX3UQXLU.js';
-import { parseManifestFile } from '../chunk-XOGG7VDZ.js';
-import '../chunk-BTISGSK4.js';
+import { AssetManager, MissingManifestError, parseRefTolerant, normalizeRepoUrl, FACTORY_SOURCE_URL } from '../chunk-D5HOETOB.js';
+import { cloneOrInitGitRepo, trackOriginBranch, ensureGitRepo, setManifestPublisher, LIBRARY_OWNERSHIPS, syncManifestWithDisk, isGitRepo, assertManifestEditable, installLibraryAsset, missingRootAssets, assertValidLibraryName, stampManifestPublisher, upsertManifestAsset, getStoreManifestsDir, getDefaultValue, isSecretPlaceholder } from '../chunk-DFFD4BFG.js';
+import { parseManifestFile, requiresSyntaxErrors, SEMVER_RE } from '../chunk-6VRJH4MR.js';
+import '../chunk-FAP63KV7.js';
 import '../chunk-R7FOF242.js';
 import '../chunk-3TXEJN4W.js';
-import { installTargetOf } from '../chunk-2KOKBTR4.js';
+import { installTargetOf, SCAFFOLD_KINDS } from '../chunk-74EEFB52.js';
 import '../chunk-CGYEHQOX.js';
 import '../chunk-KTBKW2FI.js';
 import '../chunk-UQ6LFBPZ.js';
-import '../chunk-VKSXST23.js';
+import '../chunk-AVCUPPG6.js';
 import { effectiveComposes, validatePreset, composeSlotDiagnostics, agentDeprecationDiagnostics, validateAgent, SLOT_ID_PATTERN } from '../chunk-FRHE7FFB.js';
-import { resolveSettings, globalSettingsPath, projectSettingsPath, loadSettings, saveSettings, WorkspaceYamlEditor, resolveLibraryDir, checkAgentSkillConformance, globalInstallDir, GLOBAL_INSTALL_DIR_NAME, readLock, aiResourceRoots, workspaceProviderRegistryPath, userProviderRegistryPath, loadProviderRegistryFile } from '../chunk-TZCQ7ZWQ.js';
+import { resolveSettings, globalSettingsPath, projectSettingsPath, loadSettings, saveSettings, WorkspaceYamlEditor, resolveLibraryDir, checkAgentSkillConformance, globalInstallDir, GLOBAL_INSTALL_DIR_NAME, readLock, aiResourceRoots, workspaceProviderRegistryPath, userProviderRegistryPath, loadProviderRegistryFile } from '../chunk-OOLT6HGP.js';
 import '../chunk-4GY63JU6.js';
-import { factoryAssetRoots } from '../chunk-BF33SCLY.js';
-import '../chunk-46OVMT76.js';
+import { factoryAssetRoots } from '../chunk-SWO25LTO.js';
+import '../chunk-G67BOI2J.js';
 import { DEFAULT_DRIVER_ID, DRIVER_DEFAULTS } from '../chunk-5BEFNLOR.js';
 import { findKindDirs } from '../chunk-A2ULN3KX.js';
-import { sourceCacheKey, getGlobalCacheDir, resolveAgentDir, AgentRefResolutionError, resolveAgentDefinitionDir, resolveSkWorkspaceConfig, matchPin, coerceVersion, loadSkWorkspaceConfig, normalizeAgentInstances, agentInstanceDiagnostics, storeManifestSlug, isWorkspaceConfigFilename } from '../chunk-2W4LBLIN.js';
-import { globalCacheRoot, globalSkaileDir, userConfigPath } from '../chunk-MFHKHXDE.js';
+import { sourceCacheKey, getGlobalCacheDir, resolveAgentDir, AgentRefResolutionError, resolveAgentDefinitionDir, resolveSkWorkspaceConfig, matchPin, coerceVersion, loadSkWorkspaceConfig, normalizeAgentInstances, agentInstanceDiagnostics, storeManifestSlug, isWorkspaceConfigFilename } from '../chunk-LCU5U5IW.js';
+import { globalCacheRoot, globalSkaileDir, userConfigPath } from '../chunk-L5VSIPQD.js';
 import { SUPPORTED_DRIVER_TARGETS, driverTargetForDriver } from '../chunk-CPSIPIX7.js';
-import { loadSkPublishManifest, SKAILE_MANIFEST_FILENAME, decodeSkaileManifest, encodeSkaileManifest } from '../chunk-7ZHLYXTI.js';
+import { SKAILE_MANIFEST_FILENAME, loadSkPublishManifest, decodeSkaileManifest, encodeSkaileManifest } from '../chunk-RVIZQ5XD.js';
 import { pluginTitle } from '../chunk-RVRB27AN.js';
-import { parseFrontmatter, scanDirectory } from '../chunk-PA7WLID3.js';
-import { parseAssetRef, isValidAssetName, slugifyAssetName, ASSET_NAME_HINT, assetRefToStr } from '../chunk-AO7VJ6G6.js';
+import { parseFrontmatter, scanDirectory } from '../chunk-TTPSDC2G.js';
+import { parseAssetRef, isValidPublisher, PUBLISHER_HINT, isValidAssetName, ASSET_NAME_HINT, slugifyAssetName, parseAssetRefLoose, assetRefToStr } from '../chunk-O7VPNKYN.js';
 import { portableSpawn, portableSpawnSync } from '../chunk-ICSCSM5D.js';
 import { openSqlite } from '../chunk-JMKB7IB4.js';
 import { parseModelRef, resolveEntryBaseUrl } from '../chunk-MJHSLODD.js';
 import '../chunk-C3CAXQMA.js';
 import '../chunk-BOFL7GIF.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 path25 from 'path';
-import path25__default, { resolve, join } from 'path';
+import * as fs9 from 'fs';
+import fs9__default, { readFileSync, existsSync, mkdirSync, writeFileSync, lstatSync, rmSync, readdirSync, statSync } from 'fs';
+import * as path23 from 'path';
+import path23__default, { resolve, join } from 'path';
 import { fileURLToPath } from 'url';
 import { Help, Command, Option } from 'commander';
 import { rcompare } from 'semver';
@@ -99,7 +99,7 @@ import * as readline from 'readline';
 import { createInterface } from 'readline';
 import fs6 from 'fs/promises';
 import { parse as parse$1, stringify as stringify$1 } from 'smol-toml';
-import { execSync, spawnSync } from 'child_process';
+import { execSync, spawnSync, execFileSync } from 'child_process';
 import * as readline2 from 'readline/promises';
 import { createTRPCUntypedClient, httpLink, httpSubscriptionLink } from '@trpc/client';
 
@@ -176,7 +176,7 @@ async function runSearch(kind, query, opts) {
   const showLocal = !opts.store;
   const showStore = !opts.local;
   const { resolveConfig } = await import('../library/index.js');
-  const airGapped = resolveConfig({ projectDir: path25__default.resolve(opts.projectDir) }).catalog.cache_ttl === 0;
+  const airGapped = resolveConfig({ projectDir: path23__default.resolve(opts.projectDir) }).catalog.cache_ttl === 0;
   if (showLocal) {
     await searchLocal(query, kind, opts, showStore, airGapped);
   }
@@ -185,10 +185,11 @@ async function runSearch(kind, query, opts) {
   }
 }
 async function searchIndex(query, kind) {
-  const { openLibrary: openLibrary2 } = await import('../open-library-4WUMQHES.js');
+  const { openLibrary: openLibrary2 } = await import('../open-library-P3D337NH.js');
   const library = await openLibrary2();
   try {
     const defs = await library.listAssetDefs(kind ? { kind } : {});
+    const libraryNames = new Map((await library.listSources()).map((l) => [l.id, l.name]));
     let entries = defs.map(
       (d) => ({
         name: d.name,
@@ -202,7 +203,8 @@ async function searchIndex(query, kind) {
         requires: [],
         dependencies: [],
         license: d.license,
-        category: d.category
+        category: d.category,
+        library: d.libraryId ? libraryNames.get(d.libraryId) : void 0
       })
     );
     if (query) {
@@ -217,7 +219,7 @@ async function searchIndex(query, kind) {
   }
 }
 async function searchFactory(projectDir, query, kind) {
-  const prefixes = factoryAssetRoots().map((r) => r.endsWith(path25__default.sep) ? r : r + path25__default.sep);
+  const prefixes = factoryAssetRoots().map((r) => r.endsWith(path23__default.sep) ? r : r + path23__default.sep);
   const isFactoryPath = (p6) => prefixes.some((fp) => p6 === fp.slice(0, -1) || p6.startsWith(fp));
   try {
     const entries = await new AssetManager({ registry: getKindRegistry(), projectDir }).search(
@@ -237,11 +239,11 @@ function unionEntries(indexed, factory) {
   return [...indexed, ...factory.filter((e) => !seen.has(entryDedupKey(e)))];
 }
 async function searchLocal(query, kind, opts, showStore, airGapped) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__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-JCF6KSQN.js');
+    const { autoSyncForSearch } = await import('../source-FYVSFYEI.js');
     if (await autoSyncForSearch(projectDir)) {
       entries = unionEntries(await searchIndex(query, kind), factory);
     }
@@ -264,40 +266,48 @@ var MIN_LOCAL_DESCRIPTION_WIDTH = 10;
 function layoutLocalTable(rows, width, style = {}) {
   const styleRef = style.ref ?? ((s) => s);
   const styleVer = style.version ?? ((s) => s);
+  const styleLib = style.library ?? ((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 libW = Math.max(0, ...rows.map((r) => (r.library ?? "").length));
+  const tailSpan = (verW > 0 ? gap + verW : 0) + (libW > 0 ? gap + libW : 0);
   const refCell = (ref) => styleRef(ref) + " ".repeat(nameW - ref.length);
+  const tail = (r) => {
+    if (libW === 0) return r.version ? `${COLUMN_GAP}${styleVer(r.version)}` : "";
+    const verCell = `${COLUMN_GAP}${styleVer(r.version)}${" ".repeat(verW - r.version.length)}`;
+    const ver = verW > 0 ? verCell : "";
+    return `${ver}${COLUMN_GAP}${r.library ? styleLib(r.library) : ""}`;
+  };
   const lines = [];
-  const descW = width - (indent + nameW + gap + verSpan);
+  const descW = width - (indent + nameW + gap + tailSpan);
   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)}` : ""}`
-      );
+      const descCell = tailSpan > 0 ? desc.padEnd(descW) : desc;
+      lines.push(`${pad}${refCell(r.ref)}${COLUMN_GAP}${descCell}${tail(r)}`);
     }
-    return { ruleWidth: nameW + gap + descW + verSpan, lines };
+    return { ruleWidth: nameW + gap + descW + tailSpan, lines };
   }
-  if (indent + nameW + verSpan <= width) {
+  if (indent + nameW + tailSpan <= 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)}`
-      );
+      lines.push(tailSpan > 0 ? `${pad}${refCell(r.ref)}${tail(r)}` : `${pad}${styleRef(r.ref)}`);
     }
-    return { ruleWidth: nameW + verSpan, lines };
+    return { ruleWidth: nameW + tailSpan, lines };
   }
   const subPad = " ".repeat(indent + 2);
-  const subDescW = width - (indent + 2) - verSpan;
+  const subDescW = width - (indent + 2) - tailSpan;
   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 !== "");
+    const descCell = (r.version || r.library) && desc ? desc.padEnd(subDescW) : desc;
+    const parts = [
+      descCell,
+      r.version ? styleVer(r.version) : "",
+      r.library ? styleLib(r.library) : ""
+    ].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 };
@@ -313,10 +323,11 @@ function printLocalEntries(entries, width = terminalWidth()) {
       items.map((e) => ({
         ref: localEntryRef(e),
         description: e.description,
-        version: e.version ? `v${e.version}` : ""
+        version: e.version ? `v${e.version}` : "",
+        library: e.library
       })),
       width,
-      { ref: S.cmd, version: S.dim }
+      { ref: S.cmd, version: S.dim, library: S.dim }
     );
     console.log();
     console.log(
@@ -350,9 +361,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-4WUMQHES.js');
+  const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-P3D337NH.js');
   try {
-    const remote = await openCatalogSource2({ projectDir: path25__default.resolve(opts.projectDir) });
+    const remote = await openCatalogSource2({ projectDir: path23__default.resolve(opts.projectDir) });
     const assets = await remote.listAssets(kind ? { kind } : {});
     const results = filterCatalogAssets(assets, query);
     if (results.length > 0) {
@@ -363,7 +374,7 @@ async function searchStore(query, kind, opts, airGapped) {
       logInfo("No results in store");
     }
   } catch (e) {
-    const local = e instanceof LocalCatalogDisabledError;
+    const local = e instanceof LocalCatalogDisabledError2;
     if (opts.store) {
       logErr(
         local ? "remote catalog disabled (catalog.url: local) \u2014 set catalog.url: https://skaile.store to search the store" : `Store search failed: ${e.message}`
@@ -470,7 +481,7 @@ function makeAddCommand() {
     const warnings = deferredWarnings();
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir),
+      projectDir: path23__default.resolve(opts.projectDir),
       global: opts.global || harnesses !== void 0,
       harnesses,
       driverTarget: opts.target,
@@ -527,14 +538,15 @@ function makeRemoveCommand() {
     const harnesses = parseHarnessFilter(opts.harness);
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir),
+      projectDir: path23__default.resolve(opts.projectDir),
       global: opts.global || harnesses !== void 0,
       harnesses,
       driverTarget: opts.target
     });
     const ok = am2.remove(ref);
     if (!ok) {
-      logErr(`Not deployed: ${ref}`);
+      logErr(`Not deployed or declared: ${ref}`);
+      process.exitCode = 1;
       return;
     }
     logOk(`Removed ${ref}`);
@@ -570,7 +582,7 @@ function makeListCommand() {
     }
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir),
+      projectDir: path23__default.resolve(opts.projectDir),
       driverTarget: opts.target
     });
     let declared;
@@ -618,7 +630,7 @@ function makeListCommand() {
 function runGlobalList(kind, opts, harnesses) {
   const am2 = new AssetManager({
     registry: getKindRegistry(),
-    projectDir: path25__default.resolve(opts.projectDir),
+    projectDir: path23__default.resolve(opts.projectDir),
     global: true,
     harnesses
   });
@@ -691,7 +703,7 @@ async function resolveInfoEntry(am2, ref, opts) {
     return { entry: match ?? deployed };
   }
   const lookup = opts.storeLookup ?? (async (filter) => {
-    const { resolveCatalogSource } = await import('../open-library-4WUMQHES.js');
+    const { resolveCatalogSource } = await import('../open-library-P3D337NH.js');
     const { source, close } = await resolveCatalogSource({ projectDir: opts.projectDir });
     try {
       return await source.listAssets(filter);
@@ -707,9 +719,9 @@ async function resolveInfoEntry(am2, ref, opts) {
     );
     return { entry: hit ? catalogAssetToEntry(hit) : null };
   } catch (err2) {
-    const { LocalCatalogDisabledError } = await import('../open-library-4WUMQHES.js');
+    const { LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-P3D337NH.js');
     const storeNote = err2 instanceof Error ? err2.message : String(err2);
-    const disabled = err2 instanceof LocalCatalogDisabledError || /catalog\.url/i.test(storeNote);
+    const disabled = err2 instanceof LocalCatalogDisabledError2 || /catalog\.url/i.test(storeNote);
     return { entry: null, storeNote, ...disabled ? { storeDisabled: true } : {} };
   }
 }
@@ -723,7 +735,7 @@ function infoNotFoundHint(ref, lookup) {
 }
 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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const am2 = new AssetManager({ registry: getKindRegistry(), projectDir });
     const lookup = await resolveInfoEntry(am2, ref, { projectDir });
     const entry = lookup.entry;
@@ -756,10 +768,10 @@ function makeInfoCommand() {
 }
 function makeCreateCommand() {
   return new Command("create").description("Scaffold a new asset").argument("<name>", "Asset name").addOption(
-    new Option("-k, --kind <kind>", "Asset kind").default("skill").choices(getKindRegistry().getAllKinds())
+    new Option("-k, --kind <kind>", "Asset kind").default("skill").choices([...SCAFFOLD_KINDS])
   ).option("-d, --dir <dir>", "Target directory (default: cwd)").action((name, opts) => {
     const am2 = new AssetManager({ registry: getKindRegistry(), projectDir: process.cwd() });
-    const destDir = opts.dir ? path25__default.resolve(opts.dir) : process.cwd();
+    const destDir = opts.dir ? path23__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 {
@@ -772,21 +784,29 @@ 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({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir)
+      projectDir: path23__default.resolve(opts.projectDir)
     });
     const issues = await am2.doctor();
     if (issues.length === 0) {
       logOk("No missing dependencies.");
       return;
     }
-    const assetW = Math.max(5, ...issues.map((i) => `${i.assetKind}:${i.assetName}`.length));
-    const depW = Math.max(11, ...issues.map((i) => `${i.depKind}:${i.depName}`.length));
+    const unresolved = issues.filter((i) => i.unresolved);
+    const missing = issues.filter((i) => !i.unresolved);
+    for (const i of unresolved) {
+      logErr(
+        `${i.assetKind}:${i.assetName}: locked, but no source or library provides it \u2014 run skaile install`
+      );
+    }
+    if (missing.length === 0) return;
+    const assetW = Math.max(5, ...missing.map((i) => `${i.assetKind}:${i.assetName}`.length));
+    const depW = Math.max(11, ...missing.map((i) => `${i.depKind}:${i.depName}`.length));
     console.log();
     console.log(
       `  ${S.dim("ASSET".padEnd(assetW))}  ${S.dim("MISSING DEP".padEnd(depW))}  ${S.dim("IN REPOS")}`
     );
     console.log(`  ${S.rule(assetW + depW + 15)}`);
-    for (const i of issues) {
+    for (const i of missing) {
       const asset = `${i.assetKind}:${i.assetName}`;
       const dep = `${i.depKind}:${i.depName}`;
       const status4 = i.inRepos ? S.warn("fixable") : S.err("not found");
@@ -795,12 +815,37 @@ function makeDoctorCommand() {
     console.log();
   });
 }
-async function indexLibrary(lib, index) {
+function manifestRequiresProblems(dir) {
+  const file = path23.join(dir, "skaile.manifest.yaml");
+  let doc;
+  try {
+    doc = parse(fs9.readFileSync(file, "utf-8"));
+  } catch {
+    return [];
+  }
+  const assets = doc?.assets;
+  if (!Array.isArray(assets)) return [];
+  const problems = [];
+  for (const a of assets) {
+    if (!a || typeof a !== "object") continue;
+    const { kind, name, dependencies } = a;
+    if (!Array.isArray(dependencies)) continue;
+    const entries = dependencies.map((d) => typeof d === "string" ? d : String(d));
+    for (const message of requiresSyntaxErrors(entries)) {
+      problems.push({
+        asset: `${String(kind)}:${String(name)}`,
+        message: `ManifestRequiresError: ${message}`
+      });
+    }
+  }
+  return problems;
+}
+async function indexLibrary(lib, index, opts = {}) {
   const { LocalCatalogSource } = await import('../library/index.js');
   const own = index ?? await openLibrary();
   try {
     const source = new LocalCatalogSource(own, lib.id, lib.path, getKindRegistry());
-    const res = await source.sync();
+    const res = await source.sync({ exclude: opts.exclude });
     return {
       assetsFound: res.assetsFound,
       assetsUpdated: res.assetsUpdated,
@@ -823,31 +868,23 @@ function resolveLibraryPublisherDetailed(lib, opts, storeIdentity) {
     return { publisher: "library", source: "library-name" };
   }
 }
-function resolveLibraryPublisher(lib, opts, storeIdentity) {
-  return resolveLibraryPublisherDetailed(lib, opts, storeIdentity).publisher;
+function warnLibraryNameFallback(libName, resolved) {
+  if (resolved.source !== "library-name") return;
+  logWarn(
+    `No publisher given and not signed in \u2014 using the library name "${resolved.publisher}" as the publisher. Pass --publisher <name> or run \`skaile store login\`; change it later with \`skaile library set ${libName} publisher=<name>\`.`
+  );
 }
-function stampAssetPublisher(assetDir, publisher) {
-  const markers = ["SKILL.md", "AGENT.md", "CONTRACT.md"];
-  let markerFile;
-  for (const m of markers) {
-    if (fs11.existsSync(path25.join(assetDir, m))) {
-      markerFile = path25.join(assetDir, m);
-      break;
-    }
-  }
+function normalizeAssetFrontmatter(assetDir) {
+  let markerFile = ["SKILL.md", "AGENT.md", "CONTRACT.md"].map((m) => path23.join(assetDir, m)).find((f) => fs9.existsSync(f));
   if (!markerFile) {
-    const promptMd = fs11.readdirSync(assetDir).find((f) => f.endsWith(".prompt.md"));
-    if (promptMd) markerFile = path25.join(assetDir, promptMd);
+    const promptMd = fs9.readdirSync(assetDir).find((f) => f.endsWith(".prompt.md"));
+    if (promptMd) markerFile = path23.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 { data, body } = parseFrontmatter(fs9.readFileSync(markerFile, "utf8"));
     const fm = stringify(data).trimEnd();
-    fs11.writeFileSync(markerFile, `---
+    fs9.writeFileSync(markerFile, `---
 ${fm}
 ---
 
@@ -862,17 +899,13 @@ async function registerLibraryAsset(lib, index, input) {
     { 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);
+  warnLibraryNameFallback(lib.name, { publisher, source });
+  normalizeAssetFrontmatter(input.assetDir);
   stampManifestPublisher(lib.path, publisher);
   upsertManifestAsset(lib.path, {
     kind: input.kind,
     name: input.name,
-    root: path25.relative(lib.path, input.assetDir) || input.name,
+    root: path23.relative(lib.path, input.assetDir) || input.name,
     version: input.version,
     publisher
   });
@@ -882,19 +915,27 @@ async function registerLibraryAsset(lib, index, input) {
 }
 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 removedDomainOption() {
+  return new Option("--domain <domain>", "Removed in 5.0").hideHelp();
+}
+function rejectRemovedDomainOption(opts) {
+  if (opts.domain === void 0) return;
+  logErr(DOMAIN_REMOVED_HINT);
+  process.exit(1);
+}
 function countDomainFiles(root) {
   let count = 0;
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs11.readdirSync(dir, { withFileTypes: true });
+      entries = fs9.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
-          walk(path25.join(dir, entry.name));
+          walk(path23.join(dir, entry.name));
         }
       } else if (entry.name === "DOMAIN.md") {
         count++;
@@ -919,21 +960,21 @@ function claudeSkillRoots() {
   const roots = [];
   const override = process.env.SKAILE_CLAUDE_SKILLS_DIR;
   if (override) roots.push(override);
-  roots.push(path25.join(os.homedir(), ".claude", "skills"));
+  roots.push(path23.join(os.homedir(), ".claude", "skills"));
   return roots;
 }
 function resolveImportSource(nameOrPath) {
-  const asPath = path25.resolve(nameOrPath);
-  if (fs11.existsSync(asPath)) {
-    const dir = fs11.statSync(asPath).isDirectory() ? asPath : path25.dirname(asPath);
-    const skillFile = path25.join(dir, "SKILL.md");
-    if (fs11.existsSync(skillFile)) return { dir, skillFile, via: "path" };
+  const asPath = path23.resolve(nameOrPath);
+  if (fs9.existsSync(asPath)) {
+    const dir = fs9.statSync(asPath).isDirectory() ? asPath : path23.dirname(asPath);
+    const skillFile = path23.join(dir, "SKILL.md");
+    if (fs9.existsSync(skillFile)) return { dir, skillFile, via: "path" };
   }
-  if (!nameOrPath.includes(path25.sep) && !nameOrPath.startsWith(".")) {
+  if (!nameOrPath.includes(path23.sep) && !nameOrPath.startsWith(".")) {
     for (const root of claudeSkillRoots()) {
-      const dir = path25.join(root, nameOrPath);
-      const skillFile = path25.join(dir, "SKILL.md");
-      if (fs11.existsSync(skillFile)) return { dir, skillFile, via: "claude-skills" };
+      const dir = path23.join(root, nameOrPath);
+      const skillFile = path23.join(dir, "SKILL.md");
+      if (fs9.existsSync(skillFile)) return { dir, skillFile, via: "claude-skills" };
     }
   }
   return null;
@@ -989,15 +1030,16 @@ ${body}
 
 // cli/src/commands/asset-cmd.ts
 async function resolveDefByRef(library, ref, opts) {
-  const inScope = (d) => !opts?.fromLibraryId || d.libraryId === opts.fromLibraryId;
-  const direct = await library.getAssetDef(ref);
-  if (direct && inScope(direct)) return direct;
   let parsed;
   try {
     parsed = parseAssetRef(ref);
-  } catch {
-    return null;
+  } catch (err2) {
+    logErr(
+      `malformed asset ref '${ref}' \u2014 expected ${REF_HINT}: ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+    process.exit(1);
   }
+  const inScope = (d) => !opts?.fromLibraryId || d.libraryId === opts.fromLibraryId;
   const wantPublisher = parsed.publisher?.replace(/^@/, "");
   const defs = await library.listAssetDefs({ kind: parsed.kind });
   const matches = defs.filter(
@@ -1008,7 +1050,8 @@ async function resolveDefByRef(library, ref, opts) {
   return matches[0];
 }
 function withCanonicalRef(def) {
-  return { ref: catalogAssetRef(def), ...def };
+  const { id: _storageId, ...rest } = def;
+  return { ref: catalogAssetRef(def), ...rest };
 }
 function resolveLibraryOption(opts) {
   if (opts.library && opts.to && opts.library !== opts.to) {
@@ -1021,11 +1064,12 @@ function resolveLibraryOption(opts) {
 }
 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("--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(
+  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()).addOption(removedDomainOption()).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) => {
+      rejectRemovedDomainOption(opts);
       const src = resolveImportSource(nameOrPath);
       if (!src) {
         logErr(
@@ -1055,24 +1099,24 @@ function makeAssetCommand() {
           logErr(err2 instanceof Error ? err2.message : String(err2));
           process.exit(1);
         }
-        const rawSkill = fs11.readFileSync(src.skillFile, "utf8");
+        const rawSkill = fs9.readFileSync(src.skillFile, "utf8");
         const norm = opts.normalize ? normalizeSkillContent(rawSkill, {
-          fallbackName: path25.basename(src.dir),
+          fallbackName: path23.basename(src.dir),
           version: opts.version,
           stage: opts.stage
-        }) : { content: rawSkill, name: path25.basename(src.dir), changed: false, notes: [] };
+        }) : { content: rawSkill, name: path23.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 = path25.join(target.path, norm.name);
-        if (fs11.existsSync(destDir)) {
+        const destDir = path23.join(target.path, norm.name);
+        if (fs9.existsSync(destDir)) {
           logErr(`Destination already exists: ${destDir}`);
           process.exit(1);
         }
-        fs11.cpSync(src.dir, destDir, { recursive: true });
-        fs11.writeFileSync(path25.join(destDir, "SKILL.md"), norm.content, "utf8");
+        fs9.cpSync(src.dir, destDir, { recursive: true });
+        fs9.writeFileSync(path23.join(destDir, "SKILL.md"), norm.content, "utf8");
         for (const note of norm.notes) logInfo(`  \u2022 ${note}`);
         const fm = parseFrontmatter(norm.content).data;
         for (const f of checkAgentSkillConformance(fm, { dirName: norm.name })) {
@@ -1105,13 +1149,14 @@ function makeAssetCommand() {
       }
     }
   );
-  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(
+  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()).addOption(removedDomainOption()).option("--mode <mode>", "copy | move | link", "copy").option("--commit", "Auto-commit in git-backed libraries", false).action(
     async (srcPath, opts) => {
+      rejectRemovedDomainOption(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 (!fs9.existsSync(srcPath)) {
         logErr(`Source path does not exist: ${srcPath}`);
         process.exit(1);
       }
@@ -1137,23 +1182,23 @@ function makeAssetCommand() {
           );
           process.exit(1);
         }
-        const basename2 = path25.basename(srcPath);
+        const basename2 = path23.basename(srcPath);
         const destDir = target.path;
-        fs11.mkdirSync(destDir, { recursive: true });
-        const destPath = path25.join(destDir, basename2);
-        if (fs11.existsSync(destPath)) {
+        fs9.mkdirSync(destDir, { recursive: true });
+        const destPath = path23.join(destDir, basename2);
+        if (fs9.existsSync(destPath)) {
           logErr(`Destination already exists: ${destPath}`);
           process.exit(1);
         }
         switch (opts.mode) {
           case "copy":
-            fs11.cpSync(srcPath, destPath, { recursive: true });
+            fs9.cpSync(srcPath, destPath, { recursive: true });
             break;
           case "move":
-            fs11.renameSync(srcPath, destPath);
+            fs9.renameSync(srcPath, destPath);
             break;
           case "link":
-            fs11.symlinkSync(path25.resolve(srcPath), destPath);
+            fs9.symlinkSync(path23.resolve(srcPath), destPath);
             break;
         }
         if (target.backend === "git" && opts.commit) {
@@ -1283,14 +1328,14 @@ function makeAuthCommand() {
 }
 function collectCacheTargets(scope) {
   const out = [];
-  out.push(path25__default.join(scope.projectDir, ".skaile", "cache"));
-  out.push(path25__default.join(scope.projectDir, ".skaile", "store-cache"));
-  out.push(path25__default.join(scope.projectDir, ".skaile", "repos"));
+  out.push(path23__default.join(scope.projectDir, ".skaile", "cache"));
+  out.push(path23__default.join(scope.projectDir, ".skaile", "store-cache"));
+  out.push(path23__default.join(scope.projectDir, ".skaile", "repos"));
   if (scope.global) {
     out.push(globalCacheRoot());
     const home = globalSkaileDir();
-    out.push(path25__default.join(home, "repos"));
-    out.push(path25__default.join(home, "catalog-cache"));
+    out.push(path23__default.join(home, "repos"));
+    out.push(path23__default.join(home, "catalog-cache"));
   }
   return out;
 }
@@ -1304,7 +1349,7 @@ function dirSize(target) {
 function dirSizeOfDir(dir) {
   let total = 0;
   for (const ent of readdirSync(dir, { withFileTypes: true })) {
-    const child = path25__default.join(dir, ent.name);
+    const child = path23__default.join(dir, ent.name);
     if (ent.isSymbolicLink()) continue;
     if (ent.isDirectory()) total += dirSizeOfDir(child);
     else if (ent.isFile()) total += statSync(child).size;
@@ -1330,7 +1375,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: path25__default.resolve(opts.projectDir),
+      projectDir: path23__default.resolve(opts.projectDir),
       global: opts.global
     }).filter((t) => existsSync(t));
     if (targets.length === 0) {
@@ -1360,12 +1405,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(path25__default.join(path25__default.resolve(opts.projectDir), ".skaile", "cache"));
+    console.log(path23__default.join(path23__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: path25__default.resolve(opts.projectDir),
+      projectDir: path23__default.resolve(opts.projectDir),
       global: opts.global
     });
     console.log();
@@ -1381,7 +1426,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 ? path25__default.resolve(opts.projectDir) : void 0;
+    const projectDir = opts.projectDir ? path23__default.resolve(opts.projectDir) : void 0;
     const cfg = resolveConfig({ projectDir });
     const baseUrl = opts.url ?? cfg.catalog.url;
     if (isLocalCatalogUrl(baseUrl)) {
@@ -1399,7 +1444,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 ? path25__default.resolve(opts.projectDir) : void 0;
+    const projectDir = opts.projectDir ? path23__default.resolve(opts.projectDir) : void 0;
     const cfg = resolveConfig({ projectDir });
     console.log(`url: ${cfg.catalog.url}`);
     console.log(`framing: ${cfg.catalog.framing}`);
@@ -1408,7 +1453,7 @@ function makeCatalogCommand() {
   return catalog;
 }
 async function runLocalCatalogTest(projectDir) {
-  const { resolveCatalogSource } = await import('../open-library-4WUMQHES.js');
+  const { resolveCatalogSource } = await import('../open-library-P3D337NH.js');
   let resolved;
   try {
     resolved = await resolveCatalogSource({ projectDir });
@@ -1552,8 +1597,8 @@ async function scanLibraryFlowEntries() {
     const indexPath = resolveIndexPath();
     if (!existsSync(indexPath)) return entries;
     const [{ authoringLibraries }, { getKindRegistry: getKindRegistry2 }] = await Promise.all([
-      import('../open-library-4WUMQHES.js'),
-      import('../open-registry-NVPCQPND.js')
+      import('../open-library-P3D337NH.js'),
+      import('../open-registry-Z3P2X2AB.js')
     ]);
     const index = new LocalIndex({ indexPath });
     try {
@@ -1610,11 +1655,11 @@ function findSkills() {
   return deduped;
 }
 function walkSkills(dir, out) {
-  for (const entry of fs11__default.readdirSync(dir, { withFileTypes: true })) {
-    const full = path25__default.join(dir, entry.name);
+  for (const entry of fs9__default.readdirSync(dir, { withFileTypes: true })) {
+    const full = path23__default.join(dir, entry.name);
     if (entry.isDirectory()) {
-      const skillMd = path25__default.join(full, "SKILL.md");
-      if (fs11__default.existsSync(skillMd)) {
+      const skillMd = path23__default.join(full, "SKILL.md");
+      if (fs9__default.existsSync(skillMd)) {
         out.push({ name: entry.name, path: full, skillPath: skillMd });
       } else {
         walkSkills(full, out);
@@ -1635,10 +1680,10 @@ function resolveFlowIds() {
   }
 }
 function resolveSessionIds(projectDir) {
-  const sessionsDir = path25__default.join(projectDir, ".skaile", "sessions");
-  if (!fs11__default.existsSync(sessionsDir)) return [];
+  const sessionsDir = path23__default.join(projectDir, ".skaile", "sessions");
+  if (!fs9__default.existsSync(sessionsDir)) return [];
   try {
-    return fs11__default.readdirSync(sessionsDir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
+    return fs9__default.readdirSync(sessionsDir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
   } catch {
     return [];
   }
@@ -1777,7 +1822,7 @@ function printResolvedPathsSection(config) {
   console.log(`  ${S.label("prompts:".padEnd(16))} ${config.promptsDir ?? paths.promptsDir}`);
 }
 async function showConfig(opts) {
-  const projectDir = opts.projectDir ? path25__default.resolve(opts.projectDir) : process.cwd();
+  const projectDir = opts.projectDir ? path23__default.resolve(opts.projectDir) : process.cwd();
   let config;
   let wsDefaults;
   try {
@@ -1822,13 +1867,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 ? path25__default.resolve(opts.projectDir) : process.cwd();
+    const projectDir = opts.projectDir ? path23__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 ? path25__default.resolve(opts.projectDir) : process.cwd();
+    const projectDir = opts.projectDir ? path23__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.
@@ -2168,8 +2213,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 = path25__default.resolve(opts.projectDir);
-      const yamlPath = path25__default.join(projectDir, "skaile.yaml");
+      const projectDir = path23__default.resolve(opts.projectDir);
+      const yamlPath = path23__default.join(projectDir, "skaile.yaml");
       if (!existsSync(yamlPath)) {
         logErr("No skaile.yaml found in current directory. Run 'skaile init' first.");
         process.exit(1);
@@ -2229,8 +2274,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 = path25__default.resolve(opts.projectDir);
-    const yamlPath = path25__default.join(projectDir, "skaile.yaml");
+    const projectDir = path23__default.resolve(opts.projectDir);
+    const yamlPath = path23__default.join(projectDir, "skaile.yaml");
     if (!existsSync(yamlPath)) {
       logErr("No skaile.yaml found in current directory.");
       process.exit(1);
@@ -2247,7 +2292,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const declarations = res.loadConnectorDeclarations(projectDir);
     if (declarations.length === 0) {
       console.log("No connectors configured in skaile.yaml.");
@@ -2271,7 +2316,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       console.log(JSON.stringify(manager.listConnectors(), null, 2));
@@ -2280,7 +2325,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       if (opts.all) {
@@ -2304,7 +2349,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       if (!manager.has(id)) {
@@ -2319,7 +2364,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const content = await manager.read(id, resourcePath);
@@ -2329,7 +2374,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       await manager.write(id, resourcePath, { data: content });
@@ -2339,7 +2384,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const entries = await manager.list(id, resourcePath, {
@@ -2352,7 +2397,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const results = await manager.search(id, query);
@@ -2362,7 +2407,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const ok = await manager.delete(id, resourcePath);
@@ -2372,7 +2417,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       if (!manager.has(id)) {
@@ -2481,7 +2526,7 @@ function envRecord() {
 async function buildDeployContext(projectDir) {
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const config = resolveSkWorkspaceConfig2(projectDir);
-  const workspaceId = config.name ?? path25__default.basename(projectDir);
+  const workspaceId = config.name ?? path23__default.basename(projectDir);
   let log;
   try {
     const { createLogger } = await import('../core/logging.js');
@@ -2513,13 +2558,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-66QFBNEO.js');
+    const { ensurePluginsLoaded } = await import('../plugin-store-WI4MZJLP.js');
     const result = await ensurePluginsLoaded(projectDir, config.plugins, pluginRegistry);
     for (const f of result.failed) logWarn(f.error);
   }
 }
 async function runUp(opts) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   await ensureTargetsRegistered(projectDir);
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const { resolveDeployTarget, pluginRegistry } = await import('../plugin-registry/index.js');
@@ -2587,7 +2632,7 @@ async function restoreFromHandle(projectDir) {
   return { target, handle, ctx };
 }
 async function runDown(opts) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   const restored = await restoreFromHandle(projectDir);
   if (!restored) return;
   await restored.handle.stop();
@@ -2596,7 +2641,7 @@ async function runDown(opts) {
   logOk(`Stopped ${S.cmd(restored.target.id)} and cleared the handle.`);
 }
 async function runStatus(opts) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   const restored = await restoreFromHandle(projectDir);
   if (!restored) return;
   const health = await restored.handle.health();
@@ -2610,7 +2655,7 @@ async function runStatus(opts) {
   console.log();
 }
 async function runLogs(opts) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   const restored = await restoreFromHandle(projectDir);
   if (!restored) return;
   if (!restored.handle.logs) {
@@ -2636,7 +2681,7 @@ 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({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir)
+      projectDir: path23__default.resolve(opts.projectDir)
     });
     const result = await am2.diff(ref);
     switch (result.status) {
@@ -2659,7 +2704,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(path25__default.resolve(opts.projectDir));
+    const flows = await discoverFlowsWithLibraries(path23__default.resolve(opts.projectDir));
     if (flows.length === 0) {
       logInfo("No flows found.");
       return;
@@ -2674,7 +2719,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(path25__default.resolve(opts.projectDir));
+    const flows = await discoverFlowsWithLibraries(path23__default.resolve(opts.projectDir));
     const flow = flows.find((f) => f.id === id);
     if (!flow) {
       logErr(`Flow not found: ${id}`);
@@ -2708,7 +2753,7 @@ function makeHistoryCommand() {
   cmd.argument("[limit]", "Number of entries to show", "20").option("--project-dir <path>", "Project directory", process.cwd()).action((limitStr, opts) => {
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir)
+      projectDir: path23__default.resolve(opts.projectDir)
     });
     const limit = parseInt(limitStr, 10) || 20;
     const entries = am2.history(limit);
@@ -2731,7 +2776,7 @@ function makeHistoryCommand() {
   cmd.command("clear").description("Clear action history").option("--project-dir <path>", "Project directory", process.cwd()).action((opts) => {
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir)
+      projectDir: path23__default.resolve(opts.projectDir)
     });
     am2.clearHistory();
     logOk("History cleared.");
@@ -2745,7 +2790,7 @@ var MCP_SERVER_ENTRY = {
   env: {}
 };
 function pluginDir(projectDir) {
-  return path25__default.join(projectDir, ".claude", "plugins", "skaile");
+  return path23__default.join(projectDir, ".claude", "plugins", "skaile");
 }
 async function readJsonStrict(p6) {
   let raw;
@@ -2763,7 +2808,7 @@ async function readJsonStrict(p6) {
   }
 }
 async function writeJson(p6, value) {
-  await fs6.mkdir(path25__default.dirname(p6), { recursive: true });
+  await fs6.mkdir(path23__default.dirname(p6), { recursive: true });
   await fs6.writeFile(p6, `${JSON.stringify(value, null, 2)}
 `);
 }
@@ -2771,8 +2816,8 @@ async function copyDir(src, dest) {
   await fs6.mkdir(dest, { recursive: true });
   const entries = await fs6.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path25__default.join(src, entry.name);
-    const destPath = path25__default.join(dest, entry.name);
+    const srcPath = path23__default.join(src, entry.name);
+    const destPath = path23__default.join(dest, entry.name);
     if (entry.isDirectory()) await copyDir(srcPath, destPath);
     else await fs6.copyFile(srcPath, destPath);
   }
@@ -2781,14 +2826,14 @@ async function install(projectDir, opts) {
   return opts?.full ? installFullPlugin(projectDir) : installMcp(projectDir);
 }
 async function installMcp(projectDir) {
-  const mcpPath = path25__default.join(projectDir, ".claude", "mcp.json");
+  const mcpPath = path23__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 ${path25__default.relative(projectDir, mcpPath)}`;
+    warning = `overwrote existing ${SKAILE_MCP_NAME} entry in ${path23__default.relative(projectDir, mcpPath)}`;
   }
   mcpServers[SKAILE_MCP_NAME] = MCP_SERVER_ENTRY;
   await writeJson(mcpPath, { ...existing, mcpServers });
@@ -2797,15 +2842,15 @@ async function installMcp(projectDir) {
 async function installFullPlugin(projectDir) {
   const dir = pluginDir(projectDir);
   for (const [rel, content] of Object.entries(buildClaudePluginFiles())) {
-    const dest = path25__default.join(dir, rel);
-    await fs6.mkdir(path25__default.dirname(dest), { recursive: true });
+    const dest = path23__default.join(dir, rel);
+    await fs6.mkdir(path23__default.dirname(dest), { recursive: true });
     await fs6.writeFile(dest, content);
   }
-  const projectSkillsDir = path25__default.join(projectDir, ".skaile", "skills");
+  const projectSkillsDir = path23__default.join(projectDir, ".skaile", "skills");
   if (existsSync(projectSkillsDir)) {
-    await copyDir(projectSkillsDir, path25__default.join(dir, "skills"));
+    await copyDir(projectSkillsDir, path23__default.join(dir, "skills"));
   }
-  const settingsPath = path25__default.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path23__default.join(projectDir, ".claude", "settings.json");
   const settings = await readJsonStrict(settingsPath) ?? {};
   const plugins = settings.plugins ?? [];
   if (!plugins.includes(dir)) plugins.push(dir);
@@ -2813,8 +2858,8 @@ async function installFullPlugin(projectDir) {
   return { changed: true, method: "plugin" };
 }
 async function uninstall(projectDir) {
-  const settingsPath = path25__default.join(projectDir, ".claude", "settings.json");
-  const mcpPath = path25__default.join(projectDir, ".claude", "mcp.json");
+  const settingsPath = path23__default.join(projectDir, ".claude", "settings.json");
+  const mcpPath = path23__default.join(projectDir, ".claude", "mcp.json");
   const dir = pluginDir(projectDir);
   let changed = false;
   const settings = await readJsonStrict(settingsPath);
@@ -2848,12 +2893,12 @@ async function uninstall(projectDir) {
 async function detectInstall(projectDir) {
   const dir = pluginDir(projectDir);
   const settings = await readJsonStrict(
-    path25__default.join(projectDir, ".claude", "settings.json")
+    path23__default.join(projectDir, ".claude", "settings.json")
   );
-  if (existsSync(path25__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir)) {
+  if (existsSync(path23__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir)) {
     return { method: "plugin", pluginPath: dir };
   }
-  const mcp = await readJsonStrict(path25__default.join(projectDir, ".claude", "mcp.json"));
+  const mcp = await readJsonStrict(path23__default.join(projectDir, ".claude", "mcp.json"));
   if (mcp?.mcpServers && SKAILE_MCP_NAME in mcp.mcpServers) {
     return { method: "mcp" };
   }
@@ -2862,7 +2907,7 @@ 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 = path25__default.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path23__default.join(projectDir, ".claude", "settings.json");
   const settings = await readJsonStrict(settingsPath) ?? {};
   if (detected.method === "plugin") {
     const disabled2 = settings.disabledPlugins ?? [];
@@ -2884,7 +2929,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 = path25__default.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path23__default.join(projectDir, ".claude", "settings.json");
   const settings = await readJsonStrict(settingsPath) ?? {};
   if (detected.method === "plugin") {
     const list2 = settings.disabledPlugins ?? [];
@@ -2904,12 +2949,12 @@ async function disable(projectDir) {
   return { changed: true };
 }
 async function status(projectDir) {
-  const settingsPath = path25__default.join(projectDir, ".claude", "settings.json");
-  const mcpPath = path25__default.join(projectDir, ".claude", "mcp.json");
+  const settingsPath = path23__default.join(projectDir, ".claude", "settings.json");
+  const mcpPath = path23__default.join(projectDir, ".claude", "mcp.json");
   const dir = pluginDir(projectDir);
   const settings = await readJsonStrict(settingsPath);
   const mcp = await readJsonStrict(mcpPath);
-  const pluginInstalled = !!(existsSync(path25__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir));
+  const pluginInstalled = !!(existsSync(path23__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 {
@@ -2927,7 +2972,7 @@ async function status(projectDir) {
       installed: "yes",
       enabled: disabled2 ? "no" : "yes",
       method: "plugin",
-      location: path25__default.relative(projectDir, dir)
+      location: path23__default.relative(projectDir, dir)
     };
   }
   const disabled = settings?.disabledMcpjsonServers?.includes(SKAILE_MCP_NAME) ?? false;
@@ -2936,7 +2981,7 @@ async function status(projectDir) {
     installed: "yes",
     enabled: disabled ? "no" : "yes",
     method: "mcp",
-    location: path25__default.relative(projectDir, mcpPath)
+    location: path23__default.relative(projectDir, mcpPath)
   };
 }
 var SKAILE_MCP_NAME2 = "skaile-workspace";
@@ -2963,7 +3008,7 @@ async function readConfig(p6) {
   }
 }
 async function writeConfig(p6, value) {
-  await fs6.mkdir(path25__default.dirname(p6), { recursive: true });
+  await fs6.mkdir(path23__default.dirname(p6), { recursive: true });
   const cleaned = {};
   for (const [k, v] of Object.entries(value)) {
     if (v === void 0) continue;
@@ -2972,7 +3017,7 @@ async function writeConfig(p6, value) {
   await fs6.writeFile(p6, stringify$1(cleaned));
 }
 function configPath(projectDir) {
-  return path25__default.join(projectDir, ".codex", "config.toml");
+  return path23__default.join(projectDir, ".codex", "config.toml");
 }
 async function install2(projectDir) {
   const p6 = configPath(projectDir);
@@ -2983,7 +3028,7 @@ async function install2(projectDir) {
   const matches = previous && JSON.stringify(previous) === JSON.stringify(next);
   let warning;
   if (previous && !matches) {
-    warning = `overwrote existing ${SKAILE_MCP_NAME2} entry in ${path25__default.relative(projectDir, p6)}`;
+    warning = `overwrote existing ${SKAILE_MCP_NAME2} entry in ${path23__default.relative(projectDir, p6)}`;
   }
   if (matches) return { changed: false, method: "toml" };
   servers[SKAILE_MCP_NAME2] = next;
@@ -3024,12 +3069,12 @@ async function status2(projectDir) {
     installed: "yes",
     enabled: "n/a",
     method: "mcp",
-    location: path25__default.relative(projectDir, p6)
+    location: path23__default.relative(projectDir, p6)
   };
 }
 async function install3(projectDir) {
-  const extDir = path25__default.join(projectDir, ".omp", "extensions");
-  const extPath = path25__default.join(extDir, "skaile.ts");
+  const extDir = path23__default.join(projectDir, ".omp", "extensions");
+  const extPath = path23__default.join(extDir, "skaile.ts");
   await fs6.mkdir(extDir, { recursive: true });
   const { WorkspacePlugin } = await import('../workspace-plugin/index.js');
   const plugin = new WorkspacePlugin({ projectDir });
@@ -3044,7 +3089,7 @@ async function install3(projectDir) {
   return { changed: true, method: "generated" };
 }
 async function uninstall3(projectDir) {
-  const extPath = path25__default.join(projectDir, ".omp", "extensions", "skaile.ts");
+  const extPath = path23__default.join(projectDir, ".omp", "extensions", "skaile.ts");
   try {
     await fs6.unlink(extPath);
     return { changed: true };
@@ -3053,14 +3098,14 @@ async function uninstall3(projectDir) {
   }
 }
 async function status3(projectDir) {
-  const extPath = path25__default.join(projectDir, ".omp", "extensions", "skaile.ts");
+  const extPath = path23__default.join(projectDir, ".omp", "extensions", "skaile.ts");
   if (existsSync(extPath)) {
     return {
       harness: "omp",
       installed: "yes",
       enabled: "n/a",
       method: "extension",
-      location: path25__default.relative(projectDir, extPath)
+      location: path23__default.relative(projectDir, extPath)
     };
   }
   return {
@@ -3123,7 +3168,7 @@ async function installCodex(projectDir) {
   console.log(`  ${S.dim("\u2192")} Restart Codex CLI to pick up the change.`);
 }
 async function runInstall(opts) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   const targets = resolveDriver(opts.driver);
   let exitCode = 0;
   if (targets.includes("claude-code")) {
@@ -3157,7 +3202,7 @@ async function uninstallCodex(projectDir) {
   else logInfo(`codex: not installed`);
 }
 async function runUninstall(opts) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   const targets = resolveDriver(opts.driver);
   let exitCode = 0;
   if (targets.includes("claude-code")) {
@@ -3200,7 +3245,7 @@ async function toggleTarget(t, projectDir, action3) {
   });
 }
 async function runToggle(opts, action3) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   const requestedAll = opts.driver === "all";
   const targets = resolveDriver(opts.driver);
   const usageError = checkToggleSupported(targets, requestedAll, action3);
@@ -3212,7 +3257,7 @@ async function runToggle(opts, action3) {
   return exitCode;
 }
 async function runStatus2(opts) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   const targets = resolveDriver(opts.driver);
   const rows = [];
   let exitCode = 0;
@@ -3283,7 +3328,7 @@ async function runHook(event) {
     await plugin.shutdown();
     return;
   }
-  const store = new PluginStore(path25__default.join(projectDir, ".skaile", "plugin-state.json"));
+  const store = new PluginStore(path23__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) {
@@ -3347,6 +3392,25 @@ function exitOnSyncError(err2) {
   logErr(err2 instanceof Error ? err2.message : String(err2));
   process.exit(1);
 }
+var UNFINISHED_GIT_ENTRIES = {
+  MERGE_HEAD: "a merge in progress",
+  REBASE_HEAD: "a rebase in progress",
+  "rebase-merge": "a rebase in progress",
+  "rebase-apply": "a rebase in progress",
+  CHERRY_PICK_HEAD: "a cherry-pick in progress",
+  REVERT_HEAD: "a revert in progress"
+};
+function unfinishedGitState(dir) {
+  const unmerged = spawnSync("git", ["ls-files", "-u"], { cwd: dir, encoding: "utf-8" });
+  if (unmerged.status !== 0) return "the git index could not be read";
+  if (unmerged.stdout.trim() !== "") return "unmerged files";
+  for (const [entry, state2] of Object.entries(UNFINISHED_GIT_ENTRIES)) {
+    const p6 = spawnSync("git", ["rev-parse", "--git-path", entry], { cwd: dir, encoding: "utf-8" });
+    if (p6.status !== 0) return "the git directory could not be read";
+    if (fs9.existsSync(path23.resolve(dir, p6.stdout.trim()))) return state2;
+  }
+  return null;
+}
 function assertManifestEditableOrExit(libraryPath) {
   try {
     assertManifestEditable(libraryPath);
@@ -3356,18 +3420,18 @@ function assertManifestEditableOrExit(libraryPath) {
 }
 async function assertLibraryPathFree(manager, dir, exceptId) {
   const clash = (await manager.listLibraries()).find(
-    (l) => l.id !== exceptId && path25.resolve(l.path) === dir
+    (l) => l.id !== exceptId && path23.resolve(l.path) === dir
   );
   if (clash) throw new Error(`${dir} is already registered as library "${clash.name}".`);
 }
 function canonicalDir(dir) {
-  const abs = path25.resolve(dir);
-  return fs11.existsSync(abs) ? fs11.realpathSync(abs) : abs;
+  const abs = path23.resolve(dir);
+  return fs9.existsSync(abs) ? fs9.realpathSync(abs) : abs;
 }
 function refuseGlobalInstallFolder(name, dir) {
   const reserved = globalInstallDir();
-  const rel = path25.relative(canonicalDir(reserved), canonicalDir(dir));
-  const inside = rel === "" || !rel.startsWith("..") && !path25.isAbsolute(rel);
+  const rel = path23.relative(canonicalDir(reserved), canonicalDir(dir));
+  const inside = rel === "" || !rel.startsWith("..") && !path23.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.`
@@ -3388,10 +3452,35 @@ function readOriginTracking(dir) {
 }
 function requireGitBackend(lib, verb) {
   if (lib.backend !== "git") {
-    logErr(`\`library ${verb}\` only applies to git-backed libraries.`);
+    logErr(
+      `\`library ${verb}\` only applies to git-backed libraries. Run \`skaile library link ${lib.name} <url>\` to attach a remote first.`
+    );
     process.exit(1);
   }
 }
+function requireValidLibraryName(name) {
+  try {
+    assertValidLibraryName(name);
+  } catch (err2) {
+    exitOnSyncError(err2);
+  }
+}
+var LOCAL_OWNERSHIP_REASON = "ownership only governs sync with a git remote, and a local library is always owned by you.";
+function pruneEmptyLibraryParents(libPath) {
+  const root = canonicalDir(resolveLibraryDir());
+  let dir = path23.dirname(path23.resolve(libPath));
+  for (; ; ) {
+    const rel = path23.relative(root, canonicalDir(dir));
+    if (rel === "" || rel.startsWith("..") || path23.isAbsolute(rel)) return;
+    if (!fs9.existsSync(dir) || fs9.readdirSync(dir).length > 0) return;
+    fs9.rmdirSync(dir);
+    dir = path23.dirname(dir);
+  }
+}
+async function warnIfNotGithubRemote(name, url) {
+  const { isGithubRemote, notGithubRemoteMessage } = await import('../library-publish-FGXF5TJO.js');
+  if (!isGithubRemote(url)) logWarn(notGithubRemoteMessage(name, url));
+}
 function scaffoldLibraryFiles(dir, name) {
   const readme = `# ${name}
 
@@ -3421,9 +3510,9 @@ by the same ref.
   ];
   const written = [];
   for (const [file, content] of files) {
-    const target = path25.join(dir, file);
-    if (fs11.existsSync(target)) continue;
-    fs11.writeFileSync(target, content, "utf8");
+    const target = path23.join(dir, file);
+    if (fs9.existsSync(target)) continue;
+    fs9.writeFileSync(target, content, "utf8");
     written.push(file);
   }
   return written;
@@ -3486,22 +3575,23 @@ function makeLibraryCommand() {
   });
   cmd.command("init <name>").description("Create (or adopt) a library \u2014 default location ~/.skaile/libraries/<name>").option("--git <url>", "Initialize as a git library tracking <url>").option("--path <dir>", "Register the library at <dir> (created if missing) instead").option("--owner", "Mark as owner (the default)").option("--contributor", "Mark as contributor (needs --git or an existing git clone)").option("--reader", "Mark as reader (needs --git or an existing git clone)").action(
     async (name, opts) => {
+      requireValidLibraryName(name);
       const flagged = ["owner", "contributor", "reader"].filter((o) => opts[o]);
       if (flagged.length > 1) {
         logErr("Pick one of --owner, --contributor, --reader.");
         process.exit(1);
       }
       const ownership = flagged[0] ?? "owner";
-      const libPath = opts.path ? path25.resolve(opts.path) : path25.join(resolveLibraryDir(), name);
+      const libPath = opts.path ? path23.resolve(opts.path) : path23.join(resolveLibraryDir(), name);
       refuseGlobalInstallFolder(name, libPath);
-      if (fs11.existsSync(libPath) && !fs11.statSync(libPath).isDirectory()) {
+      if (fs9.existsSync(libPath) && !fs9.statSync(libPath).isDirectory()) {
         logErr(`${libPath} exists and is not a directory.`);
         process.exit(1);
       }
       const adopted = opts.git ? null : readOriginTracking(libPath);
       if (ownership !== "owner" && !opts.git && !adopted) {
         logErr(
-          `--${ownership} needs --git <url> or an existing git clone: ownership only governs sync with a git remote, and a local library is always owned by you.`
+          `--${ownership} needs --git <url> or an existing git clone: ${LOCAL_OWNERSHIP_REASON}`
         );
         process.exit(1);
       }
@@ -3522,15 +3612,17 @@ function makeLibraryCommand() {
               `Could not clone ${opts.git}; initialised an empty repo with that origin instead. git said: ${reason}`
             );
           }
+          await warnIfNotGithubRemote(name, opts.git);
+          trackOriginBranch(libPath, branch);
           backend = "git";
           backendConfig = { url: opts.git, branch, authHint: "ssh" };
         } else if (adopted) {
           backend = "git";
           backendConfig = { url: adopted.url, branch: adopted.branch, authHint: "ssh" };
         } else {
-          fs11.mkdirSync(libPath, { recursive: true });
+          fs9.mkdirSync(libPath, { recursive: true });
         }
-        const blank = fs11.readdirSync(libPath).every((entry) => entry === ".git");
+        const blank = fs9.readdirSync(libPath).every((entry) => entry === ".git");
         const isDefault = !hasDefault && ownership !== "reader";
         await manager.addLibrary({
           name,
@@ -3557,6 +3649,13 @@ function makeLibraryCommand() {
         }
         if (!blank) {
           const lib = await manager.requireLibrary(name);
+          const resolved = resolveLibraryPublisherDetailed(lib, {}, getStoreIdentity());
+          if (resolved.source === "manifest" && !isValidPublisher(resolved.publisher)) {
+            logWarn(
+              `${SKAILE_MANIFEST_FILENAME} declares publisher "${resolved.publisher}": ${PUBLISHER_HINT}. Fix it with \`skaile library set ${name} publisher=<name>\`.`
+            );
+          }
+          warnLibraryNameFallback(name, resolved);
           const res = await indexLibrary(lib, library);
           for (const e of res.errors) logWarn(e);
           logOk(`Indexed ${res.assetsUpdated} asset(s) from ${name}.`);
@@ -3580,29 +3679,42 @@ function makeLibraryCommand() {
         process.exit(1);
       }
       ensureGitRepo(lib.path, url, opts.branch);
+      trackOriginBranch(lib.path, opts.branch, { fetch: true });
       await manager.updateLibrary(name, {
         backend: "git",
         backendConfig: { url, branch: opts.branch, authHint: "ssh" }
       });
       logOk(`Library "${name}" linked to ${url}.`);
+      await warnIfNotGithubRemote(name, url);
     } catch (err2) {
       exitOnSyncError(err2);
     } finally {
       close();
     }
   });
-  cmd.command("create <kind> <name>").description("Scaffold a new asset inside the default (or named) library").addOption(
-    new Option("--kind <kind>", "Asset kind override").choices(getKindRegistry().getAllKinds())
-  ).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(
+  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([...SCAFFOLD_KINDS])).addOption(removedDomainOption()).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 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) => {
-      const registeredKinds = getKindRegistry().getAllKinds();
-      if (!registeredKinds.includes(kind)) {
-        logErr(`Unknown asset kind "${kind}". Expected: ${registeredKinds.join(", ")}.`);
+      rejectRemovedDomainOption(opts);
+      for (const k of [kind, opts.kind]) {
+        if (k !== void 0 && !SCAFFOLD_KINDS.includes(k)) {
+          logErr(`Cannot scaffold kind "${k}". Expected: ${SCAFFOLD_KINDS.join(", ")}.`);
+          process.exit(1);
+        }
+      }
+      if (!isValidAssetName(name)) {
+        logErr(`Invalid asset name "${name}": ${ASSET_NAME_HINT}.`);
         process.exit(1);
       }
+      if (opts.publisher !== void 0) {
+        const bare = opts.publisher.trim().replace(/^@/, "");
+        if (!isValidPublisher(bare)) {
+          logErr(`Invalid publisher "${opts.publisher}": ${PUBLISHER_HINT}.`);
+          process.exit(1);
+        }
+      }
       if (opts.description !== void 0) {
         const len = opts.description.trim().length;
         if (len === 0 || len > 1024) {
@@ -3616,7 +3728,13 @@ function makeLibraryCommand() {
         assertManifestEditableOrExit(target.path);
         const effectiveKind = opts.kind ?? kind;
         const am2 = new AssetManager({ registry: getKindRegistry(), projectDir: process.cwd() });
-        const destDir = opts.dir ? path25.join(target.path, opts.dir) : target.path;
+        const libRoot = path23.resolve(target.path);
+        const destDir = opts.dir ? path23.resolve(libRoot, opts.dir) : libRoot;
+        const relDest = path23.relative(libRoot, destDir);
+        if (relDest === ".." || relDest.startsWith(`..${path23.sep}`) || path23.isAbsolute(relDest)) {
+          logErr(`--dir "${opts.dir}" must stay inside the library (${libRoot}).`);
+          process.exit(1);
+        }
         const res = am2.create(name, effectiveKind, destDir, { description: opts.description });
         if (!res.ok) {
           logErr(res.path);
@@ -3661,38 +3779,48 @@ function makeLibraryCommand() {
       close();
     }
   });
+  async function renameLibrary(manager, lib, newName) {
+    requireValidLibraryName(newName);
+    if (await manager.getLibrary(newName)) {
+      logErr(`A library named "${newName}" is already registered.`);
+      process.exit(1);
+    }
+    const newPath = path23.join(path23.dirname(lib.path), newName);
+    refuseGlobalInstallFolder(newName, newPath);
+    if (fs9.existsSync(newPath)) {
+      logErr(`Target directory already exists: ${newPath}`);
+      process.exit(1);
+    }
+    fs9.renameSync(lib.path, newPath);
+    await manager.updateLibrary(lib.id, { name: newName, path: newPath });
+    logOk(`Renamed ${lib.name} \u2192 ${newName}`);
+  }
   cmd.command("rename <old> <new>").description("Rename a library (also moves the directory)").action(async (oldName, newName) => {
     const { manager, close } = await openLibraryManager();
     try {
-      const lib = await manager.requireLibrary(oldName);
-      const parent = path25.dirname(lib.path);
-      const newPath = path25.join(parent, newName);
-      refuseGlobalInstallFolder(newName, newPath);
-      if (fs11.existsSync(newPath)) {
-        logErr(`Target directory already exists: ${newPath}`);
-        process.exit(1);
-      }
-      fs11.renameSync(lib.path, newPath);
-      await manager.updateLibrary(lib.id, { name: newName, path: newPath });
-      logOk(`Renamed ${oldName} \u2192 ${newName}`);
+      await renameLibrary(manager, await manager.requireLibrary(oldName), newName);
+    } catch (err2) {
+      exitOnSyncError(err2);
     } finally {
       close();
     }
   });
   cmd.command("set <name> <field=value>").description(
-    "Update a single library field (ownership, isDefault, path, publisher, backendConfig.<key>)"
+    "Update a single library field (name, ownership, isDefault, path, publisher, backendConfig.<key>)"
   ).action(async (name, expr) => {
     const [field, ...rest] = expr.split("=");
+    if (field === "structure") {
+      logErr(DOMAIN_REMOVED_HINT);
+      process.exit(1);
+    }
     const value = rest.join("=");
     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).`
-          );
+        if (!isValidPublisher(publisher)) {
+          logErr(`Invalid publisher "${value}": ${PUBLISHER_HINT}.`);
           process.exit(1);
         }
         if (lib.ownership === "reader") {
@@ -3709,11 +3837,42 @@ function makeLibraryCommand() {
         return;
       }
       const patch = {};
-      if (field === "ownership") patch.ownership = value;
-      else if (field === "isDefault") patch.isDefault = value === "true";
-      else if (field === "path") {
-        const dir = path25.resolve(value);
-        if (!fs11.existsSync(dir) || !fs11.statSync(dir).isDirectory()) {
+      if (field === "name") {
+        await renameLibrary(manager, lib, value);
+        return;
+      }
+      if (field === "ownership") {
+        if (!LIBRARY_OWNERSHIPS.includes(value)) {
+          logErr(
+            `Invalid ownership "${value}": expected one of ${LIBRARY_OWNERSHIPS.join(", ")}.`
+          );
+          process.exit(1);
+        }
+        if (value !== "owner" && lib.backend !== "git") {
+          logErr(`ownership=${value} needs a git-backed library: ${LOCAL_OWNERSHIP_REASON}`);
+          process.exit(1);
+        }
+        patch.ownership = value;
+      } else if (field === "isDefault") {
+        if (value !== "true" && value !== "false") {
+          logErr(`Invalid isDefault "${value}": expected true or false.`);
+          process.exit(1);
+        }
+        if (value === "true") {
+          await manager.setDefault(lib.id);
+          logOk(`Updated ${name}.isDefault`);
+          return;
+        }
+        if (lib.isDefault) {
+          logErr(
+            `Library "${lib.name}" is the default; make another library the default with \`skaile library default <name>\` instead of unsetting it.`
+          );
+          process.exit(1);
+        }
+        patch.isDefault = false;
+      } else if (field === "path") {
+        const dir = path23.resolve(value);
+        if (!fs9.existsSync(dir) || !fs9.statSync(dir).isDirectory()) {
           logErr(`Directory does not exist: ${dir}. \`library set path=\` does not move files.`);
           process.exit(1);
         }
@@ -3722,6 +3881,10 @@ function makeLibraryCommand() {
         patch.path = dir;
       } else if (field.startsWith("backendConfig.")) {
         const key = field.split(".")[1];
+        if (key === "url" && lib.backend !== "git") {
+          logErr("backendConfig.url only applies to git-backed libraries.");
+          process.exit(1);
+        }
         if (key === "url" && lib.backend === "git") {
           const branch = lib.backendConfig.branch ?? "main";
           ensureGitRepo(lib.path, value, branch);
@@ -3743,6 +3906,10 @@ function makeLibraryCommand() {
     }
   });
   cmd.command("remove <name>").description("Unregister a library (use --purge to also delete files)").option("--purge", "Also delete the library directory from disk", false).option("-y, --yes", "Skip confirmation", false).action(async (name, opts) => {
+    if (!opts.yes && !process.stdin.isTTY) {
+      logErr("library remove needs confirmation: pass -y");
+      process.exit(1);
+    }
     const { manager, close } = await openLibraryManager();
     try {
       if (!opts.yes) {
@@ -3755,8 +3922,12 @@ function makeLibraryCommand() {
           return;
         }
       }
+      const lib = await manager.requireLibrary(name);
       await manager.removeLibrary(name, { purge: opts.purge });
+      if (opts.purge) pruneEmptyLibraryParents(lib.path);
       logOk(`Removed ${name}.`);
+    } catch (err2) {
+      exitOnSyncError(err2);
     } finally {
       close();
     }
@@ -3768,6 +3939,7 @@ function makeLibraryCommand() {
       requireGitBackend(lib, "sync");
       const drv = manager.driverFor(lib.backend);
       const pull = await drv.pull(lib);
+      if (pull.conflicts.length > 0) exitOnSyncError(new Error(pull.conflicts[0].reason));
       logInfo(`Pulled: applied=${pull.applied}, conflicts=${pull.conflicts.length}`);
       if (lib.ownership === "owner") {
         const push = await drv.push(lib);
@@ -3786,9 +3958,12 @@ function makeLibraryCommand() {
     try {
       const lib = await manager.requireLibrary(name);
       assertManifestEditableOrExit(lib.path);
-      const removed = await syncManifestWithDisk(
+      const badRequires = manifestRequiresProblems(lib.path);
+      const resolved = resolveLibraryPublisherDetailed(lib, {}, getStoreIdentity());
+      warnLibraryNameFallback(name, resolved);
+      const { removed, skipped } = await syncManifestWithDisk(
         lib.path,
-        resolveLibraryPublisher(lib, {}, getStoreIdentity()),
+        resolved.publisher,
         getKindRegistry()
       );
       const manifest = loadSkPublishManifest(lib.path);
@@ -3796,13 +3971,35 @@ function makeLibraryCommand() {
         const ref = manifest ? assetEntryRef(a, manifest) : `${a.kind}:${a.name}`;
         logInfo(`Removed manifest entry ${ref} (root ${a.root} is gone)`);
       }
-      const res = await indexLibrary(lib, library);
+      for (const s of skipped.filter((x) => x.reason === "invalid-version")) {
+        logWarn(
+          `${s.kind}:${s.name} skipped: ${s.detail}. Set a valid \`metadata.version\` (e.g. 0.1.0) and re-run \`skaile library index ${name}\`.`
+        );
+      }
+      const skippedKeys = new Set(skipped.map((s) => `${s.kind}:${s.name}`));
+      const res = await indexLibrary(lib, library, {
+        exclude: (a) => skippedKeys.has(`${a.kind}:${a.name}`)
+      });
       const unparsable = res.errors.filter((e) => e.includes("ManifestSchemaError:"));
       for (const e of res.errors) (unparsable.includes(e) ? logErr : logWarn)(e);
+      const syncUnparsable = skipped.filter(
+        (s) => s.reason === "unparsable" && !unparsable.some((e) => e.includes(s.file))
+      );
+      for (const s of syncUnparsable) {
+        logErr(`${s.kind}:${s.name} skipped: manifest file ${s.file} could not be parsed.`);
+      }
+      for (const p6 of badRequires) logErr(`${p6.asset}: ${p6.message}`);
       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.`);
+      const skippedUnparsable = unparsable.length + syncUnparsable.length;
+      if (skippedUnparsable > 0) {
+        logErr(`${skippedUnparsable} asset(s) skipped: manifest could not be parsed.`);
+        process.exitCode = 1;
+      }
+      if (badRequires.length > 0) {
+        logErr(
+          `${badRequires.length} invalid requires entr${badRequires.length === 1 ? "y" : "ies"} ignored: use the \`kind:@<publisher>/name[#version]\` form.`
+        );
         process.exitCode = 1;
       }
     } finally {
@@ -3816,7 +4013,7 @@ function makeLibraryCommand() {
       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(", ")}`);
+        exitOnSyncError(new Error(res.conflicts[0].reason));
       } else {
         logOk(`Pulled ${res.applied} change(s).`);
       }
@@ -3862,6 +4059,13 @@ function makeLibraryCommand() {
         );
         process.exit(1);
       }
+      const unfinished = unfinishedGitState(lib.path);
+      if (unfinished) {
+        logErr(
+          `library commit refused: ${unfinished} in ${lib.path}. Resolve the conflicts (\`skaile library git ${name} status\`), finish or abort the rebase/merge, then commit again.`
+        );
+        process.exit(1);
+      }
       const add = spawnSync("git", ["add", "-A"], { cwd: lib.path, stdio: "inherit" });
       if (add.status !== 0) {
         logErr(`git add failed in ${lib.path}.`);
@@ -3916,16 +4120,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-LFOJJVMK.js');
+      const { runLibraryPublish } = await import('../library-publish-FGXF5TJO.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-LFOJJVMK.js');
+    const { runLibraryRegister } = await import('../library-publish-FGXF5TJO.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-LFOJJVMK.js');
+    const { runLibraryYank } = await import('../library-publish-FGXF5TJO.js');
     await withStoreErrorHandling(() => runLibraryYank(lib, opts));
   });
   return cmd;
@@ -3976,9 +4180,9 @@ async function printOverallStatus(projectDir, asJson) {
     } catch {
       secretsStrategy = "unavailable";
     }
-    const resolvedProjectDir = path25.resolve(projectDir);
-    const hasWorkspaceConfig = existsSync(path25.join(resolvedProjectDir, "skaile.yaml"));
-    const hasLockFile = existsSync(path25.join(resolvedProjectDir, "skaile.lock.yaml"));
+    const resolvedProjectDir = path23.resolve(projectDir);
+    const hasWorkspaceConfig = existsSync(path23.join(resolvedProjectDir, "skaile.yaml"));
+    const hasLockFile = existsSync(path23.join(resolvedProjectDir, "skaile.lock.yaml"));
     let assignments = [];
     if (hasWorkspaceConfig) {
       try {
@@ -4585,13 +4789,18 @@ function scheduleSoftDepPreview() {
 }
 async function loadAssets() {
   softDepPreviewCache.clear();
-  const { gatherAssetFeeds } = await import('../asset-feeds-LU7NHOAP.js');
+  const { gatherAssetFeeds } = await import('../asset-feeds-K36CR52Q.js');
   const { entries, notes } = await gatherAssetFeeds(am, am.projectDir);
   if (notes.length > 0) {
     state.message = notes.map((n) => `[${n.feed}] ${n.message}`).join(" \u2022 ");
   }
   const installed = new Set(am.listDeployed().map((e) => `${e.kind}:${e.name}`));
-  const rows = buildAssetRows(entries, installed);
+  let lock = null;
+  try {
+    lock = readLock(path23__default.join(am.projectDir, "skaile.lock.yaml"));
+  } catch {
+  }
+  const rows = buildAssetRows(entries, installed, lockedLibraryByIdentity(lock));
   state.assetRows = rows;
   reconcileCollapsedSets(rows);
   rebuildVisible();
@@ -4605,7 +4814,7 @@ function rebuildSourceTree() {
   rebuildVisibleSources();
 }
 function sourceOrgRepo(s) {
-  const parts = s.path.split(path25__default.sep).filter(Boolean);
+  const parts = s.path.split(path23__default.sep).filter(Boolean);
   if (parts.length < 2) return null;
   return { org: parts[parts.length - 2], repo: parts[parts.length - 1] };
 }
@@ -4678,7 +4887,22 @@ function rebuildVisibleLibraries() {
   );
   clampCursor();
 }
-function buildAssetRows(entries, installed) {
+function lockedLibraryByIdentity(lock) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, locked] of Object.entries(lock?.assets ?? {})) {
+    if (!locked.library) continue;
+    const ref = parseAssetRefLoose(key);
+    if (ref?.publisher) out.set(`${ref.kind}:${ref.publisher}/${ref.name}`, locked.library.name);
+  }
+  return out;
+}
+function isRowInstalled(origin, group, entry, installed, lockedLibrary) {
+  if (!installed.has(`${entry.kind}:${entry.name}`)) return false;
+  const publisher = entry.publisher?.replace(/^@/, "");
+  const locked = publisher ? lockedLibrary.get(`${entry.kind}:${publisher}/${entry.name}`) : void 0;
+  return locked === void 0 || origin === "library" && group === locked;
+}
+function buildAssetRows(entries, installed, lockedLibrary = /* @__PURE__ */ new Map()) {
   const byOrigin = /* @__PURE__ */ new Map();
   for (const { origin, entry, group } of entries) {
     const publisher = group || entry.publisher || "other";
@@ -4706,7 +4930,7 @@ function buildAssetRows(entries, installed) {
             source: group,
             org: entry.repo?.includes("/") ? entry.repo.slice(0, entry.repo.indexOf("/")) : void 0,
             entry,
-            installed: installed.has(`${entry.kind}:${entry.name}`),
+            installed: isRowInstalled(origin, group, entry, installed, lockedLibrary),
             plugin
           });
         }
@@ -4752,13 +4976,13 @@ function reconcileCollapsedSets(rows) {
 async function loadSourcesAndLibraries() {
   try {
     const [{ openLibraryManager: openLibraryManager2 }, { getGlobalCacheDir: getGlobalCacheDir2, globalSkaileDir: globalSkaileDir2 }] = await Promise.all([
-      import('../open-library-4WUMQHES.js'),
+      import('../open-library-P3D337NH.js'),
       import('../core/index.js')
     ]);
     const { manager, library, close } = await openLibraryManager2();
     try {
       const newRoot = getGlobalCacheDir2();
-      const legacyRoot = path25__default.join(globalSkaileDir2(), "sources");
+      const legacyRoot = path23__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();
@@ -5694,7 +5918,7 @@ 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(path25__default.resolve(opts.projectDir));
+    await run(path23__default.resolve(opts.projectDir));
   });
 }
 function makeMcpServerCommand() {
@@ -5747,10 +5971,10 @@ function walkFiles(root, match) {
       return;
     }
     for (const entry of entries) {
-      const full = path25__default.join(dir, entry.name);
+      const full = path23__default.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (SKIPPED_DIRS.has(entry.name)) continue;
-        if (entry.name === "cache" && path25__default.basename(dir) === ".skaile") continue;
+        if (entry.name === "cache" && path23__default.basename(dir) === ".skaile") continue;
         visit(full);
       } else if (entry.isFile() && match(entry.name)) {
         out.push(full);
@@ -5768,14 +5992,14 @@ function applyChanges2(changes) {
     switch (change.type) {
       case "write":
       case "create":
-        mkdirSync(path25__default.dirname(change.path), { recursive: true });
+        mkdirSync(path23__default.dirname(change.path), { recursive: true });
         writeFileSync(change.path, change.after, "utf-8");
         break;
       case "delete":
         rmSync(change.path, { force: true });
         break;
       case "move":
-        mkdirSync(path25__default.dirname(change.to), { recursive: true });
+        mkdirSync(path23__default.dirname(change.to), { recursive: true });
         writeFileSync(change.to, change.after, "utf-8");
         rmSync(change.from, { force: true });
         break;
@@ -5868,7 +6092,7 @@ function unifiedDiff(before, after, oldLabel, newLabel, context = 3) {
   return `${out.join("\n")}
 `;
 }
-var posix = (p6) => p6.split(path25__default.sep).join("/");
+var posix = (p6) => p6.split(path23__default.sep).join("/");
 function colorizeDiff(diff) {
   return diff.split("\n").map((line) => {
     if (line.startsWith("+++") || line.startsWith("---")) return S.bold(line);
@@ -5879,7 +6103,7 @@ function colorizeDiff(diff) {
   }).join("\n");
 }
 function renderChange(change, base) {
-  const rel = (p6) => posix(path25__default.relative(base, p6) || path25__default.basename(p6));
+  const rel = (p6) => posix(path23__default.relative(base, p6) || path23__default.basename(p6));
   switch (change.type) {
     case "write":
       return unifiedDiff(
@@ -5906,7 +6130,7 @@ ${diff}`;
   }
 }
 function changeLabel(change, base) {
-  const rel = (p6) => posix(path25__default.relative(base, p6) || path25__default.basename(p6));
+  const rel = (p6) => posix(path23__default.relative(base, p6) || path23__default.basename(p6));
   switch (change.type) {
     case "write":
       return `modify ${rel(change.path)}`;
@@ -5966,10 +6190,10 @@ function loadAsset(projectDir, id, ref) {
       )
     };
   }
-  const manifestPath = path25__default.join(dir, AGENT_MANIFEST_FILE);
+  const manifestPath = path23__default.join(dir, AGENT_MANIFEST_FILE);
   let text;
   try {
-    text = fs11__default.readFileSync(manifestPath, "utf-8");
+    text = fs9__default.readFileSync(manifestPath, "utf-8");
   } catch {
     return {
       diagnostic: err(
@@ -6148,12 +6372,12 @@ function findManifestCandidates(rootPath) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs11__default.readdirSync(dir, { withFileTypes: true });
+      entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path25__default.join(dir, entry.name);
+      const fullPath = path23__default.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) walk(fullPath);
       } else if (entry.isFile()) {
@@ -6189,10 +6413,10 @@ function checkManifestIdentity(kind, parsed) {
   return null;
 }
 function parseManifestCandidate(c, absRoot) {
-  const content = fs11__default.readFileSync(c.filePath, "utf-8");
+  const content = fs9__default.readFileSync(c.filePath, "utf-8");
   const res = parseManifestFile(c.filePath, content);
   if (!res.ok) {
-    logErr(`${path25__default.relative(absRoot, c.filePath)} [${c.kind}] \u2014 parse error: ${res.reason}`);
+    logErr(`${path23__default.relative(absRoot, c.filePath)} [${c.kind}] \u2014 parse error: ${res.reason}`);
     return { kind: "error" };
   }
   return {
@@ -6222,7 +6446,7 @@ function checkComposeKinds(parsed, registry) {
   return diagnostics;
 }
 function validateManifestCandidate(c, parsed, body, absRoot, registry, strictConformance) {
-  const relPath = path25__default.relative(absRoot, c.filePath);
+  const relPath = path23__default.relative(absRoot, c.filePath);
   let errors = 0;
   let warnings = 0;
   const identityError = checkManifestIdentity(c.kind, parsed);
@@ -6230,9 +6454,15 @@ function validateManifestCandidate(c, parsed, body, absRoot, registry, strictCon
     logErr(`${relPath} [${c.kind}] \u2014 ${identityError}`);
     errors++;
   }
-  if (c.kind === "skill" && parsed && typeof parsed === "object") {
-    const dirName = path25__default.basename(path25__default.dirname(c.filePath));
-    for (const f of checkSkillManifest(parsed, body, dirName)) {
+  if (parsed && typeof parsed === "object") {
+    const manifest = parsed;
+    const version = declaredVersion(manifest);
+    if (version !== void 0 && !isValidSemver(version)) {
+      logErr(`${relPath} [${c.kind}] \u2014 version "${version}" is not valid semver`);
+      errors++;
+    }
+    const dirName = path23__default.basename(path23__default.dirname(c.filePath));
+    for (const f of checkAssetManifest(c.kind, manifest, body, dirName)) {
       const line = `${relPath} [${f.tag}] \u2014 ${f.text}`;
       if (f.conformance && strictConformance) {
         logErr(line);
@@ -6243,7 +6473,7 @@ function validateManifestCandidate(c, parsed, body, absRoot, registry, strictCon
       }
     }
   }
-  if (c.kind === "agent" && path25__default.basename(c.filePath) === "agent.yaml") {
+  if (c.kind === "agent" && path23__default.basename(c.filePath) === "agent.yaml") {
     for (const d of [
       ...checkComposeKinds(parsed, registry),
       ...composeSlotDiagnostics(parsed),
@@ -6274,8 +6504,8 @@ function validateManifestCandidate(c, parsed, body, absRoot, registry, strictCon
   return { errors, warnings };
 }
 function validateManifests(rootPath, strictConformance) {
-  const absRoot = path25__default.resolve(rootPath);
-  if (!fs11__default.existsSync(absRoot)) {
+  const absRoot = path23__default.resolve(rootPath);
+  if (!fs9__default.existsSync(absRoot)) {
     logErr(`Path does not exist: ${absRoot}`);
     return { total: 0, errors: 1, warnings: 0 };
   }
@@ -6307,12 +6537,12 @@ function findWorkspaceManifests(rootPath) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs11__default.readdirSync(dir, { withFileTypes: true });
+      entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path25__default.join(dir, entry.name);
+      const full = path23__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)) {
@@ -6375,14 +6605,14 @@ function validateWorkspaceAssets(parsed, relPath) {
   return errors;
 }
 function validateWorkspaceManifests(rootPath) {
-  const absRoot = path25__default.resolve(rootPath);
+  const absRoot = path23__default.resolve(rootPath);
   const files = findWorkspaceManifests(absRoot);
   let errors = 0;
   for (const file of files) {
-    const relPath = path25__default.relative(absRoot, file);
+    const relPath = path23__default.relative(absRoot, file);
     let parsed;
     try {
-      parsed = parse(fs11__default.readFileSync(file, "utf-8")) ?? {};
+      parsed = parse(fs9__default.readFileSync(file, "utf-8")) ?? {};
     } catch (e) {
       logErr(`${relPath} \u2014 parse error: ${e instanceof Error ? e.message : String(e)}`);
       errors++;
@@ -6390,7 +6620,7 @@ function validateWorkspaceManifests(rootPath) {
     }
     errors += validateWorkspaceRefs(collectWorkspaceRefFields(parsed), relPath);
     errors += validateWorkspaceAssets(parsed, relPath);
-    for (const d of checkAgentInstances(path25__default.dirname(file), parsed)) {
+    for (const d of checkAgentInstances(path23__default.dirname(file), parsed)) {
       const line = `${relPath} [agents] \u2014 ${d.code}: ${d.path ? `${d.path}: ` : ""}${d.message}`;
       if (d.severity === "error") {
         logErr(line);
@@ -6403,7 +6633,7 @@ function validateWorkspaceManifests(rootPath) {
   return { total: files.length, errors };
 }
 function validatePublishManifestRoots(rootPath) {
-  const absRoot = path25__default.resolve(rootPath);
+  const absRoot = path23__default.resolve(rootPath);
   const manifest = loadSkPublishManifest(absRoot);
   if (!manifest) return 0;
   const missing = missingRootAssets(absRoot, manifest);
@@ -6414,99 +6644,128 @@ function validatePublishManifestRoots(rootPath) {
   }
   return missing.length;
 }
+function validatePublishManifestRequires(rootPath) {
+  const problems = manifestRequiresProblems(path23__default.resolve(rootPath));
+  for (const p6 of problems) {
+    logErr(
+      `${SKAILE_MANIFEST_FILENAME} [assets] \u2014 ${p6.asset}: ${p6.message}. Use the \`kind:@<publisher>/name[#version]\` form.`
+    );
+  }
+  return problems.length;
+}
+function validatePublishManifestVersions(rootPath) {
+  const absRoot = path23__default.resolve(rootPath);
+  const manifest = loadSkPublishManifest(absRoot);
+  if (!manifest || manifest.source) return 0;
+  let warnings = 0;
+  for (const a of manifest.assets ?? []) {
+    if (!a.root || a.source || !a.version) continue;
+    const file = findAssetManifestFile(path23__default.join(absRoot, a.root), a.kind, a.name);
+    if (!file) continue;
+    const res = parseManifestFile(file, fs9__default.readFileSync(file, "utf-8"));
+    if (!res.ok) continue;
+    const fileVersion = declaredVersion(res.data);
+    if (fileVersion === void 0 || fileVersion === a.version) continue;
+    logWarn(
+      `${SKAILE_MANIFEST_FILENAME} [assets] \u2014 ${assetEntryRef(a, manifest)}: manifest version ${a.version} differs from ${toPosix(path23__default.relative(absRoot, file))} (${fileVersion}). The file is the source of truth: bump the version there, then run \`skaile library index <library>\`.`
+    );
+    warnings++;
+  }
+  return warnings;
+}
+function validatePublishManifestPublishers(rootPath) {
+  const absRoot = path23__default.resolve(rootPath);
+  const manifest = loadSkPublishManifest(absRoot);
+  if (!manifest || manifest.source) return 0;
+  const bare = (p6) => p6.trim().replace(/^@/, "");
+  let warnings = 0;
+  for (const a of manifest.assets ?? []) {
+    const resolved = a.publisher ?? manifest.publisher;
+    if (!a.root || a.source || !resolved) continue;
+    const file = findAssetManifestFile(path23__default.join(absRoot, a.root), a.kind, a.name);
+    if (!file) continue;
+    const res = parseManifestFile(file, fs9__default.readFileSync(file, "utf-8"));
+    if (!res.ok) continue;
+    const meta = res.data.metadata;
+    const declared = meta !== null && typeof meta === "object" ? meta.publisher : null;
+    if (typeof declared !== "string" || bare(declared) === bare(resolved)) continue;
+    logWarn(
+      `${toPosix(path23__default.relative(absRoot, file))} [publisher] \u2014 metadata.publisher "${bare(declared)}" differs from the manifest publisher "${bare(resolved)}" for ${assetEntryRef(a, manifest)}. The manifest wins and the file value is ignored: delete \`metadata.publisher\` from the file, or set the publisher in ${SKAILE_MANIFEST_FILENAME}.`
+    );
+    warnings++;
+  }
+  return warnings;
+}
 var EXCLUDED_PATHS = ["skaileup-shared/", "external/", "docs/"];
 function toPosix(p6) {
-  return p6.split(path25__default.sep).join("/");
+  return p6.split(path23__default.sep).join("/");
 }
 function isExcludedPath(relPath) {
   const rel = toPosix(relPath);
   return EXCLUDED_PATHS.some((prefix) => rel.startsWith(prefix));
 }
-function collectAssetVersions() {
-  const assets = [];
-  if (!fs11__default.existsSync(AI_RESOURCES)) return assets;
-  const kindDirs = (kindDirName) => findKindDirs(AI_RESOURCES, kindDirName).filter(
-    (dir) => !isExcludedPath(path25__default.relative(AI_RESOURCES, dir))
-  );
-  for (const dir of kindDirs("skills")) collectSkillVersions(dir, assets);
-  for (const dir of kindDirs("agents")) collectAgentVersions(dir, assets);
-  for (const dir of kindDirs("flows")) collectFlowVersions(dir, assets);
-  for (const dir of kindDirs("prompts")) collectPromptVersions(dir, assets);
-  const seen = /* @__PURE__ */ new Set();
-  return assets.filter((a) => !seen.has(a.filePath) && seen.add(a.filePath));
-}
-function collectFlowVersions(dir, out) {
-  for (const f of fs11__default.readdirSync(dir)) {
-    if (!f.endsWith(".flow.yaml")) continue;
-    const fp = path25__default.join(dir, f);
-    const content = fs11__default.readFileSync(fp, "utf-8");
-    const parsed = parse(content);
-    out.push({
-      kind: "flow",
-      name: parsed?.id ?? f.replace(".flow.yaml", ""),
-      version: parsed?.version ?? "",
-      filePath: fp
-    });
-  }
-}
-function collectPromptVersions(dir, out) {
-  for (const f of fs11__default.readdirSync(dir)) {
-    if (!f.endsWith(".prompt.md")) continue;
-    const fp = path25__default.join(dir, f);
-    const content = fs11__default.readFileSync(fp, "utf-8");
+var VERSIONED_KINDS = {
+  skill: true,
+  agent: true,
+  flow: true,
+  prompt: true
+};
+function readAssetVersion(c) {
+  const kind = c.kind;
+  const fileName = path23__default.basename(c.filePath);
+  const dirName = path23__default.basename(path23__default.dirname(c.filePath));
+  const content = fs9__default.readFileSync(c.filePath, "utf-8");
+  if (c.filePath.endsWith(".md")) {
     const fm = parseSkillFrontmatter(content);
-    out.push({
-      kind: "prompt",
-      name: fm?.name ?? f.replace(".prompt.md", ""),
+    const stem = fileName.replace(/\.prompt\.md$/, "");
+    return {
+      kind,
+      name: fm?.name ?? (kind === "prompt" ? stem : dirName),
       version: fm?.metadata?.version ?? "",
-      filePath: fp
-    });
+      filePath: c.filePath
+    };
   }
-}
-function collectSkillVersions(dir, out) {
-  for (const entry of fs11__default.readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const full = path25__default.join(dir, entry.name);
-    const skillMd = path25__default.join(full, "SKILL.md");
-    if (fs11__default.existsSync(skillMd)) {
-      const content = fs11__default.readFileSync(skillMd, "utf-8");
-      const fm = parseSkillFrontmatter(content);
-      out.push({
-        kind: "skill",
-        name: fm?.name ?? entry.name,
-        version: fm?.metadata?.version ?? "",
-        filePath: skillMd
-      });
-    } else {
-      collectSkillVersions(full, out);
-    }
+  let parsed = null;
+  try {
+    parsed = parse(content);
+  } catch {
+  }
+  if (kind === "flow") {
+    return {
+      kind,
+      name: String(parsed?.id ?? fileName.replace(".flow.yaml", "")),
+      version: String(parsed?.version ?? ""),
+      filePath: c.filePath
+    };
   }
+  return {
+    kind,
+    name: String(parsed?.name ?? dirName),
+    version: String(parsed?.version ?? ""),
+    filePath: c.filePath
+  };
 }
-function collectAgentVersions(dir, out) {
-  for (const entry of fs11__default.readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const agentYaml = path25__default.join(dir, entry.name, "agent.yaml");
-    if (!fs11__default.existsSync(agentYaml)) continue;
-    const content = fs11__default.readFileSync(agentYaml, "utf-8");
-    const parsed = parse(content);
-    out.push({
-      kind: "agent",
-      name: parsed?.name ?? entry.name,
-      version: parsed?.version ?? "",
-      filePath: agentYaml
-    });
+function collectAssetVersions(root) {
+  if (!fs9__default.existsSync(root)) return [];
+  const assets = [];
+  for (const c of findManifestCandidates(root)) {
+    if (!VERSIONED_KINDS[c.kind]) continue;
+    if (c.filePath.endsWith(".flow.json")) continue;
+    if (isExcludedPath(path23__default.relative(root, c.filePath))) continue;
+    assets.push(readAssetVersion(c));
   }
+  return assets;
 }
-function assetLocation(a) {
-  return toPosix(path25__default.relative(AI_RESOURCES, a.filePath));
+function assetLocation(a, root) {
+  return toPosix(path23__default.relative(root, a.filePath));
 }
 function findChangelogUnit(assetRelPath, root) {
-  let dir = path25__default.posix.dirname(toPosix(assetRelPath));
+  let dir = path23__default.posix.dirname(toPosix(assetRelPath));
   for (; ; ) {
     const candidate = dir === "." ? "CHANGELOG.md" : `${dir}/CHANGELOG.md`;
-    if (fs11__default.existsSync(path25__default.join(root, candidate))) return candidate;
+    if (fs9__default.existsSync(path23__default.join(root, candidate))) return candidate;
     if (dir === ".") return null;
-    dir = path25__default.posix.dirname(dir);
+    dir = path23__default.posix.dirname(dir);
   }
 }
 function checkChangelogUnits(modifiedFiles, root) {
@@ -6525,7 +6784,7 @@ function checkChangelogUnits(modifiedFiles, root) {
   return { updated, stale, orphans };
 }
 function isValidSemver(v) {
-  return /^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/.test(v);
+  return SEMVER_RE.test(v);
 }
 function extractVersionFromContent(filePath, content) {
   if (filePath.endsWith(".yaml")) {
@@ -6537,51 +6796,37 @@ function extractVersionFromContent(filePath, content) {
   const parsed = parse(fmMatch[1]);
   return parsed?.metadata?.version ?? parsed?.version ?? null;
 }
-function filterToChangedAssets(assets) {
-  try {
-    const diffOutput = execSync("git diff --name-only HEAD", {
-      cwd: AI_RESOURCES,
-      encoding: "utf-8"
-    });
-    const changedFiles = new Set(
-      diffOutput.trim().split("\n").filter(Boolean).map((f) => path25__default.resolve(AI_RESOURCES, f))
-    );
-    return assets.filter((a) => changedFiles.has(a.filePath));
-  } catch {
-    logErr("Failed to run git diff \u2014 are you in a git repository?");
-    process.exit(1);
-  }
-}
-function checkAssetVersions(assets) {
+function checkAssetVersions(assets, root) {
   let errors = 0;
-  let warnings = 0;
+  const warnings = 0;
   for (const a of assets) {
     if (!a.version) {
-      logErr(`${a.kind}:${a.name} (${assetLocation(a)}) \u2014 missing version`);
+      logErr(`${a.kind}:${a.name} (${assetLocation(a, root)}) \u2014 missing version`);
       errors++;
     } else if (!isValidSemver(a.version)) {
-      logWarn(
-        `${a.kind}:${a.name} (${assetLocation(a)}) \u2014 version "${a.version}" is not valid semver`
+      logErr(
+        `${a.kind}:${a.name} (${assetLocation(a, root)}) \u2014 version "${a.version}" is not valid semver`
       );
-      warnings++;
+      errors++;
     }
   }
   return { errors, warnings };
 }
-function checkVersionBumps(assets) {
+function checkVersionBumps(assets, root) {
   let warnings = 0;
   for (const a of assets) {
     if (!a.version) continue;
-    const relPath = path25__default.relative(AI_RESOURCES, a.filePath);
+    const relPath = toPosix(path23__default.relative(root, a.filePath));
     try {
-      const headContent = execSync(`git show HEAD:${relPath}`, {
-        cwd: AI_RESOURCES,
-        encoding: "utf-8"
+      const headContent = execFileSync("git", ["show", `HEAD:./${relPath}`], {
+        cwd: root,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
       });
       const headVersion = extractVersionFromContent(a.filePath, headContent);
       if (headVersion && headVersion === a.version) {
         logWarn(
-          `${a.kind}:${a.name} (${assetLocation(a)}) \u2014 file changed but version not bumped (${a.version})`
+          `${a.kind}:${a.name} (${assetLocation(a, root)}) \u2014 file changed but version not bumped (${a.version})`
         );
         warnings++;
       }
@@ -6590,7 +6835,7 @@ function checkVersionBumps(assets) {
   }
   return warnings;
 }
-function checkFlowVersionPins(assets) {
+function checkFlowVersionPins(assets, root) {
   const flows = assets.filter((a) => a.kind === "flow");
   const skillVersionMap = /* @__PURE__ */ new Map();
   for (const a of assets.filter((a2) => a2.kind === "skill")) {
@@ -6604,7 +6849,7 @@ function checkFlowVersionPins(assets) {
       pins = flowSkillVersionPins(loadFlow(f.filePath));
     } catch (err2) {
       logWarn(
-        `flow:${f.name} (${path25__default.relative(AI_RESOURCES, f.filePath)}) \u2014 could not be read: ${err2 instanceof Error ? err2.message : err2}`
+        `flow:${f.name} (${path23__default.relative(root, f.filePath)}) \u2014 could not be read: ${err2 instanceof Error ? err2.message : err2}`
       );
       warnings++;
       continue;
@@ -6620,18 +6865,63 @@ function checkFlowVersionPins(assets) {
   }
   return { errors, warnings };
 }
-function runVersionsCheck(opts) {
-  let assets = collectAssetVersions();
+function resolveCheckRoot(pathArg) {
+  if (pathArg) {
+    const abs = path23__default.resolve(pathArg);
+    if (!fs9__default.existsSync(abs)) {
+      logErr(`Path does not exist: ${abs}`);
+      return null;
+    }
+    return abs;
+  }
+  for (let dir = process.cwd(); ; dir = path23__default.dirname(dir)) {
+    if (fs9__default.existsSync(path23__default.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
+    if (path23__default.dirname(dir) === dir) return AI_RESOURCES;
+  }
+}
+function changedFiles(root, ref) {
+  try {
+    const out = execFileSync(
+      "git",
+      ["diff", "--name-only", "--relative", "--end-of-options", ref],
+      {
+        cwd: root,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    return out.trim().split("\n").filter(Boolean);
+  } catch (err2) {
+    const stderr = err2 instanceof Error && "stderr" in err2 ? String(err2.stderr).trim() : "";
+    const reason = (stderr || (err2 instanceof Error ? err2.message : String(err2))).split("\n")[0];
+    logErr(`git diff failed in ${root}: ${reason}`);
+    return null;
+  }
+}
+function runVersionsCheck(pathArg, opts) {
+  const root = resolveCheckRoot(pathArg);
+  if (root === null) {
+    process.exit(1);
+    return;
+  }
+  let assets = collectAssetVersions(root);
   if (opts.changedOnly) {
-    assets = filterToChangedAssets(assets);
+    const changed = changedFiles(root, "HEAD");
+    if (changed === null) {
+      process.exit(1);
+      return;
+    }
+    const changedAbs = new Set(changed.map((f) => path23__default.resolve(root, f)));
+    assets = assets.filter((a) => changedAbs.has(a.filePath));
   }
-  const versionCheck = checkAssetVersions(assets);
+  logInfo(`Checking versions in ${root}`);
+  const versionCheck = checkAssetVersions(assets, root);
   let errors = versionCheck.errors;
   let warnings = versionCheck.warnings;
   if (opts.changedOnly) {
-    warnings += checkVersionBumps(assets);
+    warnings += checkVersionBumps(assets, root);
   }
-  const pinCheck = checkFlowVersionPins(assets);
+  const pinCheck = checkFlowVersionPins(assets, root);
   errors += pinCheck.errors;
   warnings += pinCheck.warnings;
   console.log();
@@ -6654,7 +6944,7 @@ function makeValidateCommand() {
     "--strict-conformance",
     "Treat Agent Skills (agentskills.io) standard findings as errors"
   ).action((targetPath, opts) => {
-    const absPath = path25__default.resolve(targetPath);
+    const absPath = path23__default.resolve(targetPath);
     logInfo(`Validating manifests in ${absPath}`);
     const { total, errors, warnings } = validateManifests(
       absPath,
@@ -6662,11 +6952,15 @@ function makeValidateCommand() {
     );
     const ws = validateWorkspaceManifests(absPath);
     const rootErrors = validatePublishManifestRoots(absPath);
-    const totalErrors = errors + ws.errors + rootErrors;
+    const requiresErrors = validatePublishManifestRequires(absPath);
+    const versionWarnings = validatePublishManifestVersions(absPath);
+    const publisherWarnings = validatePublishManifestPublishers(absPath);
+    const totalErrors = errors + ws.errors + rootErrors + requiresErrors;
     console.log();
     warnIgnoredDomainFiles(absPath);
     logInfo(`Scanned ${total} asset manifest(s) and ${ws.total} skaile.yaml file(s)`);
-    if (warnings > 0) logWarn(`${warnings} warning(s)`);
+    const totalWarnings = warnings + versionWarnings + publisherWarnings;
+    if (totalWarnings > 0) logWarn(`${totalWarnings} warning(s)`);
     if (totalErrors === 0) {
       logOk("All manifests valid");
     } else {
@@ -6674,23 +6968,24 @@ function makeValidateCommand() {
       process.exit(1);
     }
   });
-  cmd.command("versions").description("Check version fields and flow version pins").option("--changed-only", "Only check assets modified since last commit").option("--strict", "Exit 1 on warnings (for CI)").action((opts) => {
-    runVersionsCheck(opts);
-  });
-  cmd.command("changelog").description("Check that modified assets have an updated nearest CHANGELOG.md").option("--base <ref>", "Git base ref for diff", "HEAD").action((opts) => {
-    let diffOutput;
-    try {
-      diffOutput = execSync(`git diff --name-only --relative ${opts.base}`, {
-        cwd: AI_RESOURCES,
-        encoding: "utf-8"
-      });
-    } catch {
-      logErr("Failed to run git diff \u2014 are you in a git repository?");
+  cmd.command("versions").description("Check version fields and flow version pins").argument("[path]", "Library or asset directory (default: the current library)").option("--changed-only", "Only check assets modified since last commit").option("--strict", "Exit 1 on warnings (for CI)").addOption(removedDomainOption()).action(
+    (pathArg, opts) => {
+      rejectRemovedDomainOption(opts);
+      runVersionsCheck(pathArg, opts);
+    }
+  );
+  cmd.command("changelog").description("Check that modified assets have an updated nearest CHANGELOG.md").argument("[path]", "Library or asset directory (default: the current library)").option("--base <ref>", "Git base ref for diff", "HEAD").action((pathArg, opts) => {
+    const root = resolveCheckRoot(pathArg);
+    if (root === null) {
       process.exit(1);
       return;
     }
-    const modifiedFiles = diffOutput.trim().split("\n").filter(Boolean);
-    const { updated, stale, orphans } = checkChangelogUnits(modifiedFiles, AI_RESOURCES);
+    const modifiedFiles = changedFiles(root, opts.base);
+    if (modifiedFiles === null) {
+      process.exit(1);
+      return;
+    }
+    const { updated, stale, orphans } = checkChangelogUnits(modifiedFiles, root);
     if (updated.length + stale.length + orphans.length === 0) {
       logOk("No modified assets found");
       return;
@@ -6734,7 +7029,7 @@ function itemFromRef(raw, defaultKind, ctx) {
     return { kind: prefixed[1], ref: value };
   }
   if (PATH_LIKE.test(value)) return { kind: defaultKind, ref: value };
-  if (defaultKind === "skill" && !value.includes("/") && existsSync(path25__default.join(ctx.agentDir, "skills", value, "SKILL.md"))) {
+  if (defaultKind === "skill" && !value.includes("/") && existsSync(path23__default.join(ctx.agentDir, "skills", value, "SKILL.md"))) {
     return { kind: "skill", ref: `./skills/${value}` };
   }
   return { kind: defaultKind, ref: `${defaultKind}:${value}` };
@@ -6870,7 +7165,7 @@ function migrateAgentYaml(source, options) {
         manual.push("metadata.soul: not a string; left unchanged");
         continue;
       }
-      if (path25__default.posix.basename(soul.replace(/\\/g, "/")).toLowerCase() === "soul.md") {
+      if (path23__default.posix.basename(soul.replace(/\\/g, "/")).toLowerCase() === "soul.md") {
         notes.push("metadata.soul \u2192 dropped (SOUL.md is a convention file)");
       } else {
         derived.push({ kind: "persona", ref: soul });
@@ -7104,7 +7399,7 @@ function migrateSubagents(skaileYamlPath, source) {
   if (!isMap(agentNode)) return void 0;
   const subNode = agentNode.get("subagents", true);
   if (!isMap(subNode)) return void 0;
-  const dir = path25__default.dirname(skaileYamlPath);
+  const dir = path23__default.dirname(skaileYamlPath);
   const notes = [];
   const manual = [];
   const changes = [];
@@ -7122,10 +7417,10 @@ function migrateSubagents(skaileYamlPath, source) {
       continue;
     }
     const id = instanceId(name);
-    const assetDir = path25__default.join(dir, ".skaile", "agents", id);
+    const assetDir = path23__default.join(dir, ".skaile", "agents", id);
     if (takenIds.has(id) || existsSync(assetDir)) {
       manual.push(
-        `agent.subagents.${name}: ${takenIds.has(id) ? `agents.${id} already exists` : `${path25__default.relative(dir, assetDir)} already exists`}; left in place`
+        `agent.subagents.${name}: ${takenIds.has(id) ? `agents.${id} already exists` : `${path23__default.relative(dir, assetDir)} already exists`}; left in place`
       );
       continue;
     }
@@ -7149,13 +7444,13 @@ function migrateSubagents(skaileYamlPath, source) {
       manifest.tools = { ...allowed ? { allowed } : {}, ...denied ? { denied } : {} };
     }
     const text = stringify(manifest, { lineWidth: 0 });
-    const manifestPath = path25__default.join(assetDir, "agent.yaml");
+    const manifestPath = path23__default.join(assetDir, "agent.yaml");
     changes.push({ type: "create", path: manifestPath, after: text });
     assetManifests.push({ file: manifestPath, text });
     if (typeof spec.prompt === "string" && spec.prompt.trim() !== "") {
       changes.push({
         type: "create",
-        path: path25__default.join(assetDir, "SOUL.md"),
+        path: path23__default.join(assetDir, "SOUL.md"),
         after: `${spec.prompt.replace(/\s+$/, "")}
 `
       });
@@ -7214,7 +7509,7 @@ function validateMigratedAgent(text, registry) {
 function collectAgentFiles(paths) {
   const files = /* @__PURE__ */ new Set();
   for (const input of paths) {
-    const abs = path25__default.resolve(input);
+    const abs = path23__default.resolve(input);
     if (!existsSync(abs)) continue;
     if (statSync(abs).isDirectory()) {
       for (const f of walkFiles(abs, (b) => b === "agent.yaml" || b === "skaile.yaml"))
@@ -7231,7 +7526,7 @@ function planAgentMigration(options) {
   const reports = [];
   for (const file of collectAgentFiles(options.paths)) {
     const source = readText(file);
-    const base = path25__default.basename(file);
+    const base = path23__default.basename(file);
     if (base === "skaile.yaml") {
       const result = migrateSubagents(file, source);
       if (!result) continue;
@@ -7239,7 +7534,7 @@ function planAgentMigration(options) {
       for (const asset of result.assetManifests) {
         const v = validateMigratedAgent(asset.text, options.registry);
         validation2.errors.push(
-          ...v.errors.map((e) => `${path25__default.basename(path25__default.dirname(asset.file))}: ${e}`)
+          ...v.errors.map((e) => `${path23__default.basename(path23__default.dirname(asset.file))}: ${e}`)
         );
         validation2.warnings.push(...v.warnings);
       }
@@ -7267,7 +7562,7 @@ function planAgentMigration(options) {
         });
         continue;
       }
-      migration = migrateAgentYaml(source, { agentDir: path25__default.dirname(file), knownKinds });
+      migration = migrateAgentYaml(source, { agentDir: path23__default.dirname(file), knownKinds });
     } catch (error) {
       reports.push({
         file,
@@ -7296,7 +7591,7 @@ function planAgentMigration(options) {
 }
 var DEFAULT_PUBLISHER = "skaile-ai";
 var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
-var posix2 = (p6) => p6.split(path25__default.sep).join("/");
+var posix2 = (p6) => p6.split(path23__default.sep).join("/");
 var MOVED_KINDS = { persona: "PERSONA.md", ruleset: "RULESET.md" };
 var KIND_MANIFEST_FILES = /* @__PURE__ */ new Set(["PERSONA.md", "RULESET.md", "SKILL.md"]);
 function readFrontmatterType(text) {
@@ -7327,14 +7622,14 @@ function planMarkdownMoves(root, knownKinds, manual, unknownTypes) {
     if (!text.startsWith("---")) continue;
     const found = readFrontmatterType(text);
     if (!found) continue;
-    const base = path25__default.basename(file);
-    const inAgentParts = file.split(path25__default.sep).includes("_agent-parts");
+    const base = path23__default.basename(file);
+    const inAgentParts = file.split(path23__default.sep).includes("_agent-parts");
     const targetName = MOVED_KINDS[found.type];
     if (targetName !== void 0 && !KIND_MANIFEST_FILES.has(base)) {
-      const to = path25__default.join(path25__default.dirname(file), base.replace(/\.md$/i, ""), targetName);
+      const to = path23__default.join(path23__default.dirname(file), base.replace(/\.md$/i, ""), targetName);
       if (existsSync(to) || targets.has(to)) {
         manual.push(
-          `${posix2(path25__default.relative(root, file))}: ${posix2(path25__default.relative(root, to))} already exists; not moved`
+          `${posix2(path23__default.relative(root, file))}: ${posix2(path23__default.relative(root, to))} already exists; not moved`
         );
         continue;
       }
@@ -7355,13 +7650,13 @@ function planAgentRefRewrites(root, moves, knownKinds, notes) {
   const changes = [];
   for (const file of walkFiles(root, (b) => b === "agent.yaml")) {
     const source = readText(file);
-    const agentDir = path25__default.dirname(file);
+    const agentDir = path23__default.dirname(file);
     let hits = 0;
     const refRewrite = (_kind, ref) => {
-      const moved = byOldPath.get(path25__default.resolve(agentDir, ref));
+      const moved = byOldPath.get(path23__default.resolve(agentDir, ref));
       if (moved === void 0) return ref;
       hits++;
-      const rel = posix2(path25__default.relative(agentDir, moved));
+      const rel = posix2(path23__default.relative(agentDir, moved));
       return rel.startsWith(".") ? rel : `./${rel}`;
     };
     let output;
@@ -7378,7 +7673,7 @@ function planAgentRefRewrites(root, moves, knownKinds, notes) {
     if (hits === 0 || output === source) continue;
     changes.push({ type: "write", path: file, before: source, after: output });
     notes.push(
-      `${posix2(path25__default.relative(root, file))}: persona/ruleset refs \u2192 composes items at the new paths`
+      `${posix2(path23__default.relative(root, file))}: persona/ruleset refs \u2192 composes items at the new paths`
     );
   }
   return changes;
@@ -7403,14 +7698,14 @@ function presetText(name, description, refs, publisher) {
 }
 function skillDirs(dir) {
   try {
-    return readdirSync(path25__default.join(dir, "skills"), { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync(path25__default.join(dir, "skills", e.name, "SKILL.md"))).map((e) => e.name).sort();
+    return readdirSync(path23__default.join(dir, "skills"), { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync(path23__default.join(dir, "skills", e.name, "SKILL.md"))).map((e) => e.name).sort();
   } catch {
     return [];
   }
 }
 function repoPublisher(root) {
   for (const name of ["skaile.manifest.yaml", "skaile.yaml"]) {
-    const file = path25__default.join(root, name);
+    const file = path23__default.join(root, name);
     if (!existsSync(file)) continue;
     try {
       const parsed = parse(readText(file));
@@ -7426,9 +7721,9 @@ function planBundles(root, skaileYamls, publisher, notes, manual) {
   const changes = [];
   const presets = [];
   const handled = /* @__PURE__ */ new Set();
-  const rel = (p6) => posix2(path25__default.relative(root, p6));
+  const rel = (p6) => posix2(path23__default.relative(root, p6));
   const convert = (name, bundleFile, dir) => {
-    const target = path25__default.join(dir, `${name}.preset.yaml`);
+    const target = path23__default.join(dir, `${name}.preset.yaml`);
     if (existsSync(target)) {
       manual.push(`${rel(target)} already exists; bundle ${name} not converted`);
       return;
@@ -7454,7 +7749,7 @@ function planBundles(root, skaileYamls, publisher, notes, manual) {
     }
     if (refs.length === 0) {
       manual.push(
-        `bundle ${name}: no dependencies found${bundleFile ? ` in ${rel(bundleFile)}` : ` and no skills under ${rel(path25__default.join(dir, "skills"))}`}; no preset generated`
+        `bundle ${name}: no dependencies found${bundleFile ? ` in ${rel(bundleFile)}` : ` and no skills under ${rel(path23__default.join(dir, "skills"))}`}; no preset generated`
       );
       return;
     }
@@ -7476,18 +7771,18 @@ function planBundles(root, skaileYamls, publisher, notes, manual) {
     const assets = Array.isArray(raw.assets) ? raw.assets : [];
     for (const entry of assets) {
       if (!isRecord(entry) || entry.kind !== "bundle" || typeof entry.name !== "string") continue;
-      const baseDir = path25__default.dirname(file);
-      const entryRoot = typeof entry.root === "string" ? path25__default.join(baseDir, entry.root) : baseDir;
+      const baseDir = path23__default.dirname(file);
+      const entryRoot = typeof entry.root === "string" ? path23__default.join(baseDir, entry.root) : baseDir;
       const files = Array.isArray(entry.files) ? entry.files : [];
       const bundleName = files.find(
         (f) => typeof f === "string" && f.endsWith(".bundle.yaml")
       );
-      convert(entry.name, bundleName ? path25__default.join(entryRoot, bundleName) : void 0, entryRoot);
+      convert(entry.name, bundleName ? path23__default.join(entryRoot, bundleName) : void 0, entryRoot);
     }
   }
   for (const bundleFile of walkFiles(root, (b) => b.endsWith(".bundle.yaml"))) {
     if (handled.has(bundleFile)) continue;
-    const base = path25__default.basename(bundleFile);
+    const base = path23__default.basename(bundleFile);
     let name = base.replace(/\.bundle\.yaml$/, "");
     try {
       const parsed = parse(readText(bundleFile));
@@ -7496,7 +7791,7 @@ function planBundles(root, skaileYamls, publisher, notes, manual) {
     } catch {
     }
     if (presets.some((p6) => p6.bundleFile === bundleFile)) continue;
-    convert(name, bundleFile, path25__default.dirname(bundleFile));
+    convert(name, bundleFile, path23__default.dirname(bundleFile));
   }
   return changes;
 }
@@ -7506,8 +7801,8 @@ function planSkaileYaml(root, file, source, notes, manual) {
   if (doc.errors.length > 0 || !isMap(doc.contents)) return [];
   const map = doc.contents;
   const raw = doc.toJS();
-  const dir = path25__default.dirname(file);
-  const rel = (p6) => posix2(path25__default.relative(root, p6));
+  const dir = path23__default.dirname(file);
+  const rel = (p6) => posix2(path23__default.relative(root, p6));
   const changes = [];
   let changed = false;
   const deps = map.get("dependencies", true);
@@ -7524,7 +7819,7 @@ function planSkaileYaml(root, file, source, notes, manual) {
   const hasPublication = PUBLICATION_KEYS.some((k) => raw[k] !== void 0);
   let remove = false;
   if (hasPublication) {
-    const manifestPath = path25__default.join(dir, "skaile.manifest.yaml");
+    const manifestPath = path23__default.join(dir, "skaile.manifest.yaml");
     if (existsSync(manifestPath)) {
       manual.push(
         `${rel(file)}: publisher/version/assets left in place \u2014 ${rel(manifestPath)} already exists; merge by hand`
@@ -7581,7 +7876,7 @@ function planSkaileYaml(root, file, source, notes, manual) {
   return changes;
 }
 function planAssetMigration(options) {
-  const root = path25__default.resolve(options.root);
+  const root = path23__default.resolve(options.root);
   const knownKinds = new Set(options.registry.getAllKinds());
   const notes = [];
   const manual = [];
@@ -7589,7 +7884,7 @@ function planAssetMigration(options) {
   const { moves, changes: moveChanges } = planMarkdownMoves(root, knownKinds, manual, unknownTypes);
   for (const move of moves) {
     notes.push(
-      `${posix2(path25__default.relative(root, move.from))} \u2192 ${posix2(path25__default.relative(root, move.to))} (${move.kind})`
+      `${posix2(path23__default.relative(root, move.from))} \u2192 ${posix2(path23__default.relative(root, move.to))} (${move.kind})`
     );
   }
   const agentChanges = planAgentRefRewrites(root, moves, knownKinds, notes);
@@ -7601,7 +7896,7 @@ function planAssetMigration(options) {
       const raw = parse(source);
       if (isRecord(raw)) skaileYamls.push({ file, source, raw });
     } catch {
-      manual.push(`${posix2(path25__default.relative(root, file))}: invalid YAML; skipped`);
+      manual.push(`${posix2(path23__default.relative(root, file))}: invalid YAML; skipped`);
     }
   }
   const publisher = repoPublisher(root);
@@ -7755,7 +8050,7 @@ function workspaceConfigFiles(dir) {
   } catch {
     return [];
   }
-  return names.filter((name) => isWorkspaceConfigFilename(name)).sort().map((name) => path25__default.join(dir, name));
+  return names.filter((name) => isWorkspaceConfigFilename(name)).sort().map((name) => path23__default.join(dir, name));
 }
 function readAgentConfigBlock(raw) {
   const key = AGENT_CONFIG_KEYS.find((candidate) => raw[candidate] !== void 0);
@@ -7767,7 +8062,7 @@ function readAgentConfigBlock(raw) {
   return flat ? { key, profiles: { default: profiles }, flat } : { key, profiles, flat };
 }
 function planProviderMigration(options) {
-  const projectDir = path25__default.resolve(options.projectDir);
+  const projectDir = path23__default.resolve(options.projectDir);
   const registryPath = options.workspace ? workspaceProviderRegistryPath(projectDir) : userProviderRegistryPath();
   const plan = {
     registryPath,
@@ -7783,7 +8078,7 @@ function planProviderMigration(options) {
       raw = parseDocument(readFileSync(file, "utf-8")).toJS() ?? {};
     } catch (error) {
       plan.warnings.push(
-        `${path25__default.basename(file)}: not valid YAML (${error instanceof Error ? error.message : String(error)}) \u2014 skipped`
+        `${path23__default.basename(file)}: not valid YAML (${error instanceof Error ? error.message : String(error)}) \u2014 skipped`
       );
       continue;
     }
@@ -7832,7 +8127,7 @@ function planProviderMigration(options) {
       });
       if (!model) {
         plan.warnings.push(
-          `${path25__default.basename(file)}: profile '${profile}' had no model: \u2014 it now resolves against registry order. Pin it with 'model: ${providerId}/<modelId>'.`
+          `${path23__default.basename(file)}: profile '${profile}' had no model: \u2014 it now resolves against registry order. Pin it with 'model: ${providerId}/<modelId>'.`
         );
       }
       touched = true;
@@ -7899,7 +8194,7 @@ function printPlan(plan) {
   for (const entry of plan.entries) {
     const base = entry.entry.base_url ?? S.dim("(transport-derived)");
     console.log(
-      `  ${S.label(`${path25__default.basename(entry.file)} ${entry.profile}`)} provider: ${entry.legacy.provider}, cloud: ${entry.legacy.cloud}`
+      `  ${S.label(`${path23__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(
@@ -7915,7 +8210,7 @@ function printPlan(plan) {
   console.log();
 }
 async function runMigrateProviders(opts) {
-  const projectDir = opts.projectDir ? path25__default.resolve(opts.projectDir) : process.cwd();
+  const projectDir = opts.projectDir ? path23__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) {
@@ -8046,7 +8341,7 @@ async function runMigrateAgents(paths, opts) {
   let failures = 0;
   let manualCount = 0;
   for (const report of plan.reports) {
-    const rel = path25__default.relative(base, report.file) || report.file;
+    const rel = path23__default.relative(base, report.file) || report.file;
     for (const note of report.notes) console.log(`  ${S.label(rel)} ${note}`);
     for (const note of report.manual) {
       manualCount++;
@@ -8073,14 +8368,14 @@ async function runMigrateAssets(root, opts) {
   const write = resolveMode(opts);
   const base = process.cwd();
   const plan = planAssetMigration({
-    root: path25__default.resolve(root ?? base),
+    root: path23__default.resolve(root ?? base),
     registry: getKindRegistry()
   });
   for (const note of plan.notes) console.log(`  ${note}`);
   for (const note of plan.manual) logWarn(note);
   for (const { file, type } of plan.unknownTypes) {
     logWarn(
-      `${path25__default.relative(base, file) || file}: frontmatter type "${type}" is not a registered asset kind (reported, not rewritten)`
+      `${path23__default.relative(base, file) || file}: frontmatter type "${type}" is not a registered asset kind (reported, not rewritten)`
     );
   }
   printChanges(plan.changes, base);
@@ -8103,8 +8398,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 = path25__default.resolve(opts.projectDir);
-    const projYaml = path25__default.join(projectDir, "skaile.yaml");
+    const projectDir = path23__default.resolve(opts.projectDir);
+    const projYaml = path23__default.join(projectDir, "skaile.yaml");
     if (!existsSync(projYaml)) {
       logErr(`No skaile.yaml in ${projectDir} \u2014 run \`skaile init\` first.`);
       process.exit(1);
@@ -8117,11 +8412,11 @@ function makeNpxCommand() {
     }
     const spinner = createSpinner();
     const key = sourceCacheKey(url);
-    const clonePath = path25__default.join(getGlobalCacheDir(), key);
+    const clonePath = path23__default.join(getGlobalCacheDir(), key);
     spinner.start(`Cloning ${url}`);
     try {
       if (!existsSync(clonePath)) {
-        mkdirSync(path25__default.dirname(clonePath), { recursive: true });
+        mkdirSync(path23__default.dirname(clonePath), { recursive: true });
         execSync(`git clone ${url} ${clonePath}`, { stdio: "ignore" });
       }
       spinner.stop(`Cloned to ${key}`);
@@ -8176,7 +8471,7 @@ function makeNpxCommand() {
   return npx;
 }
 function resolvePublisher(clonePath, url) {
-  const manifestPath = path25__default.join(clonePath, SKAILE_MANIFEST_FILENAME);
+  const manifestPath = path23__default.join(clonePath, SKAILE_MANIFEST_FILENAME);
   if (existsSync(manifestPath)) {
     try {
       const { manifest } = decodeSkaileManifest(readFileSync(manifestPath, "utf8"));
@@ -8189,12 +8484,12 @@ function resolvePublisher(clonePath, url) {
   return url.match(/github\.com[/:]([^/]+)\/[^/]+/)?.[1];
 }
 function resolveSkillName(clonePath, requested) {
-  const skillsDir = path25__default.join(clonePath, "skills");
-  if (existsSync(path25__default.join(skillsDir, requested, "SKILL.md"))) return requested;
+  const skillsDir = path23__default.join(clonePath, "skills");
+  if (existsSync(path23__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 = path25__default.join(skillsDir, entry.name, "SKILL.md");
+    const md = path23__default.join(skillsDir, entry.name, "SKILL.md");
     if (!existsSync(md)) continue;
     try {
       const { data } = parseFrontmatter(readFileSync(md, "utf8"));
@@ -8225,7 +8520,7 @@ function makeOutdatedCommand() {
   ).action(async (filter, opts) => {
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir),
+      projectDir: path23__default.resolve(opts.projectDir),
       driverTarget: opts.target
     });
     const entries = await am2.outdated();
@@ -8243,7 +8538,7 @@ function makeOutdatedCommand() {
     console.log(S.heading("  Outdated Assets"));
     console.log(`  ${S.rule(refW + 34)}`);
     for (const e of filtered) {
-      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`;
+      const status4 = e.problem !== void 0 ? e.problem : e.contentChanged ? `${e.currentVersion} content changed since lock ${S.dim(`(library ${e.library})`)}` : 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)}  ${e.problem !== void 0 ? pc5.red(status4) : pc5.yellow(status4)}`
       );
@@ -8262,7 +8557,7 @@ function makePatchCommand() {
   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({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir)
+      projectDir: path23__default.resolve(opts.projectDir)
     });
     try {
       const dest = await am2.patch(ref);
@@ -8276,7 +8571,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({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir)
+      projectDir: path23__default.resolve(opts.projectDir)
     });
     try {
       const patchFile = await am2.patchCommit(ref);
@@ -8290,7 +8585,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({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir)
+      projectDir: path23__default.resolve(opts.projectDir)
     });
     try {
       await am2.patchSubmit(ref);
@@ -8306,7 +8601,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({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir)
+      projectDir: path23__default.resolve(opts.projectDir)
     });
     am2.patchRemove(ref);
     logOk(`Patch removed for ${ref}`);
@@ -8325,7 +8620,7 @@ function action2(fn) {
   };
 }
 async function reconcileAndReport(projectDir, plugins) {
-  const { reconcilePlugins } = await import('../plugin-store-66QFBNEO.js');
+  const { reconcilePlugins } = await import('../plugin-store-WI4MZJLP.js');
   if (plugins.length === 0) {
     logInfo("No plugins declared \u2014 nothing to reconcile.");
     return;
@@ -8339,10 +8634,10 @@ async function reconcileAndReport(projectDir, plugins) {
   }
 }
 async function runInstall2(spec, opts) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-  const { specName } = await import('../plugin-store-66QFBNEO.js');
-  const yamlPath = path25__default.join(projectDir, "skaile.yaml");
+  const { specName } = await import('../plugin-store-WI4MZJLP.js');
+  const yamlPath = path23__default.join(projectDir, "skaile.yaml");
   const editor = WorkspaceYamlEditor2.load(yamlPath);
   const replaced = editor.addPlugin(spec, specName);
   editor.save();
@@ -8351,10 +8646,10 @@ async function runInstall2(spec, opts) {
   await reconcileAndReport(projectDir, editor.getPlugins());
 }
 async function runRemove(name, opts) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-  const { specName } = await import('../plugin-store-66QFBNEO.js');
-  const yamlPath = path25__default.join(projectDir, "skaile.yaml");
+  const { specName } = await import('../plugin-store-WI4MZJLP.js');
+  const yamlPath = path23__default.join(projectDir, "skaile.yaml");
   const editor = WorkspaceYamlEditor2.load(yamlPath);
   const removed = editor.removePlugin(name, specName);
   if (!removed) {
@@ -8366,7 +8661,7 @@ async function runRemove(name, opts) {
   await reconcileAndReport(projectDir, editor.getPlugins());
 }
 async function runList(opts) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const config = resolveSkWorkspaceConfig2(projectDir);
   const declared = config.plugins ?? [];
@@ -8381,7 +8676,7 @@ async function runList(opts) {
   const registry = createPluginRegistry();
   if (declared.length > 0) {
     try {
-      const { loadPlugins } = await import('../plugin-store-66QFBNEO.js');
+      const { loadPlugins } = await import('../plugin-store-WI4MZJLP.js');
       const result = await loadPlugins(projectDir, declared, registry);
       for (const f of result.failed) logWarn(f.error);
     } catch (err2) {
@@ -8556,7 +8851,7 @@ function neededSources(config, lock) {
 }
 function sourcesWithSidecar(sources) {
   const dir = getStoreManifestsDir();
-  return sources.filter((s) => existsSync(path25.join(dir, `${storeManifestSlug(s.url)}.yaml`))).map((s) => s.url);
+  return sources.filter((s) => existsSync(path23.join(dir, `${storeManifestSlug(s.url)}.yaml`))).map((s) => s.url);
 }
 function compact(obj) {
   const out = {};
@@ -8672,7 +8967,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 = path25__default.join(path25__default.resolve(opts.dir), filename);
+    const outPath = path23__default.join(path23__default.resolve(opts.dir), filename);
     if (existsSync(outPath)) {
       logErr(`File already exists: ${outPath}`);
       logInfo("Choose a different name or remove the existing file.");
@@ -8705,7 +9000,7 @@ function makePresetCommand() {
   return cmd;
 }
 async function runPresetExport(name, opts) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   const file = loadSkWorkspaceConfig(projectDir);
   if (!file) {
     logErr(`No skaile.yaml found in ${projectDir}`);
@@ -8715,7 +9010,7 @@ async function runPresetExport(name, opts) {
   const presetName = name ?? file.config.name ?? "my-preset";
   let lock = null;
   try {
-    lock = readLock(path25__default.join(projectDir, "skaile.lock.yaml"));
+    lock = readLock(path23__default.join(projectDir, "skaile.lock.yaml"));
   } catch {
     lock = null;
   }
@@ -8756,7 +9051,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 ? path25__default.resolve(opts.out) : path25__default.join(path25__default.resolve(opts.dir), `${presetName}.preset.yaml`);
+  const outPath = opts.out ? path23__default.resolve(opts.out) : path23__default.join(path23__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.");
@@ -8768,7 +9063,7 @@ ${body}` : body;
     logErr(`Failed to write ${outPath}: ${e.message}`);
     process.exit(1);
   }
-  logOk(`Exported ${S.brand(path25__default.basename(outPath))}`);
+  logOk(`Exported ${S.brand(path23__default.basename(outPath))}`);
   logInfo(`Path: ${outPath}`);
   if (unresolved.length > 0) {
     console.error(S.err("This file is NOT safe to share."));
@@ -8809,13 +9104,13 @@ function collectInput(value, acc) {
   return acc;
 }
 async function runPresetApply(filePath, opts) {
-  const projectDir = path25__default.resolve(opts.projectDir);
+  const projectDir = path23__default.resolve(opts.projectDir);
   const file = loadSkWorkspaceConfig(projectDir);
   if (!file) {
     logErr("No skaile.yaml \u2014 run `skaile init` first");
     process.exit(1);
   }
-  const resolved = path25__default.resolve(filePath);
+  const resolved = path23__default.resolve(filePath);
   if (!existsSync(resolved)) {
     logErr(`File not found: ${resolved}`);
     process.exit(1);
@@ -8994,7 +9289,7 @@ async function runPresetInstall(projectDir) {
     logInfo("Installing new dependencies\u2026");
     const result = await am2.install({});
     for (const d of result.deployed) logOk(d);
-    for (const m of result.missing) logErr(`Missing: ${m}`);
+    for (const m of result.missing) logErr(`Missing: ${m}${result.missingHints?.[m] ?? ""}`);
     await reportInstalledSoftDeps(am2);
   } catch (err2) {
     logErr(`Install failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
@@ -9031,7 +9326,7 @@ async function reportNestedPresetRefs(preset) {
 }
 async function checkPresetCycles(preset, resolved) {
   const { detectCycles } = await import('../discovery/index.js');
-  const presetRef = path25__default.basename(resolved, ".preset.yaml");
+  const presetRef = path23__default.basename(resolved, ".preset.yaml");
   const edges = [];
   for (const item of preset.items) {
     if (item.ref) {
@@ -9083,7 +9378,7 @@ function printPresetSummary(preset, placeholderCount, hasWarnings) {
   }
 }
 async function runPresetValidate(filePath) {
-  const resolved = path25__default.resolve(filePath);
+  const resolved = path23__default.resolve(filePath);
   const preset = await loadPresetForValidation(resolved);
   await reportNestedPresetRefs(preset);
   await checkPresetCycles(preset, resolved);
@@ -9133,11 +9428,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     let agentDir;
     if (agentArg) {
       if (agentArg.includes("/") || agentArg.includes("\\")) {
-        agentDir = path25__default.resolve(projectDir, agentArg);
+        agentDir = path23__default.resolve(projectDir, agentArg);
       } else {
         let resolved;
         try {
@@ -9146,7 +9441,7 @@ function makeRebuildCommand() {
           if (!(err2 instanceof AgentRefResolutionError)) throw err2;
           logWarn(`${err2.message} \u2014 using "${agentArg}"`);
         }
-        agentDir = resolved ?? path25__default.resolve(projectDir, agentArg);
+        agentDir = resolved ?? path23__default.resolve(projectDir, agentArg);
       }
     } else {
       let resolved;
@@ -9216,9 +9511,9 @@ Try a different harness with \`--driver claude-sdk\`.`;
 // cli/src/commands/run.ts
 function resolveSingleShotAgentDir(projectDir, agentDefinition) {
   if (!agentDefinition) return resolveAgentDir(projectDir);
-  const asPath = agentDefinition.endsWith("agent.yaml") ? path25__default.dirname(path25__default.resolve(projectDir, agentDefinition)) : agentDefinition;
+  const asPath = agentDefinition.endsWith("agent.yaml") ? path23__default.dirname(path23__default.resolve(projectDir, agentDefinition)) : agentDefinition;
   const dir = resolveAgentDefinitionDir(projectDir, asPath);
-  if (!dir || !fs11__default.existsSync(path25__default.join(dir, "agent.yaml"))) {
+  if (!dir || !fs9__default.existsSync(path23__default.join(dir, "agent.yaml"))) {
     throw new Error(
       `--agent-definition "${agentDefinition}" does not resolve to an agent directory with agent.yaml${dir ? ` (looked in ${dir})` : ""}`
     );
@@ -9317,7 +9612,7 @@ function makeRunCommand() {
     "--agent-definition <ref|path>",
     "Agent asset for this one invocation (agent:@pub/name, ai-assets://\u2026, or a directory with agent.yaml); single-shot prompts only"
   ).option("--skill <name>", "Skill name (for single-shot mode)").action(async (positional, opts) => {
-    const projectDir = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const cliDriver = opts.driver;
     const dryRun = opts.dryRun ?? false;
     const agentDefinition = opts.agentDefinition?.trim() || void 0;
@@ -9436,7 +9731,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const sessionId = opts.session;
     const dryRun = opts.dryRun ?? false;
     const session = sessionId ? await loadSessionById(projectDir, sessionId) : await loadSession(projectDir);
@@ -9463,7 +9758,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const session = await loadSession(projectDir);
     if (!session) {
       logInfo("No active session.");
@@ -9488,7 +9783,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     await clearSession(projectDir);
     logOk("Session cleared.");
   });
@@ -9498,7 +9793,7 @@ function makeReplCommand() {
     const { findWorkspaceRoot } = await import('../core/index.js');
     const { startRepl } = await import('../tui/index.js');
     const os2 = await import('os');
-    const userCwd = path25__default.resolve(opts.projectDir ?? process.cwd());
+    const userCwd = path23__default.resolve(opts.projectDir ?? process.cwd());
     const workspaceRoot = findWorkspaceRoot(userCwd);
     let projectDir;
     let agentCwd;
@@ -9520,13 +9815,13 @@ function makeReplCommand() {
         p4.cancel("Cancelled.");
         process.exit(0);
       }
-      const tmpDir = fs11__default.mkdtempSync(path25__default.join(os2.tmpdir(), "skaile-repl-"));
+      const tmpDir = fs9__default.mkdtempSync(path23__default.join(os2.tmpdir(), "skaile-repl-"));
       projectDir = tmpDir;
       agentCwd = userCwd;
       logOk(`Temporary workspace: ${S.cmd(tmpDir)}`);
       if (!driverOverride) {
-        const claudeDir = path25__default.join(os2.homedir(), ".claude");
-        if (fs11__default.existsSync(claudeDir)) {
+        const claudeDir = path23__default.join(os2.homedir(), ".claude");
+        if (fs9__default.existsSync(claudeDir)) {
           driverOverride = "claude-sdk";
           logInfo(`Detected ${S.cmd("~/.claude")} \u2192 using ${S.cmd("claude-sdk")} harness`);
         } else {
@@ -9598,12 +9893,12 @@ function makeServeCommand() {
   );
 }
 async function ensurePluginsLoadedForServe(projectDir) {
-  const { logInfo: logInfo2, logWarn: logWarn2 } = await import('../helpers-R44RUTDY.js');
+  const { logInfo: logInfo2, logWarn: logWarn2 } = await import('../helpers-KC5O7CML.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-66QFBNEO.js');
+    const { ensurePluginsLoaded } = await import('../plugin-store-WI4MZJLP.js');
     const { pluginRegistry } = await import('../plugin-registry/index.js');
     const result = await ensurePluginsLoaded(projectDir, config.plugins, pluginRegistry);
     if (result.loaded.length > 0) {
@@ -9617,14 +9912,14 @@ async function ensurePluginsLoadedForServe(projectDir) {
   }
 }
 async function runCompileTest(opts) {
-  const { logOk: logOk2, logErr: logErr2, logInfo: logInfo2, S: S2 } = await import('../helpers-R44RUTDY.js');
+  const { logOk: logOk2, logErr: logErr2, logInfo: logInfo2, S: S2 } = await import('../helpers-KC5O7CML.js');
   const { tmpdir } = await import('os');
   const { dirname: dirname3, join: join7, resolve: resolve5 } = await import('path');
   const { fileURLToPath: fileURLToPath2 } = await import('url');
   const { unlinkSync, existsSync: existsSync18 } = await import('fs');
   const { spawn } = await import('child_process');
   const { portableSpawnSync: portableSpawnSync2 } = await import('../core/index.js');
-  const { MONOREPO_ROOT } = await import('../paths-YUCP7K6U.js');
+  const { MONOREPO_ROOT } = await import('../paths-JKEKXM52.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).");
@@ -10107,7 +10402,7 @@ function resolveMode2(opts) {
   if (opts.forceLocal && opts.forceRemote) {
     throw new Error("Cannot use both --local and --remote");
   }
-  const startDir = path25__default.resolve(opts.projectDir ?? process.cwd());
+  const startDir = path23__default.resolve(opts.projectDir ?? process.cwd());
   const localDb = findLogsDb(startDir);
   if (opts.forceLocal) {
     if (!localDb) {
@@ -10140,14 +10435,14 @@ function resolveMode2(opts) {
 function findLogsDb(startDir) {
   let dir = startDir;
   for (let i = 0; i < MAX_WALK_LEVELS; i++) {
-    const candidate = path25__default.join(dir, ".skaile", "logs.db");
+    const candidate = path23__default.join(dir, ".skaile", "logs.db");
     if (existsSync(candidate)) {
       try {
         if (statSync(candidate).isFile()) return candidate;
       } catch {
       }
     }
-    const parent = path25__default.dirname(dir);
+    const parent = path23__default.dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -10322,7 +10617,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const sessions = await listSessions(projectDir);
     const current = await loadSession(projectDir);
     if (sessions.length === 0) {
@@ -10350,7 +10645,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     const session = await loadSessionById(projectDir, runId);
     if (!session) {
       logErr(`Session not found: ${runId}`);
@@ -10359,12 +10654,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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__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 = path25__default.resolve(opts.projectDir);
+    const projectDir = path23__default.resolve(opts.projectDir);
     await deleteSession(projectDir, runId);
     logOk(`Deleted session: ${S.dim(runId.slice(0, 8))}`);
   });
@@ -10418,12 +10713,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 && fs9__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(fs9__default.readFileSync(entry.source, "utf-8"));
     return;
   }
   logErr(`Asset not found: ${kind}:${name}`);
@@ -10433,7 +10728,7 @@ function makeShowCommand() {
   return new Command("show").description("Show deployed assets overview, or print asset content").argument("[kind]", "Asset kind (skill, agent, prompt, flow, preset, 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({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir),
+      projectDir: path23__default.resolve(opts.projectDir),
       driverTarget: opts.target
     });
     if (!kind) {
@@ -10496,14 +10791,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 ${path25__default.join(globalSkaileDir(), "store", "config.yaml")}.`
+      `\`skaile store mode\` is scaffolded but not yet wired. Store config lives at ${path23__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-4WUMQHES.js');
+    const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-P3D337NH.js');
     try {
-      const remote = await openCatalogSource2({ projectDir: path25__default.resolve(opts.projectDir) });
+      const remote = await openCatalogSource2({ projectDir: path23__default.resolve(opts.projectDir) });
       const assets = await remote.listAssets(opts.kind ? { kind: opts.kind } : {});
       const results = filterCatalogAssets(assets, query);
       if (results.length === 0) {
@@ -10518,7 +10813,7 @@ function makeStoreCommand() {
 `
       );
     } catch (e) {
-      if (e instanceof LocalCatalogDisabledError) {
+      if (e instanceof LocalCatalogDisabledError2) {
         logErr(
           `Remote catalog disabled (catalog.url: local). Set \`catalog.url: https://skaile.store\` in ${userConfigPath()}.`
         );
@@ -10529,10 +10824,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-4WUMQHES.js');
-    const { supportsInstallManifest } = await import('../project-VMOHUXBD.js');
+    const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-P3D337NH.js');
+    const { supportsInstallManifest } = await import('../project-WFUDVYNN.js');
     try {
-      const remote = await openCatalogSource2({ projectDir: path25__default.resolve(opts.projectDir) });
+      const remote = await openCatalogSource2({ projectDir: path23__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)`);
@@ -10580,7 +10875,7 @@ function makeStoreCommand() {
       console.log(`  ${S.dim(`Install:  skaile add ${canonical}`)}`);
       console.log();
     } catch (e) {
-      if (e instanceof LocalCatalogDisabledError) {
+      if (e instanceof LocalCatalogDisabledError2) {
         logErr(
           `Remote catalog disabled (catalog.url: local). Set \`catalog.url: https://skaile.store\` in ${userConfigPath()}.`
         );
@@ -10656,7 +10951,7 @@ 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({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir)
+      projectDir: path23__default.resolve(opts.projectDir)
     });
     const root = am2.tree();
     if (root.children.length === 0) {
@@ -10683,20 +10978,24 @@ function makeUpdateCommand() {
         const catalogSpinner = createSpinner();
         catalogSpinner.start("Refreshing catalog cache");
         try {
-          const remote = await openCatalogSource({ projectDir: path25__default.resolve(opts.projectDir) });
+          const remote = await openCatalogSource({ projectDir: path23__default.resolve(opts.projectDir) });
           const result2 = await remote.refresh();
           catalogSpinner.stop(
             `Catalog refreshed: ${S.heading(String(result2.assetsCached))} assets cached`
           );
           logInfo(`Source: ${remote.baseUrl}`);
         } catch (err2) {
-          catalogSpinner.stop("Catalog refresh failed");
-          logErr(`Catalog refresh failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
-          logInfo("Continuing with asset re-deploy. Run `skaile catalog test` to debug.");
+          if (err2 instanceof LocalCatalogDisabledError) {
+            catalogSpinner.stop("Catalog refresh skipped (catalog.url: local)");
+          } else {
+            catalogSpinner.stop("Catalog refresh failed");
+            logErr(`Catalog refresh failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
+            logInfo("Continuing with asset re-deploy. Run `skaile catalog test` to debug.");
+          }
         }
       }
       if (opts.catalogOnly) return;
-      const projectDir = path25__default.resolve(opts.projectDir);
+      const projectDir = path23__default.resolve(opts.projectDir);
       if (await shouldSyncSources(opts)) {
         const syncSpinner = createSpinner();
         syncSpinner.start("Syncing sources");
@@ -10840,7 +11139,7 @@ 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({
       registry: getKindRegistry(),
-      projectDir: path25__default.resolve(opts.projectDir)
+      projectDir: path23__default.resolve(opts.projectDir)
     });
     const chain = am2.why(ref);
     if (chain.length === 0) {
@@ -10875,10 +11174,19 @@ function makeWhyCommand() {
 var _defaultFormatHelp = Help.prototype.formatHelp;
 var pkg = JSON.parse(
   readFileSync(
-    path25__default.resolve(path25__default.dirname(fileURLToPath(import.meta.url)), "../../package.json"),
+    path23__default.resolve(path23__default.dirname(fileURLToPath(import.meta.url)), "../../package.json"),
     "utf-8"
   )
 );
+for (const key of [
+  "SKAILE_HOME",
+  "SKAILE_INDEX_PATH",
+  "SKAILE_LIBRARIES_DIR",
+  "SKAILE_CACHE_DIR"
+]) {
+  const value = process.env[key];
+  if (value) process.env[key] = path23__default.resolve(value);
+}
 var program = new Command("skaile").description("AI asset manager").version(pkg.version, "-v, --version", "Show the skaile CLI version").enablePositionalOptions().configureHelp({
   formatHelp(cmd, helper) {
     if (cmd.name() !== "skaile") return _defaultFormatHelp.call(helper, cmd, helper);
@@ -10938,7 +11246,7 @@ Execution:
   debug tools|connectors|mcp|config|state  Inspect running container state
   connect <url>                Interactive WebSocket REPL
   logs [--follow] [--filter]   Tail skaile container logs
-  session list|show|switch|del Session management
+  session list|show|switch|delete  Session management
   status                       Current session state
   clear                        Unset current session
 
@@ -11006,31 +11314,31 @@ async function runInit(projectDir, opts) {
     process.exitCode = 1;
     return;
   }
-  const resolved = path25__default.resolve(projectDir ?? ".");
-  const projectName = path25__default.basename(resolved);
+  const resolved = path23__default.resolve(projectDir ?? ".");
+  const projectName = path23__default.basename(resolved);
   const created = [];
   const { existsSync: existsSync18 } = await import('fs');
   if (!existsSync18(resolved)) {
     mkdirSync5(resolved, { recursive: true });
     created.push(".");
   }
-  const skaileDir = path25__default.join(resolved, ".skaile");
+  const skaileDir = path23__default.join(resolved, ".skaile");
   if (!existsSync18(skaileDir)) {
-    mkdirSync5(path25__default.join(skaileDir, "sessions"), { recursive: true });
+    mkdirSync5(path23__default.join(skaileDir, "sessions"), { recursive: true });
     created.push(".skaile/");
   }
-  const settingsPath = path25__default.join(skaileDir, "settings.json");
+  const settingsPath = path23__default.join(skaileDir, "settings.json");
   if (!existsSync18(settingsPath)) {
     writeFileSync7(settingsPath, "{}\n");
     created.push(".skaile/settings.json");
   }
-  const wsConfigPath = path25__default.join(resolved, "skaile.yaml");
+  const wsConfigPath = path23__default.join(resolved, "skaile.yaml");
   if (!existsSync18(wsConfigPath)) {
     writeFileSync7(wsConfigPath, stringify2(buildInitWorkspaceConfig(projectName, harness)));
     created.push("skaile.yaml");
   }
   for (const dir of new Set(Object.values(DRIVER_TARGETS[harness].local))) {
-    const full = path25__default.join(resolved, dir);
+    const full = path23__default.join(resolved, dir);
     if (!existsSync18(full)) {
       mkdirSync5(full, { recursive: true });
       created.push(`${dir}/`);
@@ -11060,9 +11368,9 @@ function buildInitWorkspaceConfig(projectName, harness) {
   };
 }
 async function initGitScaffold(resolved, created) {
-  const { execSync: execSync3 } = await import('child_process');
+  const { execSync: execSync2 } = await import('child_process');
   const { existsSync: existsSync18, readFileSync: readFileSync10, writeFileSync: writeFileSync7 } = await import('fs');
-  const gitignorePath = path25__default.join(resolved, ".gitignore");
+  const gitignorePath = path23__default.join(resolved, ".gitignore");
   const entries = [
     "node_modules/",
     ".skaile/sessions/",
@@ -11088,9 +11396,9 @@ async function initGitScaffold(resolved, created) {
 `);
     if (!existing) created.push(".gitignore");
   }
-  if (!existsSync18(path25__default.join(resolved, ".git"))) {
+  if (!existsSync18(path23__default.join(resolved, ".git"))) {
     try {
-      execSync3("git init", { cwd: resolved, stdio: "pipe" });
+      execSync2("git init", { cwd: resolved, stdio: "pipe" });
       created.push(".git/");
     } catch (err2) {
       const msg = err2 instanceof Error ? err2.message : String(err2);
@@ -11118,7 +11426,7 @@ async function bootstrapUserConfig() {
 }
 async function hydrateInitSources(resolved, created) {
   try {
-    const { ensureSourcesCloned } = await import('../ensure-sources-DSTSXJWK.js');
+    const { ensureSourcesCloned } = await import('../ensure-sources-277VI7R3.js');
     const hydrate = ensureSourcesCloned(resolved, { quiet: true });
     for (const n of hydrate.cloned) created.push(`~/.skaile/cache/sources/${n}/`);
     if (hydrate.failed.length > 0) {
@@ -11134,7 +11442,7 @@ function printInitSummary(resolved, projectDir, created) {
   logOk(`Initialized project at ${S.heading(resolved)}`);
   console.log();
   console.log(S.heading("  Next steps:"));
-  const isCurrentDir = resolved === path25__default.resolve(".");
+  const isCurrentDir = resolved === path23__default.resolve(".");
   let step = 1;
   if (!isCurrentDir) {
     console.log(`  ${S.dim(`${step}.`)} ${S.cmd(`cd ${projectDir}`)}`);
@@ -11158,7 +11466,7 @@ function printInitSummary(resolved, projectDir, created) {
   console.log();
 }
 program.command("setup").description("Interactive provider setup wizard").action(async () => {
-  const { cmdSetup } = await import('../setup-PYY23HGZ.js');
+  const { cmdSetup } = await import('../setup-RAMLTORM.js');
   await cmdSetup([], { projectDir: process.cwd() });
 });
 program.addCommand(makeInstallCommand());
@@ -11232,6 +11540,10 @@ program.command("path").description("Show resolved paths (honours SKAILE_HOME an
   console.log();
 });
 program.addCommand(makeCompleteCommand(program));
+process.stdout.on("error", (err2) => {
+  if (err2.code === "EPIPE") process.exit(0);
+  throw err2;
+});
 try {
   await program.parseAsync();
 } catch (err2) {