@skaile/workspaces 0.21.0 → 0.22.0-beta.1

package/dist/{chunk-DEQ3OOTU.js → chunk-VCYXVP2S.js}

@@ -1,17 +1,32 @@
-import { removeAsset, deployAll, createScaffold } from './chunk-XGWGLIHZ.js';
-import { readLock, buildLockFile, writeLock, verifyLock, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-W5DFC35Z.js';
+import { removeAsset, deployAll, createScaffold } from './chunk-PTIHB2TV.js';
+import { writeLock, buildLockFile, readLock, verifyLock, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-UMOENHVH.js';
+import { resolveRuntimeAssets } from './chunk-GFNW72LW.js';
+import { resolveSkWorkspaceConfig, getRepoCommit, ensureRepo, buildProvenanceIndex, resolveAll, scanRepo, checkRepoStatus, resolveAsset, readLinks, getGlobalCacheDir } from './chunk-J3VKAEQP.js';
+import { parseAssetRef } from './chunk-I3UEM3FX.js';
 import { deployedBase, isDeployed, deployedDir } from './chunk-JKNWJ64A.js';
-import { resolveRuntimeAssets } from './chunk-DFUXWNTS.js';
-import { resolveSkWorkspaceConfig, ensureRepo, resolveAll, resolveAsset, scanRepo, checkRepoStatus, readLinks, getGlobalCacheDir } from './chunk-5QNQLSBW.js';
-import { parseAssetRef } from './chunk-37JKX6D7.js';
 import { appendHistory, getRecentHistory, clearHistory } from './chunk-KTBKW2FI.js';
 import { commitChanges } from './chunk-UQ6LFBPZ.js';
 import { spawnSync } from 'child_process';
-import { existsSync, readFileSync, readdirSync, rmSync, lstatSync, unlinkSync, writeFileSync } from 'fs';
+import { existsSync, readdirSync, rmSync, lstatSync, unlinkSync, readFileSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { resolve, join, dirname } from 'path';
 import { parse, stringify } from 'yaml';
 
+function sourceSlug(url) {
+  return url.replace(/\.git$/, "").split(/[/:]/).pop() ?? "source";
+}
+function parseCanonicalLockKey(key) {
+  const slash = key.indexOf("/");
+  const colon = key.indexOf(":", slash + 1);
+  const at = key.lastIndexOf("@");
+  if (slash === -1 || colon === -1 || at === -1 || at < colon) return {};
+  return {
+    publisher: key.slice(0, slash),
+    kind: key.slice(slash + 1, colon),
+    name: key.slice(colon + 1, at),
+    version: key.slice(at + 1)
+  };
+}
 var AssetManager = class {
   /** Resolved absolute path to the workspace root. */
   projectDir;
@@ -37,44 +52,85 @@ var AssetManager = class {
     return { driverTarget: this.driverTarget, global: this.global, cwd: this.projectDir };
   }
   loadConfig() {
-    const configPath = join(this.projectDir, "skaile.yaml");
-    let raw = {};
-    if (existsSync(configPath)) {
-      try {
-        raw = parse(readFileSync(configPath, "utf8")) ?? {};
-      } catch {
-      }
-    }
     const config = resolveSkWorkspaceConfig(this.projectDir);
+    const sources = config.sources ?? [];
+    const stores = config.stores ?? [];
+    const dependencies = config.dependencies ?? [];
+    const overrides = config.overrides ?? [];
+    const patches = config.patches ?? {};
+    const skaileHome = process.env.SKAILE_HOME ?? join(homedir(), ".skaile");
+    const sourcesDir = join(skaileHome, "sources");
     const repositories = {};
-    let dependencies = raw.dependencies ?? [];
-    const patches = raw.patches ?? {};
-    const aiResources = raw.ai_resources ?? config.ai_resources;
-    if (aiResources?.length) {
-      for (const entry of aiResources) {
-        if (repositories[entry.name]) continue;
-        const isUrl = /^(https?:|git@|git:)/.test(entry.path);
-        repositories[entry.name] = isUrl ? { url: entry.path, branch: entry.branch } : { path: entry.path, branch: entry.branch };
-        if (entry.dependencies) {
-          dependencies = [...dependencies, ...entry.dependencies];
-        }
+    for (const s of sources) {
+      const slug = sourceSlug(s.url);
+      if (repositories[slug]) continue;
+      repositories[slug] = { path: join(sourcesDir, slug), url: s.url, branch: s.pin };
+    }
+    return { repositories, sources, stores, dependencies, overrides, patches, config };
+  }
+  /** Build provenance-index clones from the resolved source declarations. */
+  buildClones(repositories) {
+    const clones = [];
+    for (const [slug, decl] of Object.entries(repositories)) {
+      const localPath = this.resolveRepoDir(decl, slug);
+      if (!localPath || !existsSync(localPath)) continue;
+      const commit = getRepoCommit(localPath) ?? "0".repeat(40);
+      clones.push({
+        localPath,
+        sourceUrl: decl.url ?? localPath,
+        commit,
+        tag: decl.branch
+      });
+    }
+    return clones;
+  }
+  /**
+   * Bridge a resolved {@link ProvenanceCandidate} to a {@link CatalogEntry} for
+   * the deploy pipeline. `source` is the absolute path to the asset's primary
+   * manifest (or its directory) inside the clone; `publisher` is set to the
+   * clone slug so `deployAll`'s repositories lookup resolves local-vs-remote.
+   */
+  candidateToCatalogEntry(c, repositories) {
+    let slug;
+    let cloneDir;
+    for (const [s, decl] of Object.entries(repositories)) {
+      if (decl.url === c.sourceUrl) {
+        slug = s;
+        cloneDir = this.resolveRepoDir(decl, s) ?? void 0;
+        break;
       }
     }
-    const sourcesRaw = raw.sources ?? config.sources ?? [];
-    if (sourcesRaw.length > 0) {
-      const skaileHome = process.env.SKAILE_HOME ?? join(homedir(), ".skaile");
-      const sourcesDir = join(skaileHome, "sources");
-      for (const entry of sourcesRaw) {
-        if (!entry?.name || !entry.url) continue;
-        if (repositories[entry.name]) continue;
-        repositories[entry.name] = {
-          path: join(sourcesDir, entry.name),
-          url: entry.url,
-          branch: entry.branch
-        };
+    if (!cloneDir) {
+      const first = Object.entries(repositories)[0];
+      if (first) {
+        slug = first[0];
+        cloneDir = this.resolveRepoDir(first[1], first[0]) ?? void 0;
       }
     }
-    return { repositories, dependencies, patches, config };
+    if (!cloneDir || !slug) return null;
+    const MD_BY_KIND = {
+      skill: "SKILL.md",
+      agent: "AGENT.md",
+      bundle: "BUNDLE.md",
+      "mcp-server": "MCP.md",
+      connector: "CONNECTOR.md",
+      prompt: "PROMPT.md",
+      contract: "CONTRACT.md"
+    };
+    const mdName = MD_BY_KIND[c.kind];
+    const mdRel = c.files.find((f) => mdName ? f.path.endsWith(mdName) : false)?.path;
+    const source = mdRel ? join(cloneDir, mdRel) : cloneDir;
+    return {
+      name: c.name,
+      kind: c.kind,
+      description: "",
+      source,
+      publisher: slug,
+      version: c.version,
+      requires: [],
+      dependencies: [],
+      metadata: c.metadata
+    };
   }
   // ── Install / resolve ──────────────────────────────────────────────────
   /**
@@ -89,50 +145,46 @@ var AssetManager = class {
    * @returns {@link InstallResult} summarising what was deployed, what was missing, and any collisions.
    */
   async install(opts) {
-    const { repositories, dependencies, patches } = this.loadConfig();
+    const { repositories, stores, dependencies, overrides, patches } = this.loadConfig();
     if (opts?.locked) {
       return this.installLocked(repositories, patches);
     }
     for (const [name, decl] of Object.entries(repositories)) {
       try {
         ensureRepo(decl, name, this.reposDir, { projectDir: this.projectDir });
-      } catch (err) {
-        return {
-          deployed: [],
-          removed: [],
-          missing: [`repo:${name}`],
-          lockWritten: false,
-          collisions: []
-        };
+      } catch {
+        return { deployed: [], removed: [], missing: [`source:${name}`], lockWritten: false };
       }
     }
-    const { resolved, missing, resolvedBy, collisions } = resolveAll(
-      dependencies,
-      repositories,
-      this.reposDir,
-      { projectDir: this.projectDir }
+    const provenanceIndex = buildProvenanceIndex(this.buildClones(repositories), {
+      projectDir: this.projectDir
+    });
+    const { resolved, missing, overridesApplied } = await resolveAll(dependencies, {
+      provenanceIndex,
+      overrides,
+      stores,
+      storeFetcher: this.buildStoreFetcher(stores),
+      projectDir: this.projectDir
+    });
+    const oldLock = this.tryReadLock();
+    const resolvedRefs = new Set(
+      resolved.map((c) => `${c.publisher}/${c.kind}:${c.name}@${c.version}`)
     );
-    const oldLock = readLock(this.lockPath);
-    const resolvedRefs = new Set(resolved.map((e) => `${e.kind}:${e.name}`));
     const removed = [];
     if (oldLock) {
       for (const ref of Object.keys(oldLock.assets)) {
         if (!resolvedRefs.has(ref)) {
-          const [kind, name] = ref.split(":");
-          removeAsset(kind, name, this.deployOpts);
-          removed.push(ref);
+          const { kind, name } = parseCanonicalLockKey(ref);
+          if (kind && name) {
+            removeAsset(kind, name, this.deployOpts);
+            removed.push(ref);
+          }
         }
       }
     }
-    const deployed = deployAll(resolved, repositories, patches, this.deployOpts);
-    const lockData = buildLockFile(
-      repositories,
-      resolved,
-      resolvedBy,
-      this.reposDir,
-      this.projectDir
-    );
-    writeLock(this.lockPath, lockData);
+    const entries = resolved.map((c) => this.candidateToCatalogEntry(c, repositories)).filter((e) => e !== null);
+    const deployed = deployAll(entries, repositories, patches, this.deployOpts);
+    writeLock(this.lockPath, buildLockFile(resolved, overridesApplied));
     for (const ref of deployed) {
       appendHistory(this.projectDir, {
         ref,
@@ -150,14 +202,41 @@ var AssetManager = class {
       });
     }
     const { npmInstalled, npmFailed } = await this.installRuntimeAssetDeps();
+    return { deployed, removed, missing, lockWritten: true, npmInstalled, npmFailed };
+  }
+  /** Read the lock, returning null on a legacy v1 lock instead of throwing. */
+  tryReadLock() {
+    try {
+      return readLock(this.lockPath);
+    } catch {
+      return null;
+    }
+  }
+  /** Build a store fetcher from the configured stores, or undefined when none. */
+  buildStoreFetcher(stores) {
+    if (stores.length === 0) return void 0;
     return {
-      deployed,
-      removed,
-      missing,
-      lockWritten: true,
-      collisions,
-      npmInstalled,
-      npmFailed
+      getInstallManifest: async (storeUrl, ref) => {
+        const { RemoteCatalogSource, CatalogHttpError } = await import('./library/index.js');
+        const src = new RemoteCatalogSource({ baseUrl: storeUrl });
+        try {
+          const m = await src.getInstallManifest(ref);
+          return {
+            sourceUrl: m.source.url,
+            commit: m.source.commitSha,
+            sha256: m.sha256,
+            files: m.files
+          };
+        } catch (err) {
+          if (err instanceof CatalogHttpError && err.status === 404) return null;
+          throw err;
+        }
+      },
+      getCanonicalDigest: async (storeUrl, ref) => {
+        const { RemoteCatalogSource } = await import('./library/index.js');
+        const src = new RemoteCatalogSource({ baseUrl: storeUrl });
+        return src.getCanonicalDigest(ref);
+      }
     };
   }
   /**
@@ -192,19 +271,22 @@ var AssetManager = class {
     return { npmInstalled, npmFailed };
   }
   installLocked(repositories, patches) {
-    const lock = readLock(this.lockPath);
+    const lock = this.tryReadLock();
     if (!lock) {
       throw new Error("No lock file found. Run `skaile install` first.");
     }
-    for (const [name, lockRepo] of Object.entries(lock.repositories)) {
-      const decl = repositories[name] ?? {
-        url: lockRepo.url,
-        path: lockRepo.path,
-        branch: lockRepo.branch
-      };
-      ensureRepo(decl, name, this.reposDir, { projectDir: this.projectDir });
+    const declBySlug = new Map(Object.entries(repositories));
+    for (const src of lock.sources) {
+      const slug = sourceSlug(src.url);
+      const decl = declBySlug.get(slug) ?? { url: src.url };
+      ensureRepo(decl, slug, this.reposDir, { projectDir: this.projectDir, pin: src.commit });
     }
-    const verification = verifyLock(lock, this.reposDir);
+    const resolveCloneDir = (sourceUrl) => {
+      const slug = sourceSlug(sourceUrl);
+      const decl = declBySlug.get(slug) ?? { url: sourceUrl };
+      return this.resolveRepoDir(decl, slug);
+    };
+    const verification = verifyLock(lock, resolveCloneDir);
     if (!verification.ok) {
       const issues = [
         ...verification.drifted.map((r) => `drifted: ${r}`),
@@ -215,27 +297,25 @@ var AssetManager = class {
     }
     const resolved = [];
     for (const [ref, entry] of Object.entries(lock.assets)) {
-      const [kind, name] = ref.split(":");
-      const repoDecl = repositories[entry.repository];
-      let repoDir;
-      if (repoDecl?.path) {
-        repoDir = resolve(this.projectDir, repoDecl.path);
-      } else {
-        repoDir = join(this.reposDir, entry.repository);
-      }
+      const { publisher, kind, name } = parseCanonicalLockKey(ref);
+      if (!publisher || !kind || !name) continue;
+      const slug = sourceSlug(entry.source.url);
+      const cloneDir = resolveCloneDir(entry.source.url) ?? join(this.reposDir, slug);
+      const mdRel = entry.files.find((f) => /\.(md|yaml)$/i.test(f.path))?.path ?? entry.files[0]?.path ?? "";
       resolved.push({
         name,
         kind,
         description: "",
-        source: join(repoDir, entry.source),
-        repository: entry.repository,
-        version: entry.version,
+        source: mdRel ? join(cloneDir, mdRel) : cloneDir,
+        publisher: slug,
+        version: entry.source.commit,
         requires: [],
         dependencies: []
       });
+      if (!repositories[slug]) repositories[slug] = { url: entry.source.url, path: cloneDir };
     }
     const deployed = deployAll(resolved, repositories, patches, this.deployOpts);
-    return { deployed, removed: [], missing: [], lockWritten: false, collisions: [] };
+    return { deployed, removed: [], missing: [], lockWritten: false };
   }
   /**
    * Add a single asset (and its transitive dependencies) to the workspace.
@@ -247,21 +327,31 @@ var AssetManager = class {
    * @returns Array of asset refs that were deployed in this call.
    * @throws When the asset cannot be found in any configured repository.
    */
-  add(ref) {
-    const { repositories, patches } = this.loadConfig();
-    const parsed = parseAssetRef(ref);
+  async add(ref) {
+    const { repositories, stores, overrides, patches } = this.loadConfig();
+    parseAssetRef(ref);
     for (const [name, decl] of Object.entries(repositories)) {
       try {
         ensureRepo(decl, name, this.reposDir, { projectDir: this.projectDir });
       } catch {
       }
     }
-    const entry = resolveAsset(parsed, repositories, this.reposDir);
-    if (!entry) throw new Error(`Asset not found: ${ref}`);
-    const { resolved, missing } = resolveAll([ref], repositories, this.reposDir);
-    const deployed = deployAll(resolved, repositories, patches, this.deployOpts);
-    const depRef = `${parsed.kind}:${parsed.name}`;
-    this.addDependencyToConfig(depRef);
+    const provenanceIndex = buildProvenanceIndex(this.buildClones(repositories), {
+      projectDir: this.projectDir
+    });
+    const { resolved, missing } = await resolveAll([ref], {
+      provenanceIndex,
+      overrides,
+      stores,
+      storeFetcher: this.buildStoreFetcher(stores),
+      projectDir: this.projectDir
+    });
+    if (resolved.length === 0) {
+      throw new Error(`Asset not found: ${ref}${missing.length ? ` (missing: ${missing.join(", ")})` : ""}`);
+    }
+    const entries = resolved.map((c) => this.candidateToCatalogEntry(c, repositories)).filter((e) => e !== null);
+    const deployed = deployAll(entries, repositories, patches, this.deployOpts);
+    this.addDependencyToConfig(ref);
     for (const d of deployed) {
       appendHistory(this.projectDir, {
         ref: d,
@@ -332,7 +422,7 @@ var AssetManager = class {
     for (const [name, decl] of Object.entries(repositories)) {
       const repoDir = this.resolveRepoDir(decl, name);
       if (!repoDir) continue;
-      if (parsed.repository && parsed.repository !== name) continue;
+      if (parsed.publisher && parsed.publisher !== name) continue;
       const entries = scanRepo(repoDir, name);
       const match = entries.find((e) => e.kind === parsed.kind && e.name === parsed.name);
       if (match) return match;
@@ -393,7 +483,7 @@ var AssetManager = class {
    */
   overview() {
     const { repositories } = this.loadConfig();
-    const lock = readLock(this.lockPath);
+    const lock = this.tryReadLock();
     const deployed = this.listDeployed();
     const repoStatuses = /* @__PURE__ */ new Map();
     for (const [name, decl] of Object.entries(repositories)) {
@@ -406,23 +496,34 @@ var AssetManager = class {
         error: status.error
       });
     }
+    const lockByKindName = /* @__PURE__ */ new Map();
+    for (const [key] of Object.entries(lock?.assets ?? {})) {
+      const parsed = parseCanonicalLockKey(key);
+      if (parsed.kind && parsed.name && parsed.publisher && parsed.version) {
+        lockByKindName.set(`${parsed.kind}:${parsed.name}`, {
+          publisher: parsed.publisher,
+          version: parsed.version,
+          url: lock.assets[key].source.url
+        });
+      }
+    }
     const entries = [];
     for (const d of deployed) {
-      const lockKey = `${d.kind}:${d.name}`;
-      const lockEntry = lock?.assets[lockKey];
-      const domain = lockEntry?.domain ?? "unknown";
-      const repository = lockEntry?.repository ?? "";
+      const lockEntry = lockByKindName.get(`${d.kind}:${d.name}`);
+      const publisher = lockEntry?.publisher ?? "";
       const version = lockEntry?.version ?? "";
+      const slug = lockEntry ? sourceSlug(lockEntry.url) : "";
       let syncStatus = "unknown";
-      if (repository) {
-        const repoStatus = repoStatuses.get(repository);
+      if (slug) {
+        const repoStatus = repoStatuses.get(slug);
         if (!repoStatus) syncStatus = "unknown";
         else if (repoStatus.kind === "local") syncStatus = "local";
         else if (repoStatus.error) syncStatus = "error";
         else if (repoStatus.upToDate) syncStatus = "synced";
         else syncStatus = "outdated";
       }
-      entries.push({ kind: d.kind, name: d.name, domain, repository, version, syncStatus });
+      const domain = publisher || "unknown";
+      entries.push({ kind: d.kind, name: d.name, domain, publisher, version, syncStatus });
     }
     const byDomain = /* @__PURE__ */ new Map();
     for (const e of entries) {
@@ -452,22 +553,11 @@ var AssetManager = class {
    *   Returns a single node with `ref === "(no lock file)"` when no lock exists.
    */
   tree() {
-    const lock = readLock(this.lockPath);
+    const lock = this.tryReadLock();
     if (!lock) return { ref: "(no lock file)", children: [] };
-    const byParent = /* @__PURE__ */ new Map();
-    for (const [ref, entry] of Object.entries(lock.assets)) {
-      const parent = entry.resolved_by;
-      if (!byParent.has(parent)) byParent.set(parent, []);
-      byParent.get(parent).push(ref);
-    }
-    function buildNode(ref) {
-      const children = (byParent.get(ref) ?? []).map(buildNode);
-      return { ref, children };
-    }
-    const directChildren = byParent.get("direct") ?? [];
     return {
       ref: "project",
-      children: directChildren.map(buildNode)
+      children: Object.keys(lock.assets).map((ref) => ({ ref, children: [] }))
     };
   }
   /**
@@ -478,22 +568,10 @@ var AssetManager = class {
    *   the asset is not in the lock file.
    */
   why(ref) {
-    const lock = readLock(this.lockPath);
+    const lock = this.tryReadLock();
     if (!lock) return [];
     if (!lock.assets[ref]) return [];
-    const chain = [];
-    let current = ref;
-    const seen = /* @__PURE__ */ new Set();
-    while (current && current !== "direct") {
-      if (seen.has(current)) break;
-      seen.add(current);
-      chain.push(current);
-      const entry = lock.assets[current];
-      if (!entry) break;
-      current = entry.resolved_by;
-    }
-    if (current === "direct") chain.push("direct (skaile.yaml)");
-    return chain;
+    return [ref, "direct (skaile.yaml)"];
   }
   /**
    * List installed assets whose source repository is behind the remote.
@@ -505,27 +583,26 @@ var AssetManager = class {
    */
   outdated() {
     const { repositories } = this.loadConfig();
-    const lock = readLock(this.lockPath);
+    const lock = this.tryReadLock();
     if (!lock) return [];
     const result = [];
-    for (const [name, lockRepo] of Object.entries(lock.repositories)) {
-      if (!lockRepo.commit || lockRepo.path) continue;
-      const decl = repositories[name];
-      if (!decl) continue;
-      const status = checkRepoStatus(decl, name, this.reposDir);
-      if (status.behind > 0) {
-        for (const [ref, entry] of Object.entries(lock.assets)) {
-          if (entry.repository === name) {
-            const [kind, assetName] = ref.split(":");
-            result.push({
-              kind,
-              name: assetName,
-              repository: name,
-              currentVersion: entry.version,
-              behind: status.behind
-            });
-          }
-        }
+    for (const src of lock.sources) {
+      const slug = sourceSlug(src.url);
+      const decl = repositories[slug];
+      if (!decl || decl.path) continue;
+      const status = checkRepoStatus(decl, slug, this.reposDir);
+      if (status.behind <= 0) continue;
+      for (const [ref, entry] of Object.entries(lock.assets)) {
+        if (entry.source.url !== src.url) continue;
+        const { publisher, kind, name, version } = parseCanonicalLockKey(ref);
+        if (!kind || !name) continue;
+        result.push({
+          kind,
+          name,
+          publisher: publisher ?? slug,
+          currentVersion: version ?? "",
+          behind: status.behind
+        });
       }
     }
     return result;
@@ -561,22 +638,25 @@ var AssetManager = class {
    *
    * @returns The written {@link LockFile} data.
    */
-  lock() {
-    const { repositories, dependencies } = this.loadConfig();
+  async lock() {
+    const { repositories, stores, dependencies, overrides } = this.loadConfig();
     for (const [name, decl] of Object.entries(repositories)) {
       try {
         ensureRepo(decl, name, this.reposDir, { projectDir: this.projectDir });
       } catch {
       }
     }
-    const { resolved, resolvedBy } = resolveAll(dependencies, repositories, this.reposDir);
-    const lockData = buildLockFile(
-      repositories,
-      resolved,
-      resolvedBy,
-      this.reposDir,
-      this.projectDir
-    );
+    const provenanceIndex = buildProvenanceIndex(this.buildClones(repositories), {
+      projectDir: this.projectDir
+    });
+    const { resolved, overridesApplied } = await resolveAll(dependencies, {
+      provenanceIndex,
+      overrides,
+      stores,
+      storeFetcher: this.buildStoreFetcher(stores),
+      projectDir: this.projectDir
+    });
+    const lockData = buildLockFile(resolved, overridesApplied);
     writeLock(this.lockPath, lockData);
     return lockData;
   }
@@ -633,11 +713,11 @@ var AssetManager = class {
   patchSubmit(ref) {
     const parsed = parseAssetRef(ref);
     const entry = this.info(ref);
-    if (!entry?.repository) throw new Error(`Asset not found or no repository: ${ref}`);
+    if (!entry?.publisher) throw new Error(`Asset not found or no publisher: ${ref}`);
     const { repositories } = this.loadConfig();
-    const decl = repositories[entry.repository];
-    if (!decl?.url) throw new Error("Can only submit patches for remote repositories.");
-    const repoDir = join(this.reposDir, entry.repository);
+    const decl = repositories[entry.publisher];
+    if (!decl?.url) throw new Error("Can only submit patches for remote sources.");
+    const repoDir = join(this.reposDir, entry.publisher);
     const branchName = `patch/${parsed.kind}-${parsed.name}`;
     const patchFile = join(this.patchDir, `${parsed.kind}-${parsed.name}.patch`);
     if (!existsSync(patchFile)) throw new Error("No patch file. Run `skaile patch-commit` first.");
@@ -749,12 +829,13 @@ var AssetManager = class {
    *   and `unmanaged` (deployed assets not in the lock file).
    */
   clean(opts) {
-    const lock = readLock(this.lockPath);
+    const lock = this.tryReadLock();
     const removed = [];
     const skipped = [];
     if (lock) {
       for (const ref of Object.keys(lock.assets)) {
-        const [kind, name] = ref.split(":");
+        const { kind, name } = parseCanonicalLockKey(ref);
+        if (!kind || !name) continue;
         const dest = deployedDir(
           kind,
           name,
@@ -772,7 +853,12 @@ var AssetManager = class {
         }
       }
     }
-    const lockRefs = lock ? new Set(Object.keys(lock.assets)) : /* @__PURE__ */ new Set();
+    const lockRefs = lock ? new Set(
+      Object.keys(lock.assets).map((r) => {
+        const p = parseCanonicalLockKey(r);
+        return p.kind && p.name ? `${p.kind}:${p.name}` : r;
+      })
+    ) : /* @__PURE__ */ new Set();
     const unmanaged = [];
     const allDeployed = this.listDeployed();
     for (const d of allDeployed) {
@@ -846,5 +932,5 @@ var AssetManager = class {
 };
 
 export { AssetManager };
-//# sourceMappingURL=chunk-DEQ3OOTU.js.map
-//# sourceMappingURL=chunk-DEQ3OOTU.js.map
+//# sourceMappingURL=chunk-VCYXVP2S.js.map
+//# sourceMappingURL=chunk-VCYXVP2S.js.map