@skaile/workspaces 0.44.0 → 0.46.0

package/dist/cli/index.js

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
-import { openCatalogSource, openLibraryManager, createFullRegistry, openLibrary } from '../chunk-PCXU2CVW.js';
+import { openCatalogSource, openLibraryManager, createFullRegistry, openLibrary } from '../chunk-FAALG3QN.js';
 import { logErr, S, logOk, logInfo, colorRef, logWarn, kindColorPad, kindColor, formatRelativeTime, fitWidth } from '../chunk-GYPA2Q7F.js';
-import { getStoreConfig, storeFetch, saveStoreTokens, clearStoreTokens, isStoreAuthenticated } from '../chunk-XF2BBX6P.js';
-import { AI_RESOURCES, aiResourceRoots } from '../chunk-ETDXTGDF.js';
+import { getStoreConfig, storeFetch, saveStoreTokens, clearStoreTokens, isStoreAuthenticated } from '../chunk-Z3ZRI2AE.js';
+import { AI_RESOURCES, aiResourceRoots } from '../chunk-HOEP5CJQ.js';
 import { LocalSecretsProvider } from '../chunk-6BEGKO2Q.js';
-import { resolveLibraryDir, LocalCatalogSource } from '../chunk-ZAEJ33Y6.js';
-import '../chunk-5FVJXQDP.js';
+import { resolveLibraryDir, LocalCatalogSource } from '../chunk-LLOXWWB6.js';
+import '../chunk-JXHULIOA.js';
 import '../chunk-JXT46QFC.js';
 import '../chunk-UKJMQZV6.js';
 import '../chunk-R7FOF242.js';
-import { runFlow, resumeFlow } from '../chunk-7NQXVBCQ.js';
+import { runFlow, resumeFlow } from '../chunk-TKTXIAG5.js';
 import '../chunk-4R6DROGN.js';
 import { validateFlowVersions, parseSkillFrontmatter } from '../chunk-GXC3TYMQ.js';
-import { runAgentChat, loadSessionById, loadSession, listSessions, setCurrentSession, deleteSession, clearSession, loadAgentManifest, compileComposition, MarkdownStreamer, resolveMixin } from '../chunk-5LHPKVGR.js';
-import { buildClaudePluginFiles } from '../chunk-NHLXS2CH.js';
+import { runAgentChat, loadSessionById, loadSession, listSessions, setCurrentSession, deleteSession, clearSession, loadAgentManifest, compileComposition, MarkdownStreamer, resolveMixin } from '../chunk-FX4BDEUN.js';
+import { buildClaudePluginFiles } from '../chunk-PPSRBFYE.js';
 import '../chunk-X5YPJV4N.js';
 import '../chunk-O7SG5PC2.js';
 import '../chunk-7QBNJTTQ.js';
@@ -28,59 +28,514 @@ import '../chunk-BMQKMOQY.js';
 import '../chunk-GAH4YRCI.js';
 import '../chunk-OCAQH66V.js';
 import '../chunk-LV2HPH3C.js';
-import '../chunk-LMRO2QNF.js';
+import '../chunk-3VT2I7IA.js';
 import '../chunk-OVRSNIKJ.js';
-import '../chunk-CBZEIFU4.js';
+import '../chunk-DDR4OSSM.js';
 import '../chunk-FYLIR4AV.js';
 import '../chunk-6E6PKKAD.js';
 import { loadFlow, loadAllFlows } from '../chunk-X46FY45B.js';
 import '../chunk-DEYYRFQU.js';
 import '../chunk-IFGTRL2I.js';
-import { AssetManager, NON_DEPLOYABLE_KINDS } from '../chunk-JUZLVRI4.js';
-import '../chunk-CVWA4RIK.js';
-import { readLock, resolveSettings, globalSettingsPath, projectSettingsPath, loadSettings, saveSettings, portableSpawn, portableSpawnSync, WorkspaceYamlEditor } from '../chunk-BLGHFVXE.js';
+import { AssetManager, NON_DEPLOYABLE_KINDS, MissingManifestError } from '../chunk-CNP2FHRM.js';
+import '../chunk-4VPRAG35.js';
+import { readLock, resolveSettings, globalSettingsPath, projectSettingsPath, loadSettings, saveSettings, portableSpawn, portableSpawnSync, WorkspaceYamlEditor, checkAgentSkillConformance } from '../chunk-G3GODNHM.js';
 import { assetSearchDirs, detectDomains } from '../chunk-ZAP2BDHG.js';
-import '../chunk-VPXV2Z5E.js';
-import { globalCacheRoot, getGlobalCacheDir, resolveAgentDir, findWorkspaceRoot, workspaceConfigFilename, resolveSkWorkspaceConfig } from '../chunk-COSTF7QW.js';
-import { SKAILE_MANIFEST_FILENAME, decodeSkaileManifest } from '../chunk-DZCK7GRW.js';
+import '../chunk-3VBQJZYL.js';
+import { globalCacheRoot, sourceCacheKey, getGlobalCacheDir, resolveAgentDir, sourceShortName, findWorkspaceRoot, workspaceConfigFilename, resolveSkWorkspaceConfig } from '../chunk-WTFJFW7F.js';
+import { SKAILE_MANIFEST_FILENAME, decodeSkaileManifest, loadSkPublishManifest, saveSkPublishManifest } from '../chunk-DZCK7GRW.js';
 import { parseFrontmatter } from '../chunk-6IDBWPK2.js';
-import { parseAssetRef, ASSET_KINDS, isValidAssetName, ASSET_NAME_HINT, assetRefToStr } from '../chunk-GEEW6SY2.js';
+import { parseAssetRef, ASSET_KINDS, isValidAssetName, slugifyAssetName, ASSET_NAME_HINT, assetRefToStr } from '../chunk-GEEW6SY2.js';
 import '../chunk-XGCXFX7X.js';
 import { SUPPORTED_DRIVER_TARGETS } from '../chunk-O4JH3KUE.js';
 import { DRIVER_DEFAULTS } from '../chunk-K5GBV4SA.js';
 import { openSqlite } from '../chunk-JB35MVBN.js';
 import '../chunk-KTBKW2FI.js';
 import '../chunk-UQ6LFBPZ.js';
-import '../chunk-XUXVH3JK.js';
-import '../chunk-RGPBEGP2.js';
+import '../chunk-WRBF34YE.js';
+import '../chunk-CU5Z7GH3.js';
 import '../chunk-CGYEHQOX.js';
 import '../chunk-NSBPE2FW.js';
-import * as fs11 from 'fs';
-import fs11__default, { readFileSync, existsSync, writeFileSync, lstatSync, rmSync, readdirSync, statSync } from 'fs';
-import * as path13 from 'path';
-import path13__default, { resolve, join } from 'path';
+import * as fs12 from 'fs';
+import fs12__default, { readFileSync, existsSync, mkdirSync, writeFileSync, lstatSync, rmSync, readdirSync, statSync } from 'fs';
+import * as path14 from 'path';
+import path14__default, { resolve, join } from 'path';
 import { fileURLToPath } from 'url';
 import { Help, Command, Option } from 'commander';
-import { homedir } from 'os';
 import * as p6 from '@clack/prompts';
 import pc5 from 'picocolors';
+import * as os from 'os';
+import { homedir } from 'os';
+import { parse, stringify } from 'yaml';
 import * as readline from 'readline';
 import { createInterface } from 'readline';
-import fs5 from 'fs/promises';
-import { parse as parse$1, stringify } from 'smol-toml';
+import fs6 from 'fs/promises';
+import { parse as parse$1, stringify as stringify$1 } from 'smol-toml';
 import { execSync, spawnSync } from 'child_process';
 import { createTRPCUntypedClient, httpLink, httpSubscriptionLink } from '@trpc/client';
-import { parse } from 'yaml';
 
