@vibe-forge/workspace-assets 2.0.2 → 2.0.4-alpha.0

package/__tests__/skill-dependencies-cli.spec.ts

@@ -0,0 +1,234 @@
+/* eslint-disable import/first -- hoisted vitest mocks must be declared before importing the bundle entrypoint */
+import { access, mkdir, mkdtemp, rm, utimes, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path, { join } from 'node:path'
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  findSkillsCli: vi.fn(),
+  installSkillsCliRefToTemp: vi.fn(),
+  installSkillsCliSkillToTemp: vi.fn()
+}))
+
+vi.mock('@vibe-forge/utils/skills-cli', async () => {
+  const actual = await vi.importActual<typeof import('@vibe-forge/utils/skills-cli')>('@vibe-forge/utils/skills-cli')
+  return {
+    ...actual,
+    findSkillsCli: mocks.findSkillsCli,
+    installSkillsCliRefToTemp: mocks.installSkillsCliRefToTemp,
+    installSkillsCliSkillToTemp: mocks.installSkillsCliSkillToTemp
+  }
+})
+
+import { buildAdapterAssetPlan, resolveWorkspaceAssetBundle } from '#~/index.js'
+
+import { createWorkspace, writeDocument } from './test-helpers'
+
+describe('skills CLI dependency resolution', () => {
+  let installWorkspace: string
+
+  const pathExists = async (targetPath: string) => {
+    try {
+      await access(targetPath)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  beforeEach(async () => {
+    installWorkspace = await mkdtemp(path.join(os.tmpdir(), 'vf-skills-cli-dependency-'))
+    vi.clearAllMocks()
+  })
+
+  afterEach(async () => {
+    await rm(installWorkspace, { recursive: true, force: true })
+  })
+
+  it('installs missing bare-name dependencies through skills CLI by default', async () => {
+    const workspace = await createWorkspace()
+    const installedSkillDir = join(installWorkspace, '.agents', 'skills', 'frontend-design')
+    await mkdir(installedSkillDir, { recursive: true })
+    await writeFile(
+      join(installedSkillDir, 'SKILL.md'),
+      '---\nname: frontend-design\ndescription: UI design guidance\n---\nUse strong visual hierarchy.\n'
+    )
+
+    mocks.findSkillsCli.mockResolvedValue([
+      {
+        installRef: 'anthropics/skills@frontend-design',
+        source: 'anthropics/skills',
+        skill: 'frontend-design'
+      }
+    ])
+    mocks.installSkillsCliRefToTemp.mockResolvedValue({
+      tempDir: installWorkspace,
+      installedSkill: {
+        dirName: 'frontend-design',
+        name: 'frontend-design',
+        sourcePath: installedSkillDir
+      }
+    })
+
+    await writeDocument(
+      join(workspace, '.ai/skills/app-builder/SKILL.md'),
+      [
+        '---',
+        'name: app-builder',
+        'description: Build apps',
+        'dependencies:',
+        '  - frontend-design',
+        '---',
+        'Build the app.'
+      ].join('\n')
+    )
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [undefined, undefined],
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    await buildAdapterAssetPlan({
+      adapter: 'opencode',
+      bundle,
+      options: {
+        skills: {
+          include: ['app-builder']
+        }
+      }
+    })
+
+    const dependency = bundle.skills.find(asset => asset.name === 'frontend-design')
+    expect(bundle.skills.map(asset => asset.name).sort()).toEqual(['app-builder', 'frontend-design'])
+    expect(dependency?.sourcePath).toContain(
+      '/.ai/caches/skill-dependencies/skills-cli/skills/latest/default/anthropics/skills/latest/frontend-design/'
+    )
+    expect(mocks.findSkillsCli).toHaveBeenCalledWith({
+      query: 'frontend-design'
+    })
+    expect(mocks.installSkillsCliRefToTemp).toHaveBeenCalledWith({
+      installRef: 'anthropics/skills@frontend-design'
+    })
+  })
+
+  it('parses registry and version from dependency specs', async () => {
+    const workspace = await createWorkspace()
+    const installedSkillDir = join(installWorkspace, '.agents', 'skills', 'frontend-design')
+    await mkdir(installedSkillDir, { recursive: true })
+    await writeFile(
+      join(installedSkillDir, 'SKILL.md'),
+      '---\nname: frontend-design\ndescription: UI design guidance\n---\nUse internal design system.\n'
+    )
+
+    mocks.installSkillsCliSkillToTemp.mockResolvedValue({
+      tempDir: installWorkspace,
+      installedSkill: {
+        dirName: 'frontend-design',
+        name: 'frontend-design',
+        sourcePath: installedSkillDir
+      }
+    })
+
+    await writeDocument(
+      join(workspace, '.ai/skills/app-builder/SKILL.md'),
+      [
+        '---',
+        'name: app-builder',
+        'description: Build apps',
+        'dependencies:',
+        '  - https://registry.example.com@example-source/default/public@frontend-design@1.0.3',
+        '---',
+        'Build the app.'
+      ].join('\n')
+    )
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [undefined, undefined],
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    await buildAdapterAssetPlan({
+      adapter: 'opencode',
+      bundle,
+      options: {
+        skills: {
+          include: ['app-builder']
+        }
+      }
+    })
+
+    expect(mocks.installSkillsCliSkillToTemp).toHaveBeenCalledWith({
+      registry: 'https://registry.example.com',
+      skill: 'frontend-design',
+      source: 'example-source/default/public',
+      version: '1.0.3'
+    })
+  })
+
+  it('clears stale dependency install locks before retrying a direct startup install', async () => {
+    const workspace = await createWorkspace()
+    const installedSkillDir = join(installWorkspace, '.agents', 'skills', 'lynx-cat')
+    await mkdir(installedSkillDir, { recursive: true })
+    await writeFile(
+      join(installedSkillDir, 'SKILL.md'),
+      '---\nname: lynx-cat\ndescription: Lynx helper\n---\nDebug Lynx apps.\n'
+    )
+
+    mocks.installSkillsCliSkillToTemp.mockResolvedValue({
+      tempDir: installWorkspace,
+      installedSkill: {
+        dirName: 'lynx-cat',
+        name: 'lynx-cat',
+        sourcePath: installedSkillDir
+      }
+    })
+
+    await writeDocument(
+      join(workspace, '.ai/skills/lynx-miniapp/SKILL.md'),
+      [
+        '---',
+        'name: lynx-miniapp',
+        'description: lynx 调试使用',
+        'dependencies:',
+        '  - https://registry.example.com@example-source/lynx/skills@lynx-cat@latest',
+        '---',
+        '这是一个测试的 lynx 调试技能'
+      ].join('\n')
+    )
+
+    const lockDir = join(
+      workspace,
+      '.ai/caches/skill-dependencies/skills-cli/skills/latest/https-registry.example.com/example-source/lynx/skills/latest/lynx-cat.lock'
+    )
+    await mkdir(lockDir, { recursive: true })
+    await utimes(lockDir, new Date(Date.now() - 120_000), new Date(Date.now() - 120_000))
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [undefined, undefined],
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    await buildAdapterAssetPlan({
+      adapter: 'opencode',
+      bundle,
+      options: {
+        skills: {
+          include: ['lynx-miniapp']
+        }
+      }
+    })
+
+    expect(mocks.installSkillsCliSkillToTemp).toHaveBeenCalledWith({
+      registry: 'https://registry.example.com',
+      skill: 'lynx-cat',
+      source: 'example-source/lynx/skills',
+      version: 'latest'
+    })
+    await expect(pathExists(lockDir)).resolves.toBe(false)
+    expect(bundle.skills.map(asset => asset.name).sort()).toEqual(['lynx-cat', 'lynx-miniapp'])
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-forge/workspace-assets",
-  "version": "2.0.2",
+  "version": "2.0.4-alpha.0",
   "description": "Workspace asset resolution and adapter asset planning for Vibe Forge",
   "imports": {
     "#~/*.js": {
@@ -32,7 +32,7 @@
     "js-yaml": "^4.1.1",
     "@vibe-forge/definition-core": "^2.0.0",
     "@vibe-forge/types": "^2.0.2",
-    "@vibe-forge/utils": "^2.0.3"
+    "@vibe-forge/utils": "^2.0.4-alpha.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9"

package/src/bundle-internal.ts

@@ -9,7 +9,12 @@ import {
   resolveDefaultVibeForgeMcpServerConfig
 } from '@vibe-forge/config'
 import type { Config, Definition, Entity, PluginConfig, WorkspaceAsset, WorkspaceAssetKind } from '@vibe-forge/types'
-import { resolveProjectAiBaseDir, resolveProjectAiEntitiesDir, resolveRelativePath } from '@vibe-forge/utils'
+import {
+  isLegacySkillsConfig,
+  resolveProjectAiBaseDir,
+  resolveProjectAiEntitiesDir,
+  resolveRelativePath
+} from '@vibe-forge/utils'
 import { listManagedPluginInstalls, toManagedPluginConfig } from '@vibe-forge/utils/managed-plugin'
 import {
   flattenPluginInstances,
@@ -28,6 +33,7 @@ import {
   resolveSkillIdentifier,
   resolveSpecIdentifier
 } from '@vibe-forge/definition-core'
+import { ensureConfiguredProjectSkills } from './configured-skills'
 import { HOME_BRIDGE_RESOLVED_BY } from './home-bridge'
 import { resolveConfiguredWorkspaceAssets } from './workspaces'
 
@@ -153,8 +159,8 @@ const warnInvalidHomeSkillRoot = (root: string) => {
 
 const resolveHomeBridgeConfig = (configs: [Config?, Config?]) => {
   const [config, userConfig] = configs
-  const projectHomeBridge = config?.skills?.homeBridge
-  const userHomeBridge = userConfig?.skills?.homeBridge
+  const projectHomeBridge = isLegacySkillsConfig(config?.skills) ? config.skills.homeBridge : undefined
+  const userHomeBridge = isLegacySkillsConfig(userConfig?.skills) ? userConfig.skills.homeBridge : undefined
 
   return {
     enabled: userHomeBridge?.enabled ?? projectHomeBridge?.enabled ?? true,
@@ -526,6 +532,8 @@ export async function collectWorkspaceAssets(params: {
   plugins?: PluginConfig
   overlaySource?: string
   includeManagedPlugins?: boolean
+  syncConfiguredSkills?: boolean
+  updateConfiguredSkills?: boolean
   useDefaultVibeForgeMcpServer?: boolean
 }): Promise<{
   assets: WorkspaceAsset[]
@@ -544,6 +552,13 @@ export async function collectWorkspaceAssets(params: {
   workspaces: Array<Extract<WorkspaceAsset, { kind: 'workspace' }>>
 }> {
   const [config, userConfig] = params.configs ?? await loadWorkspaceConfig(params.cwd)
+  if (params.syncConfiguredSkills === true) {
+    await ensureConfiguredProjectSkills({
+      configs: [config, userConfig],
+      updateInstalledSkills: params.updateConfiguredSkills,
+      workspaceFolder: params.cwd
+    })
+  }
   const managedPluginConfigs = params.includeManagedPlugins === false
     ? undefined
     : toManagedPluginConfig(await listManagedPluginInstalls(params.cwd))

package/src/bundle.ts

@@ -8,6 +8,8 @@ export async function resolveWorkspaceAssetBundle(params: {
   plugins?: PluginConfig
   overlaySource?: string
   includeManagedPlugins?: boolean
+  syncConfiguredSkills?: boolean
+  updateConfiguredSkills?: boolean
   useDefaultVibeForgeMcpServer?: boolean
 }): Promise<WorkspaceAssetBundle> {
   const collected = await collectWorkspaceAssets(params)

package/src/configured-skills.ts

@@ -0,0 +1,85 @@
+import { access } from 'node:fs/promises'
+import process from 'node:process'
+
+import type { Config, ConfiguredSkillInstallConfig } from '@vibe-forge/types'
+import {
+  installProjectSkill,
+  normalizeProjectSkillInstall,
+  resolveConfiguredSkillInstalls as resolveDeclaredConfiguredSkillInstalls,
+  resolveProjectAiPath
+} from '@vibe-forge/utils'
+import type { NormalizedProjectSkillInstall } from '@vibe-forge/utils'
+
+const resolveConfiguredSkillInstalls = (configs: [Config?, Config?]) => (
+  [
+    ...resolveDeclaredConfiguredSkillInstalls(configs[0]?.skills),
+    ...resolveDeclaredConfiguredSkillInstalls(configs[1]?.skills)
+  ]
+    .map((item) => normalizeProjectSkillInstall(item as string | ConfiguredSkillInstallConfig))
+    .filter((item): item is NormalizedProjectSkillInstall => item != null)
+)
+
+const pathExists = async (targetPath: string) => {
+  try {
+    await access(targetPath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+const ensureUniqueTargets = (skills: NormalizedProjectSkillInstall[]) => {
+  const seen = new Map<string, string>()
+
+  for (const skill of skills) {
+    const previous = seen.get(skill.targetDirName)
+    if (previous != null) {
+      throw new Error(
+        `Configured skills "${previous}" and "${skill.ref}" resolve to the same target "${skill.targetDirName}"`
+      )
+    }
+    seen.set(skill.targetDirName, skill.ref)
+  }
+}
+
+export const ensureConfiguredProjectSkills = async (params: {
+  configs: [Config?, Config?]
+  updateInstalledSkills?: boolean
+  workspaceFolder: string
+}) => {
+  const installs = resolveConfiguredSkillInstalls(params.configs)
+  if (installs.length === 0) {
+    return []
+  }
+
+  ensureUniqueTargets(installs)
+
+  const ensured: Array<{ dirName: string; skillPath: string }> = []
+
+  for (const skill of installs) {
+    const skillPath = resolveProjectAiPath(
+      params.workspaceFolder,
+      process.env,
+      'skills',
+      skill.targetDirName,
+      'SKILL.md'
+    )
+    if (params.updateInstalledSkills !== true && await pathExists(skillPath)) {
+      ensured.push({
+        dirName: skill.targetDirName,
+        skillPath
+      })
+      continue
+    }
+
+    ensured.push(
+      await installProjectSkill({
+        force: true,
+        skill,
+        workspaceFolder: params.workspaceFolder
+      })
+    )
+  }
+
+  return ensured
+}

package/src/prompt-selection.ts

@@ -35,7 +35,7 @@ import {
   resolveSelectedSkillAssetsWithDependencies,
   toDocumentDefinitions
 } from './selection-internal'
-import { expandSkillAssetDependenciesWithRegistry } from './skill-dependencies'
+import { expandSkillAssetDependenciesWithRemoteResolution } from './skill-dependencies'
 import { generateWorkspaceRoutePrompt } from './workspace-prompt'
 
 export async function resolvePromptAssetSelection(params: {
@@ -164,7 +164,7 @@ export async function resolvePromptAssetSelection(params: {
       resolveNamedAssets(effectiveBundle.skills, excludedRefs, targetInstancePath).map(asset => asset.id)
     )
 
-    const expandedTargetSkills = await expandSkillAssetDependenciesWithRegistry({
+    const expandedTargetSkills = await expandSkillAssetDependenciesWithRemoteResolution({
       allAssets: effectiveBundle.assets,
       configs: effectiveBundle.configs ?? [undefined, undefined],
       cwd: effectiveBundle.cwd,

package/src/selection-internal.ts

@@ -26,7 +26,7 @@ import {
   isRemoteRuleReference,
   parseScopedReference
 } from '@vibe-forge/definition-core'
-import { expandSkillAssetDependencies, expandSkillAssetDependenciesWithRegistry } from './skill-dependencies'
+import { expandSkillAssetDependencies, expandSkillAssetDependenciesWithRemoteResolution } from './skill-dependencies'
 
 type DocumentAssetKind = Extract<WorkspaceAssetKind, 'rule' | 'spec' | 'entity' | 'skill'>
 type DocumentAsset<TDefinition> = Extract<WorkspaceAsset, { kind: DocumentAssetKind }> & {
@@ -538,7 +538,7 @@ export const resolveSelectedSkillAssetsWithDependencies = async (
   const excluded = new Set(
     resolveNamedAssets(bundle.skills, selection?.exclude).map(asset => asset.id)
   )
-  return await expandSkillAssetDependenciesWithRegistry({
+  return await expandSkillAssetDependenciesWithRemoteResolution({
     allAssets: bundle.assets,
     configs: bundle.configs ?? [undefined, undefined],
     cwd: bundle.cwd,

package/src/skill-dependencies.ts

@@ -5,18 +5,19 @@ import fm from 'front-matter'
 
 import { parseScopedReference, resolveSkillIdentifier } from '@vibe-forge/definition-core'
 import type { Config, Definition, Skill, WorkspaceAsset } from '@vibe-forge/types'
-import { resolveRelativePath } from '@vibe-forge/utils'
+import { formatSkillsSpec, parseSkillsSpec, resolveRelativePath } from '@vibe-forge/utils'
 
 import { HOME_BRIDGE_RESOLVED_BY } from './home-bridge'
-import { installRegistrySkillDependency } from './skill-registry'
+import { installSkillsCliDependency } from './skills-cli-dependency'
 
 type SkillAsset = Extract<WorkspaceAsset, { kind: 'skill' }>
 
 export interface NormalizedSkillDependency {
   ref: string
   name: string
-  source?: string
   registry?: string
+  source?: string
+  version?: string
 }
 
 interface DependencyExpansionParams {
@@ -119,7 +120,7 @@ const parseFrontmatterSkill = async (path: string): Promise<Definition<Skill>> =
   }
 }
 
-const createRegistrySkillAsset = (params: {
+const createResolvedSkillAsset = (params: {
   cwd: string
   definition: Definition<Skill>
 }) => {
@@ -138,47 +139,29 @@ const createRegistrySkillAsset = (params: {
   } satisfies SkillAsset
 }
 
-const parseStringDependency = (value: string): NormalizedSkillDependency => {
-  const ref = value.trim()
-  const atIndex = ref.lastIndexOf('@')
-  if (atIndex > 0 && atIndex < ref.length - 1) {
-    return {
-      ref,
-      source: ref.slice(0, atIndex),
-      name: ref.slice(atIndex + 1)
-    }
-  }
-
-  const sourcePathMatch = ref.match(/^([^/\s]+\/[^/\s]+)\/([^/\s]+)$/)
-  if (sourcePathMatch != null) {
-    return {
-      ref,
-      source: sourcePathMatch[1],
-      name: sourcePathMatch[2]
-    }
-  }
-
-  return {
-    ref,
-    name: ref
-  }
-}
-
 export const normalizeSkillDependency = (value: unknown): NormalizedSkillDependency | undefined => {
   const stringValue = asNonEmptyString(value)
-  if (stringValue != null) return parseStringDependency(stringValue)
+  if (stringValue != null) return parseSkillsSpec(stringValue)
 
   if (value == null || typeof value !== 'object' || Array.isArray(value)) return undefined
   const record = value as Record<string, unknown>
   const name = asNonEmptyString(record.name)
   if (name == null) return undefined
 
+  const registry = asNonEmptyString(record.registry)
   const source = asNonEmptyString(record.source)
+  const version = asNonEmptyString(record.version)
   return {
-    ref: source == null ? name : `${source}@${name}`,
+    ref: formatSkillsSpec({
+      name,
+      registry,
+      source,
+      version
+    }),
     name,
+    ...(registry == null ? {} : { registry }),
     ...(source == null ? {} : { source }),
-    ...(asNonEmptyString(record.registry) == null ? {} : { registry: asNonEmptyString(record.registry) })
+    ...(version == null ? {} : { version })
   }
 }
 
@@ -242,7 +225,7 @@ export const expandSkillAssetDependencies = (
   return selected
 }
 
-export const expandSkillAssetDependenciesWithRegistry = async (
+export const expandSkillAssetDependenciesWithRemoteResolution = async (
   params: DependencyExpansionParams
 ) => {
   const selected: SkillAsset[] = []
@@ -260,16 +243,16 @@ export const expandSkillAssetDependenciesWithRegistry = async (
     dependency: NormalizedSkillDependency,
     currentInstancePath?: string
   ) => {
-    const fetchKey = `${dependency.registry ?? ''}:${dependency.ref}`
+    const fetchKey = dependency.ref
     if (!fetchedDependencyRefs.has(fetchKey)) {
       fetchedDependencyRefs.add(fetchKey)
-      const installed = await installRegistrySkillDependency({
+      const installed = await installSkillsCliDependency({
         cwd: params.cwd,
         configs: params.configs,
         dependency
       })
       const definition = await parseFrontmatterSkill(installed.skillPath)
-      const dependencyAsset = createRegistrySkillAsset({
+      const dependencyAsset = createResolvedSkillAsset({
         cwd: params.cwd,
         definition
       })
@@ -334,14 +317,13 @@ export const expandSkillAssetDependenciesWithRegistry = async (
       const dependencyAsset = await installDependencyAsset(dependency, asset.instancePath).catch((error: unknown) => {
         if (
           localOrBridgedDependency != null &&
-          dependency.source == null &&
-          dependency.registry == null
+          dependency.source == null
         ) {
           return localOrBridgedDependency
         }
         throw error
       }) ?? (
-        dependency.source == null && dependency.registry == null
+        dependency.source == null
           ? localOrBridgedDependency
           : undefined
       )

package/src/skills-cli-dependency-helpers.ts

@@ -0,0 +1,94 @@
+import { access, copyFile, lstat, mkdir, readdir } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import process from 'node:process'
+
+import { withDirectoryInstallLock } from '@vibe-forge/utils/install-lock'
+import { resolveProjectSharedCachePath } from '@vibe-forge/utils/project-cache-path'
+import { toSkillSlug } from '@vibe-forge/utils/skills-cli'
+
+const toCacheSegment = (value: string) => (
+  value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'default'
+)
+
+export const pathExists = async (targetPath: string) => {
+  try {
+    await access(targetPath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export const withInstallLock = async <T>(lockDir: string, callback: () => Promise<T>) => {
+  try {
+    return await withDirectoryInstallLock({ lockDir }, callback)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new Error(
+      message.replace('Timed out waiting for install lock', 'Timed out waiting for skill dependency install lock')
+    )
+  }
+}
+
+export const copyRegularFiles = async (sourceDir: string, targetDir: string) => {
+  let fileCount = 0
+  const entries = await readdir(sourceDir, { withFileTypes: true })
+
+  await mkdir(targetDir, { recursive: true })
+
+  for (const entry of entries) {
+    const sourcePath = resolve(sourceDir, entry.name)
+    const targetPath = resolve(targetDir, entry.name)
+    const stat = await lstat(sourcePath)
+
+    if (stat.isDirectory()) {
+      fileCount += await copyRegularFiles(sourcePath, targetPath)
+      continue
+    }
+
+    if (!stat.isFile()) continue
+
+    await mkdir(dirname(targetPath), { recursive: true })
+    await copyFile(sourcePath, targetPath)
+    fileCount += 1
+  }
+
+  return fileCount
+}
+
+export const pickSearchResult = <T extends { skill: string }>(
+  results: T[],
+  name: string
+) => {
+  const slug = toSkillSlug(name)
+  return results.find(result => (
+    result.skill === name ||
+    toSkillSlug(result.skill) === slug
+  )) ?? results[0]
+}
+
+export const buildInstallDir = (params: {
+  cwd: string
+  registry?: string
+  skill: string
+  source: string
+  version?: string
+}) => {
+  const registry = params.registry ?? 'default'
+  return resolveProjectSharedCachePath(
+    params.cwd,
+    process.env,
+    'skill-dependencies',
+    'skills-cli',
+    toCacheSegment('skills'),
+    toCacheSegment('latest'),
+    toCacheSegment(registry),
+    ...params.source.split('/').map(toCacheSegment),
+    toCacheSegment(params.version ?? 'latest'),
+    toCacheSegment(params.skill)
+  )
+}