@skaile/workspaces 5.11.0 → 5.13.0

package/dist/cli/index.js

@@ -1,98 +1,101 @@
 #!/usr/bin/env node
-import { makeProvidersCommand, loadRegistryView, addProviderEntry, ProviderRegistryWriteError } from '../chunk-XDKH7XSA.js';
-import { makeSourceCommand, syncProjectSources, divergedSourceClones } from '../chunk-WSBKB4CJ.js';
-import { makeInstallCommand, makeCheckCommand, makeCleanCommand, reportReplaced, reportRelocked, reportMoved, REF_HINT, reportInstalledSoftDeps } from '../chunk-CJERAGFY.js';
+import { makeProvidersCommand, loadRegistryView, addProviderEntry, ProviderRegistryWriteError } from '../chunk-R6QHJEHE.js';
+import { makeInstallCommand, makeCheckCommand, makeCleanCommand, reportReplaced, reportRelocked, reportMoved, editedConventionFiles, REF_HINT, reportInstalledSoftDeps } from '../chunk-6GICC4RJ.js';
 import { createSpinner } from '../chunk-NESV47MF.js';
-import { AI_RESOURCES } from '../chunk-S3O3GKB7.js';
-import { unresolvedManifestDependencies, warnIgnoredDomainFiles, warnLegacyBundleFiles, removedDomainOption, rejectRemovedDomainOption, resolveLibraryPublisherDetailed, warnLibraryNameFallback, indexLibrary, requireValidPublisherOrExit, exitOnManifestPublisherProblems, registerLibraryAsset, DOMAIN_REMOVED_HINT, manifestPublisherProblems, manifestRequiresProblems, findAssetManifestFile, declaredVersion, checkAssetFile, duplicateAssetMessage, readAssetBody, checkAsset, invalidSemverText } from '../chunk-YOH2L76X.js';
-import { getStoreConfig, storeFetch, deviceLogin, loadStoreAuthConfig, logout, hasStoredAuth, isStoreAuthenticated, getStoreToken, getStoreIdentity, assetEntryRef, manifestVersionMismatchMessage } from '../chunk-RYYLMBA2.js';
-import { openCatalogSource, LocalCatalogDisabledError, openLibraryManager, openLibrary } from '../chunk-PQFHMQHQ.js';
-import { logErr, S, logOk, logInfo, logWarn, TARGET_DEFAULT_HINT, requireProjectConfig, deferredWarnings, warnLegacyClaudeCopies, kindColorPad, kindColor, colorRef, formatSoftDepSection, bareSoftDepName, formatSoftDepHint, formatRelativeTime, formatSoftDepRemovePreview, formatSoftDepAddPreview, fitWidth, KIND_COL_WIDTH } from '../chunk-GV4DZ6MT.js';
-import { getKindRegistry, getKnownKinds } from '../chunk-CAHB6MHA.js';
+import { makeSourceCommand, syncProjectSources, divergedSourceClones } from '../chunk-ZSMMX3JD.js';
+import { AI_RESOURCES } from '../chunk-HWGYJMME.js';
+import { checkAsset, agentComposeRefAdvisories, findAssetManifestFile, declaredVersion, checkAssetFile, duplicateAssetMessage, readAssetBody, checkAgentFiles, invalidSemverText } from '../chunk-PN44DOGP.js';
+import { getStoreConfig, storeFetch, isStoreAuthenticated, getStoreToken } from '../chunk-PZOO7L26.js';
+import { unresolvedManifestDependencies, warnIgnoredDomainFiles, warnLegacyBundleFiles, removedDomainOption, rejectRemovedDomainOption, deviceLogin, loadStoreAuthConfig, logout, hasStoredAuth, resolveLibraryPublisherDetailed, getStoreIdentity, warnLibraryNameFallback, indexLibrary, requireValidPublisherOrExit, exitOnManifestPublisherProblems, registerLibraryAsset, DOMAIN_REMOVED_HINT, reportLibrarySymlinks, assetEntryRef, manifestPublisherProblems, manifestRequiresProblems, manifestVersionMismatchMessage, exitOnLibrarySymlinks } from '../chunk-FB3NREF7.js';
+import { storeNotInstallableReason } from '../chunk-U27JRO5L.js';
+import { openCatalogSource, LocalCatalogDisabledError, openLibraryManager, openLibrary } from '../chunk-VLBIME5L.js';
+import { logErr, S, logOk, logInfo, logWarn, TARGET_DEFAULT_HINT, requireProjectConfig, deferredWarnings, logNoProject, warnLegacyClaudeCopies, kindColorPad, kindColor, colorRef, formatSoftDepSection, bareSoftDepName, formatSoftDepHint, formatRelativeTime, formatSoftDepRemovePreview, formatSoftDepAddPreview, fitWidth, KIND_COL_WIDTH } from '../chunk-PYTTF754.js';
+import { getKindRegistry, getKnownKinds } from '../chunk-4NJ3QQHZ.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-VLTQGE2E.js';
-import { buildClaudePluginFiles } from '../chunk-6O2X3GPW.js';
-import '../chunk-IER3KIPH.js';
-import '../chunk-QVFAS5IO.js';
+import { runAgentChat, isCompositionError, loadSessionById, loadSession, listSessions, setCurrentSession, deleteSession, clearSession, loadAgentManifest, hashAgentFiles, createCompositionContentSource, compileComposition, instanceForSession, resolveAgentInstance, describeComposition, MarkdownStreamer, createFinalTextFallback, resolveBinding, UnknownCompositionKindError } from '../chunk-HBZD3MIW.js';
+import { buildClaudePluginFiles } from '../chunk-J4DB5G36.js';
+import '../chunk-NDUYFYJB.js';
+import '../chunk-V5JHD4I2.js';
 import '../chunk-R6O6YWU7.js';
-import '../chunk-G4FFOV3N.js';
-import '../chunk-T42WRQ4O.js';
+import '../chunk-6JKIOPT3.js';
+import '../chunk-2BIESC6S.js';
 import '../chunk-4ZTPYIBE.js';
-import '../chunk-MZG34MBZ.js';
+import '../chunk-XJYBCDY2.js';
 import '../chunk-X5YPJV4N.js';
 import '../chunk-O7SG5PC2.js';
 import '../chunk-7QBNJTTQ.js';
-import '../chunk-OBYKJB4U.js';
-import '../chunk-5LKOAX7I.js';
+import '../chunk-O2SYFJWP.js';
+import '../chunk-OQ5MKDS3.js';
 import '../chunk-32NA4TVC.js';
 import '../chunk-W3UDISS2.js';
-import '../chunk-NWDSLXOX.js';
-import { runFlow, resumeFlow } from '../chunk-3SM2DL2T.js';
+import '../chunk-PHRNUTSG.js';
+import { runFlow, resumeFlow } from '../chunk-GMDSRSGI.js';
 import '../chunk-4R6DROGN.js';
-import { validateFlowVersions } from '../chunk-X77SUM4P.js';
-import '../chunk-GCHPUTA3.js';
+import { parseSkillRequirements, validateRequirements, validateFlowVersions } from '../chunk-USHB5KEY.js';
+import '../chunk-ZU24LWBI.js';
 import '../chunk-ISHJITXJ.js';
-import '../chunk-4A4OD24G.js';
+import '../chunk-Y4Z7LGSH.js';
 import '../chunk-X4BAYGMT.js';
-import '../chunk-R7NHYEJF.js';
-import '../chunk-T7CTHHG7.js';
-import '../chunk-HCEVNYSH.js';
+import '../chunk-5SKVCMRC.js';
+import '../chunk-6NQDDCIL.js';
+import '../chunk-YTZFSKWL.js';
 import '../chunk-LOO5CB5M.js';
 import '../chunk-2H73V6XR.js';
-import '../chunk-M3B6EIJD.js';
+import '../chunk-B7CZYFB2.js';
 import '../chunk-B4X2N7JQ.js';
 import '../chunk-YROR332M.js';
-import { getProviderPreset, AI_PROVIDER_PRESETS } from '../chunk-47U4GZ4M.js';
+import { listDrivers, getProviderPreset, AI_PROVIDER_PRESETS } from '../chunk-BVJU2GKE.js';
 import '../chunk-6E6PKKAD.js';
 import '../chunk-IFGTRL2I.js';
-import { projectAiAssetsRoots, loadFlow, loadAllFlowEntries, findFlowFileInRoots } from '../chunk-TCHRMVTO.js';
+import { projectAiAssetsRoots, loadFlow, loadAllFlowEntries, findFlowFileInRoots } from '../chunk-XBYSURMK.js';
 import '../chunk-LNFKL23K.js';
-import '../chunk-D3B36CYC.js';
+import '../chunk-X3RMRJNR.js';
 import '../chunk-M3WPBTGJ.js';
 import { nodeLabel, nodeSkillAsset, nodeIsInert, nodeIsOptional, nodeRunKind, flowSkillVersionPins } from '../chunk-7RGTAEG6.js';
 import '../chunk-NUELZWCF.js';
 import '../chunk-F4NJDSR7.js';
-import { AssetManager, MissingManifestError, parseRefTolerant, normalizeRepoUrl, FACTORY_SOURCE_URL } from '../chunk-DZMNFCWB.js';
-import { libraryDirMissing, missingLibraryDirMessage, cloneOrInitGitRepo, trackOriginBranch, stampManifestPublisher, ensureGitRepo, conflictingAssetRoot, setManifestPublisher, LIBRARY_OWNERSHIPS, isGitRepo, assertManifestEditable, installLibraryAsset, missingRootAssets, assertValidLibraryName, syncManifestWithDisk, getStoreManifestsDir, getDefaultValue, isSecretPlaceholder } from '../chunk-2F5AWQX5.js';
-import { parseManifestFile, SEMVER_RE } from '../chunk-J4RBUFGM.js';
-import '../chunk-COH6FQAG.js';
-import '../chunk-R7FOF242.js';
+import { AssetManager, parseRefTolerant, MissingManifestError, normalizeRepoUrl, FACTORY_SOURCE_URL } from '../chunk-Y7WKXPWS.js';
+import { libraryDirMissing, missingLibraryDirMessage, cloneOrInitGitRepo, trackOriginBranch, stampManifestPublisher, isGitRepo, ensureGitRepo, conflictingAssetRoot, setManifestPublisher, LIBRARY_OWNERSHIPS, assertManifestEditable, installLibraryAsset, missingRootAssets, getStoreManifestsDir, assertValidLibraryName, syncManifestWithDisk, getDefaultValue, isSecretPlaceholder } from '../chunk-DKGEV6SQ.js';
+import { parseManifestFile, SEMVER_RE } from '../chunk-NVO6WECE.js';
+import '../chunk-PXDWTJ3P.js';
+import '../chunk-H5U7LNTJ.js';
 import '../chunk-3TXEJN4W.js';
-import { installTargetOf, SCAFFOLD_KINDS } from '../chunk-FH7W6TJ4.js';
-import '../chunk-CGYEHQOX.js';
+import { installTargetOf, SCAFFOLD_KINDS } from '../chunk-5FYOM4RF.js';
+import '../chunk-NOA6EJXE.js';
 import '../chunk-KTBKW2FI.js';
 import '../chunk-UQ6LFBPZ.js';
-import '../chunk-HZXUXHIV.js';
-import { effectiveComposes, validatePreset, composeSlotDiagnostics, agentDeprecationDiagnostics, validateAgent, SLOT_ID_PATTERN } from '../chunk-ZCAJZ4B2.js';
-import { resolveSettings, globalSettingsPath, projectSettingsPath, loadSettings, saveSettings, WorkspaceYamlEditor, resolveLibraryDir, checkAgentSkillConformance, globalInstallDir, GLOBAL_INSTALL_DIR_NAME, readLock, aiResourceRoots, workspaceProviderRegistryPath, userProviderRegistryPath, loadProviderRegistryFile } from '../chunk-PBBPZYVG.js';
+import '../chunk-4L4R5LV3.js';
+import { effectiveComposes, validatePreset, composeSlotDiagnostics, agentDeprecationDiagnostics, validateAgent, SLOT_ID_PATTERN } from '../chunk-57SF6W6E.js';
+import { resolveSettings, globalSettingsPath, projectSettingsPath, loadSettings, saveSettings, WorkspaceYamlEditor, resolveLibraryDir, checkAgentSkillConformance, resolveSettingsWithSources, readLock, globalInstallDir, GLOBAL_INSTALL_DIR_NAME, aiResourceRoots, workspaceProviderRegistryPath, userProviderRegistryPath, loadProviderRegistryFile } from '../chunk-BF422IDP.js';
 import '../chunk-4GY63JU6.js';
-import { factoryAssetRoots } from '../chunk-EDYHEMJA.js';
-import '../chunk-PMECEZK3.js';
+import { resolveRuntimeAssets, factoryAssetRoots } from '../chunk-QO7CR3KB.js';
+import { deployedDir } from '../chunk-D54T2F54.js';
 import { DEFAULT_DRIVER_ID, DRIVER_DEFAULTS } from '../chunk-5BEFNLOR.js';
 import { findKindDirs } from '../chunk-A2ULN3KX.js';
-import { SourceEntryError, sourceCacheKey, getGlobalCacheDir, resolveAgentDir, AgentRefResolutionError, resolveAgentDefinitionDir, resolveSkWorkspaceConfig, matchPin, coerceVersion, loadSkWorkspaceConfig, normalizeAgentInstances, agentInstanceDiagnostics, storeManifestSlug, isWorkspaceConfigFilename } from '../chunk-ALEYHUC5.js';
+import { SourceEntryError, resolveSkWorkspaceConfig, sourceCacheKey, getGlobalCacheDir, resolveAgentDir, AgentRefResolutionError, resolveAgentDefinitionDir, decodeSkaileYaml, matchPin, coerceVersion, loadSkWorkspaceConfig, normalizeAgentInstances, agentBlockKeyDiagnostics, agentInstanceDiagnostics, storeManifestSlug, isWorkspaceConfigFilename } from '../chunk-L3ZGYSWY.js';
 import { globalCacheRoot, globalSkaileDir, userConfigPath } from '../chunk-L5VSIPQD.js';
-import { SUPPORTED_DRIVER_TARGETS, driverTargetForDriver } from '../chunk-CPSIPIX7.js';
-import { SKAILE_MANIFEST_FILENAME, decodeSkaileManifest, loadSkPublishManifest, encodeSkaileManifest } from '../chunk-ZPWTOUTK.js';
+import { SUPPORTED_DRIVER_TARGETS, driverTargetForDriver } from '../chunk-IG5LZ3WU.js';
+import { SKAILE_MANIFEST_FILENAME, loadSkPublishManifest, decodeSkaileManifest, isNonAssetPath, isNonAssetDir, encodeSkaileManifest } from '../chunk-IY5E7Y5W.js';
 import { pluginTitle } from '../chunk-RVRB27AN.js';
-import { dedupeRequirements, parseFrontmatter, scanDirectory } from '../chunk-SBSA3IQA.js';
-import { parseAssetRef, isValidPublisher, PUBLISHER_HINT, isValidAssetName, ASSET_NAME_HINT, slugifyAssetName, parseAssetRefLoose, assetRefToStr } from '../chunk-BNMZVPYA.js';
+import { dedupeRequirements, parseFrontmatter, scanDirectory, parseRequires } from '../chunk-M3P4BYRK.js';
+import { parseAssetRef, isValidPublisher, PUBLISHER_HINT, isValidAssetName, ASSET_NAME_HINT, depToStr, slugifyAssetName, parseAssetRefLoose, assetRefToStr } from '../chunk-J4OYIYFQ.js';
 import { portableSpawn, portableSpawnSync } from '../chunk-ICSCSM5D.js';
-import { openSqlite } from '../chunk-DALV4HHP.js';
+import { openSqlite } from '../chunk-DKXNKFKP.js';
 import { parseModelRef, resolveEntryBaseUrl } from '../chunk-MJHSLODD.js';
 import '../chunk-C3CAXQMA.js';
-import '../chunk-BOFL7GIF.js';
+import { registerLogStore, LogStore, StdoutSink } from '../chunk-BOFL7GIF.js';
 import '../chunk-NSBPE2FW.js';
-import * as fs8 from 'fs';
-import fs8__default, { readFileSync, existsSync, mkdirSync, writeFileSync, lstatSync, rmSync, readdirSync, statSync } from 'fs';
-import * as path18 from 'path';
-import path18__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 path22 from 'path';
+import path22__default, { resolve, join } from 'path';
 import { fileURLToPath } from 'url';
 import { Help, Command, Option } from 'commander';
 import { rcompare } from 'semver';
+import * as os from 'os';
+import { homedir } from 'os';
 import * as p4 from '@clack/prompts';
 import pc5 from 'picocolors';
-import * as os from 'os';
 import { parse, stringify, parseDocument, isMap, isScalar, isSeq } from 'yaml';
 import * as readline from 'readline';
 import { createInterface } from 'readline';
@@ -128,6 +131,45 @@ function filterCatalogAssets(assets, query) {
     (a) => a.name.toLowerCase().includes(q) || (a.description?.toLowerCase().includes(q) ?? false) || a.publisher.toLowerCase().includes(q)
   );
 }
+var STORE_TEST_NAME_RE = /^(test|demo)(-|$)/;
+var STORE_ROW_LIMIT = 20;
+function selectStoreRows(matches, query, all) {
+  const q = query?.toLowerCase();
+  const rank = (a) => {
+    if (!q) return 3;
+    const n = a.name.toLowerCase();
+    if (n === q) return 0;
+    if (n.startsWith(q)) return 1;
+    if (n.includes(q)) return 2;
+    return 3;
+  };
+  const ranked = [...matches].sort(
+    (a, b) => rank(a) - rank(b) || a.name.localeCompare(b.name) || a.version.localeCompare(b.version)
+  );
+  if (all) return { shown: ranked, hidden: 0, cut: 0 };
+  const keep = ranked.filter(
+    (a) => storeNotInstallableReason(a) === void 0 && !a.demo && !STORE_TEST_NAME_RE.test(a.name)
+  );
+  return {
+    shown: keep.slice(0, STORE_ROW_LIMIT),
+    hidden: ranked.length - keep.length,
+    cut: Math.max(0, keep.length - STORE_ROW_LIMIT)
+  };
+}
+function storeSelectionNotes(sel, indent) {
+  const notes = [];
+  if (sel.cut > 0) {
+    notes.push(
+      `${indent}${S.dim(`\u2026 ${sel.cut} more store match(es); narrow the query, or pass --all to list every one`)}`
+    );
+  }
+  if (sel.hidden > 0) {
+    notes.push(
+      `${indent}${S.dim(`${sel.hidden} store entr${sel.hidden === 1 ? "y" : "ies"} hidden: names that are not valid refs, demo/internal entries; --all lists them`)}`
+    );
+  }
+  return notes;
+}
 function nearAssetKind(word) {
   const w = word.toLowerCase();
   let best;
@@ -175,7 +217,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: path18__default.resolve(opts.projectDir) }).catalog.cache_ttl === 0;
+  const airGapped = resolveConfig({ projectDir: path22__default.resolve(opts.projectDir) }).catalog.cache_ttl === 0;
   if (showLocal) {
     await searchLocal(query, kind, opts, showStore, airGapped);
   }
