@skaile/workspaces 5.12.0 → 5.13.0

package/dist/cli/index.js

@@ -1,25 +1,26 @@
 #!/usr/bin/env node
-import { makeProvidersCommand, loadRegistryView, addProviderEntry, ProviderRegistryWriteError } from '../chunk-KVSDRB35.js';
-import { makeSourceCommand, syncProjectSources, divergedSourceClones } from '../chunk-WI4T3KIS.js';
-import { makeInstallCommand, makeCheckCommand, makeCleanCommand, reportReplaced, reportRelocked, reportMoved, REF_HINT, reportInstalledSoftDeps } from '../chunk-P23WJCH2.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-SMT3LNAG.js';
-import { unresolvedManifestDependencies, warnIgnoredDomainFiles, warnLegacyBundleFiles, removedDomainOption, rejectRemovedDomainOption, resolveLibraryPublisherDetailed, warnLibraryNameFallback, indexLibrary, requireValidPublisherOrExit, exitOnManifestPublisherProblems, registerLibraryAsset, DOMAIN_REMOVED_HINT, checkAsset, agentComposeRefAdvisories, manifestPublisherProblems, manifestRequiresProblems, findAssetManifestFile, declaredVersion, checkAssetFile, duplicateAssetMessage, readAssetBody, checkAgentFiles, invalidSemverText } from '../chunk-ID745F3R.js';
-import { getStoreConfig, storeFetch, deviceLogin, loadStoreAuthConfig, logout, hasStoredAuth, isStoreAuthenticated, getStoreToken, getStoreIdentity, assetEntryRef, manifestVersionMismatchMessage } from '../chunk-NR7H7ZJP.js';
-import { storeNotInstallableReason, STORE_UNADDABLE_KINDS } from '../chunk-K4VOEYOR.js';
-import { openCatalogSource, LocalCatalogDisabledError, openLibraryManager, openLibrary } from '../chunk-JQ3DXNQV.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-POQ6PGNE.js';
-import { getKindRegistry, getKnownKinds } from '../chunk-GWD3QNVS.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, createFinalTextFallback } from '../chunk-N5M2EISA.js';
-import { buildClaudePluginFiles } from '../chunk-YQU2BPQD.js';
-import '../chunk-X6LKA3TJ.js';
-import '../chunk-HYMERG57.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-3HUV2LJF.js';
-import '../chunk-QCEKGYHF.js';
+import '../chunk-6JKIOPT3.js';
+import '../chunk-2BIESC6S.js';
 import '../chunk-4ZTPYIBE.js';
-import '../chunk-XZY6SBGU.js';
+import '../chunk-XJYBCDY2.js';
 import '../chunk-X5YPJV4N.js';
 import '../chunk-O7SG5PC2.js';
 import '../chunk-7QBNJTTQ.js';
@@ -28,64 +29,64 @@ import '../chunk-OQ5MKDS3.js';
 import '../chunk-32NA4TVC.js';
 import '../chunk-W3UDISS2.js';
 import '../chunk-PHRNUTSG.js';
-import { runFlow, resumeFlow } from '../chunk-2X3JBVGD.js';
+import { runFlow, resumeFlow } from '../chunk-GMDSRSGI.js';
 import '../chunk-4R6DROGN.js';
-import { parseSkillRequirements, validateRequirements, validateFlowVersions } from '../chunk-G3X4MLDB.js';
-import '../chunk-DCHQ6BAZ.js';
+import { parseSkillRequirements, validateRequirements, validateFlowVersions } from '../chunk-USHB5KEY.js';
+import '../chunk-ZU24LWBI.js';
 import '../chunk-ISHJITXJ.js';
-import '../chunk-27L6BBAT.js';
+import '../chunk-Y4Z7LGSH.js';
 import '../chunk-X4BAYGMT.js';
-import '../chunk-ICIYSJBQ.js';
-import '../chunk-NDF24LYP.js';
-import '../chunk-2JFIFDDO.js';
+import '../chunk-5SKVCMRC.js';
+import '../chunk-6NQDDCIL.js';
+import '../chunk-YTZFSKWL.js';
 import '../chunk-LOO5CB5M.js';
 import '../chunk-2H73V6XR.js';
-import '../chunk-NJXR5OAM.js';
+import '../chunk-B7CZYFB2.js';
 import '../chunk-B4X2N7JQ.js';
 import '../chunk-YROR332M.js';