+async function runSearch(kind, query, opts) {
+  if (kind?.includes(":")) {
+    query = kind;
+    kind = void 0;
+  }
+  const showLocal = !opts.store;
+  const showStore = !opts.local;
+  if (showLocal) {
+    searchLocal(query, kind, opts, showStore);
+  }
+  if (showStore) {
+    await searchStore(query, kind, opts);
+  }
+}
+function searchLocal(query, kind, opts, showStore) {
+  const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
+  const entries = am2.search(query, kind);
+  if (entries.length === 0) {
+    if (!showStore) {
+      logInfo(
+        query ? `No entries matching "${query}".` : "No assets found. Run `skaile source sync` first."
+      );
+    }
+    return;
+  }
+  if (showStore) {
+    console.log(`
+  ${S.heading("Local:")}`);
+  }
+  printLocalEntries(entries);
+}
+function printLocalEntries(entries) {
+  const byKind = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    if (!byKind.has(e.kind)) byKind.set(e.kind, []);
+    byKind.get(e.kind).push(e);
+  }
+  for (const [k, items] of byKind) {
+    const nameW = Math.max(4, ...items.map((e) => e.name.length));
+    console.log();
+    console.log(
+      `  ${kindColor(k)} ${S.heading(`${k.toUpperCase()}S`)} ${S.dim(`(${items.length})`)}`
+    );
+    console.log(`  ${S.rule(nameW + 62)}`);
+    for (const e of items) {
+      const ver = e.version ? S.dim(` v${e.version}`) : "";
+      console.log(`  ${S.cmd(e.name.padEnd(nameW))}  ${e.description.slice(0, 60)}${ver}`);
+    }
+  }
+  console.log(`
+  ${S.dim(`${entries.length} total`)}
+`);
+}
+async function searchStore(query, kind, opts) {
+  try {
+    const { getStoreConfig: getStoreConfig2, storeFetch: storeFetch2 } = await import('../store-client-U4FMAIWX.js');
+    const config = getStoreConfig2();
+    const params = {};
+    if (query) params.q = query;
+    if (kind) params.kind = kind;
+    const storeRes = await storeFetch2(config, "/api/assets", { params });
+    if (storeRes.results.length > 0) {
+      console.log(`
+  ${S.heading("Store:")}`);
+      for (const asset of storeRes.results) {
+        const ref = `${asset.kind}:@${asset.publisher}/${asset.slug}`;
+        console.log(
+          `    \u2B21 ${kindColorPad(asset.kind)}  ${colorRef(ref).padEnd(40)}  ${S.dim(asset.description?.slice(0, 50) || "")}  ${S.dim(`\u2193${asset.downloads}`)}`
+        );
+      }
+    } else if (opts.store) {
+      logInfo("No results in store");
+    }
+  } catch (e) {
+    if (opts.store) {
+      logErr(`Store search failed: ${e.message}`);
+    }
+  }
+}
+function makeSearchCommand() {
+  return new Command("search").description("Search across all repos").argument("[kind]", "Filter by asset kind").argument("[query]", "Search query").option("--project-dir <path>", "Project directory", process.cwd()).option("--store", "Search only the store").option("--local", "Search only local repos").action(async (kind, query, opts) => {
+    await runSearch(kind, query, opts);
+  });
+}
+function makeAddCommand() {
+  return new Command("add").description("Add to skaile.yaml + deploy").argument("<ref>", "Asset reference (kind:@<publisher>/name#<version>)").option("--project-dir <path>", "Project directory", process.cwd()).option("--global", "Deploy to global dir (~/.claude)").option("--target <agent>", "Driver target", "claude-code").action(async (ref, opts) => {
+    const am2 = new AssetManager({
+      projectDir: path14__default.resolve(opts.projectDir),
+      global: opts.global,
+      driverTarget: opts.target
+    });
+    const spinner5 = p6.spinner();
+    spinner5.start(`Adding ${ref}`);
+    try {
+      const added = await am2.add(ref);
+      spinner5.stop("Done");
+      if (added.length === 0) {
+        const kind = parseAssetRef(ref).kind;
+        if (NON_DEPLOYABLE_KINDS.has(kind))
+          logInfo(
+            `Recorded in skaile.yaml. ${kind} assets are not deployed into the driver target \u2014 they are wired when skaile runs the agent.`
+          );
+        else logInfo("Nothing to deploy (already up to date).");
+      } else for (const a of added) logOk(a);
+    } catch (err) {
+      spinner5.stop("Failed");
+      logErr(String(err));
+      process.exit(1);
+    }
+  });
+}
+function makeRemoveCommand() {
+  return new Command("remove").description("Remove from skaile.yaml + undeploy").argument("<ref>", "Asset reference (kind:name)").option("--project-dir <path>", "Project directory", process.cwd()).option("--global", "Remove from global dir").option("--target <agent>", "Driver target", "claude-code").action((ref, opts) => {
+    const am2 = new AssetManager({
+      projectDir: path14__default.resolve(opts.projectDir),
+      global: opts.global,
+      driverTarget: opts.target
+    });
+    const ok = am2.remove(ref);
+    if (ok) logOk(`Removed ${ref}`);
+    else logErr(`Not deployed: ${ref}`);
+  });
+}
+function stateLabel(s) {
+  if (s === "installed") return S.ok(s);
+  if (s === "drift") return S.warn(s);
+  if (s === "invalid") return S.err(s);
+  return S.dim(s);
+}
+function makeListCommand() {
+  return new Command("list").description("List declared dependencies from skaile.yaml with state").argument("[kind]", "Filter by asset kind").option("--project-dir <path>", "Project directory", process.cwd()).option("-g, --global", "Inspect the global deployment dir for state").option("--json", "Output as JSON").addOption(
+    new Option("--target <agent>", "Driver target").default("claude-code").choices(SUPPORTED_DRIVER_TARGETS)
+  ).action((kind, opts) => {
+    const am2 = new AssetManager({
+      projectDir: path14__default.resolve(opts.projectDir),
+      global: opts.global,
+      driverTarget: opts.target
+    });
+    let declared;
+    try {
+      declared = am2.listDeclared(kind);
+    } catch (err) {
+      if (err instanceof MissingManifestError)
+        logErr(`No ${S.cmd("skaile.yaml")} found. Run ${S.cmd("skaile init")} to create one.`);
+      else logErr(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(declared, null, 2));
+      return;
+    }
+    if (declared.length === 0) {
+      logInfo("No dependencies declared in skaile.yaml.");
+      return;
+    }
+    const kindW = Math.max(4, ...declared.map((e) => e.kind.length));
+    const nameW = Math.max(4, ...declared.map((e) => e.name.length));
+    console.log();
+    console.log(
+      `  ${S.dim("KIND".padEnd(kindW))}  ${S.dim("NAME".padEnd(nameW))}  ${S.dim("STATE")}`
+    );
+    console.log(`  ${S.rule(kindW + nameW + 4 + "installed".length)}`);
+    for (const e of declared) {
+      console.log(
+        `  ${kindColorPad(e.kind, kindW)}  ${e.name.padEnd(nameW)}  ${stateLabel(e.state)}`
+      );
+    }
+    console.log(`
+  ${S.dim(`${declared.length} declared`)}`);
+    const drift = declared.filter((e) => e.state === "drift").length;
+    if (drift > 0)
+      logInfo(`${drift} with drift \u2014 run ${S.cmd("skaile install")} to materialize.`);
+    const invalid = declared.filter((e) => e.state === "invalid").length;
+    if (invalid > 0)
+      logInfo(`${invalid} invalid \u2014 fix the ${S.cmd("skaile.yaml")} dependencies entry.`);
+    console.log();
+  });
+}
+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((ref, opts) => {
+    const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
+    const entry = am2.info(ref);
+    if (!entry) {
+      logErr(
+        `'${ref}' not found. Run ${S.cmd("skaile source sync")} then ${S.cmd("skaile search")}.`
+      );
+      process.exit(1);
+    }
+    console.log();
+    console.log(`  ${S.heading(entry.name)}`);
+    console.log(`  ${S.rule(40)}`);
+    console.log(`  kind:        ${kindColor(entry.kind)}`);
+    if (entry.version) console.log(`  version:     ${entry.version}`);
+    if (entry.description) console.log(`  description: ${entry.description}`);
+    if (entry.publisher) console.log(`  repository:  ${S.dim(entry.publisher)}`);
+    console.log(`  source:      ${S.dim(entry.source)}`);
+    if (entry.requires.length) {
+      console.log(`  requires:`);
+      for (const d of entry.requires)
+        console.log(`    ${S.dim("\xB7")}  ${kindColor(d.kind)}:${d.name}`);
+    }
+    if (entry.dependencies.length) {
+      console.log(`  dependencies:`);
+      for (const s of entry.dependencies) console.log(`    ${S.dim("\xB7")}  ${colorRef(s)}`);
+    }
+    console.log();
+  });
+}
+function makeCreateCommand() {
+  return new Command("create").description("Scaffold a new asset").argument("<name>", "Asset name").addOption(
+    new Option("-k, --kind <kind>", "Asset kind").default("skill").choices([...ASSET_KINDS])
+  ).option("-d, --dir <dir>", "Target directory (default: cwd)").action((name, opts) => {
+    const am2 = new AssetManager({ projectDir: process.cwd() });
+    const destDir = opts.dir ? path14__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 {
+      logErr(result.path);
+      process.exit(1);
+    }
+  });
+}
+function makeDoctorCommand() {
+  return new Command("doctor").description("Scan for missing dependency chains").argument("[name]", "Check a specific asset (kind:name)").option("--project-dir <path>", "Project directory", process.cwd()).action((name, opts) => {
+    const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
+    const issues = am2.doctor();
+    if (issues.length === 0) {
+      logOk("No missing dependencies.");
+      return;
+    }
+    const assetW = Math.max(5, ...issues.map((i) => `${i.assetKind}:${i.assetName}`.length));
+    const depW = Math.max(11, ...issues.map((i) => `${i.depKind}:${i.depName}`.length));
+    console.log();
+    console.log(
+      `  ${S.dim("ASSET".padEnd(assetW))}  ${S.dim("MISSING DEP".padEnd(depW))}  ${S.dim("IN REPOS")}`
+    );
+    console.log(`  ${S.rule(assetW + depW + 15)}`);
+    for (const i of issues) {
+      const asset = `${i.assetKind}:${i.assetName}`;
+      const dep = `${i.depKind}:${i.depName}`;
+      const status4 = i.inRepos ? S.warn("fixable") : S.err("not found");
+      console.log(`  ${asset.padEnd(assetW)}  ${dep.padEnd(depW)}  ${status4}`);
+    }
+    console.log();
+  });
+}
+var DEFAULT_IMPORT_VERSION = "0.1.0";
+var DEFAULT_IMPORT_STAGE = "alpha";
+function claudeSkillRoots() {
+  const roots = [];
+  const override = process.env.SKAILE_CLAUDE_SKILLS_DIR;
+  if (override) roots.push(override);
+  roots.push(path14.join(os.homedir(), ".claude", "skills"));
+  return roots;
+}
+function resolveImportSource(nameOrPath) {
+  const asPath = path14.resolve(nameOrPath);
+  if (fs12.existsSync(asPath)) {
+    const dir = fs12.statSync(asPath).isDirectory() ? asPath : path14.dirname(asPath);
+    const skillFile = path14.join(dir, "SKILL.md");
+    if (fs12.existsSync(skillFile)) return { dir, skillFile, via: "path" };
+  }
+  if (!nameOrPath.includes(path14.sep) && !nameOrPath.startsWith(".")) {
+    for (const root of claudeSkillRoots()) {
+      const dir = path14.join(root, nameOrPath);
+      const skillFile = path14.join(dir, "SKILL.md");
+      if (fs12.existsSync(skillFile)) return { dir, skillFile, via: "claude-skills" };
+    }
+  }
+  return null;
+}
+function normalizeSkillContent(raw, opts = {}) {
+  const notes = [];
+  const { data, body } = parseFrontmatter(raw);
+  const rawName = typeof data.name === "string" && data.name.trim() ? data.name.trim() : void 0;
+  const sourceName = rawName ?? opts.fallbackName ?? "";
+  let name = sourceName;
+  let originalName;
+  if (!sourceName) {
+    throw new Error("skill has no `name` in frontmatter and no fallback was provided");
+  }
+  if (!isValidAssetName(sourceName)) {
+    name = slugifyAssetName(sourceName);
+    originalName = sourceName;
+    notes.push(`renamed "${sourceName}" \u2192 "${name}" (canonical kebab-case)`);
+  }
+  const existingMeta = data.metadata && typeof data.metadata === "object" && !Array.isArray(data.metadata) ? { ...data.metadata } : {};
+  if (existingMeta.version == null) {
+    existingMeta.version = opts.version ?? DEFAULT_IMPORT_VERSION;
+    notes.push(`stamped metadata.version: ${existingMeta.version}`);
+  }
+  if (existingMeta.stage == null) {
+    existingMeta.stage = opts.stage ?? DEFAULT_IMPORT_STAGE;
+    notes.push(`stamped metadata.stage: ${existingMeta.stage}`);
+  }
+  if (existingMeta.tags == null) {
+    const keywords = Array.isArray(data.keywords) ? data.keywords : [];
+    existingMeta.tags = keywords.filter((k) => typeof k === "string");
+    if (existingMeta.tags.length > 0) {
+      notes.push("promoted top-level keywords \u2192 metadata.tags");
+    }
+  }
+  const ordered = { name };
+  if (data.description != null) ordered.description = data.description;
+  ordered.metadata = existingMeta;
+  for (const [k, v] of Object.entries(data)) {
+    if (k === "name" || k === "description" || k === "metadata" || k === "keywords") continue;
+    ordered[k] = v;
+  }
+  const fm = stringify(ordered).trimEnd();
+  const content = `---
+${fm}
+---
+
+${body}
+`;
+  const changed = notes.length > 0;
+  return { content, name, originalName, changed, notes };
+}
+var DOMAIN_TEMPLATE = (name, publisher, description) => {
+  const fm = stringify({ name, publisher, description }).trimEnd();
+  return `---
+${fm}
+---
+
+# ${name}
+
+${description}
+`;
+};
+function ensureDomain(libraryPath, domain, opts = {}) {
+  const dir = path14.join(libraryPath, domain);
+  const domainFile = path14.join(dir, "DOMAIN.md");
+  const publisher = opts.publisher ?? slugifyAssetName(domain);
+  if (fs12.existsSync(domainFile)) {
+    return { dir, publisher, created: false };
+  }
+  fs12.mkdirSync(dir, { recursive: true });
+  const description = opts.description ?? `The ${domain} domain.`;
+  fs12.writeFileSync(domainFile, DOMAIN_TEMPLATE(domain, publisher, description), "utf8");
+  return { dir, publisher, created: true };
+}
+function listDomains(libraryPath) {
+  if (!fs12.existsSync(libraryPath)) return [];
+  return fs12.readdirSync(libraryPath, { withFileTypes: true }).filter((e) => e.isDirectory() && fs12.existsSync(path14.join(libraryPath, e.name, "DOMAIN.md"))).map((e) => e.name).sort();
+}
+function upsertManifestAsset(libraryPath, input) {
+  const manifest = loadSkPublishManifest(libraryPath) ?? { assets: [] };
+  const assets = Array.isArray(manifest.assets) ? [...manifest.assets] : [];
+  const entry = { kind: input.kind, name: input.name, root: input.root };
+  if (input.version) entry.version = input.version;
+  if (input.publisher) entry.publisher = input.publisher;
+  if (input.description) entry.description = input.description;
+  if (input.keywords && input.keywords.length > 0) entry.keywords = input.keywords;
+  const idx = assets.findIndex((a) => a.kind === input.kind && a.name === input.name);
+  const added = idx < 0;
+  if (added) {
+    assets.push(entry);
+  } else {
+    assets[idx] = { ...assets[idx], ...entry };
+  }
+  const manifestPath = saveSkPublishManifest(libraryPath, { ...manifest, assets });
+  return { manifestPath, added };
+}
+
+// cli/src/commands/asset-cmd.ts
 function makeAssetCommand() {
   const cmd = new Command("asset").description("Author and install AI assets");
+  cmd.command("import <name-or-path>").description("Import + skailify an existing coding-agent skill into a library").option("--to <library>", "Target library (default: auto / personal)").option("--domain <name>", "Place under this domain's skills/ (created if missing)").option("--version <semver>", "Version to stamp when the skill ships none").option("--stage <stage>", "Lifecycle stage to stamp (default: alpha)").option("--no-normalize", "Copy verbatim \u2014 skip frontmatter normalization").option("--commit", "Auto-commit in git-backed libraries", false).action(
+    async (nameOrPath, opts) => {
+      const src = resolveImportSource(nameOrPath);
+      if (!src) {
+        logErr(
+          `No skill found for "${nameOrPath}". Pass a path to a SKILL.md dir, or a bare name present under ~/.claude/skills/.`
+        );
+        process.exit(1);
+      }
+      logInfo(`Source: ${S.dim(src.dir)} (${src.via})`);
+      const { manager, close } = await openLibraryManager();
+      try {
+        let target;
+        if (opts.to) {
+          target = await manager.requireLibrary(opts.to);
+        } else {
+          const all = await manager.listLibraries();
+          const def = all.find(
+            (l) => l.isDefault && (l.ownership === "owner" || l.ownership === "contributor")
+          );
+          target = def ?? (await manager.ensurePersonalLibrary(resolveLibraryDir())).library;
+        }
+        if (target.ownership === "reader") {
+          logErr(`Library "${target.name}" is read-only (ownership=reader). Choose --to.`);
+          process.exit(1);
+        }
+        const rawSkill = fs12.readFileSync(src.skillFile, "utf8");
+        const norm = opts.normalize ? normalizeSkillContent(rawSkill, {
+          fallbackName: path14.basename(src.dir),
+          version: opts.version,
+          stage: opts.stage
+        }) : { content: rawSkill, name: path14.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.`
+          );
+        }
+        let destParent = target.path;
+        let publisher;
+        if (opts.domain) {
+          const dom = ensureDomain(target.path, opts.domain);
+          if (dom.created) logOk(`Scaffolded domain ${S.cmd(opts.domain)} \u2192 ${dom.dir}`);
+          destParent = path14.join(dom.dir, "skills");
+          publisher = dom.publisher;
+        }
+        fs12.mkdirSync(destParent, { recursive: true });
+        const destDir = path14.join(destParent, norm.name);
+        if (fs12.existsSync(destDir)) {
+          logErr(`Destination already exists: ${destDir}`);
+          process.exit(1);
+        }
+        fs12.cpSync(src.dir, destDir, { recursive: true });
+        fs12.writeFileSync(path14.join(destDir, "SKILL.md"), norm.content, "utf8");
+        for (const note of norm.notes) logInfo(`  \u2022 ${note}`);
+        const fm = parseFrontmatter(norm.content).data;
+        const descRaw = fm.description;
+        const description = typeof descRaw === "string" ? descRaw.trim() : void 0;
+        for (const f of checkAgentSkillConformance(fm, { dirName: norm.name })) {
+          logWarn(`conformance: ${f.field} \u2014 ${f.message}`);
+        }
+        const root = path14.relative(target.path, destDir);
+        const up = upsertManifestAsset(target.path, {
+          kind: "skill",
+          name: norm.name,
+          root,
+          version: opts.version,
+          publisher,
+          description
+        });
+        logOk(`${up.added ? "Added" : "Updated"} manifest entry skill:${norm.name}`);
+        if (target.backend === "git" && opts.commit) {
+          const { spawnSync: spawnSync2 } = await import('child_process');
+          spawnSync2("git", ["add", "--", destDir], { cwd: target.path, stdio: "inherit" });
+          const r = spawnSync2("git", ["commit", "-m", `skaile: import ${norm.name}`], {
+            cwd: target.path,
+            stdio: "inherit"
+          });
+          if (r.status !== 0) {
+            logWarn("Nothing committed (working tree clean or commit aborted).");
+          }
+        }
+        logOk(`Imported ${S.cmd(norm.name)} \u2192 ${target.name}`);
+        logInfo(`Verify: ${S.cmd(`skaile validate ${target.path}`)}`);
+      } finally {
+        close();
+      }
+    }
+  );
   cmd.command("migrate <path>").description("Move/copy/link a workspace asset into a library").option("--to <library>", "Target library (default: auto)").option("--domain <name>", "Place inside this domain (domain-structured libs)").option("--mode <mode>", "copy | move | link", "copy").option("--commit", "Auto-commit in git-backed libraries", false).action(
     async (srcPath, opts) => {
       if (!["copy", "move", "link"].includes(opts.mode)) {
         logErr(`Invalid --mode "${opts.mode}". Expected: copy | move | link.`);
         process.exit(1);
       }
-      if (!fs11.existsSync(srcPath)) {
+      if (!fs12.existsSync(srcPath)) {
         logErr(`Source path does not exist: ${srcPath}`);
         process.exit(1);
       }
@@ -107,32 +562,35 @@ function makeAssetCommand() {
           );
           process.exit(1);
         }
-        const basename2 = path13.basename(srcPath);
-        const destDir = target.structure === "domain" && opts.domain ? path13.join(target.path, opts.domain) : target.path;
-        fs11.mkdirSync(destDir, { recursive: true });
-        const destPath = path13.join(destDir, basename2);
-        if (fs11.existsSync(destPath)) {
+        const basename2 = path14.basename(srcPath);
+        const destDir = target.structure === "domain" && opts.domain ? path14.join(target.path, opts.domain) : target.path;
+        fs12.mkdirSync(destDir, { recursive: true });
+        const destPath = path14.join(destDir, basename2);
+        if (fs12.existsSync(destPath)) {
           logErr(`Destination already exists: ${destPath}`);
           process.exit(1);
         }
         switch (opts.mode) {
           case "copy":
-            fs11.cpSync(srcPath, destPath, { recursive: true });
+            fs12.cpSync(srcPath, destPath, { recursive: true });
             break;
           case "move":
-            fs11.renameSync(srcPath, destPath);
+            fs12.renameSync(srcPath, destPath);
             break;
           case "link":
-            fs11.symlinkSync(path13.resolve(srcPath), destPath);
+            fs12.symlinkSync(path14.resolve(srcPath), destPath);
             break;
         }
         if (target.backend === "git" && opts.commit) {
           const { spawnSync: spawnSync2 } = await import('child_process');
-          spawnSync2("git", ["add", "-A"], { cwd: target.path, stdio: "ignore" });
-          spawnSync2("git", ["commit", "-m", `skaile: migrate ${basename2}`], {
+          spawnSync2("git", ["add", "--", destPath], { cwd: target.path, stdio: "inherit" });
+          const r = spawnSync2("git", ["commit", "-m", `skaile: migrate ${basename2}`], {
             cwd: target.path,
-            stdio: "ignore"
+            stdio: "inherit"
           });
+          if (r.status !== 0) {
+            logWarn("Nothing committed (working tree clean or commit aborted).");
+          }
         }
         logOk(`Migrated ${basename2} \u2192 ${target.name} (${opts.mode})`);
         if (opts.mode === "move") {
@@ -157,7 +615,7 @@ function makeAssetCommand() {
       try {
         const def = await library.getAssetDef(ref);
         if (!def) {
-          logErr(`No asset found for ref "${ref}". Try \`skaile asset list\`.`);
+          logErr(`No asset found for ref "${ref}". Try \`skaile search\`.`);
           process.exit(1);
         }
         const target = opts.target ?? process.cwd();
@@ -171,17 +629,17 @@ function makeAssetCommand() {
         }
         const manifestPath = def.manifest.path;
         const candidateSubpath = typeof manifestPath === "string" && manifestPath.length > 0 ? manifestPath : def.name;
-        const srcPath = path13.join(lib.path, candidateSubpath);
-        if (!fs11.existsSync(srcPath)) {
+        const srcPath = path14.join(lib.path, candidateSubpath);
+        if (!fs12.existsSync(srcPath)) {
           logErr(`Asset path not found: ${srcPath}`);
           process.exit(1);
         }
-        const destPath = path13.join(target, candidateSubpath);
-        fs11.mkdirSync(path13.dirname(destPath), { recursive: true });
+        const destPath = path14.join(target, candidateSubpath);
+        fs12.mkdirSync(path14.dirname(destPath), { recursive: true });
         if (opts.mode === "copy") {
-          fs11.cpSync(srcPath, destPath, { recursive: true });
+          fs12.cpSync(srcPath, destPath, { recursive: true });
         } else {
-          fs11.symlinkSync(path13.resolve(srcPath), destPath);
+          fs12.symlinkSync(path14.resolve(srcPath), destPath);
         }
         logOk(`Installed ${ref} \u2192 ${destPath} (${opts.mode})`);
       } finally {
@@ -189,29 +647,7 @@ function makeAssetCommand() {
       }
     }
   );
-  cmd.command("list").description("List asset definitions across libraries").option("--library <name>", "Filter by library").option("--domain <name>", "Filter by domain").option("--kind <kind>", "Filter by kind").option("--json", "Output as JSON").action(async (opts) => {
-    const { manager, library, close } = await openLibraryManager();
-    try {
-      let defs = await library.listAssetDefs(opts.kind ? { kind: opts.kind } : void 0);
-      if (opts.library) {
-        const lib = await manager.requireLibrary(opts.library);
-        defs = defs.filter((d) => d.libraryId === lib.id);
-      }
-      if (opts.json) return console.log(JSON.stringify(defs, null, 2));
-      if (defs.length === 0) {
-        logInfo("No assets cached. Run `skaile library sync <name>` first.");
-        return;
-      }
-      for (const d of defs) {
-        console.log(`  ${S.cmd(d.id.padEnd(40))}  ${d.kind.padEnd(10)}  ${d.description ?? ""}`);
-      }
-      console.log(`
-  ${S.dim(`${defs.length} asset(s)`)}
-`);
-    } finally {
-      close();
-    }
-  });
+  cmd.addCommand(makeListCommand());
   cmd.command("show <ref>").description("Show details for an asset by canonical ref").action(async (ref) => {
     const { library, close } = await openLibraryManager();
     try {
@@ -237,354 +673,136 @@ function makeAuthCommand() {
     const health = await provider.testConnection();
     if (health.ok) {
       logOk(`Local provider: healthy (${health.latencyMs}ms)`);
-    } else {
-      logErr(`Local provider: ${health.error ?? "unhealthy"}`);
-    }
-  });
-  cmd.command("set-key-strategy").description("Set the master key strategy (keychain, passphrase, or machine)").argument("<strategy>", `One of: ${VALID_STRATEGIES.join(", ")}`).option(
-    "--passphrase <value>",
-    "Passphrase value (required for passphrase strategy; alternative to SKAILE_SECRETS_PASSPHRASE env var)"
-  ).action(async (strategy, opts) => {
-    if (!VALID_STRATEGIES.includes(strategy)) {
-      logErr(`Invalid strategy "${strategy}". Must be one of: ${VALID_STRATEGIES.join(", ")}`);
-      process.exit(1);
-    }
-    if (strategy === "passphrase" && !opts.passphrase && !process.env.SKAILE_SECRETS_PASSPHRASE) {
-      logErr(
-        "Passphrase required. Provide via --passphrase or set SKAILE_SECRETS_PASSPHRASE:\n  export SKAILE_SECRETS_PASSPHRASE='...'\n  skaile auth set-key-strategy passphrase"
-      );
-      process.exit(1);
-    }
-    const provider = new LocalSecretsProvider();
-    try {
-      await provider.setKeyStrategy(strategy, opts.passphrase);
-      logOk(`Key strategy set to: ${strategy}`);
-    } catch (e) {
-      logErr(`Failed to set strategy: ${e instanceof Error ? e.message : String(e)}`);
-      process.exit(1);
-    }
-  });
-  return cmd;
-}
-function collectCacheTargets(scope) {
-  const out = [];
-  out.push(path13__default.join(scope.projectDir, ".skaile", "cache"));
-  out.push(path13__default.join(scope.projectDir, ".skaile", "store-cache"));
-  out.push(path13__default.join(scope.projectDir, ".skaile", "repos"));
-  if (scope.global) {
-    out.push(globalCacheRoot());
-    const home = process.env.SKAILE_HOME ?? path13__default.join(homedir(), ".skaile");
-    out.push(path13__default.join(home, "repos"));
-    out.push(path13__default.join(home, "catalog-cache"));
-  }
-  return out;
-}
-function dirSize(target) {
-  if (!existsSync(target)) return 0;
-  const st = lstatSync(target);
-  if (st.isSymbolicLink()) return 0;
-  if (!st.isDirectory()) return st.size;
-  return dirSizeOfDir(target);
-}
-function dirSizeOfDir(dir) {
-  let total = 0;
-  for (const ent of readdirSync(dir, { withFileTypes: true })) {
-    const child = path13__default.join(dir, ent.name);
-    if (ent.isSymbolicLink()) continue;
-    if (ent.isDirectory()) total += dirSizeOfDir(child);
-    else if (ent.isFile()) total += statSync(child).size;
-  }
-  return total;
-}
-function removeCacheTargets(targets, opts) {
-  const present = targets.filter((t) => existsSync(t));
-  for (const t of present) rmSync(t, { recursive: true, force: true });
-  return present;
-}
-function fmtBytes(n) {
-  const u = ["B", "KB", "MB", "GB"];
-  let i = 0;
-  let v = n;
-  while (v >= 1024 && i < u.length - 1) {
-    v /= 1024;
-    i++;
-  }
-  return `${v.toFixed(i === 0 ? 0 : 1)} ${u[i]}`;
-}
-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: path13__default.resolve(opts.projectDir),
-      global: opts.global
-    }).filter((t) => existsSync(t));
-    if (targets.length === 0) {
-      logInfo("Cache is already empty.");
-      return;
-    }
-    console.log();
-    console.log(`  ${S.heading("Will remove:")}`);
-    for (const t of targets)
-      console.log(`    ${S.dim(t)}  ${S.dim(`(${fmtBytes(dirSize(t))})`)}`);
-    if (opts.dryRun) {
-      console.log();
-      logInfo("Dry run \u2014 no changes made.");
-      return;
-    }
-    if (!opts.yes) {
-      const ok = await p6.confirm({
-        message: opts.global ? "Clear project AND global cache?" : "Clear project cache?"
-      });
-      if (p6.isCancel(ok) || !ok) {
-        logInfo("Cancelled.");
-        return;
-      }
-    }
-    const removed = removeCacheTargets(targets);
-    console.log();
-    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(path13__default.join(path13__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: path13__default.resolve(opts.projectDir),
-      global: opts.global
-    });
-    console.log();
-    for (const t of targets) {
-      if (!existsSync(t)) continue;
-      console.log(`  ${S.dim(fmtBytes(dirSize(t)).padStart(9))}  ${t}`);
-    }
-    console.log();
-  });
-  return cmd;
-}
-async function runSearch(kind, query, opts) {
-  if (kind?.includes(":")) {
-    query = kind;
-    kind = void 0;
-  }
-  const showLocal = !opts.store;
-  const showStore = !opts.local;
-  if (showLocal) {
-    searchLocal(query, kind, opts, showStore);
-  }
-  if (showStore) {
-    await searchStore(query, kind, opts);
-  }
-}
-function searchLocal(query, kind, opts, showStore) {
-  const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
-  const entries = am2.search(query, kind);
-  if (entries.length === 0) {
-    if (!showStore) {
-      logInfo(
-        query ? `No entries matching "${query}".` : "No assets found. Run `skaile source sync` first."
-      );
-    }
-    return;
-  }
-  if (showStore) {
-    console.log(`
-  ${S.heading("Local:")}`);
-  }
-  printLocalEntries(entries);
-}
-function printLocalEntries(entries) {
-  const byKind = /* @__PURE__ */ new Map();
-  for (const e of entries) {
-    if (!byKind.has(e.kind)) byKind.set(e.kind, []);
-    byKind.get(e.kind).push(e);
-  }
-  for (const [k, items] of byKind) {
-    const nameW = Math.max(4, ...items.map((e) => e.name.length));
-    console.log();
-    console.log(
-      `  ${kindColor(k)} ${S.heading(`${k.toUpperCase()}S`)} ${S.dim(`(${items.length})`)}`
-    );
-    console.log(`  ${S.rule(nameW + 62)}`);
-    for (const e of items) {
-      const ver = e.version ? S.dim(` v${e.version}`) : "";
-      console.log(`  ${S.cmd(e.name.padEnd(nameW))}  ${e.description.slice(0, 60)}${ver}`);
-    }
-  }
-  console.log(`
-  ${S.dim(`${entries.length} total`)}
-`);
-}
-async function searchStore(query, kind, opts) {
-  try {
-    const { getStoreConfig: getStoreConfig2, storeFetch: storeFetch2 } = await import('../store-client-XFZFKY3W.js');
-    const config = getStoreConfig2();
-    const params = {};
-    if (query) params.q = query;
-    if (kind) params.kind = kind;
-    const storeRes = await storeFetch2(config, "/api/assets", { params });
-    if (storeRes.results.length > 0) {
-      console.log(`
-  ${S.heading("Store:")}`);
-      for (const asset of storeRes.results) {
-        const ref = `${asset.kind}:@${asset.publisher}/${asset.slug}`;
-        console.log(
-          `    \u2B21 ${kindColorPad(asset.kind)}  ${colorRef(ref).padEnd(40)}  ${S.dim(asset.description?.slice(0, 50) || "")}  ${S.dim(`\u2193${asset.downloads}`)}`
-        );
-      }
-    } else if (opts.store) {
-      logInfo("No results in store");
-    }
-  } catch (e) {
-    if (opts.store) {
-      logErr(`Store search failed: ${e.message}`);
+    } else {
+      logErr(`Local provider: ${health.error ?? "unhealthy"}`);
     }
-  }
-}
-function makeSearchCommand() {
-  return new Command("search").description("Search across all repos").argument("[kind]", "Filter by asset kind").argument("[query]", "Search query").option("--project-dir <path>", "Project directory", process.cwd()).option("--store", "Search only the store").option("--local", "Search only local repos").action(async (kind, query, opts) => {
-    await runSearch(kind, query, opts);
   });
-}
-function makeAddCommand() {
-  return new Command("add").description("Add to skaile.yaml + deploy").argument("<ref>", "Asset reference (kind:name[@repo])").option("--project-dir <path>", "Project directory", process.cwd()).option("--global", "Deploy to global dir (~/.claude)").option("--target <agent>", "Driver target", "claude-code").action(async (ref, opts) => {
-    const am2 = new AssetManager({
-      projectDir: path13__default.resolve(opts.projectDir),
-      global: opts.global,
-      driverTarget: opts.target
-    });
-    const spinner5 = p6.spinner();
-    spinner5.start(`Adding ${ref}`);
+  cmd.command("set-key-strategy").description("Set the master key strategy (keychain, passphrase, or machine)").argument("<strategy>", `One of: ${VALID_STRATEGIES.join(", ")}`).option(
+    "--passphrase <value>",
+    "Passphrase value (required for passphrase strategy; alternative to SKAILE_SECRETS_PASSPHRASE env var)"
+  ).action(async (strategy, opts) => {
+    if (!VALID_STRATEGIES.includes(strategy)) {
+      logErr(`Invalid strategy "${strategy}". Must be one of: ${VALID_STRATEGIES.join(", ")}`);
+      process.exit(1);
+    }
+    if (strategy === "passphrase" && !opts.passphrase && !process.env.SKAILE_SECRETS_PASSPHRASE) {
+      logErr(
+        "Passphrase required. Provide via --passphrase or set SKAILE_SECRETS_PASSPHRASE:\n  export SKAILE_SECRETS_PASSPHRASE='...'\n  skaile auth set-key-strategy passphrase"
+      );
+      process.exit(1);
+    }
+    const provider = new LocalSecretsProvider();
     try {
-      const added = await am2.add(ref);
-      spinner5.stop("Done");
-      if (added.length === 0) {
-        const kind = parseAssetRef(ref).kind;
-        if (NON_DEPLOYABLE_KINDS.has(kind))
-          logInfo(
-            `Recorded in skaile.yaml. ${kind} assets are not deployed into the driver target \u2014 they are wired when skaile runs the agent.`
-          );
-        else logInfo("Nothing to deploy (already up to date).");
-      } else for (const a of added) logOk(a);
-    } catch (err) {
-      spinner5.stop("Failed");
-      logErr(String(err));
+      await provider.setKeyStrategy(strategy, opts.passphrase);
+      logOk(`Key strategy set to: ${strategy}`);
+    } catch (e) {
+      logErr(`Failed to set strategy: ${e instanceof Error ? e.message : String(e)}`);
       process.exit(1);
     }
   });
+  return cmd;
 }
-function makeRemoveCommand() {
-  return new Command("remove").description("Remove from skaile.yaml + undeploy").argument("<ref>", "Asset reference (kind:name)").option("--project-dir <path>", "Project directory", process.cwd()).option("--global", "Remove from global dir").option("--target <agent>", "Driver target", "claude-code").action((ref, opts) => {
-    const am2 = new AssetManager({
-      projectDir: path13__default.resolve(opts.projectDir),
-      global: opts.global,
-      driverTarget: opts.target
-    });
-    const ok = am2.remove(ref);
-    if (ok) logOk(`Removed ${ref}`);
-    else logErr(`Not deployed: ${ref}`);
-  });
+function collectCacheTargets(scope) {
+  const out = [];
+  out.push(path14__default.join(scope.projectDir, ".skaile", "cache"));
+  out.push(path14__default.join(scope.projectDir, ".skaile", "store-cache"));
+  out.push(path14__default.join(scope.projectDir, ".skaile", "repos"));
+  if (scope.global) {
+    out.push(globalCacheRoot());
+    const home = process.env.SKAILE_HOME ?? path14__default.join(homedir(), ".skaile");
+    out.push(path14__default.join(home, "repos"));
+    out.push(path14__default.join(home, "catalog-cache"));
+  }
+  return out;
 }
-function makeListCommand() {
-  return new Command("list").description("List deployed assets").argument("[kind]", "Filter by asset kind").option("--project-dir <path>", "Project directory", process.cwd()).option("-g, --global", "List global deployment").addOption(
-    new Option("--target <agent>", "Driver target").default("claude-code").choices(SUPPORTED_DRIVER_TARGETS)
-  ).action((kind, opts) => {
-    const am2 = new AssetManager({
-      projectDir: path13__default.resolve(opts.projectDir),
-      global: opts.global,
-      driverTarget: opts.target
-    });
-    const deployed = am2.listDeployed(kind);
-    if (deployed.length === 0) {
-      logInfo("Nothing deployed.");
-      return;
-    }
-    const kindW = Math.max(5, ...deployed.map((e) => e.kind.length));
-    const nameW = Math.max(4, ...deployed.map((e) => e.name.length));
-    console.log();
-    console.log(`  ${S.dim("KIND".padEnd(kindW))}  ${S.dim("NAME".padEnd(nameW))}`);
-    console.log(`  ${S.rule(kindW + nameW + 4)}`);
-    for (const e of deployed) {
-      console.log(`  ${kindColorPad(e.kind, kindW)}  ${e.name.padEnd(nameW)}`);
-    }
-    console.log(`
-  ${S.dim(`${deployed.length} deployed`)}
-`);
-  });
+function dirSize(target) {
+  if (!existsSync(target)) return 0;
+  const st = lstatSync(target);
+  if (st.isSymbolicLink()) return 0;
+  if (!st.isDirectory()) return st.size;
+  return dirSizeOfDir(target);
 }
-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((ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
-    const entry = am2.info(ref);
-    if (!entry) {
-      logErr(
-        `'${ref}' not found. Run ${S.cmd("skaile source sync")} then ${S.cmd("skaile search")}.`
-      );
-      process.exit(1);
+function dirSizeOfDir(dir) {
+  let total = 0;
+  for (const ent of readdirSync(dir, { withFileTypes: true })) {
+    const child = path14__default.join(dir, ent.name);
+    if (ent.isSymbolicLink()) continue;
+    if (ent.isDirectory()) total += dirSizeOfDir(child);
+    else if (ent.isFile()) total += statSync(child).size;
+  }
+  return total;
+}
+function removeCacheTargets(targets, opts) {
+  const present = targets.filter((t) => existsSync(t));
+  for (const t of present) rmSync(t, { recursive: true, force: true });
+  return present;
+}
+function fmtBytes(n) {
+  const u = ["B", "KB", "MB", "GB"];
+  let i = 0;
+  let v = n;
+  while (v >= 1024 && i < u.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return `${v.toFixed(i === 0 ? 0 : 1)} ${u[i]}`;
+}
+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: path14__default.resolve(opts.projectDir),
+      global: opts.global
+    }).filter((t) => existsSync(t));
+    if (targets.length === 0) {
+      logInfo("Cache is already empty.");
+      return;
     }
     console.log();
-    console.log(`  ${S.heading(entry.name)}`);
-    console.log(`  ${S.rule(40)}`);
-    console.log(`  kind:        ${kindColor(entry.kind)}`);
-    if (entry.version) console.log(`  version:     ${entry.version}`);
-    if (entry.description) console.log(`  description: ${entry.description}`);
-    if (entry.publisher) console.log(`  repository:  ${S.dim(entry.publisher)}`);
-    console.log(`  source:      ${S.dim(entry.source)}`);
-    if (entry.requires.length) {
-      console.log(`  requires:`);
-      for (const d of entry.requires)
-        console.log(`    ${S.dim("\xB7")}  ${kindColor(d.kind)}:${d.name}`);
+    console.log(`  ${S.heading("Will remove:")}`);
+    for (const t of targets)
+      console.log(`    ${S.dim(t)}  ${S.dim(`(${fmtBytes(dirSize(t))})`)}`);
+    if (opts.dryRun) {
+      console.log();
+      logInfo("Dry run \u2014 no changes made.");
+      return;
     }
-    if (entry.dependencies.length) {
-      console.log(`  dependencies:`);
-      for (const s of entry.dependencies) console.log(`    ${S.dim("\xB7")}  ${colorRef(s)}`);
+    if (!opts.yes) {
+      const ok = await p6.confirm({
+        message: opts.global ? "Clear project AND global cache?" : "Clear project cache?"
+      });
+      if (p6.isCancel(ok) || !ok) {
+        logInfo("Cancelled.");
+        return;
+      }
     }
+    const removed = removeCacheTargets(targets);
     console.log();
+    for (const r of removed) logOk(`Removed ${r}`);
   });
-}
-function makeCreateCommand() {
-  return new Command("create").description("Scaffold a new asset").argument("<name>", "Asset name").addOption(
-    new Option("-k, --kind <kind>", "Asset kind").default("skill").choices([...ASSET_KINDS])
-  ).option("-d, --dir <dir>", "Target directory (default: cwd)").action((name, opts) => {
-    const am2 = new AssetManager({ projectDir: process.cwd() });
-    const destDir = opts.dir ? path13__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 {
-      logErr(result.path);
-      process.exit(1);
-    }
+  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(path14__default.join(path14__default.resolve(opts.projectDir), ".skaile", "cache"));
+    if (opts.global) console.log(globalCacheRoot());
   });
-}
-function makeDoctorCommand() {
-  return new Command("doctor").description("Scan for missing dependency chains").argument("[name]", "Check a specific asset (kind:name)").option("--project-dir <path>", "Project directory", process.cwd()).action((name, opts) => {
-    const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
-    const issues = am2.doctor();
-    if (issues.length === 0) {
-      logOk("No missing dependencies.");
-      return;
-    }
-    const assetW = Math.max(5, ...issues.map((i) => `${i.assetKind}:${i.assetName}`.length));
-    const depW = Math.max(11, ...issues.map((i) => `${i.depKind}:${i.depName}`.length));
+  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: path14__default.resolve(opts.projectDir),
+      global: opts.global
+    });
     console.log();
-    console.log(
-      `  ${S.dim("ASSET".padEnd(assetW))}  ${S.dim("MISSING DEP".padEnd(depW))}  ${S.dim("IN REPOS")}`
-    );
-    console.log(`  ${S.rule(assetW + depW + 15)}`);
-    for (const i of issues) {
-      const asset = `${i.assetKind}:${i.assetName}`;
-      const dep = `${i.depKind}:${i.depName}`;
-      const status4 = i.inRepos ? S.warn("fixable") : S.err("not found");
-      console.log(`  ${asset.padEnd(assetW)}  ${dep.padEnd(depW)}  ${status4}`);
+    for (const t of targets) {
+      if (!existsSync(t)) continue;
+      console.log(`  ${S.dim(fmtBytes(dirSize(t)).padStart(9))}  ${t}`);
     }
     console.log();
   });
+  return cmd;
 }
 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 ? path13__default.resolve(opts.projectDir) : void 0;
+    const projectDir = opts.projectDir ? path14__default.resolve(opts.projectDir) : void 0;
     const cfg = resolveConfig({ projectDir });
     const baseUrl = opts.url ?? cfg.catalog.url;
     if (isLocalCatalogUrl(baseUrl)) {
@@ -602,7 +820,7 @@ function makeCatalogCommand() {
   });
   catalog.command("info").description("Print the resolved catalog configuration (url, framing, cacheTtlMs)").option("--project-dir <path>", "Project directory (for project-level config overlay)").action(async (opts) => {
     const { resolveConfig } = await import('../library/index.js');
-    const projectDir = opts.projectDir ? path13__default.resolve(opts.projectDir) : void 0;
+    const projectDir = opts.projectDir ? path14__default.resolve(opts.projectDir) : void 0;
     const cfg = resolveConfig({ projectDir });
     console.log(`url: ${cfg.catalog.url}`);
     console.log(`framing: ${cfg.catalog.framing}`);
@@ -611,7 +829,7 @@ function makeCatalogCommand() {
   return catalog;
 }
 async function runLocalCatalogTest(projectDir) {
-  const { resolveCatalogSource } = await import('../open-library-362BZ6OW.js');
+  const { resolveCatalogSource } = await import('../open-library-COHFCT4N.js');
   let resolved;
   try {
     resolved = await resolveCatalogSource({ projectDir });
@@ -744,8 +962,8 @@ function findFlowFile(flowId, priorityRoots = []) {
   for (const root of [...priorityRoots, ...aiResourceRoots()]) {
     for (const { dir } of assetSearchDirs(root, "flows")) {
       for (const ext of [".flow.yaml", ".flow.json", ".json"]) {
-        const candidate = path13__default.join(dir, `${flowId}${ext}`);
-        if (fs11__default.existsSync(candidate)) return candidate;
+        const candidate = path14__default.join(dir, `${flowId}${ext}`);
+        if (fs12__default.existsSync(candidate)) return candidate;
       }
     }
   }
@@ -755,7 +973,7 @@ function findSkills(domain) {
   const found = [];
   for (const root of aiResourceRoots()) {
     for (const { dir, domain: dirDomain } of assetSearchDirs(root, "skills")) {
-      if (fs11__default.existsSync(dir)) walkSkills(dir, dirDomain, found);
+      if (fs12__default.existsSync(dir)) walkSkills(dir, dirDomain, found);
     }
   }
   const seen = /* @__PURE__ */ new Set();
@@ -768,11 +986,11 @@ function findSkills(domain) {
   return deduped;
 }
 function walkSkills(dir, domain, out) {
-  for (const entry of fs11__default.readdirSync(dir, { withFileTypes: true })) {
-    const full = path13__default.join(dir, entry.name);
+  for (const entry of fs12__default.readdirSync(dir, { withFileTypes: true })) {
+    const full = path14__default.join(dir, entry.name);
     if (entry.isDirectory()) {
-      const skillMd = path13__default.join(full, "SKILL.md");
-      if (fs11__default.existsSync(skillMd)) {
+      const skillMd = path14__default.join(full, "SKILL.md");
+      if (fs12__default.existsSync(skillMd)) {
         out.push({ name: entry.name, path: full, skillPath: skillMd, domain });
       } else {
         walkSkills(full, domain, out);
@@ -800,10 +1018,10 @@ function resolveFlowIds() {
   }
 }
 function resolveSessionIds(projectDir) {
-  const sessionsDir = path13__default.join(projectDir, ".skaile", "sessions");
-  if (!fs11__default.existsSync(sessionsDir)) return [];
+  const sessionsDir = path14__default.join(projectDir, ".skaile", "sessions");
+  if (!fs12__default.existsSync(sessionsDir)) return [];
   try {
-    return fs11__default.readdirSync(sessionsDir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
+    return fs12__default.readdirSync(sessionsDir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
   } catch {
     return [];
   }
@@ -919,7 +1137,7 @@ function printResolvedPathsSection(config) {
   console.log(`  ${S.label("prompts:".padEnd(16))} ${config.promptsDir ?? paths.promptsDir}`);
 }
 async function showConfig(opts) {
-  const projectDir = opts.projectDir ? path13__default.resolve(opts.projectDir) : process.cwd();
+  const projectDir = opts.projectDir ? path14__default.resolve(opts.projectDir) : process.cwd();
   const config = await resolveSettings(projectDir);
   const wsDefaults = collectWorkspaceDefaults(projectDir);
   printEffectiveSection(config);
@@ -932,13 +1150,13 @@ function makeConfigCommand() {
   const cmd = new Command("config").description("Manage personal config (.skaile/settings.json)");
   cmd.command("show").description("Show effective config with sources").option("--project-dir <path>", "Project directory").action((opts) => showConfig(opts));
   cmd.command("get <key>").description("Get an effective config value").option("--project-dir <path>", "Project directory").action(async (key, opts) => {
-    const projectDir = opts.projectDir ? path13__default.resolve(opts.projectDir) : process.cwd();
+    const projectDir = opts.projectDir ? path14__default.resolve(opts.projectDir) : process.cwd();
     const config = await resolveSettings(projectDir);
     const value = config[key];
     console.log(value ?? S.dim("(not set)"));
   });
   cmd.command("set <key> <value>").description("Set a personal config value (driver, model, provider, 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 ? path13__default.resolve(opts.projectDir) : process.cwd();
+    const projectDir = opts.projectDir ? path14__default.resolve(opts.projectDir) : process.cwd();
     const isApiKey = key.startsWith(API_KEY_PREFIX);
     if (!PERSONAL_KEYS.has(key) && !isApiKey) {
       logErr(
@@ -1053,11 +1271,11 @@ function makeConnectCommand() {
         process.exitCode = 1;
         return;
       }
-      await new Promise((resolve4) => {
+      await new Promise((resolve5) => {
         client.onMessage((event) => {
           console.log(formatEvent(event));
           if (event.type === "finished" || event.type === "debug_result") {
-            resolve4();
+            resolve5();
           }
         });
         client.send(parsed);
@@ -1101,12 +1319,12 @@ function makeConnectCommand() {
       client.send(cmd);
       rl.prompt();
     });
-    await new Promise((resolve4) => {
-      rl.on("close", resolve4);
+    await new Promise((resolve5) => {
+      rl.on("close", resolve5);
       client.onDisconnect(() => {
         logErr("Server disconnected");
         rl.close();
-        resolve4();
+        resolve5();
       });
     });
     await client.disconnect();
@@ -1188,15 +1406,15 @@ function parseOpArgs(args) {
 async function promptText(label, defaultVal) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   const hint = defaultVal ? ` [${defaultVal}]` : "";
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     rl.question(`  ${label}${hint}: `, (answer) => {
       rl.close();
-      resolve4(answer.trim() || defaultVal || "");
+      resolve5(answer.trim() || defaultVal || "");
     });
   });
 }
 async function promptSecret(label) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     process.stdout.write(`  ${label} (hidden): `);
     const stdin = process.stdin;
     stdin.setRawMode?.(true);
@@ -1209,7 +1427,7 @@ async function promptSecret(label) {
         stdin.pause();
         stdin.removeListener("data", onData);
         process.stdout.write("\n");
-        resolve4(value);
+        resolve5(value);
       } else if (char === "") {
         process.exit(1);
       } else if (char === "\x7F") {
@@ -1256,8 +1474,8 @@ function makeConnectorCommand() {
     async (driver, opts) => {
       const { installNpmPackages } = await import('../connectors/index.js');
       const { scanDirectory, factoryAssetRoots, WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-      const projectDir = path13__default.resolve(opts.projectDir);
-      const yamlPath = path13__default.join(projectDir, "skaile.yaml");
+      const projectDir = path14__default.resolve(opts.projectDir);
+      const yamlPath = path14__default.join(projectDir, "skaile.yaml");
       if (!existsSync(yamlPath)) {
         logErr("No skaile.yaml found in current directory. Run 'skaile init' first.");
         process.exit(1);
@@ -1317,8 +1535,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 = path13__default.resolve(opts.projectDir);
-    const yamlPath = path13__default.join(projectDir, "skaile.yaml");
+    const projectDir = path14__default.resolve(opts.projectDir);
+    const yamlPath = path14__default.join(projectDir, "skaile.yaml");
     if (!existsSync(yamlPath)) {
       logErr("No skaile.yaml found in current directory.");
       process.exit(1);
@@ -1335,7 +1553,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const declarations = res.loadConnectorDeclarations(projectDir);
     if (declarations.length === 0) {
       console.log("No connectors configured in skaile.yaml.");
@@ -1359,7 +1577,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       console.log(JSON.stringify(manager.listConnectors(), null, 2));
@@ -1368,7 +1586,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       if (opts.all) {
@@ -1392,7 +1610,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       if (!manager.has(id)) {
@@ -1407,7 +1625,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const content = await manager.read(id, resourcePath);
@@ -1417,7 +1635,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       await manager.write(id, resourcePath, { data: content });
@@ -1427,7 +1645,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const entries = await manager.list(id, resourcePath, {
@@ -1440,7 +1658,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const results = await manager.search(id, query);
@@ -1450,7 +1668,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       const ok = await manager.delete(id, resourcePath);
@@ -1460,7 +1678,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const manager = await connectConnectors(projectDir);
     try {
       if (!manager.has(id)) {
@@ -1495,17 +1713,17 @@ async function runDebugQuery(query, parentOpts, args) {
     process.exitCode = 1;
     return;
   }
-  await new Promise((resolve4) => {
+  await new Promise((resolve5) => {
     const timeout = setTimeout(() => {
       logErr("Timeout: no debug_result received within 5s");
       process.exitCode = 1;
-      resolve4();
+      resolve5();
     }, 5e3);
     client.onMessage((event) => {
       if (event.type !== "debug_result") return;
       clearTimeout(timeout);
       printDebugResult(query, event.data);
-      resolve4();
+      resolve5();
     });
     client.send({ type: "debug", query, args });
   });
@@ -1569,7 +1787,7 @@ function envRecord() {
 async function buildDeployContext(projectDir) {
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const config = resolveSkWorkspaceConfig2(projectDir);
-  const workspaceId = config.name ?? path13__default.basename(projectDir);
+  const workspaceId = config.name ?? path14__default.basename(projectDir);
   let log;
   try {
     const { createLogger } = await import('../core/logging.js');
@@ -1601,13 +1819,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-RBCDBO7K.js');
+    const { ensurePluginsLoaded } = await import('../plugin-store-UNENLB56.js');
     const result = await ensurePluginsLoaded(projectDir, config.plugins, pluginRegistry);
     for (const f of result.failed) logWarn(f.error);
   }
 }
 async function runUp(opts) {
-  const projectDir = path13__default.resolve(opts.projectDir);
+  const projectDir = path14__default.resolve(opts.projectDir);
   await ensureTargetsRegistered(projectDir);
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const { resolveDeployTarget, pluginRegistry } = await import('../plugin-registry/index.js');
@@ -1639,12 +1857,12 @@ async function runUp(opts) {
   await holdUntilSignal(handle, controller);
 }
 function holdUntilSignal(handle, controller) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const onSig = () => {
       process.removeListener("SIGINT", onSig);
       controller.abort();
       logInfo("Stopping\u2026");
-      handle.stop().then(() => logOk("Stopped.")).catch((e) => logErr(`stop failed: ${e instanceof Error ? e.message : String(e)}`)).finally(() => resolve4());
+      handle.stop().then(() => logOk("Stopped.")).catch((e) => logErr(`stop failed: ${e instanceof Error ? e.message : String(e)}`)).finally(() => resolve5());
     };
     process.on("SIGINT", onSig);
   });
@@ -1675,7 +1893,7 @@ async function restoreFromHandle(projectDir) {
   return { target, handle, ctx };
 }
 async function runDown(opts) {
-  const projectDir = path13__default.resolve(opts.projectDir);
+  const projectDir = path14__default.resolve(opts.projectDir);
   const restored = await restoreFromHandle(projectDir);
   if (!restored) return;
   await restored.handle.stop();
@@ -1684,7 +1902,7 @@ async function runDown(opts) {
   logOk(`Stopped ${S.cmd(restored.target.id)} and cleared the handle.`);
 }
 async function runStatus(opts) {
-  const projectDir = path13__default.resolve(opts.projectDir);
+  const projectDir = path14__default.resolve(opts.projectDir);
   const restored = await restoreFromHandle(projectDir);
   if (!restored) return;
   const health = await restored.handle.health();
@@ -1698,7 +1916,7 @@ async function runStatus(opts) {
   console.log();
 }
 async function runLogs(opts) {
-  const projectDir = path13__default.resolve(opts.projectDir);
+  const projectDir = path14__default.resolve(opts.projectDir);
   const restored = await restoreFromHandle(projectDir);
   if (!restored) return;
   if (!restored.handle.logs) {
@@ -1722,7 +1940,7 @@ function makeDeployCommand() {
 }
 function makeDiffCommand() {
   return new Command("diff").description("Show changes between deployed and source versions").argument("<ref>", "Asset reference (kind:name)").option("--project-dir <path>", "Project directory", process.cwd()).action((ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
     const result = am2.diff(ref);
     if (result === null) {
       logInfo("No differences (or asset not found).");
@@ -1775,7 +1993,7 @@ function makeFlowCommand() {
 function makeHistoryCommand() {
   const cmd = new Command("history").description("Show recent add/remove/update actions");
   cmd.argument("[limit]", "Number of entries to show", "20").option("--project-dir <path>", "Project directory", process.cwd()).action((limitStr, opts) => {
-    const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
     const limit = parseInt(limitStr, 10) || 20;
     const entries = am2.history(limit);
     if (entries.length === 0) {
@@ -1795,7 +2013,7 @@ function makeHistoryCommand() {
     console.log();
   });
   cmd.command("clear").description("Clear action history").option("--project-dir <path>", "Project directory", process.cwd()).action((opts) => {
-    const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
     am2.clearHistory();
     logOk("History cleared.");
   });
@@ -1808,12 +2026,12 @@ var MCP_SERVER_ENTRY = {
   env: {}
 };
 function pluginDir(projectDir) {
-  return path13__default.join(projectDir, ".claude", "plugins", "skaile");
+  return path14__default.join(projectDir, ".claude", "plugins", "skaile");
 }
 async function readJsonStrict(p9) {
   let raw;
   try {
-    raw = await fs5.readFile(p9, "utf-8");
+    raw = await fs6.readFile(p9, "utf-8");
   } catch {
     return null;
   }
@@ -1826,32 +2044,32 @@ async function readJsonStrict(p9) {
   }
 }
 async function writeJson(p9, value) {
-  await fs5.mkdir(path13__default.dirname(p9), { recursive: true });
-  await fs5.writeFile(p9, `${JSON.stringify(value, null, 2)}
+  await fs6.mkdir(path14__default.dirname(p9), { recursive: true });
+  await fs6.writeFile(p9, `${JSON.stringify(value, null, 2)}
 `);
 }
 async function copyDir(src, dest) {
-  await fs5.mkdir(dest, { recursive: true });
-  const entries = await fs5.readdir(src, { withFileTypes: true });
+  await fs6.mkdir(dest, { recursive: true });
+  const entries = await fs6.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path13__default.join(src, entry.name);
-    const destPath = path13__default.join(dest, entry.name);
+    const srcPath = path14__default.join(src, entry.name);
+    const destPath = path14__default.join(dest, entry.name);
     if (entry.isDirectory()) await copyDir(srcPath, destPath);
-    else await fs5.copyFile(srcPath, destPath);
+    else await fs6.copyFile(srcPath, destPath);
   }
 }
 async function install(projectDir, opts) {
   return opts?.full ? installFullPlugin(projectDir) : installMcp(projectDir);
 }
 async function installMcp(projectDir) {
-  const mcpPath = path13__default.join(projectDir, ".claude", "mcp.json");
+  const mcpPath = path14__default.join(projectDir, ".claude", "mcp.json");
   const existing = await readJsonStrict(mcpPath) ?? {};
   const mcpServers = { ...existing.mcpServers ?? {} };
   const previous = mcpServers[SKAILE_MCP_NAME];
   const matches = previous && JSON.stringify(previous) === JSON.stringify(MCP_SERVER_ENTRY);
   let warning;
   if (previous && !matches) {
-    warning = `overwrote existing ${SKAILE_MCP_NAME} entry in ${path13__default.relative(projectDir, mcpPath)}`;
+    warning = `overwrote existing ${SKAILE_MCP_NAME} entry in ${path14__default.relative(projectDir, mcpPath)}`;
   }
   mcpServers[SKAILE_MCP_NAME] = MCP_SERVER_ENTRY;
   await writeJson(mcpPath, { ...existing, mcpServers });
@@ -1860,15 +2078,15 @@ async function installMcp(projectDir) {
 async function installFullPlugin(projectDir) {
   const dir = pluginDir(projectDir);
   for (const [rel, content] of Object.entries(buildClaudePluginFiles())) {
-    const dest = path13__default.join(dir, rel);
-    await fs5.mkdir(path13__default.dirname(dest), { recursive: true });
-    await fs5.writeFile(dest, content);
+    const dest = path14__default.join(dir, rel);
+    await fs6.mkdir(path14__default.dirname(dest), { recursive: true });
+    await fs6.writeFile(dest, content);
   }
-  const projectSkillsDir = path13__default.join(projectDir, ".skaile", "skills");
+  const projectSkillsDir = path14__default.join(projectDir, ".skaile", "skills");
   if (existsSync(projectSkillsDir)) {
-    await copyDir(projectSkillsDir, path13__default.join(dir, "skills"));
+    await copyDir(projectSkillsDir, path14__default.join(dir, "skills"));
   }
-  const settingsPath = path13__default.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path14__default.join(projectDir, ".claude", "settings.json");
   const settings = await readJsonStrict(settingsPath) ?? {};
   const plugins = settings.plugins ?? [];
   if (!plugins.includes(dir)) plugins.push(dir);
@@ -1876,8 +2094,8 @@ async function installFullPlugin(projectDir) {
   return { changed: true, method: "plugin" };
 }
 async function uninstall(projectDir) {
-  const settingsPath = path13__default.join(projectDir, ".claude", "settings.json");
-  const mcpPath = path13__default.join(projectDir, ".claude", "mcp.json");
+  const settingsPath = path14__default.join(projectDir, ".claude", "settings.json");
+  const mcpPath = path14__default.join(projectDir, ".claude", "mcp.json");
   const dir = pluginDir(projectDir);
   let changed = false;
   const settings = await readJsonStrict(settingsPath);
@@ -1891,7 +2109,7 @@ async function uninstall(projectDir) {
     }
   }
   if (existsSync(dir)) {
-    await fs5.rm(dir, { recursive: true, force: true });
+    await fs6.rm(dir, { recursive: true, force: true });
     changed = true;
   }
   const mcp = await readJsonStrict(mcpPath);
@@ -1901,7 +2119,7 @@ async function uninstall(projectDir) {
     const updated = { ...mcp, mcpServers: rest };
     if (Object.keys(rest).length === 0) delete updated.mcpServers;
     if (Object.keys(updated).length === 0) {
-      await fs5.unlink(mcpPath);
+      await fs6.unlink(mcpPath);
     } else {
       await writeJson(mcpPath, updated);
     }
@@ -1911,12 +2129,12 @@ async function uninstall(projectDir) {
 async function detectInstall(projectDir) {
   const dir = pluginDir(projectDir);
   const settings = await readJsonStrict(
-    path13__default.join(projectDir, ".claude", "settings.json")
+    path14__default.join(projectDir, ".claude", "settings.json")
   );
-  if (existsSync(path13__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir)) {
+  if (existsSync(path14__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir)) {
     return { method: "plugin", pluginPath: dir };
   }
-  const mcp = await readJsonStrict(path13__default.join(projectDir, ".claude", "mcp.json"));
+  const mcp = await readJsonStrict(path14__default.join(projectDir, ".claude", "mcp.json"));
   if (mcp?.mcpServers && SKAILE_MCP_NAME in mcp.mcpServers) {
     return { method: "mcp" };
   }
@@ -1925,7 +2143,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 = path13__default.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path14__default.join(projectDir, ".claude", "settings.json");
   const settings = await readJsonStrict(settingsPath) ?? {};
   if (detected.method === "plugin") {
     const disabled2 = settings.disabledPlugins ?? [];
@@ -1947,7 +2165,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 = path13__default.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path14__default.join(projectDir, ".claude", "settings.json");
   const settings = await readJsonStrict(settingsPath) ?? {};
   if (detected.method === "plugin") {
     const list2 = settings.disabledPlugins ?? [];
@@ -1967,12 +2185,12 @@ async function disable(projectDir) {
   return { changed: true };
 }
 async function status(projectDir) {
-  const settingsPath = path13__default.join(projectDir, ".claude", "settings.json");
-  const mcpPath = path13__default.join(projectDir, ".claude", "mcp.json");
+  const settingsPath = path14__default.join(projectDir, ".claude", "settings.json");
+  const mcpPath = path14__default.join(projectDir, ".claude", "mcp.json");
   const dir = pluginDir(projectDir);
   const settings = await readJsonStrict(settingsPath);
   const mcp = await readJsonStrict(mcpPath);
-  const pluginInstalled = !!(existsSync(path13__default.join(dir, ".claude-plugin", "plugin.json")) && settings?.plugins?.includes(dir));
+  const pluginInstalled = !!(existsSync(path14__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 {
@@ -1990,7 +2208,7 @@ async function status(projectDir) {
       installed: "yes",
       enabled: disabled2 ? "no" : "yes",
       method: "plugin",
-      location: path13__default.relative(projectDir, dir)
+      location: path14__default.relative(projectDir, dir)
     };
   }
   const disabled = settings?.disabledMcpjsonServers?.includes(SKAILE_MCP_NAME) ?? false;
@@ -1999,7 +2217,7 @@ async function status(projectDir) {
     installed: "yes",
     enabled: disabled ? "no" : "yes",
     method: "mcp",
-    location: path13__default.relative(projectDir, mcpPath)
+    location: path14__default.relative(projectDir, mcpPath)
   };
 }
 var SKAILE_MCP_NAME2 = "skaile-workspace";
@@ -2013,7 +2231,7 @@ function buildEntry(projectDir) {
 async function readConfig(p9) {
   let raw;
   try {
-    raw = await fs5.readFile(p9, "utf-8");
+    raw = await fs6.readFile(p9, "utf-8");
   } catch {
     return null;
   }
@@ -2026,16 +2244,16 @@ async function readConfig(p9) {
   }
 }
 async function writeConfig(p9, value) {
-  await fs5.mkdir(path13__default.dirname(p9), { recursive: true });
+  await fs6.mkdir(path14__default.dirname(p9), { recursive: true });
   const cleaned = {};
   for (const [k, v] of Object.entries(value)) {
     if (v === void 0) continue;
     cleaned[k] = v;
   }
-  await fs5.writeFile(p9, stringify(cleaned));
+  await fs6.writeFile(p9, stringify$1(cleaned));
 }
 function configPath(projectDir) {
-  return path13__default.join(projectDir, ".codex", "config.toml");
+  return path14__default.join(projectDir, ".codex", "config.toml");
 }
 async function install2(projectDir) {
   const p9 = configPath(projectDir);
@@ -2046,7 +2264,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 ${path13__default.relative(projectDir, p9)}`;
+    warning = `overwrote existing ${SKAILE_MCP_NAME2} entry in ${path14__default.relative(projectDir, p9)}`;
   }
   if (matches) return { changed: false, method: "toml" };
   servers[SKAILE_MCP_NAME2] = next;
@@ -2063,7 +2281,7 @@ async function uninstall2(projectDir) {
   const updated = { ...cfg, mcp_servers: rest };
   if (Object.keys(rest).length === 0) delete updated.mcp_servers;
   if (Object.keys(updated).length === 0) {
-    await fs5.unlink(p9);
+    await fs6.unlink(p9);
   } else {
     await writeConfig(p9, updated);
   }
@@ -2087,43 +2305,43 @@ async function status2(projectDir) {
     installed: "yes",
     enabled: "n/a",
     method: "mcp",
-    location: path13__default.relative(projectDir, p9)
+    location: path14__default.relative(projectDir, p9)
   };
 }
 async function install3(projectDir) {
-  const extDir = path13__default.join(projectDir, ".omp", "extensions");
-  const extPath = path13__default.join(extDir, "skaile.ts");
-  await fs5.mkdir(extDir, { recursive: true });
+  const extDir = path14__default.join(projectDir, ".omp", "extensions");
+  const extPath = path14__default.join(extDir, "skaile.ts");
+  await fs6.mkdir(extDir, { recursive: true });
   const { WorkspacePlugin } = await import('../workspace-plugin/index.js');
   const plugin = new WorkspacePlugin({ projectDir });
   const nextSrc = await plugin.buildOmpExtensionSource();
   let prevSrc = null;
   try {
-    prevSrc = await fs5.readFile(extPath, "utf-8");
+    prevSrc = await fs6.readFile(extPath, "utf-8");
   } catch {
   }
   if (prevSrc === nextSrc) return { changed: false, method: "generated" };
-  await fs5.writeFile(extPath, nextSrc);
+  await fs6.writeFile(extPath, nextSrc);
   return { changed: true, method: "generated" };
 }
 async function uninstall3(projectDir) {
-  const extPath = path13__default.join(projectDir, ".omp", "extensions", "skaile.ts");
+  const extPath = path14__default.join(projectDir, ".omp", "extensions", "skaile.ts");
   try {
-    await fs5.unlink(extPath);
+    await fs6.unlink(extPath);
     return { changed: true };
   } catch {
     return { changed: false };
   }
 }
 async function status3(projectDir) {
-  const extPath = path13__default.join(projectDir, ".omp", "extensions", "skaile.ts");
+  const extPath = path14__default.join(projectDir, ".omp", "extensions", "skaile.ts");
   if (existsSync(extPath)) {
     return {
       backend: "omp",
       installed: "yes",
       enabled: "n/a",
       method: "extension",
-      location: path13__default.relative(projectDir, extPath)
+      location: path14__default.relative(projectDir, extPath)
     };
   }
   return {
@@ -2186,7 +2404,7 @@ async function installCodex(projectDir) {
   console.log(`  ${S.dim("\u2192")} Restart Codex CLI to pick up the change.`);
 }
 async function runInstall(opts) {
-  const projectDir = path13__default.resolve(opts.projectDir);
+  const projectDir = path14__default.resolve(opts.projectDir);
   const targets = resolveDriver(opts.driver);
   let exitCode = 0;
   if (targets.includes("claude-code")) {
@@ -2220,7 +2438,7 @@ async function uninstallCodex(projectDir) {
   else logInfo(`codex: not installed`);
 }
 async function runUninstall(opts) {
-  const projectDir = path13__default.resolve(opts.projectDir);
+  const projectDir = path14__default.resolve(opts.projectDir);
   const targets = resolveDriver(opts.driver);
   let exitCode = 0;
   if (targets.includes("claude-code")) {
@@ -2263,7 +2481,7 @@ async function toggleTarget(t, projectDir, action3) {
   });
 }
 async function runToggle(opts, action3) {
-  const projectDir = path13__default.resolve(opts.projectDir);
+  const projectDir = path14__default.resolve(opts.projectDir);
   const requestedAll = opts.driver === "all";
   const targets = resolveDriver(opts.driver);
   const usageError = checkToggleSupported(targets, requestedAll, action3);
@@ -2275,7 +2493,7 @@ async function runToggle(opts, action3) {
   return exitCode;
 }
 async function runStatus2(opts) {
-  const projectDir = path13__default.resolve(opts.projectDir);
+  const projectDir = path14__default.resolve(opts.projectDir);
   const targets = resolveDriver(opts.driver);
   const rows = [];
   let exitCode = 0;
@@ -2346,7 +2564,7 @@ async function runHook(event) {
     await plugin.shutdown();
     return;
   }
-  const store = new PluginStore(path13__default.join(projectDir, ".skaile", "plugin-state.json"));
+  const store = new PluginStore(path14__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) {
@@ -2468,12 +2686,12 @@ function makeLibraryCommand() {
   cmd.command("init <name>").description("Create a new local library at ~/.skaile/libraries/<name>").option("--git <url>", "Initialize as a git library tracking <url>").option("--owner", "Mark as owner (default for local)").option("--contributor", "Mark as contributor").option("--reader", "Mark as reader").action(
     async (name, opts) => {
       const libDir = resolveLibraryDir();
-      const libPath = path13.join(libDir, name);
+      const libPath = path14.join(libDir, name);
       const ownership = opts.contributor ? "contributor" : opts.reader ? "reader" : "owner";
       const { manager, close } = await openLibraryManager();
       try {
         if (opts.git) {
-          fs11.mkdirSync(libPath, { recursive: true });
+          fs12.mkdirSync(libPath, { recursive: true });
           await manager.addLibrary({
             name,
             path: libPath,
@@ -2482,7 +2700,7 @@ function makeLibraryCommand() {
             ownership
           });
         } else {
-          fs11.mkdirSync(libPath, { recursive: true });
+          fs12.mkdirSync(libPath, { recursive: true });
           await manager.addLibrary({
             name,
             path: libPath,
@@ -2539,7 +2757,7 @@ function makeLibraryCommand() {
           target = def;
         }
         const am2 = new AssetManager({ projectDir: process.cwd() });
-        const destDir = opts.dir ? path13.join(target.path, opts.dir) : target.path;
+        const destDir = opts.dir ? path14.join(target.path, opts.dir) : target.path;
         const res = am2.create(name, opts.kind ?? kind, destDir);
         if (res.ok) {
           logOk(`Created ${opts.kind ?? kind}: ${pc5.dim(res.path)}`);
@@ -2552,6 +2770,80 @@ function makeLibraryCommand() {
       }
     }
   );
+  const domain = cmd.command("domain").description("Manage domains (publisher namespaces) inside a library");
+  async function resolveTargetLibrary(manager, libraryName) {
+    if (libraryName) return manager.requireLibrary(libraryName);
+    const all = await manager.listLibraries();
+    const def = all.find((l) => l.isDefault);
+    if (def) return def;
+    if (all.length === 1) return all[0];
+    if (all.length === 0) {
+      logErr("No libraries registered. Run `skaile library init <name>` first.");
+      process.exit(1);
+    }
+    logErr("No default library set. Run `skaile library default <name>` or pass --library.");
+    process.exit(1);
+  }
+  domain.command("create <name>").description("Scaffold a domain dir + DOMAIN.md inside a library").option("--library <name>", "Target library (default: the default-marked one)").option("--publisher <p>", "Publisher slug (default: the domain name kebab-cased)").option("--description <text>", "Domain description for DOMAIN.md").action(
+    async (name, opts) => {
+      const { manager, close } = await openLibraryManager();
+      try {
+        const target = await resolveTargetLibrary(manager, opts.library);
+        if (target.ownership === "reader") {
+          logErr(`Library "${target.name}" is read-only (ownership=reader).`);
+          process.exit(1);
+        }
+        const res = ensureDomain(target.path, name, {
+          publisher: opts.publisher,
+          description: opts.description
+        });
+        if (target.structure !== "domain") {
+          await manager.updateLibrary(target.id, { structure: "domain" });
+        }
+        if (res.created) {
+          logOk(`Created domain ${S.cmd(name)} (publisher @${res.publisher}) \u2192 ${res.dir}`);
+        } else {
+          logInfo(`Domain ${S.cmd(name)} already exists at ${res.dir}`);
+        }
+      } finally {
+        close();
+      }
+    }
+  );
+  domain.command("list").description("List domains in a library").option("--library <name>", "Target library (default: the default-marked one)").option("--json", "Output as JSON").action(async (opts) => {
+    const { manager, close } = await openLibraryManager();
+    try {
+      const target = await resolveTargetLibrary(manager, opts.library);
+      const domains = listDomains(target.path);
+      if (opts.json) return console.log(JSON.stringify(domains, null, 2));
+      if (domains.length === 0) {
+        logInfo(
+          `No domains in "${target.name}". Create one: \`skaile library domain create <name>\`.`
+        );
+        return;
+      }
+      for (const d of domains) console.log(`  ${S.cmd(d)}`);
+      console.log(`
+  ${S.dim(`${domains.length} domain(s) in ${target.name}`)}
+`);
+    } finally {
+      close();
+    }
+  });
+  domain.command("show <name>").description("Print a domain's DOMAIN.md").option("--library <name>", "Target library (default: the default-marked one)").action(async (name, opts) => {
+    const { manager, close } = await openLibraryManager();
+    try {
+      const target = await resolveTargetLibrary(manager, opts.library);
+      const domainFile = path14.join(target.path, name, "DOMAIN.md");
+      if (!existsSync(domainFile)) {
+        logErr(`Domain "${name}" not found in "${target.name}" (no ${domainFile}).`);
+        process.exit(1);
+      }
+      console.log(fs12.readFileSync(domainFile, "utf8"));
+    } finally {
+      close();
+    }
+  });
   cmd.command("default <name>").description("Set <name> as the default library").action(async (name) => {
     const { manager, close } = await openLibraryManager();
     try {
@@ -2565,13 +2857,13 @@ function makeLibraryCommand() {
     const { manager, close } = await openLibraryManager();
     try {
       const lib = await manager.requireLibrary(oldName);
-      const parent = path13.dirname(lib.path);
-      const newPath = path13.join(parent, newName);
-      if (fs11.existsSync(newPath)) {
+      const parent = path14.dirname(lib.path);
+      const newPath = path14.join(parent, newName);
+      if (fs12.existsSync(newPath)) {
         logErr(`Target directory already exists: ${newPath}`);
         process.exit(1);
       }
-      fs11.renameSync(lib.path, newPath);
+      fs12.renameSync(lib.path, newPath);
       await manager.updateLibrary(lib.id, { name: newName, path: newPath });
       logOk(`Renamed ${oldName} \u2192 ${newName}`);
     } finally {
@@ -2755,9 +3047,9 @@ async function printOverallStatus(projectDir, asJson) {
     } catch {
       secretsStrategy = "unavailable";
     }
-    const resolvedProjectDir = path13.resolve(projectDir);
-    const hasWorkspaceConfig = existsSync(path13.join(resolvedProjectDir, "skaile.yaml"));
-    const hasLockFile = existsSync(path13.join(resolvedProjectDir, "skaile.lock.yaml"));
+    const resolvedProjectDir = path14.resolve(projectDir);
+    const hasWorkspaceConfig = existsSync(path14.join(resolvedProjectDir, "skaile.yaml"));
+    const hasLockFile = existsSync(path14.join(resolvedProjectDir, "skaile.lock.yaml"));
     let assignments = [];
     if (hasWorkspaceConfig) {
       try {
@@ -3113,7 +3405,7 @@ function actOnHeader(row, action3) {
   return row.type === "domain-header" || row.type === "domain-info";
 }
 async function loadAssets() {
-  const { gatherAssetFeeds } = await import('../asset-feeds-EGSG4FUB.js');
+  const { gatherAssetFeeds } = await import('../asset-feeds-DLRQWELS.js');
   const { entries, domains, notes } = await gatherAssetFeeds(am, am.projectDir);
   if (notes.length > 0) {
     state.message = notes.map((n) => `[${n.feed}] ${n.message}`).join(" \u2022 ");
@@ -3211,14 +3503,14 @@ function reconcileCollapsedSets(rows) {
 async function loadSourcesAndLibraries() {
   try {
     const [{ openLibraryManager: openLibraryManager2 }, { skaileHomeDir }, { getGlobalCacheDir: getGlobalCacheDir2 }] = await Promise.all([
-      import('../open-library-362BZ6OW.js'),
+      import('../open-library-COHFCT4N.js'),
       import('../library/index.js'),
       import('../core/index.js')
     ]);
     const { manager, library, close } = await openLibraryManager2();
     try {
       const newRoot = getGlobalCacheDir2();
-      const legacyRoot = path13__default.join(skaileHomeDir(), "sources");
+      const legacyRoot = path14__default.join(skaileHomeDir(), "sources");
       const isSourceRow = (l) => l.path.startsWith(newRoot) || l.path.startsWith(legacyRoot);
       const libs = await manager.listLibraries();
       const defs = await library.listAssetDefs();
@@ -3598,10 +3890,10 @@ async function showInfo() {
   }
   console.log();
   console.log(pc5.dim("  Press any key to return..."));
-  await new Promise((resolve4) => {
+  await new Promise((resolve5) => {
     const onData = () => {
       process.stdin.removeListener("data", onData);
-      resolve4();
+      resolve5();
     };
     process.stdin.once("data", onData);
   });
@@ -3854,13 +4146,13 @@ async function run(projectDir) {
 }
 function makeManageCommand() {
   return new Command("manage").description("Interactive TUI for managing assets, sources, and libraries").option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {
-    await run(path13__default.resolve(opts.projectDir));
+    await run(path14__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 path36 = await import('path');
-    const projectDir = path36.default.resolve(opts.projectDir);
+    const path37 = await import('path');
+    const projectDir = path37.default.resolve(opts.projectDir);
     const { LogStore, StdoutSink, registerLogStore } = await import('../core/logging.js');
     registerLogStore(
       new LogStore({
@@ -3897,8 +4189,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", "claude-code").option("--global", "Deploy globally").action(async (url, opts) => {
-    const projectDir = path13__default.resolve(opts.projectDir);
-    const projYaml = path13__default.join(projectDir, "skaile.yaml");
+    const projectDir = path14__default.resolve(opts.projectDir);
+    const projYaml = path14__default.join(projectDir, "skaile.yaml");
     if (!existsSync(projYaml)) {
       logErr(`No skaile.yaml in ${projectDir} \u2014 run \`skaile init\` first.`);
       process.exit(1);
@@ -3910,14 +4202,15 @@ function makeNpxCommand() {
       process.exit(1);
     }
     const spinner5 = p6.spinner();
-    const slug = sourceSlug(url);
-    const clonePath = path13__default.join(getGlobalCacheDir(), slug);
+    const key = sourceCacheKey(url);
+    const clonePath = path14__default.join(getGlobalCacheDir(), key);
     spinner5.start(`Cloning ${url}`);
     try {
       if (!existsSync(clonePath)) {
+        mkdirSync(path14__default.dirname(clonePath), { recursive: true });
         execSync(`git clone ${url} ${clonePath}`, { stdio: "ignore" });
       }
-      spinner5.stop(`Cloned to ${slug}`);
+      spinner5.stop(`Cloned to ${key}`);
     } catch (err) {
       spinner5.stop("Clone failed");
       logErr(err instanceof Error ? err.message : String(err));
@@ -3960,7 +4253,7 @@ function makeNpxCommand() {
   return npx;
 }
 function resolvePublisher(clonePath, url) {
-  const manifestPath = path13__default.join(clonePath, SKAILE_MANIFEST_FILENAME);
+  const manifestPath = path14__default.join(clonePath, SKAILE_MANIFEST_FILENAME);
   if (existsSync(manifestPath)) {
     try {
       const { manifest } = decodeSkaileManifest(readFileSync(manifestPath, "utf8"));
@@ -3973,12 +4266,12 @@ function resolvePublisher(clonePath, url) {
   return url.match(/github\.com[/:]([^/]+)\/[^/]+/)?.[1];
 }
 function resolveSkillName(clonePath, requested) {
-  const skillsDir = path13__default.join(clonePath, "skills");
-  if (existsSync(path13__default.join(skillsDir, requested, "SKILL.md"))) return requested;
+  const skillsDir = path14__default.join(clonePath, "skills");
+  if (existsSync(path14__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 = path13__default.join(skillsDir, entry.name, "SKILL.md");
+    const md = path14__default.join(skillsDir, entry.name, "SKILL.md");
     if (!existsSync(md)) continue;
     try {
       const { data } = parseFrontmatter(readFileSync(md, "utf8"));
@@ -3988,15 +4281,12 @@ function resolveSkillName(clonePath, requested) {
   }
   return requested;
 }
-function sourceSlug(url) {
-  return url.replace(/\.git$/, "").split(/[/:]/).pop() ?? "source";
-}
 function makeOutdatedCommand() {
   return new Command("outdated").description("Check for assets behind their repo").argument("[name]", "Check a specific asset (kind:name)").option("--project-dir <path>", "Project directory", process.cwd()).addOption(
     new Option("--target <agent>", "Driver target").default("claude-code").choices(SUPPORTED_DRIVER_TARGETS)
   ).action((name, opts) => {
     const am2 = new AssetManager({
-      projectDir: path13__default.resolve(opts.projectDir),
+      projectDir: path14__default.resolve(opts.projectDir),
       driverTarget: opts.target
     });
     const entries = am2.outdated();
@@ -4025,7 +4315,7 @@ function makeOutdatedCommand() {
 function makePatchCommand() {
   const cmd = new Command("patch").description("Patch workflow for skill improvement");
   cmd.command("extract <ref>").alias("start").description("Extract asset for local editing").option("--project-dir <path>", "Project directory", process.cwd()).action((ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
     try {
       const dest = am2.patch(ref);
       logOk(`Extracted to ${S.dim(dest)}`);
@@ -4036,7 +4326,7 @@ function makePatchCommand() {
     }
   });
   cmd.command("commit <ref>").description("Generate .patch file from edits").option("--project-dir <path>", "Project directory", process.cwd()).action((ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
     try {
       const patchFile = am2.patchCommit(ref);
       logOk(`Patch saved to ${S.dim(patchFile)}`);
@@ -4047,7 +4337,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((ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
     try {
       am2.patchSubmit(ref);
       logOk("Patch applied to repo clone and committed.");
@@ -4060,7 +4350,7 @@ function makePatchCommand() {
     }
   });
   cmd.command("remove <ref>").description("Remove local patch after upstream merge").option("--project-dir <path>", "Project directory", process.cwd()).action((ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
     am2.patchRemove(ref);
     logOk(`Patch removed for ${ref}`);
   });
@@ -4078,7 +4368,7 @@ function action2(fn) {
   };
 }
 async function reconcileAndReport(projectDir, plugins) {
-  const { reconcilePlugins } = await import('../plugin-store-RBCDBO7K.js');
+  const { reconcilePlugins } = await import('../plugin-store-UNENLB56.js');
   if (plugins.length === 0) {
     logInfo("No plugins declared \u2014 nothing to reconcile.");
     return;
@@ -4092,10 +4382,10 @@ async function reconcileAndReport(projectDir, plugins) {
   }
 }
 async function runInstall2(spec, opts) {
-  const projectDir = path13__default.resolve(opts.projectDir);
+  const projectDir = path14__default.resolve(opts.projectDir);
   const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-  const { specName } = await import('../plugin-store-RBCDBO7K.js');
-  const yamlPath = path13__default.join(projectDir, "skaile.yaml");
+  const { specName } = await import('../plugin-store-UNENLB56.js');
+  const yamlPath = path14__default.join(projectDir, "skaile.yaml");
   const editor = WorkspaceYamlEditor2.load(yamlPath);
   const replaced = editor.addPlugin(spec, specName);
   editor.save();
@@ -4104,10 +4394,10 @@ async function runInstall2(spec, opts) {
   await reconcileAndReport(projectDir, editor.getPlugins());
 }
 async function runRemove(name, opts) {
-  const projectDir = path13__default.resolve(opts.projectDir);
+  const projectDir = path14__default.resolve(opts.projectDir);
   const { WorkspaceYamlEditor: WorkspaceYamlEditor2 } = await import('../core/index.js');
-  const { specName } = await import('../plugin-store-RBCDBO7K.js');
-  const yamlPath = path13__default.join(projectDir, "skaile.yaml");
+  const { specName } = await import('../plugin-store-UNENLB56.js');
+  const yamlPath = path14__default.join(projectDir, "skaile.yaml");
   const editor = WorkspaceYamlEditor2.load(yamlPath);
   const removed = editor.removePlugin(name, specName);
   if (!removed) {
@@ -4119,7 +4409,7 @@ async function runRemove(name, opts) {
   await reconcileAndReport(projectDir, editor.getPlugins());
 }
 async function runList(opts) {
-  const projectDir = path13__default.resolve(opts.projectDir);
+  const projectDir = path14__default.resolve(opts.projectDir);
   const { resolveSkWorkspaceConfig: resolveSkWorkspaceConfig2 } = await import('../core/index.js');
   const config = resolveSkWorkspaceConfig2(projectDir);
   const declared = config.plugins ?? [];
@@ -4134,7 +4424,7 @@ async function runList(opts) {
   const registry = createPluginRegistry();
   if (declared.length > 0) {
     try {
-      const { loadPlugins } = await import('../plugin-store-RBCDBO7K.js');
+      const { loadPlugins } = await import('../plugin-store-UNENLB56.js');
       const result = await loadPlugins(projectDir, declared, registry);
       for (const f of result.failed) logWarn(f.error);
     } catch (err) {
@@ -4173,7 +4463,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 = path13__default.join(path13__default.resolve(opts.dir), filename);
+    const outPath = path14__default.join(path14__default.resolve(opts.dir), filename);
     if (existsSync(outPath)) {
       logErr(`File already exists: ${outPath}`);
       logInfo("Choose a different name or remove the existing file.");
@@ -4221,7 +4511,7 @@ async function reportNestedPresetRefs(preset) {
 }
 async function checkPresetCycles(preset, resolved) {
   const { detectCycles } = await import('../discovery/index.js');
-  const presetRef = path13__default.basename(resolved, ".preset.yaml");
+  const presetRef = path14__default.basename(resolved, ".preset.yaml");
   const edges = [];
   for (const item of preset.items) {
     if (item.ref) {
@@ -4272,7 +4562,7 @@ function printPresetSummary(preset, placeholderCount, hasWarnings) {
   }
 }
 async function runPresetValidate(filePath) {
-  const resolved = path13__default.resolve(filePath);
+  const resolved = path14__default.resolve(filePath);
   const preset = await loadPresetForValidation(resolved);
   await reportNestedPresetRefs(preset);
   await checkPresetCycles(preset, resolved);
@@ -4366,8 +4656,8 @@ async function runRefInstall(ref, opts) {
   const spinner5 = p6.spinner();
   spinner5.start(`Installing ${ref}`);
   try {
-    const { openCatalogSource: openCatalogSource2, openLibrary: openLibrary2 } = await import('../open-library-362BZ6OW.js');
-    const catalog = await openCatalogSource2({ projectDir: path13__default.resolve(opts.projectDir) });
+    const { openCatalogSource: openCatalogSource2, openLibrary: openLibrary2 } = await import('../open-library-COHFCT4N.js');
+    const catalog = await openCatalogSource2({ projectDir: path14__default.resolve(opts.projectDir) });
     if (!supportsInstallManifest(catalog)) {
       throw new Error(
         "pointer-only install (skaile install <ref>) requires a tRPC-framed Catalog. The configured catalog uses REST framing, which does not serve install manifests. Set catalog.url to https://skaile.store, or catalog.framing: trpc, in ~/.skaile/config.yaml."
@@ -4396,9 +4686,9 @@ async function runRefInstall(ref, opts) {
   }
 }
 async function runYamlInstall(opts) {
-  const projectDir = path13__default.resolve(opts.projectDir);
+  const projectDir = path14__default.resolve(opts.projectDir);
   try {
-    const { ensureSourcesCloned } = await import('../ensure-sources-NSDMTAWN.js');
+    const { ensureSourcesCloned } = await import('../ensure-sources-KLCGXVE6.js');
     const hydrate = ensureSourcesCloned(projectDir, { quiet: true });
     if (hydrate.cloned.length > 0) {
       logOk(`Cloned source(s): ${hydrate.cloned.join(", ")}`);
@@ -4429,6 +4719,7 @@ async function runYamlInstall(opts) {
     }
     if (result.missing.length > 0) {
       for (const m of result.missing) logErr(`Missing: ${m}`);
+      process.exitCode = 1;
     }
     if (result.lockWritten) {
       logInfo(`Lock file written: ${S.dim("skaile.lock.yaml")}`);
@@ -4441,7 +4732,7 @@ async function runYamlInstall(opts) {
 }
 function makeCheckCommand() {
   return new Command("check").description("Check for unmet requirements").option("--project-dir <path>", "Project directory", process.cwd()).action((opts) => {
-    const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
     const issues = am2.doctor();
     if (issues.length === 0) {
       logOk("All dependencies satisfied.");
@@ -4458,10 +4749,10 @@ function makeCheckCommand() {
 function makeCleanCommand() {
   return new Command("clean").description("Remove all skaile-managed assets from the workspace").option("--all", "Full reset: also remove history, patches, repos, and lock file").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()).option("--target <agent>", "Agent framework", "claude-code").action(async (opts) => {
     const am2 = new AssetManager({
-      projectDir: path13__default.resolve(opts.projectDir),
+      projectDir: path14__default.resolve(opts.projectDir),
       driverTarget: opts.target
     });
-    const lock = readLock(path13__default.resolve(opts.projectDir, "skaile.lock.yaml"));
+    const lock = readLock(path14__default.resolve(opts.projectDir, "skaile.lock.yaml"));
     if (!lock || Object.keys(lock.assets).length === 0) {
       logInfo("Nothing to clean (no skaile-managed assets found).");
       return;
@@ -4514,14 +4805,14 @@ function makeCleanCommand() {
 }
 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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     let agentDir;
     if (agentArg) {
       if (agentArg.includes("/") || agentArg.includes("\\")) {
-        agentDir = path13__default.resolve(projectDir, agentArg);
+        agentDir = path14__default.resolve(projectDir, agentArg);
       } else {
         const resolved = resolveAgentDir(projectDir);
-        agentDir = resolved ?? path13__default.resolve(projectDir, agentArg);
+        agentDir = resolved ?? path14__default.resolve(projectDir, agentArg);
       }
     } else {
       const resolved = resolveAgentDir(projectDir);
@@ -4599,7 +4890,7 @@ function makeFlowEventHandler() {
 }
 function makeRunCommand() {
   const cmd = new Command("run").description("Start a flow or run a single-shot text prompt").argument("[flow-id-or-text...]", "Flow ID or text prompt").option("--project-dir <path>", "Project directory", process.cwd()).option("--driver <name>", "Driver backend (claude-sdk, codex, omp)").option("--provider <name>", "LLM provider").option("--model <name>", "Model override").option("--label <label>", "Human-readable session label").option("--dry-run", "Print plan without executing").option("--skill <name>", "Skill name (for single-shot mode)").action(async (positional, opts) => {
-    const projectDir = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const cliDriver = opts.driver;
     const dryRun = opts.dryRun ?? false;
     let flowId = positional[0];
@@ -4634,12 +4925,12 @@ function makeRunCommand() {
     const priorityRoots = [];
     let dir = projectDir;
     for (let i = 0; i < 6; i++) {
-      const candidate = path13__default.join(dir, "ai-assets");
-      if (fs11__default.existsSync(candidate)) {
+      const candidate = path14__default.join(dir, "ai-assets");
+      if (fs12__default.existsSync(candidate)) {
         priorityRoots.push(candidate);
         break;
       }
-      dir = path13__default.dirname(dir);
+      dir = path14__default.dirname(dir);
     }
     const flowPath = findFlowFile(flowId, priorityRoots);
     if (!flowPath) {
@@ -4694,7 +4985,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const sessionId = opts.session;
     const dryRun = opts.dryRun ?? false;
     const session = sessionId ? await loadSessionById(projectDir, sessionId) : await loadSession(projectDir);
@@ -4721,7 +5012,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const session = await loadSession(projectDir);
     if (!session) {
       logInfo("No active session.");
@@ -4746,7 +5037,7 @@ function makeStatusCommand() {
 }
 function makeClearCommand() {
   return new Command("clear").description("Unset current session pointer").option("--project-dir <path>", "Project directory", process.cwd()).action(async (opts) => {
-    const projectDir = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     await clearSession(projectDir);
     logOk("Session cleared.");
   });
@@ -4755,8 +5046,8 @@ function makeReplCommand() {
   return new Command("repl").description("Start an interactive agent session").option("--project-dir <path>", "Project directory").option("--driver <name>", "Driver backend (claude-sdk, omp)").option("--provider <name>", "LLM provider").option("--model <name>", "Model override").option("--resume", "Resume last session").option("--resume-session <id>", "Resume specific session").action(async (opts) => {
     const { findWorkspaceRoot: findWorkspaceRoot2 } = await import('../core/index.js');
     const { startRepl } = await import('../tui/index.js');
-    const os = await import('os');
-    const userCwd = path13__default.resolve(opts.projectDir ?? process.cwd());
+    const os2 = await import('os');
+    const userCwd = path14__default.resolve(opts.projectDir ?? process.cwd());
     const workspaceRoot = findWorkspaceRoot2(userCwd);
     let projectDir;
     let agentCwd;
@@ -4778,13 +5069,13 @@ function makeReplCommand() {
         p6.cancel("Cancelled.");
         process.exit(0);
       }
-      const tmpDir = fs11__default.mkdtempSync(path13__default.join(os.tmpdir(), "skaile-repl-"));
+      const tmpDir = fs12__default.mkdtempSync(path14__default.join(os2.tmpdir(), "skaile-repl-"));
       projectDir = tmpDir;
       agentCwd = userCwd;
       logOk(`Temporary workspace: ${S.cmd(tmpDir)}`);
       if (!driverOverride) {
-        const claudeDir = path13__default.join(os.homedir(), ".claude");
-        if (fs11__default.existsSync(claudeDir)) {
+        const claudeDir = path14__default.join(os2.homedir(), ".claude");
+        if (fs12__default.existsSync(claudeDir)) {
           driverOverride = "claude-sdk";
           logInfo(`Detected ${S.cmd("~/.claude")} \u2192 using ${S.cmd("claude-sdk")} backend`);
         } else {
@@ -4835,7 +5126,7 @@ async function ensurePluginsLoadedForServe(projectDir) {
     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-RBCDBO7K.js');
+    const { ensurePluginsLoaded } = await import('../plugin-store-UNENLB56.js');
     const { pluginRegistry } = await import('../plugin-registry/index.js');
     const result = await ensurePluginsLoaded(projectDir, config.plugins, pluginRegistry);
     if (result.loaded.length > 0) {
@@ -4851,21 +5142,21 @@ async function ensurePluginsLoadedForServe(projectDir) {
 async function runCompileTest(opts) {
   const { logOk: logOk2, logErr: logErr2, logInfo: logInfo2, S: S2 } = await import('../helpers-F4NZ66VD.js');
   const { tmpdir } = await import('os');
-  const { dirname: dirname3, join: join5, resolve: resolve4 } = await import('path');
+  const { dirname: dirname5, join: join6, resolve: resolve5 } = await import('path');
   const { fileURLToPath: fileURLToPath2 } = await import('url');
-  const { unlinkSync, existsSync: existsSync13 } = await import('fs');
+  const { unlinkSync, existsSync: existsSync14 } = await import('fs');
   const { spawn } = await import('child_process');
   const { portableSpawnSync: portableSpawnSync2 } = await import('../core/index.js');
-  const { MONOREPO_ROOT } = await import('../paths-4SSFMX5Z.js');
+  const { MONOREPO_ROOT } = await import('../paths-2SYXGTZJ.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 = join5(tmpdir(), `skaile-compile-test-${Date.now()}`);
+  const outfile = join6(tmpdir(), `skaile-compile-test-${Date.now()}`);
   const __thisFile = fileURLToPath2(import.meta.url);
-  const entryPoint = resolve4(dirname3(__thisFile), "..", "index.ts");
+  const entryPoint = resolve5(dirname5(__thisFile), "..", "index.ts");
   logInfo2(`Building compiled binary...`);
   logInfo2(`Entry: ${S2.dim(entryPoint)}`);
   logInfo2(`Output: ${S2.dim(outfile)}`);
@@ -4915,7 +5206,7 @@ async function runCompileTest(opts) {
     } catch {
     }
     try {
-      if (existsSync13(outfile)) unlinkSync(outfile);
+      if (existsSync14(outfile)) unlinkSync(outfile);
     } catch {
     }
   }
@@ -5168,19 +5459,19 @@ function buildTailSelect(q) {
   return { sql, params };
 }
 function sleepUnlessAborted(ms, signal) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     if (signal?.aborted) {
-      resolve4();
+      resolve5();
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve4();
+      resolve5();
     }, ms);
     const onAbort = () => {
       clearTimeout(timer);
       signal?.removeEventListener("abort", onAbort);
-      resolve4();
+      resolve5();
     };
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -5257,7 +5548,7 @@ async function remoteTail(opts) {
     ]
   });
   const filter = makeFilter(opts.query);
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let settled = false;
     const finish = (err) => {
       if (settled) return;
@@ -5268,11 +5559,11 @@ async function remoteTail(opts) {
       }
       opts.signal?.removeEventListener("abort", onAbort);
       if (err) reject(err);
-      else resolve4();
+      else resolve5();
     };
     const onAbort = () => finish();
     if (opts.signal?.aborted) {
-      resolve4();
+      resolve5();
       return;
     }
     opts.signal?.addEventListener("abort", onAbort, { once: true });
@@ -5326,7 +5617,7 @@ function resolveMode(opts) {
   if (opts.forceLocal && opts.forceRemote) {
     throw new Error("Cannot use both --local and --remote");
   }
-  const startDir = path13__default.resolve(opts.projectDir ?? process.cwd());
+  const startDir = path14__default.resolve(opts.projectDir ?? process.cwd());
   const localDb = findLogsDb(startDir);
   if (opts.forceLocal) {
     if (!localDb) {
@@ -5359,14 +5650,14 @@ function resolveMode(opts) {
 function findLogsDb(startDir) {
   let dir = startDir;
   for (let i = 0; i < MAX_WALK_LEVELS; i++) {
-    const candidate = path13__default.join(dir, ".skaile", "logs.db");
+    const candidate = path14__default.join(dir, ".skaile", "logs.db");
     if (existsSync(candidate)) {
       try {
         if (statSync(candidate).isFile()) return candidate;
       } catch {
       }
     }
-    const parent = path13__default.dirname(dir);
+    const parent = path14__default.dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -5392,7 +5683,7 @@ function readApiToken() {
 }
 function readGlobalSettings() {
   try {
-    const settingsPath = path13__default.join(homedir(), ".skaile", "settings.json");
+    const settingsPath = path14__default.join(homedir(), ".skaile", "settings.json");
     if (!existsSync(settingsPath)) return {};
     return JSON.parse(readFileSync(settingsPath, "utf8"));
   } catch {
@@ -5541,7 +5832,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const sessions = await listSessions(projectDir);
     const current = await loadSession(projectDir);
     if (sessions.length === 0) {
@@ -5569,7 +5860,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 = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     const session = await loadSessionById(projectDir, runId);
     if (!session) {
       logErr(`Session not found: ${runId}`);
@@ -5578,12 +5869,12 @@ function makeSessionCommand() {
     console.log(JSON.stringify(session, null, 2));
   });
   cmd.command("switch <run-id>").description("Switch the current session").option("--project-dir <path>", "Project directory", process.cwd()).action(async (runId, opts) => {
-    const projectDir = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     await setCurrentSession(projectDir, runId);
     logOk(`Switched to session: ${S.dim(runId.slice(0, 8))}`);
   });
   cmd.command("delete <run-id>").description("Delete a session").option("--project-dir <path>", "Project directory", process.cwd()).action(async (runId, opts) => {
-    const projectDir = path13__default.resolve(opts.projectDir);
+    const projectDir = path14__default.resolve(opts.projectDir);
     await deleteSession(projectDir, runId);
     logOk(`Deleted session: ${S.dim(runId.slice(0, 8))}`);
   });
@@ -5637,12 +5928,12 @@ function showOverview(am2) {
 }
 function showAsset(am2, kind, name) {
   const entry = am2.info(`${kind}:${name}`);
-  if (entry?.source && fs11__default.existsSync(entry.source)) {
+  if (entry?.source && fs12__default.existsSync(entry.source)) {
     console.log();
     console.log(`  ${kindColor(entry.kind)} ${S.heading(entry.name)}`);
     console.log(`  ${S.rule(40)}`);
     console.log();
-    console.log(fs11__default.readFileSync(entry.source, "utf-8"));
+    console.log(fs12__default.readFileSync(entry.source, "utf-8"));
     return;
   }
   logErr(`Asset not found: ${kind}:${name}`);
@@ -5651,7 +5942,7 @@ function showAsset(am2, kind, name) {
 function makeShowCommand() {
   return new Command("show").description("Show deployed assets overview, or print asset content").argument("[kind]", "Asset kind (skill, agent, prompt, flow, bundle, contract)").argument("[name]", "Asset name").option("--project-dir <path>", "Project directory", process.cwd()).option("--target <agent>", "Agent framework", "claude-code").action((kind, name, opts) => {
     const am2 = new AssetManager({
-      projectDir: path13__default.resolve(opts.projectDir),
+      projectDir: path14__default.resolve(opts.projectDir),
       driverTarget: opts.target
     });
     if (!kind) {
@@ -5688,11 +5979,8 @@ function addSourceManifestCommands(src) {
 }
 
 // cli/src/commands/source.ts
-function sourceClonePath(name) {
-  return path13.join(getGlobalCacheDir(), name);
-}
-function deriveSlug(url) {
-  return url.replace(/\.git$/, "").split(/[/:]/).pop() ?? "source";
+function sourceClonePath(key) {
+  return path14.join(getGlobalCacheDir(), key);
 }
 function normalizeSourceUrl(input) {
   const s = input.trim();
@@ -5703,9 +5991,14 @@ function normalizeSourceUrl(input) {
   return s;
 }
 function sourceMatchesKey(entry, key) {
-  if (entry.url === key || deriveSlug(entry.url) === key) return true;
+  if (entry.url === key) return true;
+  if (sourceCacheKey(entry.url) === key || sourceShortName(entry.url) === key) return true;
   return entry.url === normalizeSourceUrl(key);
 }
+function findCacheKeyCollision(sources, url) {
+  const key = sourceCacheKey(url);
+  return sources.find((s) => s.url !== url && sourceCacheKey(s.url) === key);
+}
 function requireProjectYamlPath() {
   const root = findWorkspaceRoot(process.cwd());
   if (!root) {
@@ -5714,7 +6007,7 @@ function requireProjectYamlPath() {
     );
     process.exit(1);
   }
-  return path13.join(root, workspaceConfigFilename());
+  return path14.join(root, workspaceConfigFilename());
 }
 function readProjectSources(yamlPath) {
   if (!existsSync(yamlPath)) return [];
@@ -5726,12 +6019,12 @@ function readProjectSources(yamlPath) {
   }
 }
 function ensureClone(entry, opts = {}) {
-  const slug = deriveSlug(entry.url);
-  const dest = sourceClonePath(slug);
+  const dest = sourceClonePath(sourceCacheKey(entry.url));
   if (existsSync(dest)) {
     if (!opts.force) return false;
     rmSync(dest, { recursive: true, force: true });
   }
+  mkdirSync(path14.dirname(dest), { recursive: true });
   const args = ["clone", entry.url, dest];
   if (entry.pin) args.splice(1, 0, "--branch", entry.pin);
   const clone = spawnSync("git", args, { stdio: "inherit" });
@@ -5744,11 +6037,11 @@ function ensureClone(entry, opts = {}) {
 async function refreshManifestCache(entry, includeDev = false) {
   const { manager, library, close } = await openLibraryManager();
   try {
-    const slug = deriveSlug(entry.url);
-    const dest = sourceClonePath(slug);
-    const existing = (await manager.listLibraries()).find((l) => l.name === slug);
+    const name = sourceShortName(entry.url);
+    const dest = sourceClonePath(sourceCacheKey(entry.url));
+    const existing = (await manager.listLibraries()).find((l) => l.name === name);
     const lib = existing ?? await manager.addLibrary({
-      name: slug,
+      name,
       path: dest,
       backend: "git",
       backendConfig: { url: entry.url, branch: entry.pin ?? "main", authHint: "ssh" },
@@ -5762,7 +6055,8 @@ async function refreshManifestCache(entry, includeDev = false) {
     close();
   }
 }
-async function dropManifestCache(name, purgeClone) {
+async function dropManifestCache(url, purgeClone) {
+  const name = sourceShortName(url);
   const { manager, close } = await openLibraryManager();
   try {
     const existing = (await manager.listLibraries()).find((l) => l.name === name);
@@ -5773,7 +6067,7 @@ async function dropManifestCache(name, purgeClone) {
     close();
   }
   if (purgeClone) {
-    const dest = sourceClonePath(name);
+    const dest = sourceClonePath(sourceCacheKey(url));
     if (existsSync(dest)) rmSync(dest, { recursive: true, force: true });
   }
 }
@@ -5787,19 +6081,27 @@ function makeSourceCommand() {
     async (source, opts) => {
       const url = normalizeSourceUrl(source);
       const yamlPath = requireProjectYamlPath();
+      const collision = findCacheKeyCollision(readProjectSources(yamlPath), url);
+      if (collision) {
+        logErr(
+          `"${url}" maps to the same cache key (${sourceCacheKey(url)}) as already-registered "${collision.url}". Remove that source first (skaile source remove) or re-use its exact URL to update it.`
+        );
+        process.exitCode = 1;
+        return;
+      }
       if (opts.name) {
         logWarn(
           "the --name flag is deprecated; the source entry now stores only the URL (the cache slug is derived from it)."
         );
       }
       const pin = opts.pin ?? opts.branch;
-      const slug = deriveSlug(url);
+      const slug = sourceShortName(url);
       const entry = { url };
       if (pin) entry.pin = pin;
       const editor = WorkspaceYamlEditor.load(yamlPath);
       editor.setSource(entry);
       editor.save();
-      const dest = sourceClonePath(slug);
+      const dest = sourceClonePath(sourceCacheKey(url));
       const preexisting = existsSync(dest);
       const cloned = ensureClone(entry, { force: opts.force });
       if (!cloned) {
@@ -5812,7 +6114,7 @@ function makeSourceCommand() {
       const result = await refreshManifestCache(entry, opts.dev);
       logOk(`Indexed ${result.assetsUpdated} of ${result.assetsFound} asset(s) from "${slug}".`);
       for (const err of result.errors) logWarn(err);
-      logOk(`Source "${slug}" registered in ${path13.relative(process.cwd(), yamlPath)}.`);
+      logOk(`Source "${slug}" registered in ${path14.relative(process.cwd(), yamlPath)}.`);
     }
   );
   cmd.command("list").description("List sources registered in this project's skaile.yaml").option("--json", "Output as JSON").action(async (opts) => {
@@ -5826,8 +6128,8 @@ function makeSourceCommand() {
     console.log();
     console.log(S.heading("  Sources"));
     for (const s of sources) {
-      const slug = deriveSlug(s.url);
-      const cached = existsSync(sourceClonePath(slug)) ? "" : S.warn(" (not cached)");
+      const slug = sourceShortName(s.url);
+      const cached = existsSync(sourceClonePath(sourceCacheKey(s.url))) ? "" : S.warn(" (not cached)");
       console.log(`  ${S.cmd(slug.padEnd(24))}  ${S.dim(s.url)}${cached}`);
     }
     console.log(`
@@ -5841,14 +6143,15 @@ function makeSourceCommand() {
       logErr(`No source matching "${key}" in ${yamlPath}.`);
       process.exit(1);
     }
-    const slug = deriveSlug(entry.url);
+    const slug = sourceShortName(entry.url);
+    const clonePath = sourceClonePath(sourceCacheKey(entry.url));
     console.log(
       JSON.stringify(
         {
           ...entry,
           slug,
-          clonePath: sourceClonePath(slug),
-          cached: existsSync(sourceClonePath(slug))
+          clonePath,
+          cached: existsSync(clonePath)
         },
         null,
         2
@@ -5863,10 +6166,10 @@ function makeSourceCommand() {
       logErr(`No source matching "${key}" in ${yamlPath}.`);
       process.exit(1);
     }
-    const slug = deriveSlug(match.url);
+    const slug = sourceShortName(match.url);
     editor.removeSource(match.url);
     editor.save();
-    await dropManifestCache(slug, opts.purge);
+    await dropManifestCache(match.url, opts.purge);
     logOk(
       opts.purge ? `Removed source "${slug}" and purged its clone.` : `Removed source "${slug}" from skaile.yaml (clone left in ~/.skaile/cache/sources/).`
     );
@@ -5890,7 +6193,11 @@ function makeSourceCommand() {
     } else {
       const selected = await p6.multiselect({
         message: "Select sources to sync",
-        options: sources.map((s) => ({ value: s.url, label: deriveSlug(s.url), hint: s.url })),
+        options: sources.map((s) => ({
+          value: s.url,
+          label: sourceShortName(s.url),
+          hint: s.url
+        })),
         required: true
       });
       if (p6.isCancel(selected)) {
@@ -5901,8 +6208,8 @@ function makeSourceCommand() {
       targets = sources.filter((s) => picked.has(s.url));
     }
     for (const entry of targets) {
-      const slug = deriveSlug(entry.url);
-      const dest = sourceClonePath(slug);
+      const slug = sourceShortName(entry.url);
+      const dest = sourceClonePath(sourceCacheKey(entry.url));
       if (!existsSync(dest)) {
         ensureClone(entry);
         logOk(`${slug}: cloned to ${dest}.`);
@@ -5940,10 +6247,10 @@ function makeStoreCommand() {
     if (opts.email) {
       const readline2 = await import('readline');
       const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
-      const password = await new Promise((resolve4) => {
+      const password = await new Promise((resolve5) => {
         rl.question("Password: ", (answer) => {
           rl.close();
-          resolve4(answer);
+          resolve5(answer);
         });
       });
       try {
@@ -6098,7 +6405,7 @@ function printTree(node, prefix = "", isLast = true) {
 }
 function makeTreeCommand() {
   return new Command("tree").description("Show full dependency tree").option("--project-dir <path>", "Project directory", process.cwd()).action((opts) => {
-    const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
     const root = am2.tree();
     if (root.children.length === 0) {
       logInfo("No dependencies in lock file. Run `skaile install` first.");
@@ -6116,7 +6423,7 @@ function makeUpdateCommand() {
         try {
           const catalogSpinner = p6.spinner();
           catalogSpinner.start("Refreshing catalog cache");
-          const remote = await openCatalogSource({ projectDir: path13__default.resolve(opts.projectDir) });
+          const remote = await openCatalogSource({ projectDir: path14__default.resolve(opts.projectDir) });
           const result2 = await remote.refresh();
           catalogSpinner.stop(
             `Catalog refreshed: ${S.heading(String(result2.assetsCached))} assets cached`
@@ -6128,7 +6435,7 @@ function makeUpdateCommand() {
         }
       }
       if (opts.catalogOnly) return;
-      const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
+      const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
       const spinner5 = p6.spinner();
       spinner5.start("Re-deploying assets");
       const result = await am2.install();
@@ -6162,12 +6469,12 @@ function findManifestCandidates(rootPath) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs11__default.readdirSync(dir, { withFileTypes: true });
+      entries = fs12__default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path13__default.join(dir, entry.name);
+      const fullPath = path14__default.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) walk(fullPath);
       } else if (entry.isFile()) {
@@ -6208,7 +6515,7 @@ function checkManifestIdentity(kind, parsed) {
   return null;
 }
 function parseManifestCandidate(c, absRoot) {
-  const content = fs11__default.readFileSync(c.filePath, "utf-8");
+  const content = fs12__default.readFileSync(c.filePath, "utf-8");
   if (c.filePath.endsWith(".md")) {
     const parsed = parseMdFrontmatter(content);
     if (parsed === null) {
@@ -6220,23 +6527,38 @@ function parseManifestCandidate(c, absRoot) {
     const parsed = c.filePath.endsWith(".json") ? JSON.parse(content) : parse(content);
     return { kind: "value", parsed };
   } catch (e) {
-    const relPath = path13__default.relative(absRoot, c.filePath);
+    const relPath = path14__default.relative(absRoot, c.filePath);
     logErr(`${relPath} \u2014 parse error: ${e instanceof Error ? e.message : String(e)}`);
     return { kind: "error" };
   }
 }
-function validateManifestCandidate(c, parsed, absRoot, registry) {
-  const relPath = path13__default.relative(absRoot, c.filePath);
+function validateManifestCandidate(c, parsed, absRoot, registry, strictConformance) {
+  const relPath = path14__default.relative(absRoot, c.filePath);
   let errors = 0;
+  let warnings = 0;
   const identityError = checkManifestIdentity(c.kind, parsed);
   if (identityError) {
     logErr(`${relPath} [${c.kind}] \u2014 ${identityError}`);
     errors++;
   }
+  if (c.kind === "skill" && parsed && typeof parsed === "object") {
+    const dirName = path14__default.basename(path14__default.dirname(c.filePath));
+    const findings = checkAgentSkillConformance(parsed, { dirName });
+    for (const f of findings) {
+      const line = `${relPath} [skill conformance] \u2014 ${f.field}: ${f.message}`;
+      if (strictConformance) {
+        logErr(line);
+        errors++;
+      } else {
+        logWarn(line);
+        warnings++;
+      }
+    }
+  }
   const provider = registry.getProvider(c.kind);
   if (!provider) {
     logWarn(`${relPath} [${c.kind}] \u2014 kind "${c.kind}" is not registered, skipping validation`);
-    return { errors, warnings: 1 };
+    return { errors, warnings: warnings + 1 };
   }
   const result = provider.validateManifest(parsed);
   if (!result.ok) {
@@ -6245,11 +6567,11 @@ function validateManifestCandidate(c, parsed, absRoot, registry) {
     }
     errors += result.errors.length;
   }
-  return { errors, warnings: 0 };
+  return { errors, warnings };
 }
-function validateManifests(rootPath) {
-  const absRoot = path13__default.resolve(rootPath);
-  if (!fs11__default.existsSync(absRoot)) {
+function validateManifests(rootPath, strictConformance) {
+  const absRoot = path14__default.resolve(rootPath);
+  if (!fs12__default.existsSync(absRoot)) {
     logErr(`Path does not exist: ${absRoot}`);
     return { total: 0, errors: 1, warnings: 0 };
   }
@@ -6264,7 +6586,13 @@ function validateManifests(rootPath) {
       errors++;
       continue;
     }
-    const delta = validateManifestCandidate(c, parseResult.parsed, absRoot, registry);
+    const delta = validateManifestCandidate(
+      c,
+      parseResult.parsed,
+      absRoot,
+      registry,
+      strictConformance
+    );
     errors += delta.errors;
     warnings += delta.warnings;
   }
@@ -6275,12 +6603,12 @@ function findWorkspaceManifests(rootPath) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs11__default.readdirSync(dir, { withFileTypes: true });
+      entries = fs12__default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path13__default.join(dir, entry.name);
+      const full = path14__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)) {
@@ -6343,14 +6671,14 @@ function validateWorkspaceAssets(parsed, relPath) {
   return errors;
 }
 function validateWorkspaceManifests(rootPath) {
-  const absRoot = path13__default.resolve(rootPath);
+  const absRoot = path14__default.resolve(rootPath);
   const files = findWorkspaceManifests(absRoot);
   let errors = 0;
   for (const file of files) {
-    const relPath = path13__default.relative(absRoot, file);
+    const relPath = path14__default.relative(absRoot, file);
     let parsed;
     try {
-      parsed = parse(fs11__default.readFileSync(file, "utf-8")) ?? {};
+      parsed = parse(fs12__default.readFileSync(file, "utf-8")) ?? {};
     } catch (e) {
       logErr(`${relPath} \u2014 parse error: ${e instanceof Error ? e.message : String(e)}`);
       errors++;
@@ -6364,34 +6692,34 @@ function validateWorkspaceManifests(rootPath) {
 var EXCLUDED_DOMAINS = /* @__PURE__ */ new Set(["skaileup-shared", "external", "docs"]);
 function collectAssetVersions() {
   const assets = [];
-  if (!fs11__default.existsSync(AI_RESOURCES)) return assets;
-  const domains = fs11__default.readdirSync(AI_RESOURCES, { withFileTypes: true }).filter((d) => d.isDirectory() && !EXCLUDED_DOMAINS.has(d.name));
+  if (!fs12__default.existsSync(AI_RESOURCES)) return assets;
+  const domains = fs12__default.readdirSync(AI_RESOURCES, { withFileTypes: true }).filter((d) => d.isDirectory() && !EXCLUDED_DOMAINS.has(d.name));
   for (const d of domains) {
-    const domainDir = path13__default.join(AI_RESOURCES, d.name);
-    const skillsDir = path13__default.join(domainDir, "skills");
-    if (fs11__default.existsSync(skillsDir)) {
+    const domainDir = path14__default.join(AI_RESOURCES, d.name);
+    const skillsDir = path14__default.join(domainDir, "skills");
+    if (fs12__default.existsSync(skillsDir)) {
       collectSkillVersions(skillsDir, d.name, assets);
     }
-    const agentsDir = path13__default.join(domainDir, "agents");
-    if (fs11__default.existsSync(agentsDir)) {
+    const agentsDir = path14__default.join(domainDir, "agents");
+    if (fs12__default.existsSync(agentsDir)) {
       collectAgentVersions(agentsDir, d.name, assets);
     }
-    const flowsDir = path13__default.join(domainDir, "flows");
-    if (fs11__default.existsSync(flowsDir)) {
+    const flowsDir = path14__default.join(domainDir, "flows");
+    if (fs12__default.existsSync(flowsDir)) {
       collectFlowVersions(flowsDir, d.name, assets);
     }
-    const promptsDir = path13__default.join(domainDir, "prompts");
-    if (fs11__default.existsSync(promptsDir)) {
+    const promptsDir = path14__default.join(domainDir, "prompts");
+    if (fs12__default.existsSync(promptsDir)) {
       collectPromptVersions(promptsDir, d.name, assets);
     }
   }
   return assets;
 }
 function collectFlowVersions(dir, domain, out) {
-  for (const f of fs11__default.readdirSync(dir)) {
+  for (const f of fs12__default.readdirSync(dir)) {
     if (!f.endsWith(".flow.yaml")) continue;
-    const fp = path13__default.join(dir, f);
-    const content = fs11__default.readFileSync(fp, "utf-8");
+    const fp = path14__default.join(dir, f);
+    const content = fs12__default.readFileSync(fp, "utf-8");
     const parsed = parse(content);
     out.push({
       kind: "flow",
@@ -6403,10 +6731,10 @@ function collectFlowVersions(dir, domain, out) {
   }
 }
 function collectPromptVersions(dir, domain, out) {
-  for (const f of fs11__default.readdirSync(dir)) {
+  for (const f of fs12__default.readdirSync(dir)) {
     if (!f.endsWith(".prompt.md")) continue;
-    const fp = path13__default.join(dir, f);
-    const content = fs11__default.readFileSync(fp, "utf-8");
+    const fp = path14__default.join(dir, f);
+    const content = fs12__default.readFileSync(fp, "utf-8");
     const fm = parseSkillFrontmatter(content);
     out.push({
       kind: "prompt",
@@ -6418,12 +6746,12 @@ function collectPromptVersions(dir, domain, out) {
   }
 }
 function collectSkillVersions(dir, domain, out) {
-  for (const entry of fs11__default.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs12__default.readdirSync(dir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const full = path13__default.join(dir, entry.name);
-    const skillMd = path13__default.join(full, "SKILL.md");
-    if (fs11__default.existsSync(skillMd)) {
-      const content = fs11__default.readFileSync(skillMd, "utf-8");
+    const full = path14__default.join(dir, entry.name);
+    const skillMd = path14__default.join(full, "SKILL.md");
+    if (fs12__default.existsSync(skillMd)) {
+      const content = fs12__default.readFileSync(skillMd, "utf-8");
       const fm = parseSkillFrontmatter(content);
       out.push({
         kind: "skill",
@@ -6438,11 +6766,11 @@ function collectSkillVersions(dir, domain, out) {
   }
 }
 function collectAgentVersions(dir, domain, out) {
-  for (const entry of fs11__default.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs12__default.readdirSync(dir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const agentYaml = path13__default.join(dir, entry.name, "agent.yaml");
-    if (!fs11__default.existsSync(agentYaml)) continue;
-    const content = fs11__default.readFileSync(agentYaml, "utf-8");
+    const agentYaml = path14__default.join(dir, entry.name, "agent.yaml");
+    if (!fs12__default.existsSync(agentYaml)) continue;
+    const content = fs12__default.readFileSync(agentYaml, "utf-8");
     const parsed = parse(content);
     out.push({
       kind: "agent",
@@ -6473,7 +6801,7 @@ function filterToChangedAssets(assets) {
       encoding: "utf-8"
     });
     const changedFiles = new Set(
-      diffOutput.trim().split("\n").filter(Boolean).map((f) => path13__default.resolve(AI_RESOURCES, f))
+      diffOutput.trim().split("\n").filter(Boolean).map((f) => path14__default.resolve(AI_RESOURCES, f))
     );
     return assets.filter((a) => changedFiles.has(a.filePath));
   } catch {
@@ -6499,7 +6827,7 @@ function checkVersionBumps(assets) {
   let warnings = 0;
   for (const a of assets) {
     if (!a.version) continue;
-    const relPath = path13__default.relative(AI_RESOURCES, a.filePath);
+    const relPath = path14__default.relative(AI_RESOURCES, a.filePath);
     try {
       const headContent = execSync(`git show HEAD:${relPath}`, {
         cwd: AI_RESOURCES,
@@ -6525,7 +6853,7 @@ function checkFlowVersionPins(assets) {
   }
   let errors = 0;
   for (const f of flows) {
-    const content = fs11__default.readFileSync(f.filePath, "utf-8");
+    const content = fs12__default.readFileSync(f.filePath, "utf-8");
     const parsed = parse(content);
     const nodes = (parsed?.nodes ?? []).filter((n) => n.type === "skill" && n.data?.version).map((n) => ({
       nodeId: n.id,
@@ -6571,14 +6899,21 @@ function makeValidateCommand() {
   const cmd = new Command("validate").description(
     "Validate asset manifests, versions, and changelogs"
   );
-  cmd.argument("[path]", "Path to asset repo or directory to validate", ".").action((targetPath) => {
-    const absPath = path13__default.resolve(targetPath);
+  cmd.argument("[path]", "Path to asset repo or directory to validate", ".").option(
+    "--strict-conformance",
+    "Treat Agent Skills (agentskills.io) standard findings as errors"
+  ).action((targetPath, opts) => {
+    const absPath = path14__default.resolve(targetPath);
     logInfo(`Validating manifests in ${absPath}`);
-    const { total, errors } = validateManifests(absPath);
+    const { total, errors, warnings } = validateManifests(
+      absPath,
+      opts.strictConformance ?? false
+    );
     const ws = validateWorkspaceManifests(absPath);
     const totalErrors = errors + ws.errors;
     console.log();
     logInfo(`Scanned ${total} asset manifest(s) and ${ws.total} skaile.yaml file(s)`);
+    if (warnings > 0) logWarn(`${warnings} conformance warning(s)`);
     if (totalErrors === 0) {
       logOk("All manifests valid");
     } else {
@@ -6618,7 +6953,7 @@ function makeValidateCommand() {
     let errors = 0;
     for (const domain of modifiedDomains) {
       const changelogModified = modifiedFiles.some(
-        (f) => f === `${domain}/CHANGELOG.md` || f === path13__default.join(domain, "CHANGELOG.md")
+        (f) => f === `${domain}/CHANGELOG.md` || f === path14__default.join(domain, "CHANGELOG.md")
       );
       if (changelogModified) {
         logOk(`${domain}/CHANGELOG.md updated`);
@@ -6700,7 +7035,7 @@ function makeVerifyCommand() {
 }
 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((ref, opts) => {
-    const am2 = new AssetManager({ projectDir: path13__default.resolve(opts.projectDir) });
+    const am2 = new AssetManager({ projectDir: path14__default.resolve(opts.projectDir) });
     const chain = am2.why(ref);
     if (chain.length === 0) {
       logErr(`${ref} not found in lock file. Run \`skaile install\` first.`);
@@ -6721,7 +7056,7 @@ function makeWhyCommand() {
 var _defaultFormatHelp = Help.prototype.formatHelp;
 var pkg = JSON.parse(
   readFileSync(
-    path13__default.resolve(path13__default.dirname(fileURLToPath(import.meta.url)), "../../package.json"),
+    path14__default.resolve(path14__default.dirname(fileURLToPath(import.meta.url)), "../../package.json"),
     "utf-8"
   )
 );
@@ -6842,7 +7177,7 @@ program.command("init [project-dir]").description("Initialize a project director
   (projectDir, opts) => runInit(projectDir, opts)
 );
 async function runInit(projectDir, opts) {
-  const { mkdirSync: mkdirSync3, writeFileSync: writeFileSync2 } = await import('fs');
+  const { mkdirSync: mkdirSync6, writeFileSync: writeFileSync4 } = await import('fs');
   const { stringify } = await import('yaml');
   const { DRIVER_TARGETS, SUPPORTED_DRIVER_TARGETS: SUPPORTED_DRIVER_TARGETS2 } = await import('../core/index.js');
   const backend = opts.backend;
@@ -6851,33 +7186,33 @@ async function runInit(projectDir, opts) {
     process.exitCode = 1;
     return;
   }
-  const resolved = path13__default.resolve(projectDir ?? ".");
-  const projectName = path13__default.basename(resolved);
+  const resolved = path14__default.resolve(projectDir ?? ".");
+  const projectName = path14__default.basename(resolved);
   const created = [];
-  const { existsSync: existsSync13 } = await import('fs');
-  if (!existsSync13(resolved)) {
-    mkdirSync3(resolved, { recursive: true });
+  const { existsSync: existsSync14 } = await import('fs');
+  if (!existsSync14(resolved)) {
+    mkdirSync6(resolved, { recursive: true });
     created.push(".");
   }
-  const skaileDir = path13__default.join(resolved, ".skaile");
-  if (!existsSync13(skaileDir)) {
-    mkdirSync3(path13__default.join(skaileDir, "sessions"), { recursive: true });
+  const skaileDir = path14__default.join(resolved, ".skaile");
+  if (!existsSync14(skaileDir)) {
+    mkdirSync6(path14__default.join(skaileDir, "sessions"), { recursive: true });
     created.push(".skaile/");
   }
-  const settingsPath = path13__default.join(skaileDir, "settings.json");
-  if (!existsSync13(settingsPath)) {
-    writeFileSync2(settingsPath, "{}\n");
+  const settingsPath = path14__default.join(skaileDir, "settings.json");
+  if (!existsSync14(settingsPath)) {
+    writeFileSync4(settingsPath, "{}\n");
     created.push(".skaile/settings.json");
   }
-  const wsConfigPath = path13__default.join(resolved, "skaile.yaml");
-  if (!existsSync13(wsConfigPath)) {
-    writeFileSync2(wsConfigPath, stringify(buildInitWorkspaceConfig(projectName, backend)));
+  const wsConfigPath = path14__default.join(resolved, "skaile.yaml");
+  if (!existsSync14(wsConfigPath)) {
+    writeFileSync4(wsConfigPath, stringify(buildInitWorkspaceConfig(projectName, backend)));
     created.push("skaile.yaml");
   }
   for (const dir of new Set(Object.values(DRIVER_TARGETS[backend].local))) {
-    const full = path13__default.join(resolved, dir);
-    if (!existsSync13(full)) {
-      mkdirSync3(full, { recursive: true });
+    const full = path14__default.join(resolved, dir);
+    if (!existsSync14(full)) {
+      mkdirSync6(full, { recursive: true });
       created.push(`${dir}/`);
     }
   }
@@ -6907,8 +7242,8 @@ function buildInitWorkspaceConfig(projectName, backend) {
 }
 async function initGitScaffold(resolved, created) {
   const { execSync: execSync3 } = await import('child_process');
-  const { existsSync: existsSync13, readFileSync: readFileSync6, writeFileSync: writeFileSync2 } = await import('fs');
-  const gitignorePath = path13__default.join(resolved, ".gitignore");
+  const { existsSync: existsSync14, readFileSync: readFileSync8, writeFileSync: writeFileSync4 } = await import('fs');
+  const gitignorePath = path14__default.join(resolved, ".gitignore");
   const entries = [
     "node_modules/",
     ".skaile/sessions/",
@@ -6917,16 +7252,16 @@ async function initGitScaffold(resolved, created) {
     ".env",
     ".env.local"
   ];
-  const existing = existsSync13(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : "";
+  const existing = existsSync14(gitignorePath) ? readFileSync8(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" : "";
-    writeFileSync2(gitignorePath, `${existing + prefix}${append.join("\n")}
+    writeFileSync4(gitignorePath, `${existing + prefix}${append.join("\n")}
 `);
     if (!existing) created.push(".gitignore");
   }
-  if (!existsSync13(path13__default.join(resolved, ".git"))) {
+  if (!existsSync14(path14__default.join(resolved, ".git"))) {
     try {
       execSync3("git init", { cwd: resolved, stdio: "pipe" });
       created.push(".git/");
@@ -6938,10 +7273,10 @@ async function initGitScaffold(resolved, created) {
 }
 async function bootstrapUserConfig() {
   try {
-    const fs12 = await import('fs');
+    const fs13 = await import('fs');
     const { userConfigPath, saveConfig, getConfigDefaults } = await import('../library/index.js');
     const userCfgPath = userConfigPath();
-    if (!fs12.existsSync(userCfgPath)) {
+    if (!fs13.existsSync(userCfgPath)) {
       const defaults = getConfigDefaults();
       saveConfig(userCfgPath, {
         catalog: { url: defaults.catalog.url, cache_ttl: defaults.catalog.cache_ttl }
@@ -6956,7 +7291,7 @@ async function bootstrapUserConfig() {
 }
 async function hydrateInitSources(resolved, created) {
   try {
-    const { ensureSourcesCloned } = await import('../ensure-sources-NSDMTAWN.js');
+    const { ensureSourcesCloned } = await import('../ensure-sources-KLCGXVE6.js');
     const hydrate = ensureSourcesCloned(resolved, { quiet: true });
     for (const n of hydrate.cloned) created.push(`~/.skaile/cache/sources/${n}/`);
     if (hydrate.failed.length > 0) {
@@ -6972,7 +7307,7 @@ function printInitSummary(resolved, projectDir, created) {
   logOk(`Initialized project at ${S.heading(resolved)}`);
   console.log();
   console.log(S.heading("  Next steps:"));
-  const isCurrentDir = resolved === path13__default.resolve(".");
+  const isCurrentDir = resolved === path14__default.resolve(".");
   let step = 1;
   if (!isCurrentDir) {
     console.log(`  ${S.dim(`${step}.`)} ${S.cmd(`cd ${projectDir}`)}`);
@@ -6984,7 +7319,7 @@ function printInitSummary(resolved, projectDir, created) {
   console.log();
 }
 program.command("setup").description("Interactive provider setup wizard").action(async () => {
-  const { cmdSetup } = await import('../setup-VGZTFQ32.js');
+  const { cmdSetup } = await import('../setup-AYH6SR4U.js');
   await cmdSetup([], { projectDir: process.cwd() });
 });
 program.addCommand(makeInstallCommand());