@@ -184,7 +226,7 @@ async function runSearch(kind, query, opts) {
   }
 }
 async function searchIndex(query, kind) {
-  const { openLibrary: openLibrary2 } = await import('../open-library-BOSPJVID.js');
+  const { openLibrary: openLibrary2 } = await import('../open-library-PZAT3TJA.js');
   const library = await openLibrary2();
   try {
     const { libraryDirMissing: libraryDirMissing2 } = await import('../library/index.js');
@@ -221,7 +263,7 @@ async function searchIndex(query, kind) {
   }
 }
 async function searchFactory(projectDir, query, kind) {
-  const prefixes = factoryAssetRoots().map((r) => r.endsWith(path18__default.sep) ? r : r + path18__default.sep);
+  const prefixes = factoryAssetRoots().map((r) => r.endsWith(path22__default.sep) ? r : r + path22__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(
@@ -331,11 +373,11 @@ async function expandCompetingOrigins(entries, projectDir) {
   return out;
 }
 async function searchLocal(query, kind, opts, showStore, airGapped) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__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-G2LV5LVD.js');
+    const { autoSyncForSearch } = await import('../source-36FHMN5V.js');
     if (await autoSyncForSearch(projectDir)) {
       entries = unionEntries(await searchIndex(query, kind), factory);
     }
@@ -445,34 +487,30 @@ function formatStoreRows(assets, indent, width = terminalWidth()) {
   });
 }
 async function searchStore(query, kind, opts, airGapped) {
-  if (airGapped) {
-    if (opts.store) {
-      logErr(
-        "air-gapped (catalog.cache_ttl: 0) \u2014 store search is disabled. Set catalog.cache_ttl > 0 to query the store."
-      );
-      process.exit(1);
-    }
+  if (airGapped && !opts.store) {
     logInfo("air-gapped (cache_ttl: 0) \u2014 local sources only");
     return;
   }
-  const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-BOSPJVID.js');
+  const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-PZAT3TJA.js');
   try {
-    const remote = await openCatalogSource2({ projectDir: path18__default.resolve(opts.projectDir) });
+    const remote = await openCatalogSource2({ projectDir: path22__default.resolve(opts.projectDir) });
     const assets = await remote.listAssets(kind ? { kind } : {});
-    const results = filterCatalogAssets(assets, query);
-    if (results.length > 0) {
+    const sel = selectStoreRows(filterCatalogAssets(assets, query), query, Boolean(opts.all));
+    if (sel.shown.length > 0) {
       console.log(`
   ${S.heading("Store:")}`);
-      for (const row of formatStoreRows(results, "    ")) console.log(row);
+      for (const row of formatStoreRows(sel.shown, "    ")) console.log(row);
     } else if (opts.store) {
       logInfo("No results in store");
     }
+    for (const note of storeSelectionNotes(sel, "    ")) console.log(note);
   } catch (e) {
     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}`
+        local ? "remote catalog disabled (catalog.url: local) \u2014 set catalog.url: https://skaile.store to search the store" : `Store search failed: ${await describeStoreFailure(e, path22__default.resolve(opts.projectDir))}`
       );
+      process.exit(1);
     } else {
       logInfo(
         local ? "remote catalog disabled (catalog.url: local) \u2014 showing local results only" : "store unavailable \u2014 showing local results only (run with --store to see the error)"
@@ -480,8 +518,17 @@ async function searchStore(query, kind, opts, airGapped) {
     }
   }
 }
+async function describeStoreFailure(err2, projectDir) {
+  const { resolveConfig, describeCatalogError, CatalogHttpError } = await import('../library/index.js');
+  const { catalog } = resolveConfig({ projectDir });
+  const framingHint = catalog.framing === "rest" && err2 instanceof CatalogHttpError && (err2.status === 404 || err2.status === 405) ? ` catalog.framing is rest; if this host serves tRPC, set it with \`skaile config set catalog.framing trpc\`.` : "";
+  return `${describeCatalogError(err2, catalog.url)}.${framingHint} Check the catalog with \`skaile catalog test\`.`;
+}
 function makeSearchCommand() {
-  return new Command("search").description("Search across all repos").argument("[kind]", "Filter by asset kind (a single non-kind argument is the query)").argument("[query]", "Search query").option("--project-dir <path>", "Project directory", process.cwd()).option("--store", "Search only the store").option("--local", "Search only local repos").action(async (kind, query, opts) => {
+  return new Command("search").description("Search across all repos").argument("[kind]", "Filter by asset kind (a single non-kind argument is the query)").argument("[query]", "Search query").option("--project-dir <path>", "Project directory", process.cwd()).option("--store", "Search only the store").option("--local", "Search only local repos").option(
+    "--all",
+    `Store leg: list every match (default: ${STORE_ROW_LIMIT} rows, only what add can install)`
+  ).action(async (kind, query, opts) => {
     await runSearch(kind, query, opts);
   });
 }
@@ -572,7 +619,10 @@ function makeAddCommand() {
   ).option(
     "--with-soft-deps",
     "also add the asset's report-only soft (body-link) deps, without prompting"
-  ).option("--no-soft-deps", "skip the soft-dep prompt entirely (don't add, don't report)").action(async (ref, opts) => {
+  ).option("--no-soft-deps", "skip the soft-dep prompt entirely (don't add, don't report)").option(
+    "--force",
+    "overwrite a deployed folder that no lock entry owns (a hand-made skill of the same name)"
+  ).action(async (ref, opts) => {
     if (opts.withSoftDeps && opts.softDeps === false) {
       logErr("--with-soft-deps and --no-soft-deps are mutually exclusive.");
       process.exit(1);
@@ -580,13 +630,17 @@ function makeAddCommand() {
     const harnesses = parseHarnessFilter(opts.harness);
     if (!opts.global && harnesses === void 0) requireProjectConfig(opts.projectDir);
     const warnings = deferredWarnings();
+    const collisionKeys = [];
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path18__default.resolve(opts.projectDir),
+      projectDir: path22__default.resolve(opts.projectDir),
       global: opts.global || harnesses !== void 0,
       harnesses,
       driverTarget: opts.target,
-      onLibraryCollision: warnings.push
+      onLibraryCollision: (msg) => {
+        collisionKeys.push(msg.split(" exists in ")[0]);
+        warnings.push(msg);
+      }
     });
     const spinner = createSpinner();
     spinner.start(`Adding ${ref}`);
@@ -597,6 +651,7 @@ function makeAddCommand() {
       const skippedEnv = /* @__PURE__ */ new Set();
       const added = await am2.add(ref, {
         link: opts.link,
+        force: opts.force,
         onLibraryOrigin: (deployedRef, library) => libraryOf.set(deployedRef, library),
         onLibraryMoved: (m) => warnings.push(`${m.ref} moved from ${m.from} to ${m.to}`),
         onPresets: (expanded) => {
@@ -644,9 +699,27 @@ function makeAddCommand() {
           const library = libraryOf.get(a);
           logOk(library ? `${a} (library ${library})` : a);
         }
+        if (am2.global) {
+          for (const a of added) {
+            const { kind, name } = parseAssetRef(a);
+            const component = installTargetOf(getKindRegistry(), kind);
+            if (!component) continue;
+            for (const harness of am2.deployTargets()) {
+              const dir = deployedDir(component, name, harness, true);
+              if (existsSync(dir)) logInfo(S.dim(`${harness}: ${dir.replace(homedir(), "~")}`));
+            }
+          }
+        }
+        if (added.length > 1) {
+          logInfo(S.dim(`${added.length} assets deployed (${ref} and ${added.length - 1} more)`));
+        }
       }
       const addOrigins = await competingOriginsOf(am2, ref);
-      if (addOrigins) {
+      const asked = parseRefTolerant(ref);
+      const alreadyWarned = collisionKeys.some(
+        (key) => key.startsWith(`${asked?.kind}:`) && key.endsWith(`/${asked?.name}`)
+      );
+      if (addOrigins && !alreadyWarned) {
         const [first, ...rest] = addOrigins;
         logInfo(
           S.dim(
@@ -673,7 +746,7 @@ function makeRemoveCommand() {
       requireProjectConfig(opts.projectDir, { allowMissing: true });
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path18__default.resolve(opts.projectDir),
+      projectDir: path22__default.resolve(opts.projectDir),
       global: opts.global || harnesses !== void 0,
       harnesses,
       driverTarget: opts.target
@@ -735,15 +808,14 @@ function makeListCommand() {
     }
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path18__default.resolve(opts.projectDir),
+      projectDir: path22__default.resolve(opts.projectDir),
       driverTarget: opts.target
     });
     let declared;
     try {
       declared = await am2.listDeclared(kind);
     } catch (err2) {
-      if (err2 instanceof MissingManifestError)
-        logErr(`No ${S.cmd("skaile.yaml")} found. Run ${S.cmd("skaile init")} to create one.`);
+      if (err2 instanceof MissingManifestError) logNoProject(opts.projectDir);
       else logErr(err2 instanceof Error ? err2.message : String(err2));
       process.exit(1);
     }
@@ -783,7 +855,7 @@ function makeListCommand() {
 function runGlobalList(kind, opts, harnesses) {
   const am2 = new AssetManager({
     registry: getKindRegistry(),
-    projectDir: path18__default.resolve(opts.projectDir),
+    projectDir: path22__default.resolve(opts.projectDir),
     global: true,
     harnesses
   });
@@ -856,7 +928,7 @@ async function resolveInfoEntry(am2, ref, opts) {
     return { entry: match ?? deployed };
   }
   const lookup = opts.storeLookup ?? (async (filter) => {
-    const { resolveCatalogSource } = await import('../open-library-BOSPJVID.js');
+    const { resolveCatalogSource } = await import('../open-library-PZAT3TJA.js');
     const { source, close } = await resolveCatalogSource({ projectDir: opts.projectDir });
     try {
       return await source.listAssets(filter);
@@ -872,7 +944,7 @@ async function resolveInfoEntry(am2, ref, opts) {
     );
     return { entry: hit ? catalogAssetToEntry(hit) : null };
   } catch (err2) {
-    const { LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-BOSPJVID.js');
+    const { LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-PZAT3TJA.js');
     const storeNote = err2 instanceof Error ? err2.message : String(err2);
     const disabled = err2 instanceof LocalCatalogDisabledError2 || /catalog\.url/i.test(storeNote);
     return { entry: null, storeNote, ...disabled ? { storeDisabled: true } : {} };
@@ -888,7 +960,8 @@ 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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
+    requireProjectConfig(projectDir, { allowMissing: true });
     const am2 = new AssetManager({ registry: getKindRegistry(), projectDir });
     const lookup = await resolveInfoEntry(am2, ref, { projectDir });
     const entry = lookup.entry;
@@ -937,7 +1010,7 @@ function makeCreateCommand() {
     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 ? path18__default.resolve(opts.dir) : process.cwd();
+    const destDir = opts.dir ? path22__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 {
@@ -951,14 +1024,16 @@ function makeDoctorCommand() {
     requireProjectConfig(opts.projectDir);
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path18__default.resolve(opts.projectDir)
+      projectDir: path22__default.resolve(opts.projectDir)
     });
     const { gaps } = await am2.projectState();
-    if (gaps.length === 0) {
+    const edited = await editedConventionFiles(path22__default.resolve(opts.projectDir));
+    if (gaps.length === 0 && edited.length === 0) {
       logOk("No missing dependencies.");
       return;
     }
     process.exitCode = 1;
+    for (const e of edited) logErr(e);
     for (const g of gaps) if (g.type !== "requires") logErr(g.message);
     const missing = gaps.filter((g) => g.type === "requires" && g.asset !== void 0);
     if (missing.length === 0) return;
@@ -983,21 +1058,21 @@ function claudeSkillRoots() {
   const roots = [];
   const override = process.env.SKAILE_CLAUDE_SKILLS_DIR;
   if (override) roots.push(override);
-  roots.push(path18.join(os.homedir(), ".claude", "skills"));
+  roots.push(path22.join(os.homedir(), ".claude", "skills"));
   return roots;
 }
 function resolveImportSource(nameOrPath) {
-  const asPath = path18.resolve(nameOrPath);
-  if (fs8.existsSync(asPath)) {
-    const dir = fs8.statSync(asPath).isDirectory() ? asPath : path18.dirname(asPath);
-    const skillFile = path18.join(dir, "SKILL.md");
-    if (fs8.existsSync(skillFile)) return { dir, skillFile, via: "path" };
+  const asPath = path22.resolve(nameOrPath);
+  if (fs9.existsSync(asPath)) {
+    const dir = fs9.statSync(asPath).isDirectory() ? asPath : path22.dirname(asPath);
+    const skillFile = path22.join(dir, "SKILL.md");
+    if (fs9.existsSync(skillFile)) return { dir, skillFile, via: "path" };
   }
-  if (!nameOrPath.includes(path18.sep) && !nameOrPath.startsWith(".")) {
+  if (!nameOrPath.includes(path22.sep) && !nameOrPath.startsWith(".")) {
     for (const root of claudeSkillRoots()) {
-      const dir = path18.join(root, nameOrPath);
-      const skillFile = path18.join(dir, "SKILL.md");
-      if (fs8.existsSync(skillFile)) return { dir, skillFile, via: "claude-skills" };
+      const dir = path22.join(root, nameOrPath);
+      const skillFile = path22.join(dir, "SKILL.md");
+      if (fs9.existsSync(skillFile)) return { dir, skillFile, via: "claude-skills" };
     }
   }
   return null;
@@ -1052,6 +1127,12 @@ ${body}
 }
 
 // cli/src/commands/asset-cmd.ts
+function copyFilter(root) {
+  return (src) => {
+    const rel = path22.relative(root, src).split(path22.sep).join("/");
+    return rel === "" || !(isNonAssetPath(rel) || isNonAssetDir(path22.basename(src)));
+  };
+}
 async function resolveDefByRef(library, ref, opts) {
   let parsed;
   try {
@@ -1124,19 +1205,25 @@ function makeAssetCommand() {
           process.exit(1);
         }
         exitOnManifestPublisherProblems(target.path, target.name);
-        const rawSkill = fs8.readFileSync(src.skillFile, "utf8");
+        if (reportLibrarySymlinks(src.dir, { rootIsAsset: true }) > 0) {
+          logErr(
+            `Not imported: ${src.dir} holds symlinks (listed above). Replace each with a copy of what it points at, or remove it, and run the import again.`
+          );
+          process.exit(1);
+        }
+        const rawSkill = fs9.readFileSync(src.skillFile, "utf8");
         const norm = opts.normalize ? normalizeSkillContent(rawSkill, {
-          fallbackName: path18.basename(src.dir),
+          fallbackName: path22.basename(src.dir),
           version: opts.version,
           stage: opts.stage
-        }) : { content: rawSkill, name: path18.basename(src.dir), changed: false, notes: [] };
+        }) : { content: rawSkill, name: path22.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 = path18.join(target.path, norm.name);
-        if (fs8.existsSync(destDir)) {
+        const destDir = path22.join(target.path, norm.name);
+        if (fs9.existsSync(destDir)) {
           logErr(`Destination already exists: ${destDir}`);
           process.exit(1);
         }
@@ -1147,8 +1234,27 @@ function makeAssetCommand() {
           );
           process.exit(1);
         }
-        fs8.cpSync(src.dir, destDir, { recursive: true });
-        fs8.writeFileSync(path18.join(destDir, "SKILL.md"), norm.content, "utf8");
+        const importedFm = parseFrontmatter(norm.content);
+        const checked = checkAsset(
+          "skill",
+          importedFm.data,
+          importedFm.body,
+          norm.name,
+          getKindRegistry(),
+          norm.content
+        );
+        if (checked.errors.length > 0) {
+          for (const f of checked.errors) logErr(`${norm.name}/SKILL.md [${f.tag}] \u2014 ${f.text}`);
+          logErr(
+            `Not imported: ${checked.errors.length} problem(s) in SKILL.md. Fix them in ${src.skillFile} (or drop --no-normalize) and run the import again.`
+          );
+          process.exit(1);
+        }
+        for (const f of checked.advisories) {
+          logWarn(`${norm.name}/SKILL.md [${f.tag}] \u2014 ${f.text}`);
+        }
+        fs9.cpSync(src.dir, destDir, { recursive: true, filter: copyFilter(src.dir) });
+        fs9.writeFileSync(path22.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 })) {
@@ -1188,7 +1294,7 @@ function makeAssetCommand() {
         logErr(`Invalid --mode "${opts.mode}". Expected: copy | move | link.`);
         process.exit(1);
       }
-      if (!fs8.existsSync(srcPath)) {
+      if (!fs9.existsSync(srcPath)) {
         logErr(`Source path does not exist: ${srcPath}`);
         process.exit(1);
       }
@@ -1214,23 +1320,29 @@ function makeAssetCommand() {
           );
           process.exit(1);
         }
-        const basename3 = path18.basename(srcPath);
+        const basename3 = path22.basename(srcPath);
         const destDir = target.path;
-        fs8.mkdirSync(destDir, { recursive: true });
-        const destPath = path18.join(destDir, basename3);
-        if (fs8.existsSync(destPath)) {
+        fs9.mkdirSync(destDir, { recursive: true });
+        const destPath = path22.join(destDir, basename3);
+        if (fs9.existsSync(destPath)) {
           logErr(`Destination already exists: ${destPath}`);
           process.exit(1);
         }
+        if (opts.mode === "copy" && reportLibrarySymlinks(srcPath, { rootIsAsset: true }) > 0) {
+          logErr(
+            `Not migrated: ${srcPath} holds symlinks (listed above). Replace each with a copy of what it points at, or remove it, and run the migrate again.`
+          );
+          process.exit(1);
+        }
         switch (opts.mode) {
           case "copy":
-            fs8.cpSync(srcPath, destPath, { recursive: true });
+            fs9.cpSync(srcPath, destPath, { recursive: true, filter: copyFilter(srcPath) });
             break;
           case "move":
-            fs8.renameSync(srcPath, destPath);
+            fs9.renameSync(srcPath, destPath);
             break;
           case "link":
-            fs8.symlinkSync(path18.resolve(srcPath), destPath);
+            fs9.symlinkSync(path22.resolve(srcPath), destPath);
             break;
         }
         if (target.backend === "git" && opts.commit) {
@@ -1245,6 +1357,11 @@ function makeAssetCommand() {
           }
         }
         logOk(`Migrated ${basename3} \u2192 ${target.name} (${opts.mode})`);
+        const publisher = loadSkPublishManifest(target.path)?.publisher ?? "<publisher>";
+        const migratedKind = fs9.existsSync(path22.join(destPath, "SKILL.md")) ? "skill" : "<kind>";
+        logInfo(
+          `Not addable yet: run ${S.cmd(`skaile library index ${target.name}`)}, then ${S.cmd(`skaile add ${migratedKind}:@${publisher.replace(/^@/, "")}/${basename3}`)}`
+        );
         if (opts.mode === "move") {
           logInfo("Source moved into the library \u2014 future edits modify the library copy.");
         } else if (opts.mode === "copy") {
@@ -1360,14 +1477,14 @@ function makeAuthCommand() {
 }
 function collectCacheTargets(scope) {
   const out = [];
-  out.push(path18__default.join(scope.projectDir, ".skaile", "cache"));
-  out.push(path18__default.join(scope.projectDir, ".skaile", "store-cache"));
-  out.push(path18__default.join(scope.projectDir, ".skaile", "repos"));
+  out.push(path22__default.join(scope.projectDir, ".skaile", "cache"));
+  out.push(path22__default.join(scope.projectDir, ".skaile", "store-cache"));
+  out.push(path22__default.join(scope.projectDir, ".skaile", "repos"));
   if (scope.global) {
     out.push(globalCacheRoot());
     const home = globalSkaileDir();
-    out.push(path18__default.join(home, "repos"));
-    out.push(path18__default.join(home, "catalog-cache"));
+    out.push(path22__default.join(home, "repos"));
+    out.push(path22__default.join(home, "catalog-cache"));
   }
   return out;
 }
@@ -1381,7 +1498,7 @@ function dirSize(target) {
 function dirSizeOfDir(dir) {
   let total = 0;
   for (const ent of readdirSync(dir, { withFileTypes: true })) {
-    const child = path18__default.join(dir, ent.name);
+    const child = path22__default.join(dir, ent.name);
     if (ent.isSymbolicLink()) continue;
     if (ent.isDirectory()) total += dirSizeOfDir(child);
     else if (ent.isFile()) total += statSync(child).size;
@@ -1407,7 +1524,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: path18__default.resolve(opts.projectDir),
+      projectDir: path22__default.resolve(opts.projectDir),
       global: opts.global
     }).filter((t) => existsSync(t));
     if (targets.length === 0) {
@@ -1437,12 +1554,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(path18__default.join(path18__default.resolve(opts.projectDir), ".skaile", "cache"));
+    console.log(path22__default.join(path22__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: path18__default.resolve(opts.projectDir),
+      projectDir: path22__default.resolve(opts.projectDir),
       global: opts.global
     });
     console.log();
@@ -1458,7 +1575,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 ? path18__default.resolve(opts.projectDir) : void 0;
+    const projectDir = opts.projectDir ? path22__default.resolve(opts.projectDir) : void 0;
     const cfg = resolveConfig({ projectDir });
     const baseUrl = opts.url ?? cfg.catalog.url;
     if (isLocalCatalogUrl(baseUrl)) {
@@ -1472,11 +1589,15 @@ function makeCatalogCommand() {
       );
       return;
     }
-    await runRemoteCatalogProbe(baseUrl, trpcGetUrl(baseUrl, "catalog.listKinds", void 0));
+    await runRemoteCatalogProbe(
+      baseUrl,
+      cfg.catalog.framing,
+      trpcGetUrl(baseUrl, "catalog.listKinds", void 0)
+    );
   });
   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 ? path18__default.resolve(opts.projectDir) : void 0;
+    const projectDir = opts.projectDir ? path22__default.resolve(opts.projectDir) : void 0;
     const cfg = resolveConfig({ projectDir });
     console.log(`url: ${cfg.catalog.url}`);
     console.log(`framing: ${cfg.catalog.framing}`);
@@ -1485,14 +1606,16 @@ function makeCatalogCommand() {
   return catalog;
 }
 async function runLocalCatalogTest(projectDir) {
-  const { resolveCatalogSource } = await import('../open-library-BOSPJVID.js');
+  const { resolveCatalogSource } = await import('../open-library-PZAT3TJA.js');
   let resolved;
   try {
     resolved = await resolveCatalogSource({ projectDir });
     const sources = await resolved.source.listSources();
     logOk("Catalog mode: local");
     if (sources.length === 0) {
-      logInfo("No local sources registered. Run `skaile source add <path>` first.");
+      logInfo(
+        "No local sources registered. Run `skaile library init <name> --path <dir>` first (a git repo: `skaile source add <git-url>`)."
+      );
     } else {
       for (const s of sources) {
         console.log(`  ${S.dim("\u2022")} ${s.type} ${S.heading(s.url)}`);
@@ -1513,7 +1636,8 @@ function isTrpcEnvelope(text) {
     return false;
   }
 }
-async function runRemoteCatalogProbe(baseUrl, probeUrl) {
+async function runRemoteCatalogProbe(baseUrl, framing, trpcProbeUrl) {
+  const probeUrl = framing === "rest" ? `${baseUrl.replace(/\/+$/, "")}/api/catalog/list` : trpcProbeUrl;
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), 5e3);
   try {
@@ -1524,10 +1648,24 @@ async function runRemoteCatalogProbe(baseUrl, probeUrl) {
     });
     const ms = Date.now() - started;
     if (!res.ok) {
+      if (framing === "rest" && (res.status === 404 || res.status === 405)) {
+        const trpc = await fetch(trpcProbeUrl, {
+          signal: controller.signal,
+          headers: { accept: "application/json" }
+        }).catch(() => null);
+        if (trpc?.ok && isTrpcEnvelope((await trpc.text()).trim())) {
+          logErr(
+            `${baseUrl} serves the tRPC catalog, but catalog.framing is rest (${probeUrl} answered ${res.status}).`
+          );
+          logInfo(`Set it with: skaile config set catalog.framing trpc`);
+          process.exitCode = 1;
+          return;
+        }
+      }
       logErr(`${probeUrl} responded ${res.status} ${res.statusText} (${ms}ms)`);
       if (res.status === 404) {
         logInfo(
-          `Got 404 from catalog.listKinds. Check the URL prefix in ${userConfigPath()} \u2014 Skaile mirrors must expose \`/trpc/catalog.*\` at the configured baseUrl.`
+          framing === "rest" ? `Got 404 from /api/catalog/list (catalog.framing is rest). Check the URL prefix in ${userConfigPath()}.` : `Got 404 from catalog.listKinds. Check the URL prefix in ${userConfigPath()} \u2014 Skaile mirrors must expose \`/trpc/catalog.*\` at the configured baseUrl.`
         );
       } else {
         logInfo(
@@ -1538,17 +1676,27 @@ async function runRemoteCatalogProbe(baseUrl, probeUrl) {
       return;
     }
     const text = (await res.text()).trim();
-    if (!isTrpcEnvelope(text)) {
-      logWarn(
-        `Catalog reachable at ${baseUrl} (${ms}ms) but the response is not a valid tRPC envelope.`
-      );
-      logInfo(
-        "The host responded 200 but the body is not Skaile's catalog router shape. Check that `catalog.listKinds` is mounted at the configured baseUrl."
-      );
-      process.exitCode = 1;
-      return;
+    if (framing === "trpc") {
+      if (!isTrpcEnvelope(text)) {
+        logWarn(
+          `Catalog reachable at ${baseUrl} (${ms}ms) but the response is not a valid tRPC envelope.`
+        );
+        logInfo(
+          "The host responded 200 but the body is not Skaile's catalog router shape. Check that `catalog.listKinds` is mounted at the configured baseUrl."
+        );
+        process.exitCode = 1;
+        return;
+      }
+    } else {
+      try {
+        JSON.parse(text);
+      } catch {
+        logWarn(`Catalog reachable at ${baseUrl} (${ms}ms) but /api/catalog/list is not JSON.`);
+        process.exitCode = 1;
+        return;
+      }
     }
-    logOk(`Catalog reachable at ${S.heading(baseUrl)} (${ms}ms)`);
+    logOk(`Catalog reachable at ${S.heading(baseUrl)} (${ms}ms, framing ${framing})`);
   } catch (err2) {
     if (err2 instanceof Error && err2.name === "AbortError") {
       logErr(`Timeout reaching ${probeUrl} after 5s`);
@@ -1628,7 +1776,7 @@ async function scanLibraryFlowEntries() {
     const { LocalIndex, resolveIndexPath, scanAuthoringLibraries } = await import('../library/index.js');
     const indexPath = resolveIndexPath();
     if (!existsSync(indexPath)) return entries;
-    const { getKindRegistry: getKindRegistry2 } = await import('../open-registry-4FI7HKET.js');
+    const { getKindRegistry: getKindRegistry2 } = await import('../open-registry-W46UXZ3I.js');
     const index = new LocalIndex({ indexPath });
     try {
       for (const { assets } of await scanAuthoringLibraries(index, getKindRegistry2())) {
@@ -1678,11 +1826,11 @@ function findSkills() {
   return deduped;
 }
 function walkSkills(dir, out) {
-  for (const entry of fs8__default.readdirSync(dir, { withFileTypes: true })) {
-    const full = path18__default.join(dir, entry.name);
+  for (const entry of fs9__default.readdirSync(dir, { withFileTypes: true })) {
+    const full = path22__default.join(dir, entry.name);
     if (entry.isDirectory()) {
-      const skillMd = path18__default.join(full, "SKILL.md");
-      if (fs8__default.existsSync(skillMd)) {
+      const skillMd = path22__default.join(full, "SKILL.md");
+      if (fs9__default.existsSync(skillMd)) {
         out.push({ name: entry.name, path: full, skillPath: skillMd });
       } else {
         walkSkills(full, out);
@@ -1703,10 +1851,10 @@ function resolveFlowIds() {
   }
 }
 function resolveSessionIds(projectDir) {
-  const sessionsDir = path18__default.join(projectDir, ".skaile", "sessions");
-  if (!fs8__default.existsSync(sessionsDir)) return [];
+  const sessionsDir = path22__default.join(projectDir, ".skaile", "sessions");
+  if (!fs9__default.existsSync(sessionsDir)) return [];
   try {
-    return fs8__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 [];
   }
@@ -1759,6 +1907,33 @@ function resolveDynamic(words, cword) {
   return null;
 }
 var PERSONAL_KEYS = /* @__PURE__ */ new Set(["driver", "model"]);
+var CATALOG_KEYS = /* @__PURE__ */ new Set(["catalog.url", "catalog.cache_ttl", "catalog.framing"]);
+async function setCatalogKey(key, raw) {
+  const { CatalogConfigSchema, saveConfig } = await import('../library/index.js');
+  const { parse: parseYaml5 } = await import('yaml');
+  const field = key.slice("catalog.".length);
+  const value = field === "cache_ttl" ? /^\d+$/.test(raw.trim()) ? Number(raw) : raw : raw;
+  const checked = CatalogConfigSchema.safeParse({ [field]: value });
+  if (!checked.success) {
+    const hint = field === "url" ? 'a http(s) URL, or "local" to turn the remote catalog off' : field === "cache_ttl" ? "a whole number of seconds (0 = air-gapped)" : '"trpc" or "rest"';
+    logErr(`'${key}' must be ${hint}; got "${raw}".`);
+    process.exit(1);
+  }
+  const filePath = userConfigPath();
+  const fs14 = await import('fs');
+  let existing = {};
+  if (fs14.existsSync(filePath)) {
+    const parsed = parseYaml5(fs14.readFileSync(filePath, "utf-8"));
+    if (parsed && typeof parsed === "object") existing = parsed;
+  }
+  const catalog = {
+    ...existing.catalog ?? {},
+    [field]: checked.data[field]
+  };
+  saveConfig(filePath, { ...existing, catalog });
+  logOk(`Set ${pc5.bold(key)} = ${String(checked.data[field])}`);
+  console.log(S.dim(`  \u2192 ${filePath}`));
+}
 var API_KEY_PREFIX = "apiKey.";
 function collectWorkspaceDefaults(projectDir) {
   const wsDefaults = {};
@@ -1774,14 +1949,17 @@ function collectWorkspaceDefaults(projectDir) {
   }
   return wsDefaults;
 }
-function printEffectiveSection(config) {
+function printEffectiveSection(config, sources) {
   console.log();
   console.log(S.heading("  Effective Config"));
   console.log(`  ${S.rule(40)}`);
   for (const key of ["driver", "model"]) {
     const value = config[key];
     if (value !== void 0) {
-      console.log(`  ${S.label(`${key}:`.padEnd(16))} ${value}`);
+      const origin = sources[key];
+      console.log(
+        `  ${S.label(`${key}:`.padEnd(16))} ${value}${origin ? `  ${S.dim(`(${origin})`)}` : ""}`
+      );
     }
   }
 }
@@ -1845,17 +2023,18 @@ function printResolvedPathsSection(config) {
   console.log(`  ${S.label("prompts:".padEnd(16))} ${config.promptsDir ?? paths.promptsDir}`);
 }
 async function showConfig(opts) {
-  const projectDir = opts.projectDir ? path18__default.resolve(opts.projectDir) : process.cwd();
+  const projectDir = opts.projectDir ? path22__default.resolve(opts.projectDir) : process.cwd();
   let config;
+  let sources;
   let wsDefaults;
   try {
-    config = await resolveSettings(projectDir);
+    ({ settings: config, sources } = await resolveSettingsWithSources(projectDir));
     wsDefaults = collectWorkspaceDefaults(projectDir);
   } catch (error) {
     logErr(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
-  printEffectiveSection(config);
+  printEffectiveSection(config, sources);
   printWorkspaceDefaultsSection(wsDefaults);
   printModelSelectionSection(config, projectDir);
   printResolvedPathsSection(config);
@@ -1890,13 +2069,25 @@ 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 ? path18__default.resolve(opts.projectDir) : process.cwd();
+    const projectDir = opts.projectDir ? path22__default.resolve(opts.projectDir) : process.cwd();
+    if (CATALOG_KEYS.has(key)) {
+      const { resolveConfig } = await import('../library/index.js');
+      const field = key.slice("catalog.".length);
+      console.log(resolveConfig({ projectDir }).catalog[field]);
+      return;
+    }
     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 ? path18__default.resolve(opts.projectDir) : process.cwd();
+  cmd.command("set <key> <value>").description(
+    "Set a personal config value (driver, model, apiKey.<provider>) or a catalog setting (catalog.url, catalog.cache_ttl, catalog.framing)"
+  ).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 ? path22__default.resolve(opts.projectDir) : process.cwd();
+    if (CATALOG_KEYS.has(key)) {
+      await setCatalogKey(key, value);
+      return;
+    }
     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.
@@ -1923,6 +2114,14 @@ function makeConfigCommand() {
     await saveSettings({ ...existing, [key]: value }, filePath);
     logOk(`Set ${pc5.bold(key)} = ${value}`);
     console.log(S.dim(`  \u2192 ${filePath}`));
+    if (key === "driver") {
+      const projectDriver = resolveSkWorkspaceConfig(projectDir).agent_config?.default?.driver;
+      if (projectDriver && projectDriver !== value) {
+        logWarn(
+          `skaile.yaml sets driver ${projectDriver}; a personal driver does not override the project harness. Change agent-config.default.driver in skaile.yaml to move the project.`
+        );
+      }
+    }
     if (key === "model") {
       const view = loadRegistryView({ projectDir });
       const resolved = parseModelRef(value, view.merged);
@@ -2236,8 +2435,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 = path18__default.resolve(opts.projectDir);
-      const yamlPath = path18__default.join(projectDir, "skaile.yaml");
+      const projectDir = path22__default.resolve(opts.projectDir);
+      const yamlPath = path22__default.join(projectDir, "skaile.yaml");
       if (!existsSync(yamlPath)) {
         logErr("No skaile.yaml found in current directory. Run 'skaile init' first.");
         process.exit(1);
@@ -2297,8 +2496,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 = path18__default.resolve(opts.projectDir);
-    const yamlPath = path18__default.join(projectDir, "skaile.yaml");
+    const projectDir = path22__default.resolve(opts.projectDir);
+    const yamlPath = path22__default.join(projectDir, "skaile.yaml");
     if (!existsSync(yamlPath)) {
       logErr("No skaile.yaml found in current directory.");
       process.exit(1);
@@ -2315,7 +2514,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const declarations = res.loadConnectorDeclarations(projectDir);
     if (declarations.length === 0) {
       console.log("No connectors configured in skaile.yaml.");
@@ -2339,7 +2538,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       console.log(JSON.stringify(manager.listConnectors(), null, 2));
@@ -2348,7 +2547,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       if (opts.all) {
@@ -2372,7 +2571,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       if (!manager.has(id)) {
@@ -2387,7 +2586,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const content = await manager.read(id, resourcePath);
@@ -2397,7 +2596,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       await manager.write(id, resourcePath, { data: content });
@@ -2407,7 +2606,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const entries = await manager.list(id, resourcePath, {
@@ -2420,7 +2619,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const results = await manager.search(id, query);
@@ -2430,7 +2629,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const ok = await manager.delete(id, resourcePath);
@@ -2440,7 +2639,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       if (!manager.has(id)) {
@@ -2549,7 +2748,7 @@ function envRecord() {
 async function buildDeployContext(projectDir) {
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const config = resolveSkWorkspaceConfig2(projectDir);
-  const workspaceId = config.name ?? path18__default.basename(projectDir);
+  const workspaceId = config.name ?? path22__default.basename(projectDir);
   let log;
   try {
     const { createLogger } = await import('../core/logging.js');
@@ -2581,13 +2780,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-AGQDMING.js');
+    const { ensurePluginsLoaded } = await import('../plugin-store-CK7YWRIC.js');
     const result = await ensurePluginsLoaded(projectDir, config.plugins, pluginRegistry);
     for (const f of result.failed) logWarn(f.error);
   }
 }
 async function runUp(opts) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   await ensureTargetsRegistered(projectDir);
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const { resolveDeployTarget, pluginRegistry } = await import('../plugin-registry/index.js');
@@ -2655,7 +2854,7 @@ async function restoreFromHandle(projectDir) {
   return { target, handle, ctx };
 }
 async function runDown(opts) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   const restored = await restoreFromHandle(projectDir);
   if (!restored) return;
   await restored.handle.stop();
@@ -2664,7 +2863,7 @@ async function runDown(opts) {
   logOk(`Stopped ${S.cmd(restored.target.id)} and cleared the handle.`);
 }
 async function runStatus(opts) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   const restored = await restoreFromHandle(projectDir);
   if (!restored) return;
   const health = await restored.handle.health();
@@ -2678,7 +2877,7 @@ async function runStatus(opts) {
   console.log();
 }
 async function runLogs(opts) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   const restored = await restoreFromHandle(projectDir);
   if (!restored) return;
   if (!restored.handle.logs) {
@@ -2706,12 +2905,28 @@ function makeDiffCommand() {
     requireProjectConfig(opts.projectDir);
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path18__default.resolve(opts.projectDir)
+      projectDir: path22__default.resolve(opts.projectDir)
     });
+    try {
+      parseAssetRef(ref);
+    } catch (err2) {
+      const plain = (err2 instanceof Error ? err2.message : String(err2)).replace(
+        / Run the `migrate-skaile-manifest`.*$/,
+        ""
+      );
+      const bare = /^([^:@/]+):([^@/#]+)$/.exec(ref.trim());
+      const held = plain.startsWith("publisher required") && bare ? am2.lockedRefsNamed(bare[1], bare[2]) : [];
+      if (held.length !== 1) {
+        logErr(held.length > 1 ? `${plain} (locked: ${held.join(", ")})` : plain);
+        process.exitCode = 1;
+        return;
+      }
+    }
     const gaps = await am2.gapsOf(ref);
+    const requirementGaps = await am2.requirementGapsOf(ref);
     const blocking = gaps.filter((g) => !DIFF_SHOWS[g.type]);
     if (blocking.length > 0) {
-      for (const g of blocking) logErr(g.message);
+      for (const g of [...blocking, ...requirementGaps]) logErr(g.message);
       process.exitCode = 1;
       return;
     }
@@ -2724,27 +2939,33 @@ function makeDiffCommand() {
         if (problems.length === 0) logErr(`Asset not found: ${ref}`);
         break;
       case "not-deployed":
-        if (problems.length === 0) logWarn(`${ref} is not deployed \u2014 run skaile install`);
+        if (problems.length === 0) {
+          logErr(
+            `${ref} is not deployed \u2014 nothing in this project locks it; run skaile add ${ref}`
+          );
+          process.exitCode = 1;
+        }
         break;
       case "no-files":
-        if (problems.length === 0)
+        if (problems.length === 0 && requirementGaps.length === 0)
           logInfo(`${ref}: preset has no files of its own; run skaile diff on its items`);
         break;
       case "identical":
-        if (problems.length === 0) logInfo("No differences.");
+        if (problems.length === 0 && requirementGaps.length === 0) logInfo("No differences.");
         break;
       case "differs":
         console.log(result.diff);
         break;
     }
-    for (const g of problems) logErr(g.message);
-    if (result.status === "not-found" || problems.length > 0) process.exitCode = 1;
+    for (const g of [...problems, ...requirementGaps]) logErr(g.message);
+    if (result.status === "not-found" || problems.length > 0 || requirementGaps.length > 0)
+      process.exitCode = 1;
   });
 }
 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(path18__default.resolve(opts.projectDir));
+    const flows = await discoverFlowsWithLibraries(path22__default.resolve(opts.projectDir));
     if (flows.length === 0) {
       logInfo("No flows found.");
       return;
@@ -2759,7 +2980,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(path18__default.resolve(opts.projectDir));
+    const flows = await discoverFlowsWithLibraries(path22__default.resolve(opts.projectDir));
     const flow = flows.find((f) => f.id === id);
     if (!flow) {
       logErr(`Flow not found: ${id}`);
@@ -2793,7 +3014,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: path18__default.resolve(opts.projectDir)
+      projectDir: path22__default.resolve(opts.projectDir)
     });
     const limit = parseInt(limitStr, 10) || 20;
     const entries = am2.history(limit);
@@ -2816,7 +3037,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: path18__default.resolve(opts.projectDir)
+      projectDir: path22__default.resolve(opts.projectDir)
     });
     am2.clearHistory();
     logOk("History cleared.");
@@ -2829,8 +3050,24 @@ var MCP_SERVER_ENTRY = {
   args: ["mcp-server"],
   env: {}
 };
+function mcpFilePath(projectDir) {
+  return path22__default.join(projectDir, ".mcp.json");
+}
+function legacyMcpFilePath(projectDir) {
+  return path22__default.join(projectDir, ".claude", "mcp.json");
+}
+async function removeSkaileMcpEntry(mcpPath) {
+  const mcp = await readJsonStrict(mcpPath);
+  if (!mcp?.mcpServers || !(SKAILE_MCP_NAME in mcp.mcpServers)) return false;
+  const { [SKAILE_MCP_NAME]: _removed, ...rest } = mcp.mcpServers;
+  const updated = { ...mcp, mcpServers: rest };
+  if (Object.keys(rest).length === 0) delete updated.mcpServers;
+  if (Object.keys(updated).length === 0) await fs5.unlink(mcpPath);
+  else await writeJson(mcpPath, updated);
+  return true;
+}
 function pluginDir(projectDir) {
-  return path18__default.join(projectDir, ".claude", "plugins", "skaile");
+  return path22__default.join(projectDir, ".claude", "plugins", "skaile");
 }
 async function readJsonStrict(p6) {
   let raw;
@@ -2848,7 +3085,7 @@ async function readJsonStrict(p6) {
   }
 }
 async function writeJson(p6, value) {
-  await fs5.mkdir(path18__default.dirname(p6), { recursive: true });
+  await fs5.mkdir(path22__default.dirname(p6), { recursive: true });
   await fs5.writeFile(p6, `${JSON.stringify(value, null, 2)}
 `);
 }
@@ -2856,8 +3093,8 @@ async function copyDir(src, dest) {
   await fs5.mkdir(dest, { recursive: true });
   const entries = await fs5.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path18__default.join(src, entry.name);
-    const destPath = path18__default.join(dest, entry.name);
+    const srcPath = path22__default.join(src, entry.name);
+    const destPath = path22__default.join(dest, entry.name);
     if (entry.isDirectory()) await copyDir(srcPath, destPath);
     else await fs5.copyFile(srcPath, destPath);
   }
@@ -2866,31 +3103,32 @@ async function install(projectDir, opts) {
   return opts?.full ? installFullPlugin(projectDir) : installMcp(projectDir);
 }
 async function installMcp(projectDir) {
-  const mcpPath = path18__default.join(projectDir, ".claude", "mcp.json");
+  const mcpPath = mcpFilePath(projectDir);
   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 ${path18__default.relative(projectDir, mcpPath)}`;
+    warning = `overwrote existing ${SKAILE_MCP_NAME} entry in ${path22__default.relative(projectDir, mcpPath)}`;
   }
   mcpServers[SKAILE_MCP_NAME] = MCP_SERVER_ENTRY;
   await writeJson(mcpPath, { ...existing, mcpServers });
-  return { changed: !matches, method: "mcp", warning };
+  const migrated = await removeSkaileMcpEntry(legacyMcpFilePath(projectDir));
+  return { changed: !matches || migrated, method: "mcp", warning };
 }
 async function installFullPlugin(projectDir) {
   const dir = pluginDir(projectDir);
   for (const [rel, content] of Object.entries(buildClaudePluginFiles())) {
-    const dest = path18__default.join(dir, rel);
-    await fs5.mkdir(path18__default.dirname(dest), { recursive: true });
+    const dest = path22__default.join(dir, rel);
+    await fs5.mkdir(path22__default.dirname(dest), { recursive: true });
     await fs5.writeFile(dest, content);
   }
-  const projectSkillsDir = path18__default.join(projectDir, ".skaile", "skills");
+  const projectSkillsDir = path22__default.join(projectDir, ".skaile", "skills");
   if (existsSync(projectSkillsDir)) {
-    await copyDir(projectSkillsDir, path18__default.join(dir, "skills"));
+    await copyDir(projectSkillsDir, path22__default.join(dir, "skills"));
   }
-  const settingsPath = path18__default.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path22__default.join(projectDir, ".claude", "settings.json");
   const settings = await readJsonStrict(settingsPath) ?? {};
   const plugins = settings.plugins ?? [];
   if (!plugins.includes(dir)) plugins.push(dir);
@@ -2898,47 +3136,43 @@ async function installFullPlugin(projectDir) {
   return { changed: true, method: "plugin" };
 }
 async function uninstall(projectDir) {
-  const settingsPath = path18__default.join(projectDir, ".claude", "settings.json");
-  const mcpPath = path18__default.join(projectDir, ".claude", "mcp.json");
+  const settingsPath = path22__default.join(projectDir, ".claude", "settings.json");
+  const mcpPath = mcpFilePath(projectDir);
   const dir = pluginDir(projectDir);
-  let changed = false;
+  const rel = (p6) => path22__default.relative(projectDir, p6);
+  const files = [];
   const settings = await readJsonStrict(settingsPath);
   if (settings && Array.isArray(settings.plugins)) {
     const next = settings.plugins.filter((p6) => p6 !== dir);
     if (next.length !== settings.plugins.length) {
-      changed = true;
+      files.push(rel(settingsPath));
       const updated = { ...settings, plugins: next };
       if (next.length === 0) delete updated.plugins;
-      await writeJson(settingsPath, updated);
+      if (Object.keys(updated).length === 0) await fs5.unlink(settingsPath);
+      else await writeJson(settingsPath, updated);
     }
   }
   if (existsSync(dir)) {
     await fs5.rm(dir, { recursive: true, force: true });
-    changed = true;
+    files.push(rel(dir));
   }
-  const mcp = await readJsonStrict(mcpPath);
-  if (mcp?.mcpServers && SKAILE_MCP_NAME in mcp.mcpServers) {
-    changed = true;
-    const { [SKAILE_MCP_NAME]: _removed, ...rest } = mcp.mcpServers;
-    const updated = { ...mcp, mcpServers: rest };
-    if (Object.keys(rest).length === 0) delete updated.mcpServers;
-    if (Object.keys(updated).length === 0) {
-      await fs5.unlink(mcpPath);
-    } else {
-      await writeJson(mcpPath, updated);
-    }
+  if (await removeSkaileMcpEntry(mcpPath)) files.push(rel(mcpPath));
+  const legacyPath = legacyMcpFilePath(projectDir);
+  if (await removeSkaileMcpEntry(legacyPath)) files.push(rel(legacyPath));
+  for (const emptyDir of [path22__default.dirname(dir), path22__default.join(projectDir, ".claude")]) {
+    await fs5.rmdir(emptyDir).catch(() => void 0);
   }
-  return { changed };
+  return { changed: files.length > 0, files };
 }
 async function detectInstall(projectDir) {
   const dir = pluginDir(projectDir);
   const settings = await readJsonStrict(
-    path18__default.join(projectDir, ".claude", "settings.json")
+    path22__default.join(projectDir, ".claude", "settings.json")
   );
-  if (existsSync(path18__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir)) {
+  if (existsSync(path22__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir)) {
     return { method: "plugin", pluginPath: dir };
   }
-  const mcp = await readJsonStrict(path18__default.join(projectDir, ".claude", "mcp.json"));
+  const mcp = await readJsonStrict(mcpFilePath(projectDir));
   if (mcp?.mcpServers && SKAILE_MCP_NAME in mcp.mcpServers) {
     return { method: "mcp" };
   }
@@ -2947,7 +3181,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 = path18__default.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path22__default.join(projectDir, ".claude", "settings.json");
   const settings = await readJsonStrict(settingsPath) ?? {};
   if (detected.method === "plugin") {
     const disabled2 = settings.disabledPlugins ?? [];
@@ -2969,7 +3203,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 = path18__default.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path22__default.join(projectDir, ".claude", "settings.json");
   const settings = await readJsonStrict(settingsPath) ?? {};
   if (detected.method === "plugin") {
     const list2 = settings.disabledPlugins ?? [];
@@ -2989,12 +3223,12 @@ async function disable(projectDir) {
   return { changed: true };
 }
 async function status(projectDir) {
-  const settingsPath = path18__default.join(projectDir, ".claude", "settings.json");
-  const mcpPath = path18__default.join(projectDir, ".claude", "mcp.json");
+  const settingsPath = path22__default.join(projectDir, ".claude", "settings.json");
+  const mcpPath = mcpFilePath(projectDir);
   const dir = pluginDir(projectDir);
   const settings = await readJsonStrict(settingsPath);
   const mcp = await readJsonStrict(mcpPath);
-  const pluginInstalled = !!(existsSync(path18__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir));
+  const pluginInstalled = !!(existsSync(path22__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 {
@@ -3012,7 +3246,7 @@ async function status(projectDir) {
       installed: "yes",
       enabled: disabled2 ? "no" : "yes",
       method: "plugin",
-      location: path18__default.relative(projectDir, dir)
+      location: path22__default.relative(projectDir, dir)
     };
   }
   const disabled = settings?.disabledMcpjsonServers?.includes(SKAILE_MCP_NAME) ?? false;
@@ -3021,7 +3255,7 @@ async function status(projectDir) {
     installed: "yes",
     enabled: disabled ? "no" : "yes",
     method: "mcp",
-    location: path18__default.relative(projectDir, mcpPath)
+    location: path22__default.relative(projectDir, mcpPath)
   };
 }
 var SKAILE_MCP_NAME2 = "skaile-workspace";
@@ -3048,7 +3282,7 @@ async function readConfig(p6) {
   }
 }
 async function writeConfig(p6, value) {
-  await fs5.mkdir(path18__default.dirname(p6), { recursive: true });
+  await fs5.mkdir(path22__default.dirname(p6), { recursive: true });
   const cleaned = {};
   for (const [k, v] of Object.entries(value)) {
     if (v === void 0) continue;
@@ -3057,7 +3291,7 @@ async function writeConfig(p6, value) {
   await fs5.writeFile(p6, stringify$1(cleaned));
 }
 function configPath(projectDir) {
-  return path18__default.join(projectDir, ".codex", "config.toml");
+  return path22__default.join(projectDir, ".codex", "config.toml");
 }
 async function install2(projectDir) {
   const p6 = configPath(projectDir);
@@ -3068,7 +3302,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 ${path18__default.relative(projectDir, p6)}`;
+    warning = `overwrote existing ${SKAILE_MCP_NAME2} entry in ${path22__default.relative(projectDir, p6)}`;
   }
   if (matches) return { changed: false, method: "toml" };
   servers[SKAILE_MCP_NAME2] = next;
@@ -3109,12 +3343,12 @@ async function status2(projectDir) {
     installed: "yes",
     enabled: "n/a",
     method: "mcp",
-    location: path18__default.relative(projectDir, p6)
+    location: path22__default.relative(projectDir, p6)
   };
 }
 async function install3(projectDir) {
-  const extDir = path18__default.join(projectDir, ".omp", "extensions");
-  const extPath = path18__default.join(extDir, "skaile.ts");
+  const extDir = path22__default.join(projectDir, ".omp", "extensions");
+  const extPath = path22__default.join(extDir, "skaile.ts");
   await fs5.mkdir(extDir, { recursive: true });
   const { WorkspacePlugin } = await import('../workspace-plugin/index.js');
   const plugin = new WorkspacePlugin({ projectDir });
@@ -3129,7 +3363,7 @@ async function install3(projectDir) {
   return { changed: true, method: "generated" };
 }
 async function uninstall3(projectDir) {
-  const extPath = path18__default.join(projectDir, ".omp", "extensions", "skaile.ts");
+  const extPath = path22__default.join(projectDir, ".omp", "extensions", "skaile.ts");
   try {
     await fs5.unlink(extPath);
     return { changed: true };
@@ -3138,14 +3372,14 @@ async function uninstall3(projectDir) {
   }
 }
 async function status3(projectDir) {
-  const extPath = path18__default.join(projectDir, ".omp", "extensions", "skaile.ts");
+  const extPath = path22__default.join(projectDir, ".omp", "extensions", "skaile.ts");
   if (existsSync(extPath)) {
     return {
       harness: "omp",
       installed: "yes",
       enabled: "n/a",
       method: "extension",
-      location: path18__default.relative(projectDir, extPath)
+      location: path22__default.relative(projectDir, extPath)
     };
   }
   return {
@@ -3182,7 +3416,7 @@ async function installClaudeCode(projectDir, opts) {
       `Generated ${S.cmd(".claude/plugins/skaile/")} and registered it in ${S.cmd(".claude/settings.json")}`
     );
   } else if (r.changed) {
-    logOk(`Wrote ${S.cmd(".claude/mcp.json")} (${SKAILE_MCP_LABEL})`);
+    logOk(`Wrote ${S.cmd(".mcp.json")} (${SKAILE_MCP_LABEL})`);
   } else {
     logInfo(`claude-code: already installed (mcp)`);
   }
@@ -3208,7 +3442,7 @@ async function installCodex(projectDir) {
   console.log(`  ${S.dim("\u2192")} Restart Codex CLI to pick up the change.`);
 }
 async function runInstall(opts) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   const targets = resolveDriver(opts.driver);
   let exitCode = 0;
   if (targets.includes("claude-code")) {
@@ -3223,13 +3457,18 @@ async function runInstall(opts) {
   if (targets.includes("codex")) {
     exitCode |= await runHarnessStep("codex install", () => installCodex(projectDir));
   }
-  if (exitCode === 0) logOk("Plugin installed.");
+  if (exitCode === 0) {
+    await ignorePerMachineFiles(projectDir, targets);
+    logOk("Plugin installed.");
+  }
   return exitCode;
 }
 async function uninstallClaudeCode(projectDir) {
   const r = await uninstall(projectDir);
-  if (r.changed) logOk(`Removed skaile entries from ${S.cmd(".claude/")}`);
-  else logInfo(`claude-code: not installed`);
+  if (r.changed) {
+    const from = (r.files ?? []).map((f) => S.cmd(f)).join(", ");
+    logOk(`Removed skaile entries from ${from || S.cmd(".claude/")}`);
+  } else logInfo(`claude-code: not installed`);
 }
 async function uninstallOmp(projectDir) {
   const r = await uninstall3(projectDir);
@@ -3242,7 +3481,7 @@ async function uninstallCodex(projectDir) {
   else logInfo(`codex: not installed`);
 }
 async function runUninstall(opts) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   const targets = resolveDriver(opts.driver);
   let exitCode = 0;
   if (targets.includes("claude-code")) {
@@ -3257,9 +3496,46 @@ async function runUninstall(opts) {
   if (targets.includes("codex")) {
     exitCode |= await runHarnessStep("codex uninstall", () => uninstallCodex(projectDir));
   }
-  if (exitCode === 0) logOk("Plugin uninstalled.");
+  if (exitCode === 0) {
+    await removeEmptyPluginState(projectDir);
+    logOk("Plugin uninstalled.");
+  }
   return exitCode;
 }
+async function removeEmptyPluginState(projectDir) {
+  const stateFile = path22__default.join(projectDir, ".skaile", "plugin-state.json");
+  try {
+    const parsed = JSON.parse(await fs5.readFile(stateFile, "utf-8"));
+    if (typeof parsed !== "object" || parsed === null || Object.keys(parsed).length > 0) return;
+    await fs5.unlink(stateFile);
+    await fs5.rmdir(path22__default.dirname(stateFile)).catch(() => void 0);
+  } catch {
+  }
+}
+var PER_MACHINE_FILES = {
+  "claude-code": [".skaile/plugin-state.json"],
+  omp: [".omp/extensions/skaile.ts", ".skaile/plugin-state.json"],
+  codex: [".codex/config.toml", ".skaile/plugin-state.json"]
+};
+async function ignorePerMachineFiles(projectDir, targets) {
+  const gitignore = path22__default.join(projectDir, ".gitignore");
+  let existing = null;
+  try {
+    existing = await fs5.readFile(gitignore, "utf-8");
+  } catch {
+    if (!existsSync(path22__default.join(projectDir, ".git"))) return;
+  }
+  const have = new Set((existing ?? "").split("\n").map((l) => l.trim()));
+  const wanted = [...new Set(targets.flatMap((t) => PER_MACHINE_FILES[t]))];
+  const missing = wanted.filter((f) => !have.has(f));
+  if (missing.length === 0) return;
+  const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
+  await fs5.writeFile(gitignore, `${existing ?? ""}${prefix}${missing.join("\n")}
+`);
+  logInfo(
+    `Added ${missing.map((f) => S.cmd(f)).join(", ")} to ${S.cmd(".gitignore")} (per machine)`
+  );
+}
 function checkToggleSupported(targets, requestedAll, action3) {
   if (requestedAll) return null;
   const unsupported = targets.filter((t) => !TOGGLE_SUPPORTED.includes(t));
@@ -3285,7 +3561,7 @@ async function toggleTarget(t, projectDir, action3) {
   });
 }
 async function runToggle(opts, action3) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   const requestedAll = opts.driver === "all";
   const targets = resolveDriver(opts.driver);
   const usageError = checkToggleSupported(targets, requestedAll, action3);
@@ -3297,7 +3573,7 @@ async function runToggle(opts, action3) {
   return exitCode;
 }
 async function runStatus2(opts) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   const targets = resolveDriver(opts.driver);
   const rows = [];
   let exitCode = 0;
@@ -3338,12 +3614,12 @@ function printStatusTable(rows) {
 var SKAILE_MCP_LABEL = "skaile-workspace entry";
 var HOOK_EVENTS = ["session-start", "session-end", "user-prompt-submit"];
 async function runHook(event) {
-  const { LogStore, StdoutSink, registerLogStore } = await import('../core/logging.js');
-  registerLogStore(
-    new LogStore({
+  const { LogStore: LogStore2, StdoutSink: StdoutSink2, registerLogStore: registerLogStore2 } = await import('../core/logging.js');
+  registerLogStore2(
+    new LogStore2({
       sessionId: `hook-${event}`,
       level: "info",
-      sinks: [new StdoutSink({ stream: "stderr" })]
+      sinks: [new StdoutSink2({ stream: "stderr" })]
     })
   );
   const { WorkspacePlugin, PluginStore, resolveProjectDir } = await import('../workspace-plugin/index.js');
@@ -3368,7 +3644,7 @@ async function runHook(event) {
     await plugin.shutdown();
     return;
   }
-  const store = new PluginStore(path18__default.join(projectDir, ".skaile", "plugin-state.json"));
+  const store = new PluginStore(path22__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) {
@@ -3383,6 +3659,45 @@ async function runHook(event) {
     );
   }
 }
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function runOmpExec(kind, name, projectDir) {
+  if (kind !== "tool" && kind !== "slash") {
+    logErr(`omp-exec: unknown kind '${kind}' (expected: tool | slash)`);
+    return 2;
+  }
+  const { WorkspacePlugin } = await import('../workspace-plugin/index.js');
+  const plugin = new WorkspacePlugin({ projectDir, bootOwned: true });
+  try {
+    const raw = (await readStdin()).trim();
+    const payload = raw ? JSON.parse(raw) : kind === "tool" ? {} : [];
+    await plugin.boot();
+    if (kind === "slash") {
+      const parts = Array.isArray(payload) ? payload.map(String) : [];
+      process.stdout.write(`${await plugin.handleSlashCommand(name, parts)}
+`);
+      return 0;
+    }
+    const tools = await plugin.buildOmpToolSet();
+    const tool = tools.find((t) => t.name === name);
+    if (!tool) {
+      logErr(`omp-exec: unknown tool '${name}'`);
+      return 2;
+    }
+    process.stdout.write(`${await tool.handler(payload)}
+`);
+    return 0;
+  } catch (e) {
+    logErr(`omp-exec ${kind} ${name}: ${e instanceof Error ? e.message : String(e)}`);
+    return 1;
+  } finally {
+    await plugin.shutdown();
+  }
+}
 function makeIntegrationCommand() {
   const cmd = new Command("integration").description(
     "Manage skaile agent integration / workspace-plugin adapter (Claude Code / OMP / Codex)"
@@ -3405,13 +3720,18 @@ function makeIntegrationCommand() {
   cmd.command("status").description("Show install / enable status across harnesses").option("--driver <name>", "Target: claude-code | omp | codex | all", "all").option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {
     process.exitCode = await runStatus2(opts);
   });
+  cmd.command("omp-exec <kind> <name>").description(
+    "Run one tool or slash command of the omp extension (used by .omp/extensions/skaile.ts)"
+  ).option("--project-dir <path>", "Project directory", process.cwd()).action(async (kind, name, opts) => {
+    process.exitCode = await runOmpExec(kind, name, path22__default.resolve(opts.projectDir));
+  });
   cmd.command("hook <event>").description(
     "Run a Claude Code lifecycle hook (session-start | session-end | user-prompt-submit)"
   ).action(async (event) => {
     try {
       if (!HOOK_EVENTS.includes(event)) {
         process.stderr.write(
-          `plugin hook: unknown event '${event}' (expected: ${HOOK_EVENTS.join(" | ")})
+          `integration hook: unknown event '${event}' (expected: ${HOOK_EVENTS.join(" | ")})
 `
         );
       } else {
@@ -3419,7 +3739,7 @@ function makeIntegrationCommand() {
       }
     } catch (err2) {
       process.stderr.write(
-        `plugin hook ${event} warning: ${err2 instanceof Error ? err2.message : String(err2)}
+        `integration hook ${event} warning: ${err2 instanceof Error ? err2.message : String(err2)}
 `
       );
     }
@@ -3446,13 +3766,14 @@ function unfinishedGitState(dir) {
   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 (fs8.existsSync(path18.resolve(dir, p6.stdout.trim()))) return state2;
+    if (fs9.existsSync(path22.resolve(dir, p6.stdout.trim()))) return state2;
   }
   return null;
 }
 async function reindexLibrary(lib, library, name) {
   assertManifestEditableOrExit(lib.path);
   exitOnManifestPublisherProblems(lib.path, name);
+  exitOnLibrarySymlinks(lib.path, `skaile library index ${name}`);
   const badRequires = manifestRequiresProblems(lib.path);
   const resolved = resolveLibraryPublisherDetailed(lib, {}, getStoreIdentity());
   warnLibraryNameFallback(name, resolved);
@@ -3461,7 +3782,17 @@ async function reindexLibrary(lib, library, name) {
     lib.path,
     resolved.publisher,
     registry,
-    { check: (e) => checkAssetFile(e.source, e.kind, registry) }
+    {
+      check: (e) => checkAssetFile(
+        e.source,
+        e.kind,
+        registry,
+        lib.path,
+        (f) => logWarn(
+          `${path22.relative(lib.path, e.source)} [${f.tag}] \u2014 body is still the scaffold placeholder; publish refuses it until you write the ${f.tag} prompt`
+        )
+      )
+    }
   );
   const manifest = loadSkPublishManifest(lib.path);
   for (const a of unknownKind) {
@@ -3473,19 +3804,25 @@ async function reindexLibrary(lib, library, name) {
     const ref = manifest ? assetEntryRef(a, manifest) : `${a.kind}:${a.name}`;
     logInfo(`Removed manifest entry ${ref} (root ${a.root} is gone)`);
   }
-  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 invalidVersion = skipped.filter((x) => x.reason === "invalid-version");
+  for (const s of invalidVersion) {
+    const found = checkAssetFile(path22.join(lib.path, s.file), s.kind, registry).find(
+      (f) => f.text.startsWith("version ")
+    );
+    const detail = found?.text ?? s.detail;
+    const hint = detail.includes("Write it quoted") ? "" : " Set a valid `metadata.version` (e.g. 0.1.0).";
+    logErr(
+      `${s.kind}:${s.name} skipped: ${detail}.${hint} Re-run \`skaile library index ${name}\` after the fix.`
     );
   }
   const duplicates = skipped.filter((x) => x.reason === "duplicate");
   for (const s of duplicates) {
-    logErr(duplicateAssetMessage(s.kind, s.name, path18.dirname(s.file), s.detail, name));
+    logErr(duplicateAssetMessage(s.kind, s.name, path22.dirname(s.file), s.detail, name));
   }
   for (const s of failed) {
     for (const f of s.findings) logErr(`${s.file} [${f.tag}] \u2014 ${f.text}`);
   }
-  const duplicateFiles = new Set(duplicates.map((s) => path18.resolve(lib.path, s.file)));
+  const duplicateFiles = new Set(duplicates.map((s) => path22.resolve(lib.path, s.file)));
   const skippedKeys = new Set(
     [
       ...skipped.filter((s) => s.reason !== "duplicate"),
@@ -3493,7 +3830,7 @@ async function reindexLibrary(lib, library, name) {
     ].map((s) => `${s.kind}:${s.name}`)
   );
   const res = await indexLibrary(lib, library, {
-    exclude: (a) => skippedKeys.has(`${a.kind}:${a.name}`) || duplicateFiles.has(path18.resolve(a.manifestPath))
+    exclude: (a) => skippedKeys.has(`${a.kind}:${a.name}`) || duplicateFiles.has(path22.resolve(a.manifestPath))
   });
   const unparsable = res.errors.filter((e) => e.includes("ManifestSchemaError:"));
   for (const e of res.errors) (unparsable.includes(e) ? logErr : logWarn)(e);
@@ -3505,14 +3842,21 @@ async function reindexLibrary(lib, library, name) {
   }
   for (const p6 of badRequires) logErr(`${p6.asset}: ${p6.message}`);
   for (const w of await unresolvedManifestDependencies(lib.path)) logWarn(w);
-  logOk(`Indexed ${res.assetsUpdated} asset(s) from ${name}.`);
+  const skippedUnparsable = unparsable.length + syncUnparsable.length;
+  const failing = skippedUnparsable + invalidVersion.length + badRequires.length + failed.length + duplicates.length;
+  (failing > 0 ? logWarn : logOk)(`Indexed ${res.assetsUpdated} asset(s) from ${name}.`);
   warnIgnoredDomainFiles(lib.path);
   warnLegacyBundleFiles(lib.path);
-  const skippedUnparsable = unparsable.length + syncUnparsable.length;
   if (skippedUnparsable > 0) {
     logErr(`${skippedUnparsable} asset(s) skipped: manifest could not be parsed.`);
     process.exitCode = 1;
   }
+  if (invalidVersion.length > 0) {
+    logErr(
+      `${invalidVersion.length} asset(s) skipped: the version is not valid semver (listed above).`
+    );
+    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.`
@@ -3536,8 +3880,16 @@ async function indexPulledLibrary(lib, library, name) {
   const res = await indexLibrary(lib, library);
   for (const e of res.errors) logWarn(e);
   logOk(`Indexed ${res.assetsUpdated} asset(s) from ${name}.`);
+  warnUnlistedAssets(await countUnlistedAssets(lib.path), name);
   warnIgnoredDomainFiles(lib.path);
 }
+function warnUnlistedAssets(unlisted, name) {
+  if (unlisted > 0) {
+    logWarn(
+      `${unlisted} asset(s) on disk are not in the manifest; run \`skaile library index ${name}\`.`
+    );
+  }
+}
 function assertManifestEditableOrExit(libraryPath) {
   try {
     assertManifestEditable(libraryPath);
@@ -3547,26 +3899,26 @@ function assertManifestEditableOrExit(libraryPath) {
 }
 async function assertLibraryPathFree(manager, dir, exceptId) {
   const clash = (await manager.listLibraries()).find(
-    (l) => l.id !== exceptId && path18.resolve(l.path) === dir
+    (l) => l.id !== exceptId && path22.resolve(l.path) === dir
   );
   if (clash) throw new Error(`${dir} is already registered as library "${clash.name}".`);
 }
 function canonicalDir(dir) {
-  const abs = path18.resolve(dir);
+  const abs = path22.resolve(dir);
   const missing = [];
   let existing = abs;
-  while (!fs8.existsSync(existing)) {
-    const parent = path18.dirname(existing);
+  while (!fs9.existsSync(existing)) {
+    const parent = path22.dirname(existing);
     if (parent === existing) return abs;
-    missing.unshift(path18.basename(existing));
+    missing.unshift(path22.basename(existing));
     existing = parent;
   }
-  return path18.join(fs8.realpathSync(existing), ...missing);
+  return path22.join(fs9.realpathSync(existing), ...missing);
 }
 function refuseGlobalInstallFolder(name, dir) {
   const reserved = globalInstallDir();
-  const rel = path18.relative(canonicalDir(reserved).toLowerCase(), canonicalDir(dir).toLowerCase());
-  const inside = rel === "" || !rel.startsWith("..") && !path18.isAbsolute(rel);
+  const rel = path22.relative(canonicalDir(reserved).toLowerCase(), canonicalDir(dir).toLowerCase());
+  const inside = rel === "" || !rel.startsWith("..") && !path22.isAbsolute(rel);
   if (name?.toLowerCase() === GLOBAL_INSTALL_DIR_NAME || inside) {
     logErr(
       `"${GLOBAL_INSTALL_DIR_NAME}" is reserved: ${reserved} holds assets from \`skaile install\`, not a library you author.`
@@ -3576,8 +3928,8 @@ function refuseGlobalInstallFolder(name, dir) {
 }
 async function refuseNestedLibraryPath(manager, dir, exceptId) {
   const within = (parent, child) => {
-    const rel = path18.relative(parent, child);
-    return rel === "" || !rel.startsWith("..") && !path18.isAbsolute(rel);
+    const rel = path22.relative(parent, child);
+    return rel === "" || !rel.startsWith("..") && !path22.isAbsolute(rel);
   };
   const target = canonicalDir(dir).toLowerCase();
   const librariesDir = resolveLibraryDir();
@@ -3607,29 +3959,29 @@ async function refuseNestedLibraryPath(manager, dir, exceptId) {
 function assertCreateDirInsideLibrary(libRoot, destDir, given) {
   const exists = (p6) => {
     try {
-      fs8.lstatSync(p6);
+      fs9.lstatSync(p6);
       return true;
     } catch {
       return false;
     }
   };
   let probe = destDir;
-  while (!exists(probe)) probe = path18.dirname(probe);
+  while (!exists(probe)) probe = path22.dirname(probe);
   let realProbe;
   try {
-    realProbe = fs8.realpathSync(probe);
+    realProbe = fs9.realpathSync(probe);
   } catch {
     logErr(`--dir "${given}" passes through a broken symlink (${probe}).`);
     process.exit(1);
   }
-  if (!fs8.statSync(realProbe).isDirectory()) {
+  if (!fs9.statSync(realProbe).isDirectory()) {
     logErr(`--dir "${given}": ${probe} is not a directory.`);
     process.exit(1);
   }
   const realRoot = canonicalDir(libRoot);
-  const realDest = path18.join(realProbe, path18.relative(probe, destDir));
-  const rel = path18.relative(realRoot, realDest);
-  if (rel === ".." || rel.startsWith(`..${path18.sep}`) || path18.isAbsolute(rel)) {
+  const realDest = path22.join(realProbe, path22.relative(probe, destDir));
+  const rel = path22.relative(realRoot, realDest);
+  if (rel === ".." || rel.startsWith(`..${path22.sep}`) || path22.isAbsolute(rel)) {
     logErr(
       `--dir "${given}" must stay inside the library (${realRoot}): it resolves to ${realDest}.`
     );
@@ -3637,7 +3989,7 @@ function assertCreateDirInsideLibrary(libRoot, destDir, given) {
   }
 }
 function adoptWritesManifest(libPath) {
-  if (!fs8.existsSync(path18.join(libPath, SKAILE_MANIFEST_FILENAME))) return true;
+  if (!fs9.existsSync(path22.join(libPath, SKAILE_MANIFEST_FILENAME))) return true;
   const manifest = loadSkPublishManifest(libPath);
   if (!manifest || manifest.source || (manifest.assets ?? []).length > 0) return false;
   return manifestPublisherProblems(libPath).length === 0;
@@ -3691,17 +4043,26 @@ function requireValidLibraryName(name) {
 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 = path18.dirname(path18.resolve(libPath));
+  let dir = path22.dirname(path22.resolve(libPath));
   for (; ; ) {
-    const rel = path18.relative(root, canonicalDir(dir));
-    if (rel === "" || rel.startsWith("..") || path18.isAbsolute(rel)) return;
-    if (!fs8.existsSync(dir) || fs8.readdirSync(dir).length > 0) return;
-    fs8.rmdirSync(dir);
-    dir = path18.dirname(dir);
+    const rel = path22.relative(root, canonicalDir(dir));
+    if (rel === "" || rel.startsWith("..") || path22.isAbsolute(rel)) return;
+    if (!fs9.existsSync(dir) || fs9.readdirSync(dir).length > 0) return;
+    fs9.rmdirSync(dir);
+    dir = path22.dirname(dir);
   }
 }
+function remoteBranches(url) {
+  const r = spawnSync("git", ["ls-remote", "--heads", url], {
+    encoding: "utf-8",
+    timeout: 2e4,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  if (r.status !== 0) return [];
+  return r.stdout.split("\n").map((line) => line.split("	")[1]?.replace(/^refs\/heads\//, "")).filter((b) => !!b);
+}
 async function warnIfNotGithubRemote(name, url) {
-  const { isGithubRemote, notGithubRemoteMessage } = await import('../library-publish-53UTB3MB.js');
+  const { isGithubRemote, notGithubRemoteMessage } = await import('../library-publish-FFIPWIRM.js');
   if (!isGithubRemote(url)) logWarn(notGithubRemoteMessage(name, url));
 }
 function scaffoldLibraryFiles(dir, name) {
@@ -3733,9 +4094,9 @@ by the same ref.
   ];
   const written = [];
   for (const [file, content] of files) {
-    const target = path18.join(dir, file);
-    if (fs8.existsSync(target)) continue;
-    fs8.writeFileSync(target, content, "utf8");
+    const target = path22.join(dir, file);
+    if (fs9.existsSync(target)) continue;
+    fs9.writeFileSync(target, content, "utf8");
     written.push(file);
   }
   return written;
@@ -3823,9 +4184,9 @@ function makeLibraryCommand() {
         opts.path ??= gone.path;
       }
       const ownership = flagged[0] ?? gone?.ownership ?? "owner";
-      const libPath = opts.path ? path18.resolve(opts.path) : path18.join(resolveLibraryDir(), name);
+      const libPath = opts.path ? path22.resolve(opts.path) : path22.join(resolveLibraryDir(), name);
       refuseGlobalInstallFolder(name, libPath);
-      if (fs8.existsSync(libPath) && !fs8.statSync(libPath).isDirectory()) {
+      if (fs9.existsSync(libPath) && !fs9.statSync(libPath).isDirectory()) {
         logErr(`${libPath} exists and is not a directory.`);
         process.exit(1);
       }
@@ -3864,9 +4225,9 @@ function makeLibraryCommand() {
           backend = "git";
           backendConfig = { url: adopted.url, branch: adopted.branch, authHint: "ssh" };
         } else {
-          fs8.mkdirSync(libPath, { recursive: true });
+          fs9.mkdirSync(libPath, { recursive: true });
         }
-        const blank = fs8.readdirSync(libPath).every((entry) => entry === ".git");
+        const blank = fs9.readdirSync(libPath).every((entry) => entry === ".git");
         const isDefault = !hasDefault && ownership !== "reader";
         await manager.addLibrary({
           name,
@@ -3911,11 +4272,7 @@ function makeLibraryCommand() {
           const res = await indexLibrary(lib, library);
           for (const e of res.errors) logWarn(e);
           logOk(`Indexed ${res.assetsUpdated} asset(s) from ${name}.`);
-          if (unlisted > 0) {
-            logWarn(
-              `${unlisted} asset(s) on disk are not in the manifest; run \`skaile library index ${name}\`.`
-            );
-          }
+          warnUnlistedAssets(unlisted, name);
           warnIgnoredDomainFiles(libPath);
         }
       } catch (err2) {
@@ -3925,7 +4282,10 @@ function makeLibraryCommand() {
       }
     }
   );
-  cmd.command("link <name> <git-url>").description("Attach a github remote to a local library (makes it store-publishable)").option("--branch <name>", "Default branch", "main").action(async (name, url, opts) => {
+  cmd.command("link <name> <git-url>").description("Attach a github remote to a local library (makes it store-publishable)").option(
+    "--branch <name>",
+    "Branch to track (default: the checked-out branch of an existing repo, else main)"
+  ).action(async (name, url, opts) => {
     const { manager, close } = await openLibraryManager();
     try {
       const lib = await manager.requireLibraryDir(name);
@@ -3935,11 +4295,25 @@ function makeLibraryCommand() {
         );
         process.exit(1);
       }
-      ensureGitRepo(lib.path, url, opts.branch);
-      trackOriginBranch(lib.path, opts.branch, { fetch: true });
+      const head = isGitRepo(lib.path) ? spawnSync("git", ["symbolic-ref", "--short", "-q", "HEAD"], {
+        cwd: lib.path,
+        encoding: "utf-8"
+      }) : void 0;
+      const branch = opts.branch ?? (head?.status === 0 && head.stdout.trim() || "main");
+      if (opts.branch === void 0) {
+        const theirs = remoteBranches(url);
+        if (theirs.length > 0 && !theirs.includes(branch)) {
+          logErr(
+            `The remote already has ${theirs.length === 1 ? "branch" : "branches"} ${theirs.join(", ")}; pass --branch ${theirs[0]} to track ${theirs.length === 1 ? "it" : "one"}.`
+          );
+          process.exit(1);
+        }
+      }
+      ensureGitRepo(lib.path, url, branch);
+      trackOriginBranch(lib.path, branch, { fetch: true });
       await manager.updateLibrary(name, {
         backend: "git",
-        backendConfig: { url, branch: opts.branch, authHint: "ssh" }
+        backendConfig: { url, branch, authHint: "ssh" }
       });
       logOk(`Library "${name}" linked to ${url}.`);
       await warnIfNotGithubRemote(name, url);
@@ -3980,10 +4354,10 @@ function makeLibraryCommand() {
         exitOnManifestPublisherProblems(target.path, target.name);
         const effectiveKind = opts.kind ?? kind;
         const am2 = new AssetManager({ registry: getKindRegistry(), projectDir: process.cwd() });
-        const libRoot = path18.resolve(target.path);
-        const destDir = opts.dir ? path18.resolve(libRoot, opts.dir) : libRoot;
-        const relDest = path18.relative(libRoot, destDir);
-        if (relDest === ".." || relDest.startsWith(`..${path18.sep}`) || path18.isAbsolute(relDest)) {
+        const libRoot = path22.resolve(target.path);
+        const destDir = opts.dir ? path22.resolve(libRoot, opts.dir) : libRoot;
+        const relDest = path22.relative(libRoot, destDir);
+        if (relDest === ".." || relDest.startsWith(`..${path22.sep}`) || path22.isAbsolute(relDest)) {
           logErr(`--dir "${opts.dir}" must stay inside the library (${libRoot}).`);
           process.exit(1);
         }
@@ -3992,11 +4366,11 @@ function makeLibraryCommand() {
           libRoot,
           effectiveKind,
           name,
-          path18.relative(libRoot, path18.join(destDir, name))
+          path22.relative(libRoot, path22.join(destDir, name))
         );
         if (taken) {
           logErr(
-            `${effectiveKind}:${name} already exists at "${taken}" \u2014 creating it again under "${path18.relative(libRoot, destDir) || "."}" would re-point the manifest entry. Pick another name.`
+            `${effectiveKind}:${name} already exists at "${taken}" \u2014 creating it again under "${path22.relative(libRoot, destDir) || "."}" would re-point the manifest entry. Pick another name.`
           );
           process.exit(1);
         }
@@ -4054,13 +4428,13 @@ function makeLibraryCommand() {
       logErr(`A library named "${newName}" is already registered.`);
       process.exit(1);
     }
-    const newPath = path18.join(path18.dirname(lib.path), newName);
+    const newPath = path22.join(path22.dirname(lib.path), newName);
     refuseGlobalInstallFolder(newName, newPath);
-    if (fs8.existsSync(newPath)) {
+    if (fs9.existsSync(newPath)) {
       logErr(`Target directory already exists: ${newPath}`);
       process.exit(1);
     }
-    fs8.renameSync(lib.path, newPath);
+    fs9.renameSync(lib.path, newPath);
     await manager.updateLibrary(lib.id, { name: newName, path: newPath });
     logOk(`Renamed ${lib.name} \u2192 ${newName}`);
   }
@@ -4140,8 +4514,8 @@ function makeLibraryCommand() {
         }
         patch.isDefault = false;
       } else if (field === "path") {
-        const dir = path18.resolve(value);
-        if (!fs8.existsSync(dir) || !fs8.statSync(dir).isDirectory()) {
+        const dir = path22.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);
         }
@@ -4352,16 +4726,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-53UTB3MB.js');
+      const { runLibraryPublish } = await import('../library-publish-FFIPWIRM.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-53UTB3MB.js');
+    const { runLibraryRegister } = await import('../library-publish-FFIPWIRM.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-53UTB3MB.js');
+    const { runLibraryYank } = await import('../library-publish-FFIPWIRM.js');
     await withStoreErrorHandling(() => runLibraryYank(lib, opts));
   });
   return cmd;
@@ -4412,9 +4786,9 @@ async function printOverallStatus(projectDir, asJson) {
     } catch {
       secretsStrategy = "unavailable";
     }
-    const resolvedProjectDir = path18.resolve(projectDir);
-    const hasWorkspaceConfig = existsSync(path18.join(resolvedProjectDir, "skaile.yaml"));
-    const hasLockFile = existsSync(path18.join(resolvedProjectDir, "skaile.lock.yaml"));
+    const resolvedProjectDir = path22.resolve(projectDir);
+    const hasWorkspaceConfig = existsSync(path22.join(resolvedProjectDir, "skaile.yaml"));
+    const hasLockFile = existsSync(path22.join(resolvedProjectDir, "skaile.lock.yaml"));
     let assignments = [];
     if (hasWorkspaceConfig) {
       try {
@@ -5021,7 +5395,7 @@ function scheduleSoftDepPreview() {
 }
 async function loadAssets() {
   softDepPreviewCache.clear();
-  const { gatherAssetFeeds } = await import('../asset-feeds-CXGQIDFR.js');
+  const { gatherAssetFeeds } = await import('../asset-feeds-ALMTHLPV.js');
   const { entries, notes } = await gatherAssetFeeds(am, am.projectDir);
   if (notes.length > 0) {
     state.message = notes.map((n) => `[${n.feed}] ${n.message}`).join(" \u2022 ");
@@ -5029,7 +5403,7 @@ async function loadAssets() {
   const installed = new Set(am.listDeployed().map((e) => `${e.kind}:${e.name}`));
   let lock = null;
   try {
-    lock = readLock(path18__default.join(am.projectDir, "skaile.lock.yaml"));
+    lock = readLock(path22__default.join(am.projectDir, "skaile.lock.yaml"));
   } catch {
   }
   const rows = buildAssetRows(
@@ -5051,7 +5425,7 @@ function rebuildSourceTree() {
   rebuildVisibleSources();
 }
 function sourceOrgRepo(s) {
-  const parts = s.path.split(path18__default.sep).filter(Boolean);
+  const parts = s.path.split(path22__default.sep).filter(Boolean);
   if (parts.length < 2) return null;
   return { org: parts[parts.length - 2], repo: parts[parts.length - 1] };
 }
@@ -5225,13 +5599,13 @@ function reconcileCollapsedSets(rows) {
 async function loadSourcesAndLibraries() {
   try {
     const [{ openLibraryManager: openLibraryManager2 }, { getGlobalCacheDir: getGlobalCacheDir2, globalSkaileDir: globalSkaileDir2 }] = await Promise.all([
-      import('../open-library-BOSPJVID.js'),
+      import('../open-library-PZAT3TJA.js'),
       import('../core/index.js')
     ]);
     const { manager, library, close } = await openLibraryManager2();
     try {
       const newRoot = getGlobalCacheDir2();
-      const legacyRoot = path18__default.join(globalSkaileDir2(), "sources");
+      const legacyRoot = path22__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();
@@ -6191,19 +6565,19 @@ 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(path18__default.resolve(opts.projectDir));
+    await run(path22__default.resolve(opts.projectDir));
   });
 }
 function makeMcpServerCommand() {
   return new Command("mcp-server").description("Start skaile workspace MCP server (stdio transport)").option("--project-dir <path>", "Project directory (default: cwd)", process.cwd()).action(async (opts) => {
-    const path43 = await import('path');
-    const projectDir = path43.default.resolve(opts.projectDir);
-    const { LogStore, StdoutSink, registerLogStore } = await import('../core/logging.js');
-    registerLogStore(
-      new LogStore({
+    const path44 = await import('path');
+    const projectDir = path44.default.resolve(opts.projectDir);
+    const { LogStore: LogStore2, StdoutSink: StdoutSink2, registerLogStore: registerLogStore2 } = await import('../core/logging.js');
+    registerLogStore2(
+      new LogStore2({
         sessionId: "mcp-server",
         level: "info",
-        sinks: [new StdoutSink({ stream: "stderr" })]
+        sinks: [new StdoutSink2({ stream: "stderr" })]
       })
     );
     const { WorkspacePlugin } = await import('../workspace-plugin/index.js');
@@ -6244,10 +6618,10 @@ function walkFiles(root, match) {
       return;
     }
     for (const entry of entries) {
-      const full = path18__default.join(dir, entry.name);
+      const full = path22__default.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (SKIPPED_DIRS.has(entry.name)) continue;
-        if (entry.name === "cache" && path18__default.basename(dir) === ".skaile") continue;
+        if (entry.name === "cache" && path22__default.basename(dir) === ".skaile") continue;
         visit(full);
       } else if (entry.isFile() && match(entry.name)) {
         out.push(full);
@@ -6265,14 +6639,14 @@ function applyChanges2(changes) {
     switch (change.type) {
       case "write":
       case "create":
-        mkdirSync(path18__default.dirname(change.path), { recursive: true });
+        mkdirSync(path22__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(path18__default.dirname(change.to), { recursive: true });
+        mkdirSync(path22__default.dirname(change.to), { recursive: true });
         writeFileSync(change.to, change.after, "utf-8");
         rmSync(change.from, { force: true });
         break;
@@ -6365,7 +6739,7 @@ function unifiedDiff(before, after, oldLabel, newLabel, context = 3) {
   return `${out.join("\n")}
 `;
 }
-var posix = (p6) => p6.split(path18__default.sep).join("/");
+var posix = (p6) => p6.split(path22__default.sep).join("/");
 function colorizeDiff(diff) {
   return diff.split("\n").map((line) => {
     if (line.startsWith("+++") || line.startsWith("---")) return S.bold(line);
@@ -6376,7 +6750,7 @@ function colorizeDiff(diff) {
   }).join("\n");
 }
 function renderChange(change, base) {
-  const rel = (p6) => posix(path18__default.relative(base, p6) || path18__default.basename(p6));
+  const rel = (p6) => posix(path22__default.relative(base, p6) || path22__default.basename(p6));
   switch (change.type) {
     case "write":
       return unifiedDiff(
@@ -6403,7 +6777,7 @@ ${diff}`;
   }
 }
 function changeLabel(change, base) {
-  const rel = (p6) => posix(path18__default.relative(base, p6) || path18__default.basename(p6));
+  const rel = (p6) => posix(path22__default.relative(base, p6) || path22__default.basename(p6));
   switch (change.type) {
     case "write":
       return `modify ${rel(change.path)}`;
@@ -6463,10 +6837,10 @@ function loadAsset(projectDir, id, ref) {
       )
     };
   }
-  const manifestPath = path18__default.join(dir, AGENT_MANIFEST_FILE);
+  const manifestPath = path22__default.join(dir, AGENT_MANIFEST_FILE);
   let text;
   try {
-    text = fs8__default.readFileSync(manifestPath, "utf-8");
+    text = fs9__default.readFileSync(manifestPath, "utf-8");
   } catch {
     return {
       diagnostic: err(
@@ -6571,6 +6945,7 @@ function checkAgentInstances(projectDir, parsed) {
   const diagnostics = [];
   const instances = normalizeAgentInstances(parsed.agents, diagnostics);
   const agent = isRecord(parsed.agent) ? parsed.agent : void 0;
+  diagnostics.push(...agentBlockKeyDiagnostics(parsed.agent));
   if (agent?.subagents !== void 0) {
     diagnostics.push(
       err(
@@ -6645,12 +7020,12 @@ function findManifestCandidates(rootPath) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+      entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path18__default.join(dir, entry.name);
+      const fullPath = path22__default.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) walk(fullPath);
       } else if (entry.isFile()) {
@@ -6667,10 +7042,10 @@ function findManifestCandidates(rootPath) {
   return candidates;
 }
 function parseManifestCandidate(c, absRoot) {
-  const content = fs8__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(`${path18__default.relative(absRoot, c.filePath)} [${c.kind}] \u2014 parse error: ${res.reason}`);
+    logErr(`${path22__default.relative(absRoot, c.filePath)} [${c.kind}] \u2014 parse error: ${res.reason}`);
     return { kind: "error" };
   }
   return {
@@ -6687,29 +7062,52 @@ function checkComposeKinds(parsed, registry) {
   const diagnostics = [];
   composes.forEach((item, i) => {
     if (item === null || typeof item !== "object") return;
-    const kind = item.kind;
+    const fields = item;
+    const kind = fields.kind;
     if (typeof kind !== "string") return;
-    if (PSEUDO_COMPOSE_KINDS.has(kind) || registry.getProvider(kind)) return;
-    diagnostics.push({
-      code: "unknown_asset_kind",
-      severity: "error",
-      message: `composes item kind "${kind}" is not a registered asset kind (registered: ${registry.getAllKinds().join(", ")})`,
-      path: `composes[${i}].kind`
-    });
+    if (!PSEUDO_COMPOSE_KINDS.has(kind) && !registry.getProvider(kind)) {
+      diagnostics.push({
+        code: "unknown_asset_kind",
+        severity: "error",
+        message: `composes item kind "${kind}" is not a registered asset kind (registered: ${registry.getAllKinds().join(", ")})`,
+        path: `composes[${i}].kind`
+      });
+      return;
+    }
+    if (fields.binding !== void 0 || typeof fields.ref !== "string") return;
+    try {
+      resolveBinding({ kind, ref: fields.ref });
+    } catch (err2) {
+      if (!(err2 instanceof UnknownCompositionKindError)) throw err2;
+      diagnostics.push({
+        code: "unknown_asset_kind",
+        severity: "error",
+        message: `composes item "${fields.ref}" of kind "${kind}" has no default binding; set \`binding:\` (the session build fails without it)`,
+        path: `composes[${i}].binding`
+      });
+    }
   });
   return diagnostics;
 }
+function libraryRootOf(absRoot) {
+  for (let dir = absRoot; ; dir = path22__default.dirname(dir)) {
+    if (fs9__default.existsSync(path22__default.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
+    if (path22__default.dirname(dir) === dir) return absRoot;
+  }
+}
 function validateManifestCandidate(c, parsed, body, absRoot, registry, strictConformance) {
-  const relPath = path18__default.relative(absRoot, c.filePath);
+  const relPath = path22__default.relative(absRoot, c.filePath);
   let errors = 0;
   let warnings = 0;
-  const dirName = path18__default.basename(path18__default.dirname(c.filePath));
+  const dirName = path22__default.basename(path22__default.dirname(c.filePath));
   const checked = checkAsset(
     c.kind,
     parsed ?? {},
     body,
     dirName,
-    registry
+    registry,
+    fs9__default.readFileSync(c.filePath, "utf-8"),
+    path22__default.basename(c.filePath)
   );
   for (const f of checked.errors) {
     logErr(`${relPath} [${f.tag}] \u2014 ${f.text}`);
@@ -6717,7 +7115,7 @@ function validateManifestCandidate(c, parsed, body, absRoot, registry, strictCon
   }
   for (const f of checked.advisories) {
     const line = `${relPath} [${f.tag}] \u2014 ${f.text}`;
-    if (f.conformance && strictConformance) {
+    if (f.conformance && strictConformance || f.scaffoldBody) {
       logErr(line);
       errors++;
     } else {
@@ -6725,7 +7123,17 @@ function validateManifestCandidate(c, parsed, body, absRoot, registry, strictCon
       warnings++;
     }
   }
-  if (c.kind === "agent" && path18__default.basename(c.filePath) === "agent.yaml") {
+  if (c.kind === "agent" && parsed !== null && typeof parsed === "object") {
+    for (const f of checkAgentFiles(
+      parsed,
+      path22__default.dirname(c.filePath),
+      libraryRootOf(absRoot)
+    )) {
+      logErr(`${relPath} [${f.tag}] \u2014 ${f.text}`);
+      errors++;
+    }
+  }
+  if (c.kind === "agent" && path22__default.basename(c.filePath) === "agent.yaml") {
     for (const d of [
       ...checkComposeKinds(parsed, registry),
       ...composeSlotDiagnostics(parsed),
@@ -6743,17 +7151,36 @@ function validateManifestCandidate(c, parsed, body, absRoot, registry, strictCon
   }
   return { errors, warnings };
 }
+function scanIdentities(root) {
+  const identities = /* @__PURE__ */ new Set();
+  for (const c of findManifestCandidates(root)) {
+    let parsed;
+    try {
+      const res = parseManifestFile(c.filePath, fs9__default.readFileSync(c.filePath, "utf-8"));
+      if (!res.ok) continue;
+      parsed = res.data;
+    } catch {
+      continue;
+    }
+    if (parsed === null || typeof parsed !== "object") continue;
+    const identity = parsed[c.kind === "flow" ? "id" : "name"];
+    if (typeof identity === "string" && identity.length > 0)
+      identities.add(`${c.kind}:${identity}`);
+  }
+  return identities;
+}
 function validateManifests(rootPath, strictConformance) {
-  const absRoot = path18__default.resolve(rootPath);
-  if (!fs8__default.existsSync(absRoot)) {
+  const absRoot = path22__default.resolve(rootPath);
+  if (!fs9__default.existsSync(absRoot)) {
     logErr(`Path does not exist: ${absRoot}`);
     return { total: 0, errors: 1, warnings: 0 };
   }
   const registry = getKindRegistry();
   const candidates = findManifestCandidates(absRoot);
-  let errors = 0;
+  let errors = reportLibrarySymlinks(absRoot);
   let warnings = 0;
   const seenIdentity = /* @__PURE__ */ new Map();
+  const agentsToResolve = [];
   for (const c of candidates) {
     const parseResult = parseManifestCandidate(c, absRoot);
     if (parseResult.kind === "error") {
@@ -6770,22 +7197,38 @@ function validateManifests(rootPath, strictConformance) {
     );
     errors += delta.errors;
     warnings += delta.warnings;
+    if (c.kind === "agent" && parseResult.parsed !== null && typeof parseResult.parsed === "object") {
+      agentsToResolve.push({
+        relPath: path22__default.relative(absRoot, c.filePath),
+        parsed: parseResult.parsed
+      });
+    }
     const obj = parseResult.parsed;
     const identity = obj && typeof obj === "object" ? obj[c.kind === "flow" ? "id" : "name"] : null;
     if (typeof identity === "string" && identity.length > 0) {
-      const dir = path18__default.dirname(c.filePath);
+      const dir = path22__default.dirname(c.filePath);
       const key = `${c.kind}:${identity}`;
       const first = seenIdentity.get(key);
       if (first === void 0) {
         seenIdentity.set(key, dir);
       } else if (first !== dir) {
         logErr(
-          `${path18__default.relative(absRoot, c.filePath)} [${c.kind}] \u2014 ${key} is also defined in ${path18__default.relative(absRoot, first) || "."}; two directories cannot share a kind and name (\`skaile library index\` keeps only the first).`
+          `${path22__default.relative(absRoot, c.filePath)} [${c.kind}] \u2014 ${key} is also defined in ${path22__default.relative(absRoot, first) || "."}; two directories cannot share a kind and name (\`skaile library index\` keeps only the first).`
         );
         errors++;
       }
     }
   }
+  const libraryRoot = libraryRootOf(absRoot);
+  const libraryPublisher = loadSkPublishManifest(libraryRoot)?.publisher;
+  const siblingIdentities = libraryRoot === absRoot ? /* @__PURE__ */ new Set() : scanIdentities(libraryRoot);
+  const hasAsset = (kind, name) => seenIdentity.has(`${kind}:${name}`) || siblingIdentities.has(`${kind}:${name}`);
+  for (const agent of agentsToResolve) {
+    for (const f of agentComposeRefAdvisories(agent.parsed, hasAsset, libraryPublisher)) {
+      logWarn(`${agent.relPath} [${f.tag}] \u2014 ${f.text}`);
+      warnings++;
+    }
+  }
   return { total: candidates.length, errors, warnings };
 }
 function findWorkspaceManifests(rootPath) {
@@ -6793,12 +7236,12 @@ function findWorkspaceManifests(rootPath) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs8__default.readdirSync(dir, { withFileTypes: true });
+      entries = fs9__default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path18__default.join(dir, entry.name);
+      const full = path22__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)) {
@@ -6860,15 +7303,15 @@ function validateWorkspaceAssets(parsed, relPath) {
   }
   return errors;
 }
-function validateWorkspaceManifests(rootPath) {
-  const absRoot = path18__default.resolve(rootPath);
+async function validateWorkspaceManifests(rootPath) {
+  const absRoot = path22__default.resolve(rootPath);
   const files = findWorkspaceManifests(absRoot);
   let errors = 0;
   for (const file of files) {
-    const relPath = path18__default.relative(absRoot, file);
+    const relPath = path22__default.relative(absRoot, file);
     let parsed;
     try {
-      parsed = parse(fs8__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++;
@@ -6876,7 +7319,7 @@ function validateWorkspaceManifests(rootPath) {
     }
     errors += validateWorkspaceRefs(collectWorkspaceRefFields(parsed), relPath);
     errors += validateWorkspaceAssets(parsed, relPath);
-    for (const d of checkAgentInstances(path18__default.dirname(file), parsed)) {
+    for (const d of checkAgentInstances(path22__default.dirname(file), parsed)) {
       const line = `${relPath} [agents] \u2014 ${d.code}: ${d.path ? `${d.path}: ` : ""}${d.message}`;
       if (d.severity === "error") {
         logErr(line);
@@ -6885,11 +7328,27 @@ function validateWorkspaceManifests(rootPath) {
         logWarn(line);
       }
     }
+    const decoded = decodeSkaileYaml(fs9__default.readFileSync(file, "utf-8"));
+    for (const d of decoded.diagnostics) {
+      if (d.code !== "connector_missing_driver") continue;
+      logErr(`${relPath} [connectors] \u2014 ${d.code}: ${d.path ? `${d.path}: ` : ""}${d.message}`);
+      errors++;
+    }
+    if ((decoded.config?.connectors ?? []).length > 0) {
+      const assets = await resolveRuntimeAssets(path22__default.dirname(file));
+      if (!assets.warnings.some((w) => w.code === "repo_unavailable")) {
+        for (const w of assets.warnings) {
+          if (w.code !== "missing_driver" || !w.name) continue;
+          logErr(`${relPath} [connectors] \u2014 ${w.code}: ${w.message}`);
+          errors++;
+        }
+      }
+    }
   }
   return { total: files.length, errors };
 }
 function validatePublishManifestRoots(rootPath) {
-  const absRoot = path18__default.resolve(rootPath);
+  const absRoot = path22__default.resolve(rootPath);
   const manifest = loadSkPublishManifest(absRoot);
   if (!manifest) return 0;
   const missing = missingRootAssets(absRoot, manifest);
@@ -6901,7 +7360,7 @@ function validatePublishManifestRoots(rootPath) {
   return missing.length;
 }
 function validatePublishManifestRequires(rootPath) {
-  const problems = manifestRequiresProblems(path18__default.resolve(rootPath));
+  const problems = manifestRequiresProblems(path22__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.`
@@ -6910,20 +7369,29 @@ function validatePublishManifestRequires(rootPath) {
   return problems.length;
 }
 function validatePublishManifestPublisherSlugs(rootPath) {
-  const problems = manifestPublisherProblems(path18__default.resolve(rootPath));
+  const problems = manifestPublisherProblems(path22__default.resolve(rootPath));
   for (const message of problems) logErr(message);
   return problems.length;
 }
+function validatePublishManifestParses(rootPath) {
+  try {
+    assertManifestEditable(path22__default.resolve(rootPath));
+    return 0;
+  } catch (err2) {
+    logErr(err2 instanceof Error ? err2.message : String(err2));
+    return 1;
+  }
+}
 function validatePublishManifestVersions(rootPath) {
-  const absRoot = path18__default.resolve(rootPath);
+  const absRoot = path22__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(path18__default.join(absRoot, a.root), a.kind, a.name);
+    const file = findAssetManifestFile(path22__default.join(absRoot, a.root), a.kind, a.name);
     if (!file) continue;
-    const res = parseManifestFile(file, fs8__default.readFileSync(file, "utf-8"));
+    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;
@@ -6931,7 +7399,7 @@ function validatePublishManifestVersions(rootPath) {
       manifestVersionMismatchMessage(
         assetEntryRef(a, manifest),
         a.version,
-        toPosix(path18__default.relative(absRoot, file)),
+        toPosix(path22__default.relative(absRoot, file)),
         fileVersion
       )
     );
@@ -6940,7 +7408,7 @@ function validatePublishManifestVersions(rootPath) {
   return warnings;
 }
 function validatePublishManifestPublishers(rootPath) {
-  const absRoot = path18__default.resolve(rootPath);
+  const absRoot = path22__default.resolve(rootPath);
   const manifest = loadSkPublishManifest(absRoot);
   if (!manifest || manifest.source) return 0;
   const bare = (p6) => p6.trim().replace(/^@/, "");
@@ -6948,15 +7416,15 @@ function validatePublishManifestPublishers(rootPath) {
   for (const a of manifest.assets ?? []) {
     const resolved = a.publisher ?? manifest.publisher;
     if (!a.root || a.source || !resolved) continue;
-    const file = findAssetManifestFile(path18__default.join(absRoot, a.root), a.kind, a.name);
+    const file = findAssetManifestFile(path22__default.join(absRoot, a.root), a.kind, a.name);
     if (!file) continue;
-    const res = parseManifestFile(file, fs8__default.readFileSync(file, "utf-8"));
+    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(path18__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}.`
+      `${toPosix(path22__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++;
   }
@@ -6964,7 +7432,7 @@ function validatePublishManifestPublishers(rootPath) {
 }
 var EXCLUDED_PATHS = ["skaileup-shared/", "external/", "docs/"];
 function toPosix(p6) {
-  return p6.split(path18__default.sep).join("/");
+  return p6.split(path22__default.sep).join("/");
 }
 function isExcludedPath(relPath) {
   const rel = toPosix(relPath);
@@ -6980,9 +7448,9 @@ var VERSIONED_KINDS = {
 };
 function readAssetVersion(c) {
   const kind = c.kind;
-  const fileName = path18__default.basename(c.filePath);
-  const dirName = path18__default.basename(path18__default.dirname(c.filePath));
-  const content = fs8__default.readFileSync(c.filePath, "utf-8");
+  const fileName = path22__default.basename(c.filePath);
+  const dirName = path22__default.basename(path22__default.dirname(c.filePath));
+  const content = fs9__default.readFileSync(c.filePath, "utf-8");
   if (c.filePath.endsWith(".md")) {
     const res = parseManifestFile(c.filePath, content);
     const data = res.ok ? res.data : {};
@@ -7015,26 +7483,26 @@ function readAssetVersion(c) {
   };
 }
 function collectAssetVersions(root) {
-  if (!fs8__default.existsSync(root)) return [];
+  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(path18__default.relative(root, c.filePath))) continue;
+    if (isExcludedPath(path22__default.relative(root, c.filePath))) continue;
     assets.push(readAssetVersion(c));
   }
   return assets;
 }
 function assetLocation(a, root) {
-  return toPosix(path18__default.relative(root, a.filePath));
+  return toPosix(path22__default.relative(root, a.filePath));
 }
 function findChangelogUnit(assetRelPath, root) {
-  let dir = path18__default.posix.dirname(toPosix(assetRelPath));
+  let dir = path22__default.posix.dirname(toPosix(assetRelPath));
   for (; ; ) {
     const candidate = dir === "." ? "CHANGELOG.md" : `${dir}/CHANGELOG.md`;
-    if (fs8__default.existsSync(path18__default.join(root, candidate))) return candidate;
+    if (fs9__default.existsSync(path22__default.join(root, candidate))) return candidate;
     if (dir === ".") return null;
-    dir = path18__default.posix.dirname(dir);
+    dir = path22__default.posix.dirname(dir);
   }
 }
 function checkChangelogUnits(modifiedFiles, root) {
@@ -7084,7 +7552,7 @@ function checkVersionBumps(assets, root) {
   let warnings = 0;
   for (const a of assets) {
     if (!a.version) continue;
-    const relPath = toPosix(path18__default.relative(root, a.filePath));
+    const relPath = toPosix(path22__default.relative(root, a.filePath));
     try {
       const headContent = execFileSync("git", ["show", `HEAD:./${relPath}`], {
         cwd: root,
@@ -7117,7 +7585,7 @@ function checkFlowVersionPins(assets, root) {
       pins = flowSkillVersionPins(loadFlow(f.filePath));
     } catch (err2) {
       logWarn(
-        `flow:${f.name} (${path18__default.relative(root, f.filePath)}) \u2014 could not be read: ${err2 instanceof Error ? err2.message : err2}`
+        `flow:${f.name} (${path22__default.relative(root, f.filePath)}) \u2014 could not be read: ${err2 instanceof Error ? err2.message : err2}`
       );
       warnings++;
       continue;
@@ -7135,19 +7603,34 @@ function checkFlowVersionPins(assets, root) {
 }
 function resolveCheckRoot(pathArg) {
   if (pathArg) {
-    const abs = path18__default.resolve(pathArg);
-    if (!fs8__default.existsSync(abs)) {
+    const abs = path22__default.resolve(pathArg);
+    if (!fs9__default.existsSync(abs)) {
       logErr(`Path does not exist: ${abs}`);
       return null;
     }
     return abs;
   }
-  for (let dir = process.cwd(); ; dir = path18__default.dirname(dir)) {
-    if (fs8__default.existsSync(path18__default.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
-    if (path18__default.dirname(dir) === dir) return AI_RESOURCES;
+  for (let dir = process.cwd(); ; dir = path22__default.dirname(dir)) {
+    if (fs9__default.existsSync(path22__default.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
+    if (path22__default.dirname(dir) === dir) return AI_RESOURCES;
   }
 }
-function changedFiles(root, ref) {
+function isInGitWorkTree(root) {
+  try {
+    return execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim() === "true";
+  } catch {
+    return false;
+  }
+}
+function changedFiles(root, ref, what, opts = {}) {
+  if (!isInGitWorkTree(root)) {
+    logErr(`${what} needs a git repository: ${root} is not inside a git work tree.`);
+    return null;
+  }
   try {
     const out = execFileSync(
       "git",
@@ -7158,7 +7641,16 @@ function changedFiles(root, ref) {
         stdio: ["ignore", "pipe", "pipe"]
       }
     );
-    return out.trim().split("\n").filter(Boolean);
+    const changed = out.trim().split("\n").filter(Boolean);
+    if (opts.untracked) {
+      const fresh = execFileSync("git", ["ls-files", "--others", "--exclude-standard"], {
+        cwd: root,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      changed.push(...fresh.trim().split("\n").filter(Boolean));
+    }
+    return changed;
   } 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];
@@ -7166,6 +7658,22 @@ function changedFiles(root, ref) {
     return null;
   }
 }
+function assetOwnDir(a) {
+  const dir = path22__default.dirname(a.filePath);
+  if (["skill", "agent", "contract"].includes(a.kind) || path22__default.basename(dir) === a.name) return dir;
+  return null;
+}
+function assetChanged(a, changedAbs) {
+  if (changedAbs.has(a.filePath)) return true;
+  const dir = assetOwnDir(a);
+  if (dir === null) return false;
+  for (const f of changedAbs) {
+    const rel = path22__default.relative(dir, f);
+    if (rel.startsWith("..") || path22__default.isAbsolute(rel)) continue;
+    if (!isNonAssetPath(toPosix(rel))) return true;
+  }
+  return false;
+}
 function runVersionsCheck(pathArg, opts) {
   const root = resolveCheckRoot(pathArg);
   if (root === null) {
@@ -7174,13 +7682,13 @@ function runVersionsCheck(pathArg, opts) {
   }
   let assets = collectAssetVersions(root);
   if (opts.changedOnly) {
-    const changed = changedFiles(root, "HEAD");
+    const changed = changedFiles(root, "HEAD", "--changed-only", { untracked: true });
     if (changed === null) {
       process.exit(1);
       return;
     }
-    const changedAbs = new Set(changed.map((f) => path18__default.resolve(root, f)));
-    assets = assets.filter((a) => changedAbs.has(a.filePath));
+    const changedAbs = new Set(changed.map((f) => path22__default.resolve(root, f)));
+    assets = assets.filter((a) => assetChanged(a, changedAbs));
   }
   logInfo(`Checking versions in ${root}`);
   const versionCheck = checkAssetVersions(assets, root);
@@ -7212,22 +7720,23 @@ function makeValidateCommand() {
     "--strict-conformance",
     "Treat Agent Skills (agentskills.io) standard findings as errors"
   ).action(async (targetPath, opts) => {
-    const absPath = path18__default.resolve(targetPath);
+    const absPath = path22__default.resolve(targetPath);
     logInfo(`Validating manifests in ${absPath}`);
     const { total, errors, warnings } = validateManifests(
       absPath,
       opts.strictConformance ?? false
     );
-    const ws = validateWorkspaceManifests(absPath);
+    const ws = await validateWorkspaceManifests(absPath);
     const rootErrors = validatePublishManifestRoots(absPath);
     const slugErrors = validatePublishManifestPublisherSlugs(absPath);
+    const parseErrors = validatePublishManifestParses(absPath);
     const requiresErrors = validatePublishManifestRequires(absPath);
     const versionWarnings = validatePublishManifestVersions(absPath);
     const publisherWarnings = validatePublishManifestPublishers(absPath);
     const dependencyProblems = await unresolvedManifestDependencies(absPath);
     for (const w of dependencyProblems) logWarn(w);
     const dependencyWarnings = dependencyProblems.length;
-    const totalErrors = errors + ws.errors + rootErrors + slugErrors + requiresErrors;
+    const totalErrors = errors + ws.errors + rootErrors + slugErrors + parseErrors + requiresErrors;
     console.log();
     warnIgnoredDomainFiles(absPath);
     warnLegacyBundleFiles(absPath);
@@ -7253,7 +7762,7 @@ function makeValidateCommand() {
       process.exit(1);
       return;
     }
-    const modifiedFiles = changedFiles(root, opts.base);
+    const modifiedFiles = changedFiles(root, opts.base, "changelog");
     if (modifiedFiles === null) {
       process.exit(1);
       return;
@@ -7302,7 +7811,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(path18__default.join(ctx.agentDir, "skills", value, "SKILL.md"))) {
+  if (defaultKind === "skill" && !value.includes("/") && existsSync(path22__default.join(ctx.agentDir, "skills", value, "SKILL.md"))) {
     return { kind: "skill", ref: `./skills/${value}` };
   }
   return { kind: defaultKind, ref: `${defaultKind}:${value}` };
@@ -7438,7 +7947,7 @@ function migrateAgentYaml(source, options) {
         manual.push("metadata.soul: not a string; left unchanged");
         continue;
       }
-      if (path18__default.posix.basename(soul.replace(/\\/g, "/")).toLowerCase() === "soul.md") {
+      if (path22__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 });
@@ -7672,7 +8181,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 = path18__default.dirname(skaileYamlPath);
+  const dir = path22__default.dirname(skaileYamlPath);
   const notes = [];
   const manual = [];
   const changes = [];
@@ -7690,10 +8199,10 @@ function migrateSubagents(skaileYamlPath, source) {
       continue;
     }
     const id = instanceId(name);
-    const assetDir = path18__default.join(dir, ".skaile", "agents", id);
+    const assetDir = path22__default.join(dir, ".skaile", "agents", id);
     if (takenIds.has(id) || existsSync(assetDir)) {
       manual.push(
-        `agent.subagents.${name}: ${takenIds.has(id) ? `agents.${id} already exists` : `${path18__default.relative(dir, assetDir)} already exists`}; left in place`
+        `agent.subagents.${name}: ${takenIds.has(id) ? `agents.${id} already exists` : `${path22__default.relative(dir, assetDir)} already exists`}; left in place`
       );
       continue;
     }
@@ -7717,13 +8226,13 @@ function migrateSubagents(skaileYamlPath, source) {
       manifest.tools = { ...allowed ? { allowed } : {}, ...denied ? { denied } : {} };
     }
     const text = stringify(manifest, { lineWidth: 0 });
-    const manifestPath = path18__default.join(assetDir, "agent.yaml");
+    const manifestPath = path22__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: path18__default.join(assetDir, "SOUL.md"),
+        path: path22__default.join(assetDir, "SOUL.md"),
         after: `${spec.prompt.replace(/\s+$/, "")}
 `
       });
@@ -7782,7 +8291,7 @@ function validateMigratedAgent(text, registry) {
 function collectAgentFiles(paths) {
   const files = /* @__PURE__ */ new Set();
   for (const input of paths) {
-    const abs = path18__default.resolve(input);
+    const abs = path22__default.resolve(input);
     if (!existsSync(abs)) continue;
     if (statSync(abs).isDirectory()) {
       for (const f of walkFiles(abs, (b) => b === "agent.yaml" || b === "skaile.yaml"))
@@ -7799,7 +8308,7 @@ function planAgentMigration(options) {
   const reports = [];
   for (const file of collectAgentFiles(options.paths)) {
     const source = readText(file);
-    const base = path18__default.basename(file);
+    const base = path22__default.basename(file);
     if (base === "skaile.yaml") {
       const result = migrateSubagents(file, source);
       if (!result) continue;
@@ -7807,7 +8316,7 @@ function planAgentMigration(options) {
       for (const asset of result.assetManifests) {
         const v = validateMigratedAgent(asset.text, options.registry);
         validation2.errors.push(
-          ...v.errors.map((e) => `${path18__default.basename(path18__default.dirname(asset.file))}: ${e}`)
+          ...v.errors.map((e) => `${path22__default.basename(path22__default.dirname(asset.file))}: ${e}`)
         );
         validation2.warnings.push(...v.warnings);
       }
@@ -7835,7 +8344,7 @@ function planAgentMigration(options) {
         });
         continue;
       }
-      migration = migrateAgentYaml(source, { agentDir: path18__default.dirname(file), knownKinds });
+      migration = migrateAgentYaml(source, { agentDir: path22__default.dirname(file), knownKinds });
     } catch (error) {
       reports.push({
         file,
@@ -7865,7 +8374,7 @@ function planAgentMigration(options) {
 var DEFAULT_PUBLISHER = "skaile-ai";
 var PRESET_DEFAULT_VERSION = "1.0.0";
 var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
-var posix2 = (p6) => p6.split(path18__default.sep).join("/");
+var posix2 = (p6) => p6.split(path22__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) {
@@ -7896,14 +8405,14 @@ function planMarkdownMoves(root, knownKinds, manual, unknownTypes) {
     if (!text.startsWith("---")) continue;
     const found = readFrontmatterType(text);
     if (!found) continue;
-    const base = path18__default.basename(file);
-    const inAgentParts = file.split(path18__default.sep).includes("_agent-parts");
+    const base = path22__default.basename(file);
+    const inAgentParts = file.split(path22__default.sep).includes("_agent-parts");
     const targetName = MOVED_KINDS[found.type];
     if (targetName !== void 0 && !KIND_MANIFEST_FILES.has(base)) {
-      const to = path18__default.join(path18__default.dirname(file), base.replace(/\.md$/i, ""), targetName);
+      const to = path22__default.join(path22__default.dirname(file), base.replace(/\.md$/i, ""), targetName);
       if (existsSync(to) || targets.has(to)) {
         manual.push(
-          `${posix2(path18__default.relative(root, file))}: ${posix2(path18__default.relative(root, to))} already exists; not moved`
+          `${posix2(path22__default.relative(root, file))}: ${posix2(path22__default.relative(root, to))} already exists; not moved`
         );
         continue;
       }
@@ -7924,13 +8433,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 = path18__default.dirname(file);
+    const agentDir = path22__default.dirname(file);
     let hits = 0;
     const refRewrite = (_kind, ref) => {
-      const moved = byOldPath.get(path18__default.resolve(agentDir, ref));
+      const moved = byOldPath.get(path22__default.resolve(agentDir, ref));
       if (moved === void 0) return ref;
       hits++;
-      const rel = posix2(path18__default.relative(agentDir, moved));
+      const rel = posix2(path22__default.relative(agentDir, moved));
       return rel.startsWith(".") ? rel : `./${rel}`;
     };
     let output;
@@ -7947,7 +8456,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(path18__default.relative(root, file))}: persona/ruleset refs \u2192 composes items at the new paths`
+      `${posix2(path22__default.relative(root, file))}: persona/ruleset refs \u2192 composes items at the new paths`
     );
   }
   return changes;
@@ -7958,10 +8467,9 @@ function presetItemRef(dep, publisher) {
   const [, kind, rest] = match;
   return rest.startsWith("@") ? dep.trim() : `${kind}:@${publisher}/${rest}`;
 }
-function presetText(name, description, refs, publisher, version) {
+function presetText(name, description, refs, version) {
   return stringify(
     {
-      publisher,
       name,
       version,
       description: description && description.trim() !== "" ? description : `Preset ${name}`,
@@ -7972,14 +8480,14 @@ function presetText(name, description, refs, publisher, version) {
 }
 function skillDirs(dir) {
   try {
-    return readdirSync(path18__default.join(dir, "skills"), { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync(path18__default.join(dir, "skills", e.name, "SKILL.md"))).map((e) => e.name).sort();
+    return readdirSync(path22__default.join(dir, "skills"), { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync(path22__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 = path18__default.join(root, name);
+    const file = path22__default.join(root, name);
     if (!existsSync(file)) continue;
     try {
       const parsed = parse(readText(file));
@@ -7995,9 +8503,9 @@ function planBundles(root, skaileYamls, publisher, notes, manual) {
   const changes = [];
   const presets = [];
   const handled = /* @__PURE__ */ new Set();
-  const rel = (p6) => posix2(path18__default.relative(root, p6));
+  const rel = (p6) => posix2(path22__default.relative(root, p6));
   const convert = (name, bundleFile, dir) => {
-    const target = path18__default.join(dir, `${name}.preset.yaml`);
+    const target = path22__default.join(dir === root ? path22__default.join(dir, name) : dir, `${name}.preset.yaml`);
     if (existsSync(target)) {
       manual.push(`${rel(target)} already exists; bundle ${name} not converted`);
       return;
@@ -8015,6 +8523,7 @@ function planBundles(root, skaileYamls, publisher, notes, manual) {
         const declared = typeof parsed.version === "string" || typeof parsed.version === "number" ? String(parsed.version) : void 0;
         if (declared !== void 0 && SEMVER_RE.test(declared)) version = declared;
         else if (declared !== void 0) versionNote = `version ${declared} \u2192 ${version}`;
+        else versionNote = `version (none) \u2192 ${version}`;
         const deps = Array.isArray(parsed.dependencies) ? parsed.dependencies : [];
         refs = deps.filter((d) => typeof d === "string").map((d) => presetItemRef(d, publisher));
         if (refs.length !== deps.length) {
@@ -8028,11 +8537,11 @@ 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(path18__default.join(dir, "skills"))}`}; no preset generated`
+        `bundle ${name}: no dependencies found${bundleFile ? ` in ${rel(bundleFile)}` : ` and no skills under ${rel(path22__default.join(dir, "skills"))}`}; no preset generated`
       );
       return;
     }
-    const after = presetText(name, description, refs, publisher, version);
+    const after = presetText(name, description, refs, version);
     if (before !== void 0 && bundleFile) {
       changes.push({ type: "move", from: bundleFile, to: target, before, after });
       handled.add(bundleFile);
@@ -8052,18 +8561,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 = path18__default.dirname(file);
-      const entryRoot = typeof entry.root === "string" ? path18__default.join(baseDir, entry.root) : baseDir;
+      const baseDir = path22__default.dirname(file);
+      const entryRoot = typeof entry.root === "string" ? path22__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 ? path18__default.join(entryRoot, bundleName) : void 0, entryRoot);
+      convert(entry.name, bundleName ? path22__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 = path18__default.basename(bundleFile);
+    const base = path22__default.basename(bundleFile);
     let name = base.replace(/\.bundle\.yaml$/, "");
     try {
       const parsed = parse(readText(bundleFile));
@@ -8072,7 +8581,7 @@ function planBundles(root, skaileYamls, publisher, notes, manual) {
     } catch {
     }
     if (presets.some((p6) => p6.bundleFile === bundleFile)) continue;
-    convert(name, bundleFile, path18__default.dirname(bundleFile));
+    convert(name, bundleFile, path22__default.dirname(bundleFile));
   }
   return changes;
 }
@@ -8082,8 +8591,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 = path18__default.dirname(file);
-  const rel = (p6) => posix2(path18__default.relative(root, p6));
+  const dir = path22__default.dirname(file);
+  const rel = (p6) => posix2(path22__default.relative(root, p6));
   const changes = [];
   let changed = false;
   const deps = map.get("dependencies", true);
@@ -8100,7 +8609,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 = path18__default.join(dir, "skaile.manifest.yaml");
+    const manifestPath = path22__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`
@@ -8157,7 +8666,7 @@ function planSkaileYaml(root, file, source, notes, manual) {
   return changes;
 }
 function planAssetMigration(options) {
-  const root = path18__default.resolve(options.root);
+  const root = path22__default.resolve(options.root);
   const knownKinds = new Set(options.registry.getAllKinds());
   const notes = [];
   const manual = [];
@@ -8165,7 +8674,7 @@ function planAssetMigration(options) {
   const { moves, changes: moveChanges } = planMarkdownMoves(root, knownKinds, manual, unknownTypes);
   for (const move of moves) {
     notes.push(
-      `${posix2(path18__default.relative(root, move.from))} \u2192 ${posix2(path18__default.relative(root, move.to))} (${move.kind})`
+      `${posix2(path22__default.relative(root, move.from))} \u2192 ${posix2(path22__default.relative(root, move.to))} (${move.kind})`
     );
   }
   const agentChanges = planAgentRefRewrites(root, moves, knownKinds, notes);
@@ -8177,7 +8686,7 @@ function planAssetMigration(options) {
       const raw = parse(source);
       if (isRecord(raw)) skaileYamls.push({ file, source, raw });
     } catch {
-      manual.push(`${posix2(path18__default.relative(root, file))}: invalid YAML; skipped`);
+      manual.push(`${posix2(path22__default.relative(root, file))}: invalid YAML; skipped`);
     }
   }
   const publisher = repoPublisher(root);
@@ -8331,7 +8840,7 @@ function workspaceConfigFiles(dir) {
   } catch {
     return [];
   }
-  return names.filter((name) => isWorkspaceConfigFilename(name)).sort().map((name) => path18__default.join(dir, name));
+  return names.filter((name) => isWorkspaceConfigFilename(name)).sort().map((name) => path22__default.join(dir, name));
 }
 function readAgentConfigBlock(raw) {
   const key = AGENT_CONFIG_KEYS.find((candidate) => raw[candidate] !== void 0);
@@ -8343,7 +8852,7 @@ function readAgentConfigBlock(raw) {
   return flat ? { key, profiles: { default: profiles }, flat } : { key, profiles, flat };
 }
 function planProviderMigration(options) {
-  const projectDir = path18__default.resolve(options.projectDir);
+  const projectDir = path22__default.resolve(options.projectDir);
   const registryPath = options.workspace ? workspaceProviderRegistryPath(projectDir) : userProviderRegistryPath();
   const plan = {
     registryPath,
@@ -8359,7 +8868,7 @@ function planProviderMigration(options) {
       raw = parseDocument(readFileSync(file, "utf-8")).toJS() ?? {};
     } catch (error) {
       plan.warnings.push(
-        `${path18__default.basename(file)}: not valid YAML (${error instanceof Error ? error.message : String(error)}) \u2014 skipped`
+        `${path22__default.basename(file)}: not valid YAML (${error instanceof Error ? error.message : String(error)}) \u2014 skipped`
       );
       continue;
     }
@@ -8408,7 +8917,7 @@ function planProviderMigration(options) {
       });
       if (!model) {
         plan.warnings.push(
-          `${path18__default.basename(file)}: profile '${profile}' had no model: \u2014 it now resolves against registry order. Pin it with 'model: ${providerId}/<modelId>'.`
+          `${path22__default.basename(file)}: profile '${profile}' had no model: \u2014 it now resolves against registry order. Pin it with 'model: ${providerId}/<modelId>'.`
         );
       }
       touched = true;
@@ -8475,7 +8984,7 @@ function printPlan(plan) {
   for (const entry of plan.entries) {
     const base = entry.entry.base_url ?? S.dim("(transport-derived)");
     console.log(
-      `  ${S.label(`${path18__default.basename(entry.file)} ${entry.profile}`)} provider: ${entry.legacy.provider}, cloud: ${entry.legacy.cloud}`
+      `  ${S.label(`${path22__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(
@@ -8491,7 +9000,7 @@ function printPlan(plan) {
   console.log();
 }
 async function runMigrateProviders(opts) {
-  const projectDir = opts.projectDir ? path18__default.resolve(opts.projectDir) : process.cwd();
+  const projectDir = opts.projectDir ? path22__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) {
@@ -8573,7 +9082,8 @@ var ASSETS_HELP = `
 Rewrites (run on a repo root):
   type: persona|ruleset markdown   <n>.md -> <n>/PERSONA.md | <n>/RULESET.md (type: dropped);
                                    agent persona:/rules: refs to the old path become composes items
-  *.bundle.yaml                    <name>.preset.yaml beside it (items: kind:@publisher/name);
+  *.bundle.yaml                    <name>.preset.yaml beside it, or <name>/<name>.preset.yaml
+                                   for a bundle at the repo root (items: kind:@publisher/name);
                                    kind: bundle entries of skaile.yaml#assets become kind: preset
   skaile.yaml dependencies         bundle:@... -> preset:@...
   skaile.yaml publisher/version/assets
@@ -8622,7 +9132,7 @@ async function runMigrateAgents(paths, opts) {
   let failures = 0;
   let manualCount = 0;
   for (const report of plan.reports) {
-    const rel = path18__default.relative(base, report.file) || report.file;
+    const rel = path22__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++;
@@ -8649,14 +9159,14 @@ async function runMigrateAssets(root, opts) {
   const write = resolveMode(opts);
   const base = process.cwd();
   const plan = planAssetMigration({
-    root: path18__default.resolve(root ?? base),
+    root: path22__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(
-      `${path18__default.relative(base, file) || file}: frontmatter type "${type}" is not a registered asset kind (reported, not rewritten)`
+      `${path22__default.relative(base, file) || file}: frontmatter type "${type}" is not a registered asset kind (reported, not rewritten)`
     );
   }
   printChanges(plan.changes, base);
@@ -8679,8 +9189,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 = path18__default.resolve(opts.projectDir);
-    const projYaml = path18__default.join(projectDir, "skaile.yaml");
+    const projectDir = path22__default.resolve(opts.projectDir);
+    const projYaml = path22__default.join(projectDir, "skaile.yaml");
     if (!existsSync(projYaml)) {
       logErr(`No skaile.yaml in ${projectDir} \u2014 run \`skaile init\` first.`);
       process.exit(1);
@@ -8693,11 +9203,11 @@ function makeNpxCommand() {
     }
     const spinner = createSpinner();
     const key = sourceCacheKey(url);
-    const clonePath = path18__default.join(getGlobalCacheDir(), key);
+    const clonePath = path22__default.join(getGlobalCacheDir(), key);
     spinner.start(`Cloning ${url}`);
     try {
       if (!existsSync(clonePath)) {
-        mkdirSync(path18__default.dirname(clonePath), { recursive: true });
+        mkdirSync(path22__default.dirname(clonePath), { recursive: true });
         execSync(`git clone ${url} ${clonePath}`, { stdio: "ignore" });
       }
       spinner.stop(`Cloned to ${key}`);
@@ -8752,7 +9262,7 @@ function makeNpxCommand() {
   return npx;
 }
 function resolvePublisher(clonePath, url) {
-  const manifestPath = path18__default.join(clonePath, SKAILE_MANIFEST_FILENAME);
+  const manifestPath = path22__default.join(clonePath, SKAILE_MANIFEST_FILENAME);
   if (existsSync(manifestPath)) {
     try {
       const { manifest } = decodeSkaileManifest(readFileSync(manifestPath, "utf8"));
@@ -8765,12 +9275,12 @@ function resolvePublisher(clonePath, url) {
   return url.match(/github\.com[/:]([^/]+)\/[^/]+/)?.[1];
 }
 function resolveSkillName(clonePath, requested) {
-  const skillsDir = path18__default.join(clonePath, "skills");
-  if (existsSync(path18__default.join(skillsDir, requested, "SKILL.md"))) return requested;
+  const skillsDir = path22__default.join(clonePath, "skills");
+  if (existsSync(path22__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 = path18__default.join(skillsDir, entry.name, "SKILL.md");
+    const md = path22__default.join(skillsDir, entry.name, "SKILL.md");
     if (!existsSync(md)) continue;
     try {
       const { data } = parseFrontmatter(readFileSync(md, "utf8"));
@@ -8803,7 +9313,7 @@ function makeOutdatedCommand() {
     requireProjectConfig(opts.projectDir);
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path18__default.resolve(opts.projectDir),
+      projectDir: path22__default.resolve(opts.projectDir),
       driverTarget: opts.target
     });
     const entries = await am2.outdated();
@@ -8846,7 +9356,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: path18__default.resolve(opts.projectDir)
+      projectDir: path22__default.resolve(opts.projectDir)
     });
     try {
       const dest = await am2.patch(ref);
@@ -8860,7 +9370,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: path18__default.resolve(opts.projectDir)
+      projectDir: path22__default.resolve(opts.projectDir)
     });
     try {
       const patchFile = await am2.patchCommit(ref);
@@ -8874,7 +9384,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: path18__default.resolve(opts.projectDir)
+      projectDir: path22__default.resolve(opts.projectDir)
     });
     try {
       await am2.patchSubmit(ref);
@@ -8890,7 +9400,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: path18__default.resolve(opts.projectDir)
+      projectDir: path22__default.resolve(opts.projectDir)
     });
     am2.patchRemove(ref);
     logOk(`Patch removed for ${ref}`);
@@ -8908,8 +9418,8 @@ function action2(fn) {
     }
   };
 }
-async function reconcileAndReport(projectDir, plugins) {
-  const { reconcilePlugins } = await import('../plugin-store-AGQDMING.js');
+async function reconcileAndReport(projectDir, plugins, opts = {}) {
+  const { reconcilePlugins } = await import('../plugin-store-CK7YWRIC.js');
   if (plugins.length === 0) {
     logInfo("No plugins declared \u2014 nothing to reconcile.");
     return;
@@ -8919,26 +9429,54 @@ async function reconcileAndReport(projectDir, plugins) {
     if (result.changed) logOk(`Reconciled plugin store (${result.reason}).`);
     else logInfo(`Plugin store ${result.reason}.`);
   } catch (err2) {
+    if (opts.strict) throw err2;
     logWarn(`reconcile skipped: ${err2 instanceof Error ? err2.message : String(err2)}`);
   }
 }
+async function verifyPluginLoads(projectDir, spec) {
+  const { loadPlugins } = await import('../plugin-store-CK7YWRIC.js');
+  const { createPluginRegistry } = await import('../plugin-registry/index.js');
+  const registry = createPluginRegistry();
+  const result = await loadPlugins(projectDir, [spec], registry);
+  const failure = result.failed[0];
+  if (failure) throw new Error(failure.error);
+  const contributed = ["driver", "connector", "deployTarget"].flatMap(
+    (kind) => registry.list(kind).map((m) => `${kind} ${m.id}`)
+  );
+  logOk(`Loaded ${S.cmd(spec)}${contributed.length > 0 ? ` (${contributed.join(", ")})` : ""}`);
+}
 async function runInstall2(spec, opts) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-  const { specName } = await import('../plugin-store-AGQDMING.js');
-  const yamlPath = path18__default.join(projectDir, "skaile.yaml");
+  const { specName, rollbackPluginStore } = await import('../plugin-store-CK7YWRIC.js');
+  const yamlPath = path22__default.join(projectDir, "skaile.yaml");
+  const original = existsSync(yamlPath) ? readFileSync(yamlPath, "utf8") : void 0;
   const editor = WorkspaceYamlEditor2.load(yamlPath);
+  const previousPlugins = [...editor.getPlugins()];
   const replaced = editor.addPlugin(spec, specName);
   editor.save();
   if (replaced) logOk(`Updated ${S.cmd(specName(spec))} \u2192 ${S.cmd(spec)} in skaile.yaml`);
   else logOk(`Added ${S.cmd(spec)} to skaile.yaml plugins`);
-  await reconcileAndReport(projectDir, editor.getPlugins());
+  try {
+    await reconcileAndReport(projectDir, editor.getPlugins(), { strict: true });
+    await verifyPluginLoads(projectDir, spec);
+  } catch (err2) {
+    if (original !== void 0) {
+      writeFileSync(yamlPath, original);
+      logInfo("skaile.yaml restored; the plugin was not recorded.");
+    } else {
+      rmSync(yamlPath, { force: true });
+      logInfo("skaile.yaml removed; the plugin was not recorded.");
+    }
+    await rollbackPluginStore(projectDir, previousPlugins);
+    throw err2;
+  }
 }
 async function runRemove(name, opts) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-  const { specName } = await import('../plugin-store-AGQDMING.js');
-  const yamlPath = path18__default.join(projectDir, "skaile.yaml");
+  const { specName } = await import('../plugin-store-CK7YWRIC.js');
+  const yamlPath = path22__default.join(projectDir, "skaile.yaml");
   const editor = WorkspaceYamlEditor2.load(yamlPath);
   const removed = editor.removePlugin(name, specName);
   if (!removed) {
@@ -8950,7 +9488,7 @@ async function runRemove(name, opts) {
   await reconcileAndReport(projectDir, editor.getPlugins());
 }
 async function runList(opts) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const config = resolveSkWorkspaceConfig2(projectDir);
   const declared = config.plugins ?? [];
@@ -8965,7 +9503,7 @@ async function runList(opts) {
   const registry = createPluginRegistry();
   if (declared.length > 0) {
     try {
-      const { loadPlugins } = await import('../plugin-store-AGQDMING.js');
+      const { loadPlugins } = await import('../plugin-store-CK7YWRIC.js');
       const result = await loadPlugins(projectDir, declared, registry);
       for (const f of result.failed) logWarn(f.error);
     } catch (err2) {
@@ -9039,9 +9577,11 @@ function presetItemsToWorkspace(preset, values) {
       dependencies.push(ref);
     }
   }
-  const sources = (preset.sources ?? []).map(
-    (s) => s.pin ? { url: s.url, pin: s.pin } : { url: s.url }
-  );
+  const sources = (preset.sources ?? []).map((s) => ({
+    url: s.url,
+    ...s.pin ? { pin: s.pin } : {},
+    ...s.publisher ? { publisher: s.publisher } : {}
+  }));
   return { dependencies, connectors, mcpServers, sources, envVarsToSet: [...envVarsToSet] };
 }
 function resolveItemConfig(item, preset, values, envVarsToSet) {
@@ -9140,7 +9680,7 @@ function neededSources(config, lock) {
 }
 function sourcesWithSidecar(sources) {
   const dir = getStoreManifestsDir();
-  return sources.filter((s) => existsSync(path18.join(dir, `${storeManifestSlug(s.url)}.yaml`))).map((s) => s.url);
+  return sources.filter((s) => existsSync(path22.join(dir, `${storeManifestSlug(s.url)}.yaml`))).map((s) => s.url);
 }
 function compact(obj) {
   const out = {};
@@ -9232,8 +9772,8 @@ function redactSecrets(preset, findings) {
   }
   return { preset: next, keys };
 }
-function placeholderKey(itemId, path43) {
-  return `${itemId}_${path43}`.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+function placeholderKey(itemId, path44) {
+  return `${itemId}_${path44}`.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
 }
 function setAtPath(root, segments, value) {
   let node = root;
@@ -9256,7 +9796,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 = path18__default.join(path18__default.resolve(opts.dir), filename);
+    const outPath = path22__default.join(path22__default.resolve(opts.dir), filename);
     if (existsSync(outPath)) {
       logErr(`File already exists: ${outPath}`);
       logInfo("Choose a different name or remove the existing file.");
@@ -9289,7 +9829,7 @@ function makePresetCommand() {
   return cmd;
 }
 async function runPresetExport(name, opts) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   const file = loadSkWorkspaceConfig(projectDir);
   if (!file) {
     logErr(`No skaile.yaml found in ${projectDir}`);
@@ -9299,7 +9839,7 @@ async function runPresetExport(name, opts) {
   const presetName = name ?? file.config.name ?? "my-preset";
   let lock = null;
   try {
-    lock = readLock(path18__default.join(projectDir, "skaile.lock.yaml"));
+    lock = readLock(path22__default.join(projectDir, "skaile.lock.yaml"));
   } catch {
     lock = null;
   }
@@ -9340,7 +9880,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 ? path18__default.resolve(opts.out) : path18__default.join(path18__default.resolve(opts.dir), `${presetName}.preset.yaml`);
+  const outPath = opts.out ? path22__default.resolve(opts.out) : path22__default.join(path22__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.");
@@ -9352,7 +9892,7 @@ ${body}` : body;
     logErr(`Failed to write ${outPath}: ${e.message}`);
     process.exit(1);
   }
-  logOk(`Exported ${S.brand(path18__default.basename(outPath))}`);
+  logOk(`Exported ${S.brand(path22__default.basename(outPath))}`);
   logInfo(`Path: ${outPath}`);
   if (unresolved.length > 0) {
     console.error(S.err("This file is NOT safe to share."));
@@ -9393,13 +9933,13 @@ function collectInput(value, acc) {
   return acc;
 }
 async function runPresetApply(filePath, opts) {
-  const projectDir = path18__default.resolve(opts.projectDir);
+  const projectDir = path22__default.resolve(opts.projectDir);
   const file = loadSkWorkspaceConfig(projectDir);
   if (!file) {
     logErr("No skaile.yaml \u2014 run `skaile init` first");
     process.exit(1);
   }
-  const resolved = path18__default.resolve(filePath);
+  const resolved = path22__default.resolve(filePath);
   if (!existsSync(resolved)) {
     logErr(`File not found: ${resolved}`);
     process.exit(1);
@@ -9615,7 +10155,7 @@ async function reportNestedPresetRefs(preset) {
 }
 async function checkPresetCycles(preset, resolved) {
   const { detectCycles } = await import('../discovery/index.js');
-  const presetRef = path18__default.basename(resolved, ".preset.yaml");
+  const presetRef = path22__default.basename(resolved, ".preset.yaml");
   const edges = [];
   for (const item of preset.items) {
     if (item.ref) {
@@ -9667,7 +10207,7 @@ function printPresetSummary(preset, placeholderCount, hasWarnings) {
   }
 }
 async function runPresetValidate(filePath) {
-  const resolved = path18__default.resolve(filePath);
+  const resolved = path22__default.resolve(filePath);
   const preset = await loadPresetForValidation(resolved);
   await reportNestedPresetRefs(preset);
   await checkPresetCycles(preset, resolved);
@@ -9717,11 +10257,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     let agentDir;
     if (agentArg) {
       if (agentArg.includes("/") || agentArg.includes("\\")) {
-        agentDir = path18__default.resolve(projectDir, agentArg);
+        agentDir = path22__default.resolve(projectDir, agentArg);
       } else {
         let resolved;
         try {
@@ -9730,7 +10270,7 @@ function makeRebuildCommand() {
           if (!(err2 instanceof AgentRefResolutionError)) throw err2;
           logWarn(`${err2.message} \u2014 using "${agentArg}"`);
         }
-        agentDir = resolved ?? path18__default.resolve(projectDir, agentArg);
+        agentDir = resolved ?? path22__default.resolve(projectDir, agentArg);
       }
     } else {
       let resolved;
@@ -9796,13 +10336,23 @@ function friendlyDriverError(err2) {
   return `${base}
 Try a different harness with \`--driver claude-sdk\`.`;
 }
+function driverErrorNotes(err2) {
+  const e = err2;
+  const notes = [];
+  const category = e?.category ?? e?.detail?.category;
+  const hint = e?.hint ?? e?.detail?.hint;
+  if (hint && category !== "config") notes.push(hint);
+  else if (category === "auth") notes.push("Check your API key or login.");
+  notes.push("Full records: .skaile/logs.db (skaile session logs <session-id>).");
+  return notes;
+}
 
 // cli/src/commands/run.ts
 function resolveSingleShotAgentDir(projectDir, agentDefinition) {
   if (!agentDefinition) return resolveAgentDir(projectDir);
-  const asPath = agentDefinition.endsWith("agent.yaml") ? path18__default.dirname(path18__default.resolve(projectDir, agentDefinition)) : agentDefinition;
+  const asPath = agentDefinition.endsWith("agent.yaml") ? path22__default.dirname(path22__default.resolve(projectDir, agentDefinition)) : agentDefinition;
   const dir = resolveAgentDefinitionDir(projectDir, asPath);
-  if (!dir || !fs8__default.existsSync(path18__default.join(dir, "agent.yaml"))) {
+  if (!dir || !fs9__default.existsSync(path22__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})` : ""}`
     );
@@ -9853,10 +10403,58 @@ async function printCompositionDryRun(projectDir, agentDir, driver, model) {
   }
   for (const warning of resolved.warnings) logWarn(warning);
 }
+async function findSkillFile(projectDir, skill) {
+  const name = skill.trim().replace(/^skill:/, "").replace(/^@[^/]+\//, "").replace(/#.*$/, "");
+  for (const target of SUPPORTED_DRIVER_TARGETS) {
+    const file = path22__default.join(deployedDir("skill", name, target, false, projectDir), "SKILL.md");
+    if (fs9__default.existsSync(file)) return file;
+  }
+  const am2 = new AssetManager({ registry: getKindRegistry(), projectDir });
+  const entry = await am2.info(`skill:${name}`);
+  return entry?.source && fs9__default.existsSync(entry.source) ? entry.source : void 0;
+}
+async function printSkillDryRun(projectDir, skill) {
+  const file = await findSkillFile(projectDir, skill);
+  if (!file) {
+    logErr(
+      `Skill not found: ${skill} - not deployed in the project and not held by a registered library or source`
+    );
+    return false;
+  }
+  const content = fs9__default.readFileSync(file, "utf-8");
+  const { data } = parseFrontmatter(content);
+  const meta = data.metadata ?? {};
+  console.log(`  ${S.label("Skill:")}       ${S.heading(String(data.name ?? skill))}`);
+  console.log(`  ${S.label("Source:")}      ${file}`);
+  if (meta.version) console.log(`  ${S.label("Version:")}     ${String(meta.version)}`);
+  if (data.description) console.log(`  ${S.label("About:")}       ${String(data.description)}`);
+  const requires = parseRequires(data);
+  if (requires.length > 0) {
+    console.log(`  ${S.label("Requires:")}    ${requires.map((d) => depToStr(d)).join(", ")}`);
+  }
+  const requirements = parseSkillRequirements(content);
+  const report = await validateRequirements(String(data.name ?? skill), requirements, projectDir);
+  const unmet = report.files.filter((f) => !f.exists);
+  for (const f of report.files) {
+    const mark = f.exists ? S.ok("present") : f.gate === "hard" ? S.err("missing") : S.warn("missing");
+    const gate = f.gate === "soft" ? " (soft)" : "";
+    console.log(`  ${S.label("File:")}        ${f.path}${gate} ${mark}`);
+  }
+  for (const input of report.inputs.filter((i) => i.required && !i.present)) {
+    console.log(`  ${S.label("Input:")}       ${input.id} ${S.err("required, not collected")}`);
+  }
+  if (unmet.some((f) => f.gate === "hard")) {
+    logWarn("Unmet hard prerequisites: the skill cannot run until those files exist.");
+  }
+  console.log();
+  return true;
+}
 function makeFlowEventHandler() {
   const md = new MarkdownStreamer();
   const displayed = /* @__PURE__ */ new Set();
+  const printUnstreamed = createFinalTextFallback((text) => md.write(text));
   return (event) => {
+    printUnstreamed(event);
     const e = event;
     if (e.type === "state_changed" && typeof e.store === "string" && e.store.startsWith("flow:")) {
       const nodes = e.state?.nodes ?? {};
@@ -9894,14 +10492,41 @@ function logAgentRunEvent(event) {
     return;
   }
   const verdict = e.error ? `${e.runStatus ?? "failed"}: ${e.error.code} ${e.error.message}` : e.runStatus ?? "finished";
-  console.error(`  ${S.dim("subagent")} ${who} ${verdict} output=${JSON.stringify(e.output)}`);
+  console.error(`  ${S.dim("subagent")} ${who} ${verdict}${subagentOutputSuffix(e)}`);
+}
+function subagentOutputSuffix(e) {
+  const value = e.result !== void 0 ? e.result : e.output;
+  return value === void 0 ? "" : ` output=${JSON.stringify(value)}`;
+}
+function editDistance2(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1; j <= b.length; j++) {
+      row[j] = Math.min(
+        prev[j] + 1,
+        row[j - 1] + 1,
+        prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+    }
+    prev = row;
+  }
+  return prev[b.length];
+}
+function isNearFlowId(typed, id) {
+  const a = typed.toLowerCase();
+  const b = id.toLowerCase();
+  return a.length >= 3 && (b.includes(a) || a.includes(b) || editDistance2(a, b) <= 2);
+}
+function driverOptionDescription() {
+  return `Harness to run (${listDrivers().map((d) => d.id).join(", ")})`;
 }
 function makeRunCommand() {
-  const cmd = new Command("run").description("Start a flow or run a single-shot text prompt").argument("[flow-id-or-text...]", "Flow ID or text prompt").option("--project-dir <path>", "Project directory", process.cwd()).option("--driver <name>", "Harness to run (claude-sdk, codex, omp)").option("--model <name>", "Model override").option("--label <label>", "Human-readable session label").option("--dry-run", "Print plan without executing (single-shot: resolved composition items)").option(
+  const cmd = new Command("run").description("Start a flow or run a single-shot text prompt").argument("[flow-id-or-text...]", "Flow ID or text prompt").option("--project-dir <path>", "Project directory", process.cwd()).option("--driver <name>", driverOptionDescription()).option("--model <name>", "Model override").option("--label <label>", "Human-readable session label").option("--dry-run", "Print plan without executing (single-shot: resolved composition items)").option(
     "--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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const cliDriver = opts.driver;
     const dryRun = opts.dryRun ?? false;
     const agentDefinition = opts.agentDefinition?.trim() || void 0;
@@ -9945,18 +10570,29 @@ function makeRunCommand() {
     }
     if (!flowPath) {
       const textPrompt = positional.join(" ");
-      if (!textPrompt.trim()) {
+      const promptOnlyOption = agentDefinition !== void 0 || opts.skill !== void 0;
+      if (!textPrompt.trim() || positional.length === 1 && !/\s/.test(flowId) && !promptOnlyOption) {
         logErr(`Flow not found: ${flowId}`);
         const available = (await discoverFlowsWithLibraries(projectDir)).map((f) => f.id);
-        if (available.length > 0) {
-          console.log(`  ${S.dim("Available:")} ${available.map((id) => S.cmd(id)).join(", ")}`);
+        const near = available.filter((id) => isNearFlowId(flowId, id));
+        const listed = near.length > 0 ? near : available;
+        if (listed.length > 0) {
+          console.log(
+            `  ${S.dim(near.length > 0 ? "Did you mean:" : "Available:")} ${listed.map((id) => S.cmd(id)).join(", ")}`
+          );
         }
+        console.log(
+          `  ${S.dim('To send it as a prompt, quote more than one word: skaile run "\u2026".')}`
+        );
         process.exit(1);
       }
       try {
         const agentDir = resolveSingleShotAgentDir(projectDir, agentDefinition);
         if (dryRun) {
           await printCompositionDryRun(projectDir, agentDir, driver, model);
+          if (opts.skill && !await printSkillDryRun(projectDir, opts.skill)) {
+            process.exit(1);
+          }
           return;
         }
         await runAgentChat({
@@ -9978,6 +10614,7 @@ function makeRunCommand() {
           logErr(friendly);
         } else {
           logErr(err2 instanceof Error ? err2.message : String(err2));
+          for (const note of driverErrorNotes(err2)) console.error(`    ${S.dim(note)}`);
         }
         process.exit(1);
       }
@@ -10020,7 +10657,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const sessionId = opts.session;
     const dryRun = opts.dryRun ?? false;
     const session = sessionId ? await loadSessionById(projectDir, sessionId) : await loadSession(projectDir);
@@ -10047,7 +10684,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const session = await loadSession(projectDir);
     if (!session) {
       logInfo("No active session.");
@@ -10060,6 +10697,7 @@ function makeStatusCommand() {
     console.log(`  ${S.label("Run ID:")}    ${session.runId.slice(0, 8)}`);
     if (session.label) console.log(`  ${S.label("Label:")}     ${session.label}`);
     console.log(`  ${S.label("Status:")}    ${statusColor(session.status ?? "unknown")}`);
+    if (session.error) console.log(`  ${S.label("Error:")}     ${session.error}`);
     console.log(
       `  ${S.label("Driver:")}    ${session.driver}${session.model ? S.dim(` / ${session.model}`) : ""}`
     );
@@ -10072,17 +10710,17 @@ 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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     await clearSession(projectDir);
     logOk("Session cleared.");
   });
 }
 function makeReplCommand() {
-  return new Command("repl").description("Start an interactive agent session").option("--project-dir <path>", "Project directory").option("--driver <name>", "Harness to run (claude-sdk, omp)").option("--model <name>", "Model override").option("--resume", "Resume last session").option("--resume-session <id>", "Resume specific session").action(async (opts) => {
+  return new Command("repl").description("Start an interactive agent session").option("--project-dir <path>", "Project directory").option("--driver <name>", driverOptionDescription()).option("--model <name>", "Model override").option("--resume", "Resume last session").option("--resume-session <id>", "Resume specific session").action(async (opts) => {
     const { findWorkspaceRoot } = await import('../core/index.js');
     const { startRepl } = await import('../tui/index.js');
     const os2 = await import('os');
-    const userCwd = path18__default.resolve(opts.projectDir ?? process.cwd());
+    const userCwd = path22__default.resolve(opts.projectDir ?? process.cwd());
     const workspaceRoot = findWorkspaceRoot(userCwd);
     let projectDir;
     let agentCwd;
@@ -10097,6 +10735,12 @@ function makeReplCommand() {
       console.log();
       logWarn(`No skaile.yaml found in ${S.cmd(userCwd)} or any parent directory.`);
       console.log();
+      if (!process.stdin.isTTY) {
+        logErr(
+          `repl needs a skaile.yaml here when stdin is not a terminal: run ${S.cmd("skaile init")} first.`
+        );
+        process.exit(1);
+      }
       const shouldCreate = await p4.confirm({
         message: "Create a temporary workspace? (session state in /tmp/)"
       });
@@ -10104,13 +10748,13 @@ function makeReplCommand() {
         p4.cancel("Cancelled.");
         process.exit(0);
       }
-      const tmpDir = fs8__default.mkdtempSync(path18__default.join(os2.tmpdir(), "skaile-repl-"));
+      const tmpDir = fs9__default.mkdtempSync(path22__default.join(os2.tmpdir(), "skaile-repl-"));
       projectDir = tmpDir;
       agentCwd = userCwd;
       logOk(`Temporary workspace: ${S.cmd(tmpDir)}`);
       if (!driverOverride) {
-        const claudeDir = path18__default.join(os2.homedir(), ".claude");
-        if (fs8__default.existsSync(claudeDir)) {
+        const claudeDir = path22__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 {
@@ -10139,7 +10783,10 @@ function parseProviderIds(raw) {
   return (raw ?? "").split(",").map((id) => id.trim()).filter((id) => id.length > 0);
 }
 function makeServeCommand() {
-  return new Command("serve").description("Start a WebSocket agent server (for platform integration)").option("--port <port>", "WebSocket server port", "8080").option("--project-dir <path>", "Project directory", process.cwd()).option(
+  return new Command("serve").description("Start a WebSocket agent server (for platform integration)").option("--port <port>", "WebSocket server port", "8080").option(
+    "--host <address>",
+    "Address to bind (default: all interfaces; use 127.0.0.1 for local clients only)"
+  ).option("--project-dir <path>", "Project directory", process.cwd()).option(
     "--managed-codex-config <path>",
     "Explicit private host configuration for managed Codex"
   ).option("--driver <name>", "Override driver").option("--model <name>", "Override model").option("--provider <name>", "Override provider").option("--session-id <id>", "Session ID for conversation continuity").option("--resume-session-id <id>", "OMP session ID to resume (restores native OMP context)").option(
@@ -10167,32 +10814,48 @@ function makeServeCommand() {
         await ensurePluginsLoadedForServe(opts.projectDir);
       }
       const providers = parseProviderIds(opts.providers);
-      await startAgentServer({
-        port: parseInt(opts.port, 10),
-        authTokenIntake: wsAuth,
-        ...managedCodex ? { managedCodex } : {},
-        // The CLI owns its process, so a dead stdout pipe is fatal here.
-        // `SKAILE_SERVE_EXIT_ON_BROKEN_STDOUT=0` opts out — the `local` /
-        // `nix` deploy targets set it for children meant to outlive them.
-        exitOnBrokenPipe: process.env.SKAILE_SERVE_EXIT_ON_BROKEN_STDOUT !== "0",
-        projectDir: opts.projectDir,
-        driver: opts.driver,
-        model: opts.model,
-        provider: opts.provider,
-        sessionId: opts.sessionId,
-        resumeSessionId: opts.resumeSessionId,
-        ...providers.length > 0 ? { providers } : {}
-      });
+      const { checkDriverSdk } = await import('../serve-preflight-F7MYF747.js');
+      const driverProblem = managedCodex ? null : await checkDriverSdk(opts.projectDir, opts.driver);
+      if (driverProblem) {
+        const { logErr: logErr2 } = await import('../helpers-53XZW7KF.js');
+        logErr2(driverProblem);
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        await startAgentServer({
+          port: parseInt(opts.port, 10),
+          ...opts.host ? { host: opts.host } : {},
+          authTokenIntake: wsAuth,
+          ...managedCodex ? { managedCodex } : {},
+          // The CLI owns its process, so a dead stdout pipe is fatal here.
+          // `SKAILE_SERVE_EXIT_ON_BROKEN_STDOUT=0` opts out — the `local` /
+          // `nix` deploy targets set it for children meant to outlive them.
+          exitOnBrokenPipe: process.env.SKAILE_SERVE_EXIT_ON_BROKEN_STDOUT !== "0",
+          projectDir: opts.projectDir,
+          driver: opts.driver,
+          model: opts.model,
+          provider: opts.provider,
+          sessionId: opts.sessionId,
+          resumeSessionId: opts.resumeSessionId,
+          ...providers.length > 0 ? { providers } : {}
+        });
+      } catch (err2) {
+        if (err2?.code !== "EADDRINUSE") throw err2;
+        const { logErr: logErr2 } = await import('../helpers-53XZW7KF.js');
+        logErr2(err2.message);
+        process.exit(1);
+      }
     }
   );
 }
 async function ensurePluginsLoadedForServe(projectDir) {
-  const { logInfo: logInfo2, logWarn: logWarn2 } = await import('../helpers-CFK6YP6R.js');
+  const { logInfo: logInfo2, logWarn: logWarn2 } = await import('../helpers-53XZW7KF.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-AGQDMING.js');
+    const { ensurePluginsLoaded } = await import('../plugin-store-CK7YWRIC.js');
     const { pluginRegistry } = await import('../plugin-registry/index.js');
     const result = await ensurePluginsLoaded(projectDir, config.plugins, pluginRegistry);
     if (result.loaded.length > 0) {
@@ -10206,21 +10869,21 @@ async function ensurePluginsLoadedForServe(projectDir) {
   }
 }
 async function runCompileTest(opts) {
-  const { logOk: logOk2, logErr: logErr2, logInfo: logInfo2, S: S2 } = await import('../helpers-CFK6YP6R.js');
+  const { logOk: logOk2, logErr: logErr2, logInfo: logInfo2, S: S2 } = await import('../helpers-53XZW7KF.js');
   const { tmpdir } = await import('os');
-  const { dirname: dirname3, join: join6, resolve: resolve5 } = await import('path');
+  const { dirname: dirname3, join: join7, resolve: resolve5 } = await import('path');
   const { fileURLToPath: fileURLToPath2 } = await import('url');
-  const { unlinkSync, existsSync: existsSync17 } = await import('fs');
+  const { unlinkSync, existsSync: existsSync21 } = await import('fs');
   const { spawn } = await import('child_process');
   const { portableSpawnSync: portableSpawnSync2 } = await import('../core/index.js');
-  const { MONOREPO_ROOT } = await import('../paths-SUS4S4YT.js');
+  const { MONOREPO_ROOT } = await import('../paths-KKY3NSBZ.js');
   if (MONOREPO_ROOT === null) {
     logErr2("--compile-test is only available inside the skaile-dev workspace.");
     logInfo2("Run it from a checkout of skaile-ai/skaile-dev (the monorepo shell).");
     process.exitCode = 2;
     return;
   }
-  const outfile = join6(tmpdir(), `skaile-compile-test-${Date.now()}`);
+  const outfile = join7(tmpdir(), `skaile-compile-test-${Date.now()}`);
   const __thisFile = fileURLToPath2(import.meta.url);
   const entryPoint = resolve5(dirname3(__thisFile), "..", "index.ts");
   logInfo2(`Building compiled binary...`);
@@ -10275,7 +10938,7 @@ async function runCompileTest(opts) {
     } catch {
     }
     try {
-      if (existsSync17(outfile)) unlinkSync(outfile);
+      if (existsSync21(outfile)) unlinkSync(outfile);
     } catch {
     }
   }
@@ -10696,7 +11359,7 @@ function resolveMode2(opts) {
   if (opts.forceLocal && opts.forceRemote) {
     throw new Error("Cannot use both --local and --remote");
   }
-  const startDir = path18__default.resolve(opts.projectDir ?? process.cwd());
+  const startDir = path22__default.resolve(opts.projectDir ?? process.cwd());
   const localDb = findLogsDb(startDir);
   if (opts.forceLocal) {
     if (!localDb) {
@@ -10729,14 +11392,14 @@ function resolveMode2(opts) {
 function findLogsDb(startDir) {
   let dir = startDir;
   for (let i = 0; i < MAX_WALK_LEVELS; i++) {
-    const candidate = path18__default.join(dir, ".skaile", "logs.db");
+    const candidate = path22__default.join(dir, ".skaile", "logs.db");
     if (existsSync(candidate)) {
       try {
         if (statSync(candidate).isFile()) return candidate;
       } catch {
       }
     }
-    const parent = path18__default.dirname(dir);
+    const parent = path22__default.dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -10911,7 +11574,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const sessions = await listSessions(projectDir);
     const current = await loadSession(projectDir);
     if (sessions.length === 0) {
@@ -10939,7 +11602,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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     const session = await loadSessionById(projectDir, runId);
     if (!session) {
       logErr(`Session not found: ${runId}`);
@@ -10948,7 +11611,7 @@ 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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     if (!await loadSessionById(projectDir, runId)) {
       logErr(`Session not found: ${runId}`);
       process.exit(1);
@@ -10957,7 +11620,7 @@ function makeSessionCommand() {
     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 = path18__default.resolve(opts.projectDir);
+    const projectDir = path22__default.resolve(opts.projectDir);
     if (!await loadSessionById(projectDir, runId)) {
       logErr(`Session not found: ${runId}`);
       process.exit(1);
@@ -11015,12 +11678,12 @@ function showOverview(am2) {
 }
 async function showAsset(am2, kind, name) {
   const entry = await am2.info(`${kind}:${name}`);
-  if (entry?.source && fs8__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(fs8__default.readFileSync(entry.source, "utf-8"));
+    console.log(fs9__default.readFileSync(entry.source, "utf-8"));
     return;
   }
   logErr(`Asset not found: ${kind}:${name}`);
@@ -11030,7 +11693,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: path18__default.resolve(opts.projectDir),
+      projectDir: path22__default.resolve(opts.projectDir),
       driverTarget: opts.target
     });
     if (!kind) {
@@ -11048,6 +11711,32 @@ function makeShowCommand() {
     }
   });
 }
+function searchCuratedManifests(query) {
+  const dir = getStoreManifestsDir();
+  if (!existsSync(dir)) return [];
+  const q = query.toLowerCase();
+  const hits = [];
+  for (const file of readdirSync(dir).sort()) {
+    if (!file.endsWith(".yaml")) continue;
+    const slug = file.slice(0, -".yaml".length);
+    let manifest;
+    try {
+      manifest = decodeSkaileManifest(readFileSync(path22.join(dir, file), "utf-8")).manifest;
+    } catch {
+      continue;
+    }
+    const repoPublisher2 = manifest.publisher?.replace(/^@/, "");
+    for (const a of manifest.assets ?? []) {
+      const publisher = (a.publisher ?? repoPublisher2 ?? "").replace(/^@/, "");
+      const haystack = [a.name, a.description ?? "", publisher, a.kind].join(" ").toLowerCase();
+      if (!haystack.includes(q)) continue;
+      hits.push({ slug, kind: a.kind, publisher, name: a.name, description: a.description });
+    }
+  }
+  return hits;
+}
+
+// cli/src/commands/store.ts
 async function fetchIdentity() {
   const jwt = await getStoreToken();
   return storeFetch({ ...getStoreConfig(), jwt }, "/api/v1/me");
@@ -11093,43 +11782,83 @@ 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 ${path18__default.join(globalSkaileDir(), "store", "config.yaml")}.`
+      `\`skaile store mode\` is scaffolded but not yet wired. Store config lives at ${path22__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: LocalCatalogDisabledError2 } = await import('../open-library-BOSPJVID.js');
-    try {
-      const remote = await openCatalogSource2({ projectDir: path18__default.resolve(opts.projectDir) });
-      const assets = await remote.listAssets(opts.kind ? { kind: opts.kind } : {});
-      const results = filterCatalogAssets(assets, query);
-      if (results.length === 0) {
-        logInfo(`No store results for "${query}".`);
-        return;
+  store.command("search <query>").description("Search the AI Asset Store catalog by name, description, or publisher").option("--kind <kind>", "Filter by asset kind (skill, prompt, flow, \u2026)").option(
+    "--all",
+    `List every match (default: ${STORE_ROW_LIMIT} rows, only what \`skaile add\` can install)`
+  ).option("-C, --project-dir <dir>", "Project directory (catalog config overlay)", process.cwd()).action(async (query, opts) => {
+    const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-PZAT3TJA.js');
+    const { getKnownKinds: getKnownKinds2 } = await import('../open-registry-W46UXZ3I.js');
+    const projectDir = path22__default.resolve(opts.projectDir);
+    if (opts.kind && !getKnownKinds2().has(opts.kind)) {
+      logErr(
+        `Unknown kind "${opts.kind}". Valid kinds: ${[...getKnownKinds2()].sort().join(", ")}`
+      );
+      process.exit(1);
+    }
+    const curated = searchCuratedManifests(query).filter(
+      (h) => !opts.kind || h.kind === opts.kind
+    );
+    const printCurated = () => {
+      if (curated.length === 0) return;
+      console.log(`
+  ${S.heading("Local curated manifests")}`);
+      for (const h of curated) {
+        console.log(
+          `  ${kindColorPad(h.kind)}  ${h.kind}:@${h.publisher}/${h.name}  ${S.dim(`(manifest ${h.slug})`)}`
+        );
       }
-      console.log();
-      for (const row of formatStoreRows(results, "  ")) console.log(row);
       console.log(
         `
-  ${S.dim(`${results.length} result(s) \xB7 \`skaile store show <ref>\` for details`)}
+  ${S.dim("Not published: `skaile source add <repo URL>` indexes them for `skaile add`.")}
 `
       );
+    };
+    try {
+      const remote = await openCatalogSource2({ projectDir });
+      const assets = await remote.listAssets(opts.kind ? { kind: opts.kind } : {});
+      const sel = selectStoreRows(filterCatalogAssets(assets, query), query, Boolean(opts.all));
+      if (sel.shown.length === 0) {
+        logInfo(`No store results for "${query}".`);
+        for (const note of storeSelectionNotes(sel, "")) console.log(note);
+      } else {
+        console.log();
+        for (const row of formatStoreRows(sel.shown, "  ")) console.log(row);
+        console.log(
+          `
+  ${S.dim(`${sel.shown.length} result(s) \xB7 \`skaile store show <ref>\` for details`)}`
+        );
+        for (const note of storeSelectionNotes(sel, "  ")) console.log(note);
+        if (curated.length === 0) console.log();
+      }
+      printCurated();
     } catch (e) {
+      printCurated();
+      if (e instanceof LocalCatalogDisabledError2 && curated.length > 0) return;
       if (e instanceof LocalCatalogDisabledError2) {
         logErr(
           `Remote catalog disabled (catalog.url: local). Set \`catalog.url: https://skaile.store\` in ${userConfigPath()}.`
         );
       } else {
-        logErr(`Store search failed: ${e.message}`);
+        logErr(`Store search failed: ${await describeStoreFailure(e, projectDir)}`);
       }
       process.exit(1);
     }
   });
   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: LocalCatalogDisabledError2 } = await import('../open-library-BOSPJVID.js');
-    const { supportsInstallManifest } = await import('../project-I55A4O2T.js');
+    const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-PZAT3TJA.js');
+    const { supportsInstallManifest } = await import('../project-EZUH7PUJ.js');
     try {
-      const remote = await openCatalogSource2({ projectDir: path18__default.resolve(opts.projectDir) });
+      parseAssetRef(ref);
+    } catch (e) {
+      logErr(`Invalid asset ref "${ref}": ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+    try {
+      const remote = await openCatalogSource2({ projectDir: path22__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)`);
@@ -11137,8 +11866,12 @@ function makeStoreCommand() {
       }
       const canonical = catalogAssetRef(asset);
       let manifest = null;
+      const manifestFailure = {};
       if (supportsInstallManifest(remote)) {
-        manifest = await remote.getInstallManifest(canonical).catch(() => null);
+        manifest = await remote.getInstallManifest(canonical).catch(async (err2) => {
+          manifestFailure.text = await describeStoreFailure(err2, path22__default.resolve(opts.projectDir));
+          return null;
+        });
       }
       const field = (label, value) => `  ${S.label(label.padEnd(11))}${value}`;
       console.log();
@@ -11168,13 +11901,25 @@ function makeStoreCommand() {
         console.log(field("Repo", asset.repo));
         if (asset.sha256) console.log(field("Integrity", asset.sha256));
       }
+      if (!manifest && manifestFailure.text) {
+        console.log();
+        console.log(field("Files", S.dim(`unavailable (${manifestFailure.text})`)));
+      }
+      if (asset.requires?.length) {
+        console.log();
+        console.log(`  ${S.heading("Requires")}`);
+        for (const dep of asset.requires) console.log(`  ${S.dim("\u2192")} ${dep}`);
+      }
       if (asset.softDeps?.length) {
         console.log();
         console.log(`  ${S.heading("Soft dependencies")}`);
         for (const dep of asset.softDeps) console.log(`  ${S.dim("\u2192")} ${dep}`);
       }
       console.log();
-      console.log(`  ${S.dim(`Install:  skaile add ${canonical}`)}`);
+      const notInstallable = storeNotInstallableReason(asset);
+      console.log(
+        notInstallable ? `  ${S.dim(`Not installable: ${notInstallable}`)}` : `  ${S.dim(`Install:  skaile add ${canonical}`)}`
+      );
       console.log();
     } catch (e) {
       if (e instanceof LocalCatalogDisabledError2) {
@@ -11182,7 +11927,9 @@ function makeStoreCommand() {
           `Remote catalog disabled (catalog.url: local). Set \`catalog.url: https://skaile.store\` in ${userConfigPath()}.`
         );
       } else {
-        logErr(`Store show failed: ${e.message}`);
+        logErr(
+          `Store show failed: ${await describeStoreFailure(e, path22__default.resolve(opts.projectDir))}`
+        );
       }
       process.exit(1);
     }
@@ -11252,9 +11999,10 @@ function treeRefs(nodes) {
 }
 function makeTreeCommand() {
   return new Command("tree").description("Show full dependency tree").option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {
+    requireProjectConfig(opts.projectDir);
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path18__default.resolve(opts.projectDir)
+      projectDir: path22__default.resolve(opts.projectDir)
     });
     const root = await am2.tree();
     if (root.children.length === 0) {
@@ -11281,15 +12029,17 @@ function makeUpdateCommand() {
     "Update only this declared asset (kind:@publisher/name, kind:name or name); exits 1 when none matches"
   ).option("--project-dir <path>", "Project directory", process.cwd()).option("--no-catalog", "Skip refreshing the catalog cache").option("--catalog-only", "Refresh the catalog cache only; do not re-deploy assets").option("--no-sync", "Skip syncing sources from upstream before re-deploying").option("-y, --yes", "Sync sources without the confirmation prompt").action(
     async (name, opts) => {
-      const projectDir = path18__default.resolve(opts.projectDir);
+      const projectDir = path22__default.resolve(opts.projectDir);
       if (!opts.catalogOnly) requireProjectConfig(projectDir);
       const am2 = new AssetManager({ registry: getKindRegistry(), projectDir });
       const target = name !== void 0 && !opts.catalogOnly ? await resolveUpdateTarget(am2, name) : void 0;
-      if (opts.catalog !== false) {
+      if (opts.catalog !== false && !opts.catalogOnly && onlyLibraryAssets(projectDir)) {
+        logInfo("Catalog refresh skipped (every locked asset comes from a library)");
+      } else if (opts.catalog !== false) {
         const catalogSpinner = createSpinner();
         catalogSpinner.start("Refreshing catalog cache");
         try {
-          const remote = await openCatalogSource({ projectDir: path18__default.resolve(opts.projectDir) });
+          const remote = await openCatalogSource({ projectDir: path22__default.resolve(opts.projectDir) });
           const result2 = await remote.refresh();
           catalogSpinner.stop(
             `Catalog refreshed: ${S.heading(String(result2.assetsCached))} assets cached`
@@ -11300,7 +12050,13 @@ function makeUpdateCommand() {
             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)}`);
+            const why = err2 instanceof Error ? err2.message : String(err2);
+            if (opts.catalogOnly) {
+              logErr(`Catalog refresh failed: ${why}`);
+              logInfo("Run `skaile catalog test` to debug.");
+              process.exit(1);
+            }
+            logWarn(`Catalog refresh failed: ${why}`);
             logInfo("Continuing with asset re-deploy. Run `skaile catalog test` to debug.");
           }
         }
@@ -11402,10 +12158,29 @@ async function resolveUpdateTarget(am2, name) {
     for (const h of hits) console.error(`    ${h.ref}`);
     process.exit(1);
   }
+  const chain = await am2.why(name);
+  if (chain.length > 2 && chain[chain.length - 1] === "direct (skaile.yaml)") {
+    const plain = (ref) => ref.replace(/#.*$/, "");
+    const root = chain[chain.length - 2];
+    logErr(
+      `${plain(chain[0])} is required by ${plain(chain[1])}; run \`skaile update ${plain(root)}\`.`
+    );
+    process.exit(1);
+  }
   logErr(`No declared asset matches "${name}".`);
   if (declared.length > 0) logInfo(`Declared: ${declared.map((d) => d.ref).join(", ")}`);
   process.exit(1);
 }
+function onlyLibraryAssets(projectDir) {
+  let lock;
+  try {
+    lock = readLock(path22__default.join(projectDir, "skaile.lock.yaml"));
+  } catch {
+    return false;
+  }
+  const entries = Object.values(lock?.assets ?? {});
+  return entries.length > 0 && entries.every((e) => e.library !== void 0);
+}
 function readText2(file) {
   try {
     return readFileSync(file, "utf8");
@@ -11414,13 +12189,16 @@ function readText2(file) {
   }
 }
 async function updateOne(am2, projectDir, target) {
-  const lockPath = path18__default.join(projectDir, "skaile.lock.yaml");
+  const lockPath = path22__default.join(projectDir, "skaile.lock.yaml");
   const before = readText2(lockPath);
   const spinner = createSpinner();
   spinner.start(`Updating ${target.ref}`);
   let deployed;
   try {
-    deployed = await am2.add(target.ref, { onLibraryMoved: (m) => reportMoved([m]) });
+    deployed = await am2.add(target.ref, {
+      preferLockedLibrary: true,
+      onLibraryMoved: (m) => reportMoved([m])
+    });
   } catch (err2) {
     spinner.stop("Failed");
     logErr(err2 instanceof Error ? err2.message : String(err2));
@@ -11545,9 +12323,10 @@ function whyEmptyMessage(ref, declared) {
 }
 function makeWhyCommand() {
   return new Command("why").description("Show why an asset is installed (dependency chain)").argument("<ref>", "Asset reference (kind:name)").option("--project-dir <path>", "Project directory", process.cwd()).action(async (ref, opts) => {
+    requireProjectConfig(opts.projectDir);
     const am2 = new AssetManager({
       registry: getKindRegistry(),
-      projectDir: path18__default.resolve(opts.projectDir)
+      projectDir: path22__default.resolve(opts.projectDir)
     });
     const chain = await am2.why(ref);
     if (chain.length === 0) {
@@ -11588,11 +12367,38 @@ function makeWhyCommand() {
   });
 }
 
+// cli/src/index-busy.ts
+var INDEX_BUSY_MESSAGE = "The skaile index is busy (another skaile process holds it); retry in a moment.";
+function isIndexBusyError(err2) {
+  const seen = /* @__PURE__ */ new Set();
+  let cur = err2;
+  while (cur && typeof cur === "object" && !seen.has(cur)) {
+    seen.add(cur);
+    const { code, message, cause } = cur;
+    if (typeof code === "string" && code.startsWith("SQLITE_BUSY")) return true;
+    if (typeof message === "string" && /SQLITE_BUSY|database is locked/i.test(message)) return true;
+    cur = cause;
+  }
+  return false;
+}
+
 // cli/src/index.ts
+{
+  const envLevel = process.env.SKAILE_LOG_LEVEL;
+  const level = envLevel === "debug" || envLevel === "info" || envLevel === "warn" || envLevel === "error" ? envLevel : "warn";
+  registerLogStore(
+    new LogStore({
+      sessionId: "cli",
+      level,
+      flushIntervalMs: 0,
+      sinks: [new StdoutSink({ stream: "stderr", format: "pretty" })]
+    })
+  );
+}
 var _defaultFormatHelp = Help.prototype.formatHelp;
 var pkg = JSON.parse(
   readFileSync(
-    path18__default.resolve(path18__default.dirname(fileURLToPath(import.meta.url)), "../../package.json"),
+    path22__default.resolve(path22__default.dirname(fileURLToPath(import.meta.url)), "../../package.json"),
     "utf-8"
   )
 );
@@ -11603,7 +12409,7 @@ for (const key of [
   "SKAILE_CACHE_DIR"
 ]) {
   const value = process.env[key];
-  if (value) process.env[key] = path18__default.resolve(value);
+  if (value) process.env[key] = path22__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) {
@@ -11648,7 +12454,7 @@ Execution:
   repl                         Interactive agent REPL
   resume                       Resume last session
   serve [--compile-test]       Start WebSocket agent server
-  mcp-server                   Start workspace MCP server (for .claude/mcp.json)
+  mcp-server                   Start workspace MCP server (for .mcp.json)
   integration install [--driver all]    Install agent integration (claude-code | omp | codex)
   integration uninstall [--driver all]  Uninstall agent integration
   integration enable                     Enable integration (claude-code only)
@@ -11723,7 +12529,7 @@ program.command("init [project-dir]").description("Initialize a project director
   (projectDir, opts) => runInit(projectDir, opts)
 );
 async function runInit(projectDir, opts) {
-  const { mkdirSync: mkdirSync5, writeFileSync: writeFileSync6 } = await import('fs');
+  const { mkdirSync: mkdirSync5, writeFileSync: writeFileSync7 } = await import('fs');
   const { stringify: stringify2 } = await import('yaml');
   const { DRIVER_TARGETS, SUPPORTED_DRIVER_TARGETS: SUPPORTED_DRIVER_TARGETS2 } = await import('../core/index.js');
   const harness = opts.harness;
@@ -11732,32 +12538,32 @@ async function runInit(projectDir, opts) {
     process.exitCode = 1;
     return;
   }
-  const resolved = path18__default.resolve(projectDir ?? ".");
-  const projectName = path18__default.basename(resolved);
+  const resolved = path22__default.resolve(projectDir ?? ".");
+  const projectName = path22__default.basename(resolved);
   const created = [];
-  const { existsSync: existsSync17 } = await import('fs');
-  if (!existsSync17(resolved)) {
+  const { existsSync: existsSync21 } = await import('fs');
+  if (!existsSync21(resolved)) {
     mkdirSync5(resolved, { recursive: true });
     created.push(".");
   }
-  const skaileDir = path18__default.join(resolved, ".skaile");
-  if (!existsSync17(skaileDir)) {
-    mkdirSync5(path18__default.join(skaileDir, "sessions"), { recursive: true });
+  const skaileDir = path22__default.join(resolved, ".skaile");
+  if (!existsSync21(skaileDir)) {
+    mkdirSync5(path22__default.join(skaileDir, "sessions"), { recursive: true });
     created.push(".skaile/");
   }
-  const settingsPath = path18__default.join(skaileDir, "settings.json");
-  if (!existsSync17(settingsPath)) {
-    writeFileSync6(settingsPath, "{}\n");
+  const settingsPath = path22__default.join(skaileDir, "settings.json");
+  if (!existsSync21(settingsPath)) {
+    writeFileSync7(settingsPath, "{}\n");
     created.push(".skaile/settings.json");
   }
-  const wsConfigPath = path18__default.join(resolved, "skaile.yaml");
-  if (!existsSync17(wsConfigPath)) {
-    writeFileSync6(wsConfigPath, stringify2(buildInitWorkspaceConfig(projectName, harness)));
+  const wsConfigPath = path22__default.join(resolved, "skaile.yaml");
+  if (!existsSync21(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 = path18__default.join(resolved, dir);
-    if (!existsSync17(full)) {
+    const full = path22__default.join(resolved, dir);
+    if (!existsSync21(full)) {
       mkdirSync5(full, { recursive: true });
       created.push(`${dir}/`);
     }
@@ -11787,10 +12593,13 @@ function buildInitWorkspaceConfig(projectName, harness) {
 }
 async function initGitScaffold(resolved, created) {
   const { execSync: execSync2 } = await import('child_process');
-  const { existsSync: existsSync17, readFileSync: readFileSync10, writeFileSync: writeFileSync6 } = await import('fs');
-  const gitignorePath = path18__default.join(resolved, ".gitignore");
+  const { existsSync: existsSync21, readFileSync: readFileSync12, writeFileSync: writeFileSync7 } = await import('fs');
+  const gitignorePath = path22__default.join(resolved, ".gitignore");
   const entries = [
     "node_modules/",
+    // Python bytecode a deployed skill script leaves inside `.claude/skills` and friends.
+    "__pycache__/",
+    "*.pyc",
     ".skaile/sessions/",
     ".skaile/cache/",
     // skaile-created artifacts that must never be committed: the per-session log
@@ -11801,20 +12610,29 @@ async function initGitScaffold(resolved, created) {
     ".skaile/settings.json",
     ".skaile/providers.yml",
     ".skaile/history.yaml",
+    // Per-machine files a run writes into the project: the system prompt handed to the harness
+    // (it carries the host path) and omp's session logs.
+    ".codex/skaile-session-instructions.md",
+    ".omp/system.md",
+    ".omp/sessions/",
+    // `skaile integration install` writes the absolute project path into these.
+    ".codex/config.toml",
+    ".omp/extensions/skaile.ts",
+    ".skaile/plugin-state.json",
     "*.log",
     ".env",
     ".env.local"
   ];
-  const existing = existsSync17(gitignorePath) ? readFileSync10(gitignorePath, "utf-8") : "";
+  const existing = existsSync21(gitignorePath) ? readFileSync12(gitignorePath, "utf-8") : "";
   const have = new Set(existing.split("\n").map((l) => l.trim()));
   const append = entries.filter((e) => !have.has(e));
   if (append.length > 0) {
     const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
-    writeFileSync6(gitignorePath, `${existing + prefix}${append.join("\n")}
+    writeFileSync7(gitignorePath, `${existing + prefix}${append.join("\n")}
 `);
     if (!existing) created.push(".gitignore");
   }
-  if (!existsSync17(path18__default.join(resolved, ".git"))) {
+  if (!existsSync21(path22__default.join(resolved, ".git"))) {
     try {
       execSync2("git init", { cwd: resolved, stdio: "pipe" });
       created.push(".git/");
@@ -11826,10 +12644,10 @@ async function initGitScaffold(resolved, created) {
 }
 async function bootstrapUserConfig() {
   try {
-    const fs13 = await import('fs');
+    const fs14 = await import('fs');
     const { userConfigPath: userConfigPath2, saveConfig, getConfigDefaults } = await import('../library/index.js');
     const userCfgPath = userConfigPath2();
-    if (!fs13.existsSync(userCfgPath)) {
+    if (!fs14.existsSync(userCfgPath)) {
       const defaults = getConfigDefaults();
       saveConfig(userCfgPath, {
         catalog: { url: defaults.catalog.url, cache_ttl: defaults.catalog.cache_ttl }
@@ -11844,7 +12662,7 @@ async function bootstrapUserConfig() {
 }
 async function hydrateInitSources(resolved, created) {
   try {
-    const { ensureSourcesCloned } = await import('../ensure-sources-2RONZKCU.js');
+    const { ensureSourcesCloned } = await import('../ensure-sources-VUKHL65L.js');
     const hydrate = ensureSourcesCloned(resolved, { quiet: true });
     for (const n of hydrate.cloned) created.push(`~/.skaile/cache/sources/${n}/`);
     if (hydrate.failed.length > 0) {
@@ -11860,7 +12678,7 @@ function printInitSummary(resolved, projectDir, created) {
   logOk(`Initialized project at ${S.heading(resolved)}`);
   console.log();
   console.log(S.heading("  Next steps:"));
-  const isCurrentDir = resolved === path18__default.resolve(".");
+  const isCurrentDir = resolved === path22__default.resolve(".");
   let step = 1;
   if (!isCurrentDir) {
     console.log(`  ${S.dim(`${step}.`)} ${S.cmd(`cd ${projectDir}`)}`);
@@ -11884,7 +12702,7 @@ function printInitSummary(resolved, projectDir, created) {
   console.log();
 }
 program.command("setup").description("Interactive provider setup wizard").action(async () => {
-  const { cmdSetup } = await import('../setup-7DQJKHUI.js');
+  const { cmdSetup } = await import('../setup-L632QIHV.js');
   await cmdSetup([], { projectDir: process.cwd() });
 });
 program.addCommand(makeInstallCommand());
@@ -11972,6 +12790,10 @@ try {
   await program.parseAsync();
   commandSettled = true;
 } catch (err2) {
+  if (isIndexBusyError(err2)) {
+    logErr(INDEX_BUSY_MESSAGE);
+    process.exit(1);
+  }
   const { LibrarySyncError } = await import('../library/index.js');
   if (!(err2 instanceof LibrarySyncError || err2 instanceof SourceEntryError)) throw err2;
   logErr(err2.message);