-import { listDrivers, getProviderPreset, AI_PROVIDER_PRESETS } from '../chunk-MF54ZHWT.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-7XWUJC3A.js';
+import { projectAiAssetsRoots, loadFlow, loadAllFlowEntries, findFlowFileInRoots } from '../chunk-XBYSURMK.js';
 import '../chunk-LNFKL23K.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-TVAR4JHA.js';
-import { libraryDirMissing, missingLibraryDirMessage, cloneOrInitGitRepo, trackOriginBranch, stampManifestPublisher, isGitRepo, ensureGitRepo, conflictingAssetRoot, setManifestPublisher, LIBRARY_OWNERSHIPS, assertManifestEditable, installLibraryAsset, missingRootAssets, getStoreManifestsDir, assertValidLibraryName, syncManifestWithDisk, getDefaultValue, isSecretPlaceholder } from '../chunk-C3BMXXTN.js';
-import { parseManifestFile, SEMVER_RE } from '../chunk-7CR2OZPA.js';
-import '../chunk-UTKENBB6.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-NJV5SLEK.js';
+import { installTargetOf, SCAFFOLD_KINDS } from '../chunk-5FYOM4RF.js';
 import '../chunk-NOA6EJXE.js';
 import '../chunk-KTBKW2FI.js';
 import '../chunk-UQ6LFBPZ.js';
-import '../chunk-7QWQTA5S.js';
-import { effectiveComposes, validatePreset, composeSlotDiagnostics, agentDeprecationDiagnostics, validateAgent, SLOT_ID_PATTERN } from '../chunk-6VLHITAM.js';
-import { resolveSettings, globalSettingsPath, projectSettingsPath, loadSettings, saveSettings, WorkspaceYamlEditor, resolveLibraryDir, checkAgentSkillConformance, resolveSettingsWithSources, globalInstallDir, GLOBAL_INSTALL_DIR_NAME, readLock, aiResourceRoots, workspaceProviderRegistryPath, userProviderRegistryPath, loadProviderRegistryFile } from '../chunk-T5TSLSRO.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-SHQMPGOL.js';
-import { deployedDir } from '../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, resolveSkWorkspaceConfig, sourceCacheKey, getGlobalCacheDir, resolveAgentDir, AgentRefResolutionError, resolveAgentDefinitionDir, decodeSkaileYaml, matchPin, coerceVersion, loadSkWorkspaceConfig, normalizeAgentInstances, agentInstanceDiagnostics, storeManifestSlug, isWorkspaceConfigFilename } from '../chunk-PNOGX36L.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, loadSkPublishManifest, decodeSkaileManifest, isNonAssetPath, isNonAssetDir, encodeSkaileManifest } from '../chunk-CTP3XBMF.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, parseRequires } from '../chunk-XTVSNWLL.js';
-import { parseAssetRef, isValidPublisher, PUBLISHER_HINT, isValidAssetName, ASSET_NAME_HINT, depToStr, slugifyAssetName, parseAssetRefLoose, assetRefToStr } from '../chunk-PNTXHTBC.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-DKXNKFKP.js';
 import { parseModelRef, resolveEntryBaseUrl } from '../chunk-MJHSLODD.js';
 import '../chunk-C3CAXQMA.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 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';
@@ -147,7 +148,7 @@ function selectStoreRows(matches, query, all) {
   );
   if (all) return { shown: ranked, hidden: 0, cut: 0 };
   const keep = ranked.filter(
-    (a) => storeNotInstallableReason(a) === void 0 && !STORE_TEST_NAME_RE.test(a.name)
+    (a) => storeNotInstallableReason(a) === void 0 && !a.demo && !STORE_TEST_NAME_RE.test(a.name)
   );
   return {
     shown: keep.slice(0, STORE_ROW_LIMIT),
@@ -164,7 +165,7 @@ function storeSelectionNotes(sel, indent) {
   }
   if (sel.hidden > 0) {
     notes.push(
-      `${indent}${S.dim(`${sel.hidden} store entr${sel.hidden === 1 ? "y" : "ies"} hidden: kinds \`add\` cannot install yet (${[...STORE_UNADDABLE_KINDS].join(", ")}), names that are not valid refs, test/demo entries; --all lists them`)}`
+      `${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;
@@ -225,7 +226,7 @@ async function runSearch(kind, query, opts) {
   }
 }
 async function searchIndex(query, kind) {
-  const { openLibrary: openLibrary2 } = await import('../open-library-N6ESO6IK.js');
+  const { openLibrary: openLibrary2 } = await import('../open-library-PZAT3TJA.js');
   const library = await openLibrary2();
   try {
     const { libraryDirMissing: libraryDirMissing2 } = await import('../library/index.js');
@@ -376,7 +377,7 @@ async function searchLocal(query, kind, opts, showStore, airGapped) {
   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-DX5SGWEI.js');
+    const { autoSyncForSearch } = await import('../source-36FHMN5V.js');
     if (await autoSyncForSearch(projectDir)) {
       entries = unionEntries(await searchIndex(query, kind), factory);
     }
@@ -486,17 +487,11 @@ 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-N6ESO6IK.js');
+  const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-PZAT3TJA.js');
   try {
     const remote = await openCatalogSource2({ projectDir: path22__default.resolve(opts.projectDir) });
     const assets = await remote.listAssets(kind ? { kind } : {});
@@ -524,9 +519,10 @@ async function searchStore(query, kind, opts, airGapped) {
   }
 }
 async function describeStoreFailure(err2, projectDir) {
-  const { resolveConfig, describeCatalogError } = await import('../library/index.js');
-  const url = resolveConfig({ projectDir }).catalog.url;
-  return `${describeCatalogError(err2, url)}. Check the catalog with \`skaile catalog test\`.`;
+  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").option(
@@ -623,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);
@@ -631,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: 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}`);
@@ -648,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) => {
@@ -711,7 +715,11 @@ function makeAddCommand() {
         }
       }
       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(
@@ -807,8 +815,7 @@ function makeListCommand() {
     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);
     }
@@ -921,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-N6ESO6IK.js');
+    const { resolveCatalogSource } = await import('../open-library-PZAT3TJA.js');
     const { source, close } = await resolveCatalogSource({ projectDir: opts.projectDir });
     try {
       return await source.listAssets(filter);
@@ -937,7 +944,7 @@ async function resolveInfoEntry(am2, ref, opts) {
     );
     return { entry: hit ? catalogAssetToEntry(hit) : null };
   } catch (err2) {
-    const { LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-N6ESO6IK.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 } : {} };
@@ -1020,11 +1027,13 @@ function makeDoctorCommand() {
       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;
@@ -1054,16 +1063,16 @@ function claudeSkillRoots() {
 }
 function resolveImportSource(nameOrPath) {
   const asPath = path22.resolve(nameOrPath);
-  if (fs8.existsSync(asPath)) {
-    const dir = fs8.statSync(asPath).isDirectory() ? asPath : path22.dirname(asPath);
+  if (fs9.existsSync(asPath)) {
+    const dir = fs9.statSync(asPath).isDirectory() ? asPath : path22.dirname(asPath);
     const skillFile = path22.join(dir, "SKILL.md");
-    if (fs8.existsSync(skillFile)) return { dir, skillFile, via: "path" };
+    if (fs9.existsSync(skillFile)) return { dir, skillFile, via: "path" };
   }
   if (!nameOrPath.includes(path22.sep) && !nameOrPath.startsWith(".")) {
     for (const root of claudeSkillRoots()) {
       const dir = path22.join(root, nameOrPath);
       const skillFile = path22.join(dir, "SKILL.md");
-      if (fs8.existsSync(skillFile)) return { dir, skillFile, via: "claude-skills" };
+      if (fs9.existsSync(skillFile)) return { dir, skillFile, via: "claude-skills" };
     }
   }
   return null;
@@ -1196,7 +1205,13 @@ 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: path22.basename(src.dir),
           version: opts.version,
@@ -1208,7 +1223,7 @@ function makeAssetCommand() {
           );
         }
         const destDir = path22.join(target.path, norm.name);
-        if (fs8.existsSync(destDir)) {
+        if (fs9.existsSync(destDir)) {
           logErr(`Destination already exists: ${destDir}`);
           process.exit(1);
         }
@@ -1238,8 +1253,8 @@ function makeAssetCommand() {
         for (const f of checked.advisories) {
           logWarn(`${norm.name}/SKILL.md [${f.tag}] \u2014 ${f.text}`);
         }
-        fs8.cpSync(src.dir, destDir, { recursive: true, filter: copyFilter(src.dir) });
-        fs8.writeFileSync(path22.join(destDir, "SKILL.md"), norm.content, "utf8");
+        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 })) {
@@ -1279,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);
       }
@@ -1307,21 +1322,27 @@ function makeAssetCommand() {
         }
         const basename3 = path22.basename(srcPath);
         const destDir = target.path;
-        fs8.mkdirSync(destDir, { recursive: true });
+        fs9.mkdirSync(destDir, { recursive: true });
         const destPath = path22.join(destDir, basename3);
-        if (fs8.existsSync(destPath)) {
+        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, filter: copyFilter(srcPath) });
+            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(path22.resolve(srcPath), destPath);
+            fs9.symlinkSync(path22.resolve(srcPath), destPath);
             break;
         }
         if (target.backend === "git" && opts.commit) {
@@ -1337,7 +1358,7 @@ function makeAssetCommand() {
         }
         logOk(`Migrated ${basename3} \u2192 ${target.name} (${opts.mode})`);
         const publisher = loadSkPublishManifest(target.path)?.publisher ?? "<publisher>";
-        const migratedKind = fs8.existsSync(path22.join(destPath, "SKILL.md")) ? "skill" : "<kind>";
+        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}`)}`
         );
@@ -1568,7 +1589,11 @@ 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');
@@ -1581,14 +1606,16 @@ function makeCatalogCommand() {
   return catalog;
 }
 async function runLocalCatalogTest(projectDir) {
-  const { resolveCatalogSource } = await import('../open-library-N6ESO6IK.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)}`);
@@ -1609,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 {
@@ -1620,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(
@@ -1634,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`);
@@ -1724,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-CBZ5MWTT.js');
+    const { getKindRegistry: getKindRegistry2 } = await import('../open-registry-W46UXZ3I.js');
     const index = new LocalIndex({ indexPath });
     try {
       for (const { assets } of await scanAuthoringLibraries(index, getKindRegistry2())) {
@@ -1774,11 +1826,11 @@ function findSkills() {
   return deduped;
 }
 function walkSkills(dir, out) {
-  for (const entry of fs8__default.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs9__default.readdirSync(dir, { withFileTypes: true })) {
     const full = path22__default.join(dir, entry.name);
     if (entry.isDirectory()) {
       const skillMd = path22__default.join(full, "SKILL.md");
-      if (fs8__default.existsSync(skillMd)) {
+      if (fs9__default.existsSync(skillMd)) {
         out.push({ name: entry.name, path: full, skillPath: skillMd });
       } else {
         walkSkills(full, out);
@@ -1800,9 +1852,9 @@ function resolveFlowIds() {
 }
 function resolveSessionIds(projectDir) {
   const sessionsDir = path22__default.join(projectDir, ".skaile", "sessions");
-  if (!fs8__default.existsSync(sessionsDir)) return [];
+  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 [];
   }
@@ -1868,10 +1920,10 @@ async function setCatalogKey(key, raw) {
     process.exit(1);
   }
   const filePath = userConfigPath();
-  const fs13 = await import('fs');
+  const fs14 = await import('fs');
   let existing = {};
-  if (fs13.existsSync(filePath)) {
-    const parsed = parseYaml5(fs13.readFileSync(filePath, "utf-8"));
+  if (fs14.existsSync(filePath)) {
+    const parsed = parseYaml5(fs14.readFileSync(filePath, "utf-8"));
     if (parsed && typeof parsed === "object") existing = parsed;
   }
   const catalog = {
@@ -2728,7 +2780,7 @@ async function ensureTargetsRegistered(projectDir) {
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const config = resolveSkWorkspaceConfig2(projectDir);
   if (config.plugins && config.plugins.length > 0) {
-    const { ensurePluginsLoaded } = await import('../plugin-store-XMZSPVBF.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);
   }
@@ -2872,9 +2924,9 @@ function makeDiffCommand() {
     }
     const gaps = await am2.gapsOf(ref);
     const requirementGaps = await am2.requirementGapsOf(ref);
-    const blocking = [...gaps.filter((g) => !DIFF_SHOWS[g.type]), ...requirementGaps];
+    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;
     }
@@ -2895,18 +2947,19 @@ function makeDiffCommand() {
         }
         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() {
@@ -3086,24 +3139,30 @@ async function uninstall(projectDir) {
   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));
   }
-  if (await removeSkaileMcpEntry(mcpPath)) changed = true;
-  if (await removeSkaileMcpEntry(legacyMcpFilePath(projectDir))) changed = true;
-  return { changed };
+  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: files.length > 0, files };
 }
 async function detectInstall(projectDir) {
   const dir = pluginDir(projectDir);
@@ -3398,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);
@@ -3432,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));
@@ -3665,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(path22.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);
@@ -3680,7 +3782,17 @@ async function reindexLibrary(lib, library, name) {
     lib.path,
     resolved.publisher,
     registry,
-    { check: (e) => checkAssetFile(e.source, e.kind, registry, lib.path) }
+    {
+      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) {
@@ -3768,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);
@@ -3787,13 +3907,13 @@ function canonicalDir(dir) {
   const abs = path22.resolve(dir);
   const missing = [];
   let existing = abs;
-  while (!fs8.existsSync(existing)) {
+  while (!fs9.existsSync(existing)) {
     const parent = path22.dirname(existing);
     if (parent === existing) return abs;
     missing.unshift(path22.basename(existing));
     existing = parent;
   }
-  return path22.join(fs8.realpathSync(existing), ...missing);
+  return path22.join(fs9.realpathSync(existing), ...missing);
 }
 function refuseGlobalInstallFolder(name, dir) {
   const reserved = globalInstallDir();
@@ -3839,7 +3959,7 @@ 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;
@@ -3849,12 +3969,12 @@ function assertCreateDirInsideLibrary(libRoot, destDir, given) {
   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);
   }
@@ -3869,7 +3989,7 @@ function assertCreateDirInsideLibrary(libRoot, destDir, given) {
   }
 }
 function adoptWritesManifest(libPath) {
-  if (!fs8.existsSync(path22.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;
@@ -3927,13 +4047,22 @@ function pruneEmptyLibraryParents(libPath) {
   for (; ; ) {
     const rel = path22.relative(root, canonicalDir(dir));
     if (rel === "" || rel.startsWith("..") || path22.isAbsolute(rel)) return;
-    if (!fs8.existsSync(dir) || fs8.readdirSync(dir).length > 0) return;
-    fs8.rmdirSync(dir);
+    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-DI4Q5UOG.js');
+  const { isGithubRemote, notGithubRemoteMessage } = await import('../library-publish-FFIPWIRM.js');
   if (!isGithubRemote(url)) logWarn(notGithubRemoteMessage(name, url));
 }
 function scaffoldLibraryFiles(dir, name) {
@@ -3966,8 +4095,8 @@ by the same ref.
   const written = [];
   for (const [file, content] of files) {
     const target = path22.join(dir, file);
-    if (fs8.existsSync(target)) continue;
-    fs8.writeFileSync(target, content, "utf8");
+    if (fs9.existsSync(target)) continue;
+    fs9.writeFileSync(target, content, "utf8");
     written.push(file);
   }
   return written;
@@ -4057,7 +4186,7 @@ function makeLibraryCommand() {
       const ownership = flagged[0] ?? gone?.ownership ?? "owner";
       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);
       }
@@ -4096,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,
@@ -4143,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) {
@@ -4175,6 +4300,15 @@ function makeLibraryCommand() {
         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, {
@@ -4296,11 +4430,11 @@ function makeLibraryCommand() {
     }
     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}`);
   }
@@ -4381,7 +4515,7 @@ function makeLibraryCommand() {
         patch.isDefault = false;
       } else if (field === "path") {
         const dir = path22.resolve(value);
-        if (!fs8.existsSync(dir) || !fs8.statSync(dir).isDirectory()) {
+        if (!fs9.existsSync(dir) || !fs9.statSync(dir).isDirectory()) {
           logErr(`Directory does not exist: ${dir}. \`library set path=\` does not move files.`);
           process.exit(1);
         }
@@ -4592,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-DI4Q5UOG.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-DI4Q5UOG.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-DI4Q5UOG.js');
+    const { runLibraryYank } = await import('../library-publish-FFIPWIRM.js');
     await withStoreErrorHandling(() => runLibraryYank(lib, opts));
   });
   return cmd;
@@ -5261,7 +5395,7 @@ function scheduleSoftDepPreview() {
 }
 async function loadAssets() {
   softDepPreviewCache.clear();
-  const { gatherAssetFeeds } = await import('../asset-feeds-AM6PSSGM.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 ");
@@ -5465,7 +5599,7 @@ function reconcileCollapsedSets(rows) {
 async function loadSourcesAndLibraries() {
   try {
     const [{ openLibraryManager: openLibraryManager2 }, { getGlobalCacheDir: getGlobalCacheDir2, globalSkaileDir: globalSkaileDir2 }] = await Promise.all([
-      import('../open-library-N6ESO6IK.js'),
+      import('../open-library-PZAT3TJA.js'),
       import('../core/index.js')
     ]);
     const { manager, library, close } = await openLibraryManager2();
@@ -6706,7 +6840,7 @@ function loadAsset(projectDir, id, ref) {
   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(
@@ -6811,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(
@@ -6885,7 +7020,7 @@ 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;
     }
@@ -6907,7 +7042,7 @@ 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(`${path22__default.relative(absRoot, c.filePath)} [${c.kind}] \u2014 parse error: ${res.reason}`);
@@ -6927,21 +7062,36 @@ 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 (fs8__default.existsSync(path22__default.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
+    if (fs9__default.existsSync(path22__default.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
     if (path22__default.dirname(dir) === dir) return absRoot;
   }
 }
@@ -6956,7 +7106,8 @@ function validateManifestCandidate(c, parsed, body, absRoot, registry, strictCon
     body,
     dirName,
     registry,
-    fs8__default.readFileSync(c.filePath, "utf-8")
+    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}`);
@@ -6964,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 {
@@ -7000,15 +7151,33 @@ 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 = path22__default.resolve(rootPath);
-  if (!fs8__default.existsSync(absRoot)) {
+  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 = [];
@@ -7050,8 +7219,10 @@ function validateManifests(rootPath, strictConformance) {
       }
     }
   }
-  const libraryPublisher = loadSkPublishManifest(libraryRootOf(absRoot))?.publisher;
-  const hasAsset = (kind, name) => seenIdentity.has(`${kind}:${name}`);
+  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}`);
@@ -7065,7 +7236,7 @@ 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;
     }
@@ -7132,7 +7303,7 @@ function validateWorkspaceAssets(parsed, relPath) {
   }
   return errors;
 }
-function validateWorkspaceManifests(rootPath) {
+async function validateWorkspaceManifests(rootPath) {
   const absRoot = path22__default.resolve(rootPath);
   const files = findWorkspaceManifests(absRoot);
   let errors = 0;
@@ -7140,7 +7311,7 @@ function validateWorkspaceManifests(rootPath) {
     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++;
@@ -7157,11 +7328,22 @@ function validateWorkspaceManifests(rootPath) {
         logWarn(line);
       }
     }
-    for (const d of decodeSkaileYaml(fs8__default.readFileSync(file, "utf-8")).diagnostics) {
+    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 };
 }
@@ -7209,7 +7391,7 @@ function validatePublishManifestVersions(rootPath) {
     if (!a.root || a.source || !a.version) continue;
     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;
@@ -7236,7 +7418,7 @@ function validatePublishManifestPublishers(rootPath) {
     if (!a.root || a.source || !resolved) continue;
     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;
@@ -7268,7 +7450,7 @@ function readAssetVersion(c) {
   const kind = c.kind;
   const fileName = path22__default.basename(c.filePath);
   const dirName = path22__default.basename(path22__default.dirname(c.filePath));
-  const content = fs8__default.readFileSync(c.filePath, "utf-8");
+  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 : {};
@@ -7301,7 +7483,7 @@ 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;
@@ -7318,7 +7500,7 @@ function findChangelogUnit(assetRelPath, root) {
   let dir = path22__default.posix.dirname(toPosix(assetRelPath));
   for (; ; ) {
     const candidate = dir === "." ? "CHANGELOG.md" : `${dir}/CHANGELOG.md`;
-    if (fs8__default.existsSync(path22__default.join(root, candidate))) return candidate;
+    if (fs9__default.existsSync(path22__default.join(root, candidate))) return candidate;
     if (dir === ".") return null;
     dir = path22__default.posix.dirname(dir);
   }
@@ -7422,14 +7604,14 @@ function checkFlowVersionPins(assets, root) {
 function resolveCheckRoot(pathArg) {
   if (pathArg) {
     const abs = path22__default.resolve(pathArg);
-    if (!fs8__default.existsSync(abs)) {
+    if (!fs9__default.existsSync(abs)) {
       logErr(`Path does not exist: ${abs}`);
       return null;
     }
     return abs;
   }
   for (let dir = process.cwd(); ; dir = path22__default.dirname(dir)) {
-    if (fs8__default.existsSync(path22__default.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
+    if (fs9__default.existsSync(path22__default.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
     if (path22__default.dirname(dir) === dir) return AI_RESOURCES;
   }
 }
@@ -7544,7 +7726,7 @@ function makeValidateCommand() {
       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);
@@ -9237,7 +9419,7 @@ function action2(fn) {
   };
 }
 async function reconcileAndReport(projectDir, plugins, opts = {}) {
-  const { reconcilePlugins } = await import('../plugin-store-XMZSPVBF.js');
+  const { reconcilePlugins } = await import('../plugin-store-CK7YWRIC.js');
   if (plugins.length === 0) {
     logInfo("No plugins declared \u2014 nothing to reconcile.");
     return;
@@ -9252,7 +9434,7 @@ async function reconcileAndReport(projectDir, plugins, opts = {}) {
   }
 }
 async function verifyPluginLoads(projectDir, spec) {
-  const { loadPlugins } = await import('../plugin-store-XMZSPVBF.js');
+  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);
@@ -9266,10 +9448,11 @@ async function verifyPluginLoads(projectDir, spec) {
 async function runInstall2(spec, opts) {
   const projectDir = path22__default.resolve(opts.projectDir);
   const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-  const { specName } = await import('../plugin-store-XMZSPVBF.js');
+  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`);
@@ -9285,13 +9468,14 @@ async function runInstall2(spec, opts) {
       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 = path22__default.resolve(opts.projectDir);
   const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-  const { specName } = await import('../plugin-store-XMZSPVBF.js');
+  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);
@@ -9319,7 +9503,7 @@ async function runList(opts) {
   const registry = createPluginRegistry();
   if (declared.length > 0) {
     try {
-      const { loadPlugins } = await import('../plugin-store-XMZSPVBF.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) {
@@ -9393,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) {
@@ -10150,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") ? path22__default.dirname(path22__default.resolve(projectDir, agentDefinition)) : agentDefinition;
   const dir = resolveAgentDefinitionDir(projectDir, asPath);
-  if (!dir || !fs8__default.existsSync(path22__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})` : ""}`
     );
@@ -10211,11 +10407,11 @@ 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 (fs8__default.existsSync(file)) return file;
+    if (fs9__default.existsSync(file)) return file;
   }
   const am2 = new AssetManager({ registry: getKindRegistry(), projectDir });
   const entry = await am2.info(`skill:${name}`);
-  return entry?.source && fs8__default.existsSync(entry.source) ? entry.source : void 0;
+  return entry?.source && fs9__default.existsSync(entry.source) ? entry.source : void 0;
 }
 async function printSkillDryRun(projectDir, skill) {
   const file = await findSkillFile(projectDir, skill);
@@ -10225,7 +10421,7 @@ async function printSkillDryRun(projectDir, skill) {
     );
     return false;
   }
-  const content = fs8__default.readFileSync(file, "utf-8");
+  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))}`);
@@ -10296,7 +10492,11 @@ 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);
@@ -10414,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);
       }
@@ -10496,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}`) : ""}`
     );
@@ -10546,13 +10748,13 @@ function makeReplCommand() {
         p4.cancel("Cancelled.");
         process.exit(0);
       }
-      const tmpDir = fs8__default.mkdtempSync(path22__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 = path22__default.join(os2.homedir(), ".claude");
-        if (fs8__default.existsSync(claudeDir)) {
+        if (fs9__default.existsSync(claudeDir)) {
           driverOverride = "claude-sdk";
           logInfo(`Detected ${S.cmd("~/.claude")} \u2192 using ${S.cmd("claude-sdk")} harness`);
         } else {
@@ -10612,10 +10814,10 @@ function makeServeCommand() {
         await ensurePluginsLoadedForServe(opts.projectDir);
       }
       const providers = parseProviderIds(opts.providers);
-      const { checkDriverSdk } = await import('../serve-preflight-6P2JJEJ3.js');
+      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-Y4OT7VIS.js');
+        const { logErr: logErr2 } = await import('../helpers-53XZW7KF.js');
         logErr2(driverProblem);
         process.exitCode = 1;
         return;
@@ -10640,20 +10842,20 @@ function makeServeCommand() {
         });
       } catch (err2) {
         if (err2?.code !== "EADDRINUSE") throw err2;
-        const { logErr: logErr2 } = await import('../helpers-Y4OT7VIS.js');
+        const { logErr: logErr2 } = await import('../helpers-53XZW7KF.js');
         logErr2(err2.message);
-        process.exitCode = 1;
+        process.exit(1);
       }
     }
   );
 }
 async function ensurePluginsLoadedForServe(projectDir) {
-  const { logInfo: logInfo2, logWarn: logWarn2 } = await import('../helpers-Y4OT7VIS.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-XMZSPVBF.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) {
@@ -10667,14 +10869,14 @@ async function ensurePluginsLoadedForServe(projectDir) {
   }
 }
 async function runCompileTest(opts) {
-  const { logOk: logOk2, logErr: logErr2, logInfo: logInfo2, S: S2 } = await import('../helpers-Y4OT7VIS.js');
+  const { logOk: logOk2, logErr: logErr2, logInfo: logInfo2, S: S2 } = await import('../helpers-53XZW7KF.js');
   const { tmpdir } = await import('os');
   const { dirname: dirname3, join: join7, resolve: resolve5 } = await import('path');
   const { fileURLToPath: fileURLToPath2 } = await import('url');
-  const { unlinkSync, existsSync: existsSync20 } = 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-U6W6MQNQ.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).");
@@ -10736,7 +10938,7 @@ async function runCompileTest(opts) {
     } catch {
     }
     try {
-      if (existsSync20(outfile)) unlinkSync(outfile);
+      if (existsSync21(outfile)) unlinkSync(outfile);
     } catch {
     }
   }
@@ -11476,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}`);
@@ -11588,8 +11790,15 @@ function makeStoreCommand() {
     "--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-N6ESO6IK.js');
+    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
     );
@@ -11640,8 +11849,14 @@ function makeStoreCommand() {
     }
   });
   store.command("show <ref>").description("Show a store asset's details + provenance (source, files, integrity)").option("-C, --project-dir <dir>", "Project directory (catalog config overlay)", process.cwd()).action(async (ref, opts) => {
-    const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-N6ESO6IK.js');
-    const { supportsInstallManifest } = await import('../project-UP52HEHC.js');
+    const { openCatalogSource: openCatalogSource2, LocalCatalogDisabledError: LocalCatalogDisabledError2 } = await import('../open-library-PZAT3TJA.js');
+    const { supportsInstallManifest } = await import('../project-EZUH7PUJ.js');
+    try {
+      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);
@@ -11818,7 +12033,9 @@ function makeUpdateCommand() {
       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 {
@@ -11833,11 +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.");
           }
         }
@@ -11939,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");
@@ -12303,29 +12541,29 @@ async function runInit(projectDir, opts) {
   const resolved = path22__default.resolve(projectDir ?? ".");
   const projectName = path22__default.basename(resolved);
   const created = [];
-  const { existsSync: existsSync20 } = await import('fs');
-  if (!existsSync20(resolved)) {
+  const { existsSync: existsSync21 } = await import('fs');
+  if (!existsSync21(resolved)) {
     mkdirSync5(resolved, { recursive: true });
     created.push(".");
   }
   const skaileDir = path22__default.join(resolved, ".skaile");
-  if (!existsSync20(skaileDir)) {
+  if (!existsSync21(skaileDir)) {
     mkdirSync5(path22__default.join(skaileDir, "sessions"), { recursive: true });
     created.push(".skaile/");
   }
   const settingsPath = path22__default.join(skaileDir, "settings.json");
-  if (!existsSync20(settingsPath)) {
+  if (!existsSync21(settingsPath)) {
     writeFileSync7(settingsPath, "{}\n");
     created.push(".skaile/settings.json");
   }
   const wsConfigPath = path22__default.join(resolved, "skaile.yaml");
-  if (!existsSync20(wsConfigPath)) {
+  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 = path22__default.join(resolved, dir);
-    if (!existsSync20(full)) {
+    if (!existsSync21(full)) {
       mkdirSync5(full, { recursive: true });
       created.push(`${dir}/`);
     }
@@ -12355,7 +12593,7 @@ function buildInitWorkspaceConfig(projectName, harness) {
 }
 async function initGitScaffold(resolved, created) {
   const { execSync: execSync2 } = await import('child_process');
-  const { existsSync: existsSync20, readFileSync: readFileSync12, writeFileSync: writeFileSync7 } = await import('fs');
+  const { existsSync: existsSync21, readFileSync: readFileSync12, writeFileSync: writeFileSync7 } = await import('fs');
   const gitignorePath = path22__default.join(resolved, ".gitignore");
   const entries = [
     "node_modules/",
@@ -12377,11 +12615,15 @@ async function initGitScaffold(resolved, created) {
     ".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 = existsSync20(gitignorePath) ? readFileSync12(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) {
@@ -12390,7 +12632,7 @@ async function initGitScaffold(resolved, created) {
 `);
     if (!existing) created.push(".gitignore");
   }
-  if (!existsSync20(path22__default.join(resolved, ".git"))) {
+  if (!existsSync21(path22__default.join(resolved, ".git"))) {
     try {
       execSync2("git init", { cwd: resolved, stdio: "pipe" });
       created.push(".git/");
@@ -12402,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 }
@@ -12420,7 +12662,7 @@ async function bootstrapUserConfig() {
 }
 async function hydrateInitSources(resolved, created) {
   try {
-    const { ensureSourcesCloned } = await import('../ensure-sources-POMEQSTM.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) {
@@ -12460,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-5IRUH5OS.js');
+  const { cmdSetup } = await import('../setup-L632QIHV.js');
   await cmdSetup([], { projectDir: process.cwd() });
 });
 program.addCommand(makeInstallCommand());