@codemieai/cdk 0.1.543 → 0.1.544

package/dist/cli/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
+import ora from 'ora';
+import * as crypto from 'crypto';
+import { DataSourceType, CodeMieClient, SkillVisibility } from 'codemie-sdk';
 import * as fs6 from 'fs';
 import * as path6 from 'path';
 import path6__default from 'path';
-import ora from 'ora';
-import * as crypto2 from 'crypto';
-import { DataSourceType, CodeMieClient } from 'codemie-sdk';
 import * as yaml5 from 'yaml';
 import { program } from '@commander-js/extra-typings';
 import { z } from 'zod';
@@ -21,66 +21,6 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-function sanitizeFileName(name, maxLength = 255) {
-  const nameWithHyphens = name.replaceAll(/[/\\]/g, "-");
-  const sanitized = nameWithHyphens.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "").slice(0, maxLength);
-  if (!sanitized) {
-    throw new Error(`Sanitized filename is empty for input: "${name}"`);
-  }
-  return sanitized;
-}
-function validateBackupDirectory(backupDir, minSpaceGB = 1) {
-  try {
-    const parentDir = path6.dirname(backupDir);
-    if (!fs6.existsSync(parentDir)) {
-      fs6.mkdirSync(parentDir, { recursive: true });
-    }
-    const testFile = path6.join(parentDir, ".write-test");
-    fs6.writeFileSync(testFile, "test");
-    fs6.unlinkSync(testFile);
-    try {
-      const stats = fs6.statfsSync(parentDir);
-      const availableGB = stats.bavail * stats.bsize / BYTES_IN_GB;
-      if (availableGB < minSpaceGB) {
-        throw new Error(`Insufficient disk space: ${availableGB.toFixed(2)}GB available, need ${minSpaceGB}GB`);
-      }
-    } catch (error) {
-      if (error.code !== "ERR_METHOD_NOT_SUPPORTED") {
-        throw error;
-      }
-    }
-  } catch (error) {
-    throw new Error(`Cannot write to backup directory: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function moveAtomically(tempPath, finalPath) {
-  try {
-    fs6.renameSync(tempPath, finalPath);
-  } catch (error) {
-    const err = error;
-    if (err.code === "EEXIST") {
-      throw new Error(`Destination already exists: ${finalPath}`);
-    }
-    throw error;
-  }
-}
-function cleanupDirectory(dirPath) {
-  if (fs6.existsSync(dirPath)) {
-    fs6.rmSync(dirPath, { recursive: true, force: true });
-  }
-}
-function ensureDirectoryExists(filePath) {
-  const dir = path6.dirname(filePath);
-  if (!fs6.existsSync(dir)) {
-    fs6.mkdirSync(dir, { recursive: true });
-  }
-}
-var BYTES_IN_GB;
-var init_fileUtils = __esm({
-  "src/lib/fileUtils.ts"() {
-    BYTES_IN_GB = 1024 ** 3;
-  }
-});
 function formatDuration(durationMs) {
   if (durationMs < 1e3) {
     return `${durationMs}ms`;
@@ -354,7 +294,7 @@ function calculateChecksum(content) {
   if (content.length === 0) {
     logger.warn("\u26A0\uFE0F  Calculating checksum of empty string");
   }
-  return crypto2.createHash("sha256").update(content, "utf8").digest("hex");
+  return crypto.createHash("sha256").update(content, "utf8").digest("hex");
 }
 function normalizeAssistantConfig(assistant, buildConfig = null) {
   return {
@@ -750,12 +690,84 @@ var init_converters = __esm({
     FILE_SUMMARY_ALIASES = /* @__PURE__ */ new Set(["file_summary", "file-summary", "file-summay"]);
   }
 });
+function sanitizeFileName(name, maxLength = 255) {
+  const nameWithHyphens = name.replaceAll(/[/\\]/g, "-");
+  const sanitized = nameWithHyphens.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "").slice(0, maxLength);
+  if (!sanitized) {
+    throw new Error(`Sanitized filename is empty for input: "${name}"`);
+  }
+  return sanitized;
+}
+function validateBackupDirectory(backupDir, minSpaceGB = 1) {
+  try {
+    const parentDir = path6.dirname(backupDir);
+    if (!fs6.existsSync(parentDir)) {
+      fs6.mkdirSync(parentDir, { recursive: true });
+    }
+    const testFile = path6.join(parentDir, ".write-test");
+    fs6.writeFileSync(testFile, "test");
+    fs6.unlinkSync(testFile);
+    try {
+      const stats = fs6.statfsSync(parentDir);
+      const availableGB = stats.bavail * stats.bsize / BYTES_IN_GB;
+      if (availableGB < minSpaceGB) {
+        throw new Error(`Insufficient disk space: ${availableGB.toFixed(2)}GB available, need ${minSpaceGB}GB`);
+      }
+    } catch (error) {
+      if (error.code !== "ERR_METHOD_NOT_SUPPORTED") {
+        throw error;
+      }
+    }
+  } catch (error) {
+    throw new Error(`Cannot write to backup directory: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function moveAtomically(tempPath, finalPath) {
+  try {
+    fs6.renameSync(tempPath, finalPath);
+  } catch (error) {
+    const err = error;
+    if (err.code === "EEXIST") {
+      throw new Error(`Destination already exists: ${finalPath}`);
+    }
+    throw error;
+  }
+}
+function cleanupDirectory(dirPath) {
+  if (fs6.existsSync(dirPath)) {
+    fs6.rmSync(dirPath, { recursive: true, force: true });
+  }
+}
+function ensureDirectoryExists(filePath) {
+  const dir = path6.dirname(filePath);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
+  }
+}
+var BYTES_IN_GB;
+var init_fileUtils = __esm({
+  "src/lib/fileUtils.ts"() {
+    BYTES_IN_GB = 1024 ** 3;
+  }
+});
+
+// src/lib/skillUtils.ts
+function isProjectOwnedSkill(skill, projectName) {
+  return skill.project.trim().toLowerCase() === projectName.trim().toLowerCase();
+}
+var init_skillUtils = __esm({
+  "src/lib/skillUtils.ts"() {
+  }
+});
 
 // src/lib/backupTransformers.ts
 var backupTransformers_exports = {};
 __export(backupTransformers_exports, {
+  collectReferencedSkillIds: () => collectReferencedSkillIds,
+  partitionSkillsForBackupYaml: () => partitionSkillsForBackupYaml,
   prepareAssistantForYaml: () => prepareAssistantForYaml,
   prepareDatasourceForYaml: () => prepareDatasourceForYaml,
+  prepareImportedSkillForYaml: () => prepareImportedSkillForYaml,
   prepareSkillForYaml: () => prepareSkillForYaml,
   prepareWorkflowForYaml: () => prepareWorkflowForYaml,
   transformMcpServer: () => transformMcpServer,
@@ -912,6 +924,36 @@ function prepareWorkflowForYaml(workflow, state, assistants, backupDir) {
   };
   return resource;
 }
+function collectReferencedSkillIds(assistants) {
+  const referencedSkillIds = /* @__PURE__ */ new Set();
+  for (const assistant of assistants) {
+    const assistantData = assistant;
+    for (const skillId of assistantData.skill_ids || []) {
+      referencedSkillIds.add(skillId);
+    }
+  }
+  return referencedSkillIds;
+}
+function partitionSkillsForBackupYaml(skills, projectName, referencedSkillIds) {
+  const ownedSkills = [];
+  const importedSkills = [];
+  for (const skill of skills) {
+    if (isProjectOwnedSkill(skill, projectName)) {
+      ownedSkills.push(skill);
+      continue;
+    }
+    if (referencedSkillIds.has(skill.id)) {
+      importedSkills.push(skill);
+    }
+  }
+  return { ownedSkills, importedSkills };
+}
+function prepareImportedSkillForYaml(skill) {
+  return {
+    name: skill.name,
+    id: skill.id
+  };
+}
 function prepareSkillForYaml(skill, state) {
   const resource = skillResponseToResource(skill);
   if (!state.resources.skills) {
@@ -932,13 +974,14 @@ var init_backupTransformers = __esm({
     init_converters();
     init_fileUtils();
     init_logger();
+    init_skillUtils();
     init_typeGuards();
   }
 });
 
 // package.json
 var package_default = {
-  version: "0.1.543"};
+  version: "0.1.544"};
 var appConfigSchema = z.object({
   rootDir: z.string(),
   codemieConfig: z.string(),
@@ -999,6 +1042,10 @@ function removeEmptyFields(userConfig) {
   );
 }
 
+// src/backup.ts
+init_backupTransformers();
+init_skillUtils();
+
 // src/lib/constants.ts
 var PAGINATION = {
   DEFAULT_PAGE_SIZE: 100};
@@ -1101,7 +1148,7 @@ var BackupTransaction = class {
     }
   }
   generateTransactionId() {
-    return crypto2.randomBytes(8).toString("hex");
+    return crypto.randomBytes(8).toString("hex");
   }
   /**
    * Save transaction state to disk (checkpoint) with timeout protection
@@ -1258,6 +1305,12 @@ function generateCodemieYaml(backup, projectName, backupDir, integrationSpecPath
   const integrationIdToAlias = /* @__PURE__ */ new Map();
   const integrationArray = [];
   const skillIdToName = new Map(backup.resources.skills.map((skill) => [skill.id, skill.name]));
+  const referencedSkillIds = collectReferencedSkillIds(backup.resources.assistants);
+  const { ownedSkills, importedSkills } = partitionSkillsForBackupYaml(
+    backup.resources.skills,
+    projectName,
+    referencedSkillIds
+  );
   for (const integration of backup.resources.integrations) {
     const credentialType = integration.credential_type || "integration";
     const alias = integration.alias || `${String(credentialType).toLowerCase()}_${integration.id.slice(0, 8)}`;
@@ -1303,6 +1356,7 @@ function generateCodemieYaml(backup, projectName, backupDir, integrationSpecPath
     imported: {
       assistants: [],
       datasources: [],
+      skills: importedSkills.map((skill) => prepareImportedSkillForYaml(skill)),
       integrations: integrationArray
     },
     datasource_defaults: {
@@ -1324,8 +1378,8 @@ function generateCodemieYaml(backup, projectName, backupDir, integrationSpecPath
       workflows: backup.resources.workflows.map(
         (workflow) => prepareWorkflowForYaml(workflow, backup.state, backup.resources.assistants, backupDir)
       ),
-      ...backup.resources.skills.length > 0 && {
-        skills: backup.resources.skills.map((skill) => prepareSkillForYaml(skill, backup.state))
+      ...ownedSkills.length > 0 && {
+        skills: ownedSkills.map((skill) => prepareSkillForYaml(skill, backup.state))
       }
     }
   };
@@ -1405,6 +1459,13 @@ async function createClient(config) {
   }
   return client;
 }
+
+// src/lib/nameUtils.ts
+function namesEqual(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+
+// src/lib/codemieConfigLoader.ts
 var CodemieConfigLoader = class {
   appConfig;
   constructor(appConfig) {
@@ -1499,6 +1560,14 @@ var CodemieConfigLoader = class {
         }
       }
     }
+    for (const skill of config.imported?.skills || []) {
+      if (!skill.name) {
+        errors.push("Imported skill entry is missing required field: name");
+      }
+      if (!skill.id) {
+        errors.push(`Imported skill "${skill.name || "<unknown>"}" is missing required field: id`);
+      }
+    }
     return {
       valid: errors.length === 0,
       errors
@@ -1713,6 +1782,7 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
    * - imported.integrations (array): searches by 'alias' field
    * - imported.assistants (array): searches by 'name' field
    * - imported.datasources (array): searches by 'name' field
+   * - imported.skills (array): searches by 'name' field
    */
   resolveReference(config, ref, context) {
     const parts = ref.split(".");
@@ -1736,9 +1806,16 @@ Import chain: ${[...visitedFiles].join(" \u2192 ")} \u2192 ${normalizedPath}`
       if (Array.isArray(current) && hasMorePathSegments) {
         const nextPathSegment = parts[i + 1];
         const searchField = part === "integrations" ? "alias" : "name";
-        const foundItem = current.find(
-          (item) => typeof item === "object" && item !== null && item[searchField] === nextPathSegment
-        );
+        const foundItem = current.find((item) => {
+          if (typeof item !== "object" || item === null) {
+            return false;
+          }
+          const fieldValue = item[searchField];
+          if (typeof fieldValue !== "string") {
+            return false;
+          }
+          return searchField === "alias" ? fieldValue === nextPathSegment : namesEqual(fieldValue, nextPathSegment);
+        });
         if (!foundItem) {
           throw new Error(
             `Reference path "${ref}" not found: no item with ${searchField}="${nextPathSegment}" in "${pathParts.join(".")}". Referenced in ${context}.`
@@ -1895,6 +1972,27 @@ async function* streamResources(fetchPage, resourceType) {
     }
   }
 }
+function createFallbackImportedSkillDetail(skill) {
+  return {
+    id: skill.id,
+    name: skill.name,
+    description: "",
+    project: skill.project || "",
+    visibility: SkillVisibility.PUBLIC,
+    created_by: null,
+    categories: [],
+    createdDate: "",
+    updatedDate: null,
+    is_attached: true,
+    assistants_count: 0,
+    user_abilities: [],
+    unique_likes_count: 0,
+    unique_dislikes_count: 0,
+    content: "",
+    toolkits: [],
+    mcp_servers: []
+  };
+}
 async function saveAssistantToBackup(assistant, client, backupData, backupDir) {
   logger.info(`   \u2022 ${assistant.name} (${assistant.id})`);
   const full = await withTimeout(
@@ -2087,16 +2185,24 @@ async function backupIntegrations(client, backupData, projectName) {
   logger.info(`\u2713 Backed up ${projectIntegrations.length + userIntegrations.length} integration(s)
 `);
 }
-async function backupSkills(client, backupData, backupDir, transaction) {
+async function backupSkills(client, backupData, backupDir, transaction, projectName) {
   logger.info("\u{1F9E0} Fetching skills...");
+  const referencedSkillIds = collectReferencedSkillIds(backupData.resources.assistants);
   const allSkills = [];
   for await (const skill of streamResources((params) => client.skills.list(params), "skills")) {
     allSkills.push(skill);
   }
-  logger.info(`   Found ${allSkills.length} skill(s)`);
-  transaction.setTotal("skills", allSkills.length);
+  const skillsToBackup = allSkills.filter(
+    (skill) => referencedSkillIds.has(skill.id) || !skill.project || isProjectOwnedSkill({ project: skill.project }, projectName)
+  );
+  const skippedExternalSkills = allSkills.length - skillsToBackup.length;
+  logger.info(`   Found ${allSkills.length} skill(s), backing up ${skillsToBackup.length}`);
+  if (skippedExternalSkills > 0) {
+    logger.info(`   \u21B7 Skipping ${skippedExternalSkills} unreferenced external skill(s)`);
+  }
+  transaction.setTotal("skills", skillsToBackup.length);
   const limit = createConcurrentLimiter();
-  for (const skill of allSkills) {
+  for (const skill of skillsToBackup) {
     if (transaction.isCompleted("skills", skill.id)) {
       logger.info(`   \u21B7 Skipping ${skill.name} (already backed up)`);
       continue;
@@ -2105,16 +2211,37 @@ async function backupSkills(client, backupData, backupDir, transaction) {
       await limit(
         () => withRetry(async () => {
           logger.info(`   \u2022 ${skill.name} (${skill.id})`);
-          const full = await withTimeout(
-            client.skills.get(skill.id),
-            TIMEOUTS_MS.SKILL_FETCH,
-            `Timeout fetching skill ${skill.id}`
-          );
+          const listedAsProjectOwned = skill.project ? isProjectOwnedSkill({ project: skill.project }, projectName) : false;
+          let full;
+          try {
+            full = await withTimeout(
+              client.skills.get(skill.id),
+              TIMEOUTS_MS.SKILL_FETCH,
+              `Timeout fetching skill ${skill.id}`
+            );
+          } catch (error) {
+            if (listedAsProjectOwned || !referencedSkillIds.has(skill.id)) {
+              throw error;
+            }
+            logger.warn(
+              `     \u26A0\uFE0F  Failed to fetch imported skill details for ${skill.name}. Using list response as fallback: ${error instanceof Error ? error.message : String(error)}`
+            );
+            full = createFallbackImportedSkillDetail(skill);
+          }
+          const fullIsProjectOwned = isProjectOwnedSkill(full, projectName);
+          if (!fullIsProjectOwned && !referencedSkillIds.has(skill.id)) {
+            logger.info(`     \u21B7 Skipping unreferenced external skill ${skill.name} (owner: ${full.project})`);
+            return;
+          }
           backupData.resources.skills.push(full);
-          const fileName = `${sanitizeFileName(skill.name)}.skill.md`;
-          const filePath = path6.join(backupDir, "skills", fileName);
-          ensureDirectoryExists(filePath);
-          fs6.writeFileSync(filePath, full.content || "", "utf8");
+          if (fullIsProjectOwned) {
+            const fileName = `${sanitizeFileName(skill.name)}.skill.md`;
+            const filePath = path6.join(backupDir, "skills", fileName);
+            ensureDirectoryExists(filePath);
+            fs6.writeFileSync(filePath, full.content || "", "utf8");
+          } else {
+            logger.info(`     \u21B7 Skipping content file for imported skill ${skill.name} (owner: ${full.project})`);
+          }
         }, `Backup skill ${skill.name}`)
       );
       transaction.markCompleted("skills", skill.id);
@@ -2128,7 +2255,7 @@ async function backupSkills(client, backupData, backupDir, transaction) {
       transaction.markFailed("skills", skill.id, errorDetails.message);
     }
   }
-  logger.info(`\u2713 Backed up ${transaction.getData().resources.skills.completed.length} skill(s)
+  logger.info(`\u2713 Backed up ${backupData.resources.skills.length} skill(s)
 `);
 }
 function getUniqueBackupDir(baseDir, timestamp) {
@@ -2213,11 +2340,11 @@ async function backupResources(options) {
         }
       }
     };
-    await backupSkills(client, backupData, tempBackupDir, transaction);
     await backupIntegrations(client, backupData, config.project.name);
     await backupDatasources(client, backupData, transaction, config.project.name);
     await backupWorkflows(client, backupData, tempBackupDir, transaction);
     await backupAssistants(client, backupData, tempBackupDir, transaction);
+    await backupSkills(client, backupData, tempBackupDir, transaction, config.project.name);
     const stats = transaction.getData();
     const totalFailed = stats.resources.assistants.failed.length + stats.resources.datasources.failed.length + stats.resources.workflows.failed.length + stats.resources.skills.failed.length;
     if (totalFailed > 0) {
@@ -2403,12 +2530,12 @@ var CleanupManager = class {
     const configAssistantNames = new Set((config.resources.assistants || []).map(({ name }) => name));
     const configDatasourceNames = new Set((config.resources.datasources || []).map(({ name }) => name));
     const configWorkflowNames = new Set((config.resources.workflows || []).map(({ name }) => name));
-    const configSkillNames = new Set((config.resources.skills || []).map(({ name }) => name));
+    const configSkillNames = new Set((config.resources.skills || []).map(({ name }) => name.toLowerCase()));
     return {
       assistants: managedResources.assistants.filter((name) => !configAssistantNames.has(name)),
       datasources: managedResources.datasources.filter((name) => !configDatasourceNames.has(name)),
       workflows: managedResources.workflows.filter((name) => !configWorkflowNames.has(name)),
-      skills: managedResources.skills.filter((name) => !configSkillNames.has(name))
+      skills: managedResources.skills.filter((name) => !configSkillNames.has(name.toLowerCase()))
     };
   }
   /**
@@ -2595,6 +2722,62 @@ function checkSkillExists(client, name, stateManager) {
   );
 }
 
+// src/lib/resourceResolver.ts
+init_logger();
+function findSkillStateByName(stateManager, skillName) {
+  const exactMatch = stateManager.getSkillState(skillName);
+  if (exactMatch) {
+    return exactMatch;
+  }
+  for (const name of stateManager.getAllManagedResources().skills) {
+    if (namesEqual(name, skillName)) {
+      return stateManager.getSkillState(name);
+    }
+  }
+  return void 0;
+}
+function findConfiguredSkill(config, skillName) {
+  return config.resources.skills?.find((skill) => namesEqual(skill.name, skillName));
+}
+function findImportedSkill(config, skillName) {
+  return config.imported?.skills?.find((skill) => namesEqual(skill.name, skillName));
+}
+function lookupSkillId(skillName, stateManager, config) {
+  const configuredSkill = findConfiguredSkill(config, skillName);
+  const importedSkill = findImportedSkill(config, skillName);
+  if (configuredSkill && importedSkill) {
+    return void 0;
+  }
+  if (importedSkill) {
+    return importedSkill.id;
+  }
+  if (!configuredSkill) {
+    return void 0;
+  }
+  return findSkillStateByName(stateManager, configuredSkill.name)?.id;
+}
+function resolveSkillId(skillName, stateManager, config) {
+  const configuredSkill = findConfiguredSkill(config, skillName);
+  const importedSkill = findImportedSkill(config, skillName);
+  if (configuredSkill && importedSkill) {
+    throw new Error(
+      `Skill "${skillName}" is defined in both resources.skills and imported.skills. Keep project-owned skills in resources.skills or external skills in imported.skills, not both.`
+    );
+  }
+  const skillId = lookupSkillId(skillName, stateManager, config);
+  if (skillId) {
+    const source = importedSkill ? "imported" : "state";
+    logger.info(`    \u2713 Resolved${source === "imported" ? " (imported)" : ""} "${skillName}" \u2192 ${skillId}`);
+    return skillId;
+  }
+  throw new Error(
+    `Skill "${skillName}" cannot be resolved. For project-owned skills, define it in resources.skills and deploy it so state.json contains its ID. For external skills, add name and id to imported.skills.`
+  );
+}
+function resolveSkillIds(skillNames, stateManager, config) {
+  return skillNames.map((name) => resolveSkillId(name, stateManager, config));
+}
+
 // src/lib/stateManager.ts
 init_checksumUtils();
 init_codemieConfigChecksums();
@@ -2990,16 +3173,7 @@ async function deployAssistants(config, client, loader, stateManager) {
       let resolvedSkillIds = [];
       if (assistant.skills && assistant.skills.length > 0) {
         logger.info(`  Resolving ${assistant.skills.length} skill name(s)...`);
-        const resolvedIds = [];
-        for (const skillName of assistant.skills) {
-          const skillState = stateManager.getSkillState(skillName);
-          if (!skillState) {
-            throw new Error(`Skill "${skillName}" not found in state. Ensure the skill is deployed first.`);
-          }
-          resolvedIds.push(skillState.id);
-          logger.info(`    \u2713 Resolved "${skillName}" \u2192 ${skillState.id}`);
-        }
-        resolvedSkillIds = resolvedIds;
+        resolvedSkillIds = resolveSkillIds(assistant.skills, stateManager, config);
       }
       const assistantWithResolved = {
         ...assistant,
@@ -3119,9 +3293,8 @@ async function deployAssistants(config, client, loader, stateManager) {
         logger.error(`     ${error.message}`);
         logger.debug(`     Stack:`, error.stack);
         if ("statusCode" in error) {
-          const apiError = error;
-          logger.error(`     Status: ${apiError.statusCode}`);
-          logger.error(`     Data: ${JSON.stringify(apiError.response, null, 2)}`);
+          logger.error(`     Status: ${String(error.statusCode)}`);
+          logger.error(`     Data: ${JSON.stringify("response" in error ? error.response : void 0, null, 2)}`);
         } else if ("response" in error) {
           const axiosError = error;
           logger.error(`     Status: ${axiosError.response?.status}`);
@@ -3568,6 +3741,13 @@ async function deployResources(options) {
       }
       if (orphaned.skills.length > 0) {
         logger.info(`   \u2022 ${orphaned.skills.length} skill(s)`);
+        const importedSkillNames = new Set(config.imported?.skills?.map((skill) => skill.name.toLowerCase()) || []);
+        const migratedImportedSkills = orphaned.skills.filter((name) => importedSkillNames.has(name.toLowerCase()));
+        if (migratedImportedSkills.length > 0) {
+          logger.info(
+            `     \u26A0\uFE0F  ${migratedImportedSkills.length} skill(s) also exist in imported.skills. Run with --prune to remove stale IaC-managed skill state and delete old managed skill(s) from platform.`
+          );
+        }
       }
       if (process.env.SAMPLE_DEPLOY === "1") {
         logger.info("\n\u{1F50E} SAMPLE_DEPLOY=1 -> Skipping orphan deletion (simulation / partial deploy mode)\n");
@@ -3772,6 +3952,7 @@ async function main3(options) {
 
 // src/import.ts
 init_converters();
+init_skillUtils();
 init_fileUtils();
 init_logger();
 init_checksumUtils();
@@ -3863,7 +4044,14 @@ Please use a more specific name.`);
 function checkResourceExists2(config, resourceType, name) {
   const pluralType = resourceType === "assistant" ? "assistants" : resourceType === "datasource" ? "datasources" : resourceType === "workflow" ? "workflows" : "skills";
   const resources = config.resources[pluralType] || [];
-  return resources.some((r) => r.name.toLowerCase() === name.toLowerCase());
+  if (resources.some((r) => namesEqual(r.name, name))) {
+    return true;
+  }
+  if (resourceType === "skill") {
+    const importedSkills = config.imported?.skills || [];
+    return importedSkills.some((skill) => namesEqual(skill.name, name));
+  }
+  return false;
 }
 function writeResourceFiles(rootDir, resourceType, resource, apiResponse) {
   const safeName = sanitizeFileName(resource.name);
@@ -3954,6 +4142,53 @@ function addImportToCodemieYaml(rootDir, codemieConfigPath, resourceType, relati
   fs6.writeFileSync(configPath, doc.toString(), "utf8");
   logger.info(`   \u2705 Added $import to ${codemieConfigPath} \u2192 resources.${pluralType}`);
 }
+function addImportedSkillToCodemieYaml(rootDir, codemieConfigPath, skill) {
+  const configPath = path6.join(rootDir, codemieConfigPath);
+  if (!fs6.existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  const content = fs6.readFileSync(configPath, "utf8");
+  const doc = yaml5.parseDocument(content);
+  let importedNode = doc.get("imported");
+  if (!importedNode) {
+    importedNode = doc.createNode({ assistants: [], datasources: [], skills: [], integrations: [] });
+    doc.set("imported", importedNode);
+  }
+  let skillsArray = doc.getIn(["imported", "skills"]);
+  if (!skillsArray) {
+    skillsArray = doc.createNode([]);
+    doc.setIn(["imported", "skills"], skillsArray);
+  }
+  const existingSkill = skillsArray.items.find((item) => {
+    if (!yaml5.isMap(item)) {
+      return false;
+    }
+    const existingName = item.get("name");
+    return typeof existingName === "string" && namesEqual(existingName, skill.name);
+  });
+  if (existingSkill) {
+    const existingId = existingSkill.get("id");
+    if (existingId && existingId !== skill.id) {
+      throw new Error(
+        `Skill "${skill.name}" already exists in imported.skills with a different ID (${existingId}). Remove the existing entry or use the intended skill ID.`
+      );
+    }
+    logger.info(`   \u21B7 Skill "${skill.name}" already exists in imported.skills`);
+    return;
+  }
+  skillsArray.add(doc.createNode({ name: skill.name, id: skill.id }));
+  fs6.writeFileSync(configPath, doc.toString(), "utf8");
+  logger.info(`   \u2705 Added skill to ${codemieConfigPath} \u2192 imported.skills`);
+}
+function ensureExternalSkillDoesNotConflictWithManagedSkill(config, skillName) {
+  const managedSkill = config.resources.skills?.find((skill) => namesEqual(skill.name, skillName));
+  if (!managedSkill) {
+    return;
+  }
+  throw new Error(
+    `External skill "${skillName}" is already defined in resources.skills. Keep project-owned skills in resources.skills or external skills in imported.skills, not both.`
+  );
+}
 function updateState(stateManager, resourceType, resource, apiResponse) {
   switch (resourceType) {
     case "assistant": {
@@ -4041,16 +4276,22 @@ async function importResource(options) {
         logger.info(`   Resolving ${assistantData.skill_ids.length} skill ID(s)...`);
         const skillNames = [];
         for (const skillId of assistantData.skill_ids) {
+          let skill;
           try {
-            const skill = await withTimeout(
+            skill = await withTimeout(
               client.skills.get(skillId),
               TIMEOUTS_MS.ASSISTANT_FETCH,
               `Timeout fetching skill "${skillId}"`
             );
-            skillNames.push(skill.name);
-            logger.info(`     \u2713 Resolved skill ${skillId.slice(0, 8)}... \u2192 "${skill.name}"`);
           } catch {
             logger.warn(`     \u26A0\uFE0F  Could not resolve skill ID "${skillId}" \u2014 skipping`);
+            continue;
+          }
+          skillNames.push(skill.name);
+          logger.info(`     \u2713 Resolved skill ${skillId.slice(0, 8)}... \u2192 "${skill.name}"`);
+          if (!isProjectOwnedSkill(skill, config.project.name)) {
+            ensureExternalSkillDoesNotConflictWithManagedSkill(config, skill.name);
+            addImportedSkillToCodemieYaml(rootDir, appConfig.codemieConfig, { name: skill.name, id: skill.id });
           }
         }
         if (skillNames.length > 0) {
@@ -4086,9 +4327,22 @@ async function importResource(options) {
       logger.info(`   Searching for skill "${slug}"...`);
       const skill = await findSkill(client, slug);
       logger.info(`   \u2713 Found: ${skill.name} (${skill.id})`);
-      apiResponse = skill;
-      resource = skillResponseToResource(skill);
-      break;
+      if (skill.name !== slug && checkResourceExists2(config, resourceType, skill.name)) {
+        throw new Error(
+          `A ${resourceType} named "${skill.name}" already exists in the configuration. Remove it first or use a different name.`
+        );
+      }
+      if (isProjectOwnedSkill(skill, config.project.name)) {
+        logger.info(`   Project-owned skill \u2014 importing into resources.skills`);
+        apiResponse = skill;
+        resource = skillResponseToResource(skill);
+        break;
+      }
+      addImportedSkillToCodemieYaml(rootDir, appConfig.codemieConfig, { name: skill.name, id: skill.id });
+      logger.info(`
+\u2705 Successfully imported external skill "${skill.name}" into imported.skills
+`);
+      return;
     }
   }
   const relativeResourcePath = writeResourceFiles(rootDir, resourceType, resource, apiResponse);
@@ -4418,7 +4672,7 @@ async function previewSkills(skills, loader, stateManager, client) {
   }
   return changes;
 }
-async function previewAssistants(assistants, loader, stateManager, client) {
+async function previewAssistants(assistants, loader, stateManager, client, config) {
   const changes = [];
   for (const assistant of assistants) {
     const promptContent = loader.loadPrompt(assistant.prompt);
@@ -4435,17 +4689,16 @@ async function previewAssistants(assistants, loader, stateManager, client) {
       async () => {
         const existingState = stateManager.getAssistantState(assistant.name);
         const configChanged = existingState ? existingState.promptChecksum !== calculateChecksum(promptContent) || existingState.configChecksum !== configChecksum : false;
-        if (configChanged) {
-          return {
-            hasChanged: true,
-            createDetails: `Model: ${assistant.model}`,
-            updateDetails: "Prompt or configuration changed"
-          };
-        }
-        if (existingState?.id && assistant.skills !== void 0) {
-          const desiredSkillIds = resolveDesiredSkillIds(assistant.skills, stateManager);
-          const drifted = await checkSkillAttachmentDrift(client, existingState.id, desiredSkillIds);
-          if (drifted) {
+        if (assistant.skills !== void 0) {
+          const { ids: desiredSkillIds, unresolved } = resolveDesiredSkillIds(assistant.skills, stateManager, config);
+          if (unresolved.length > 0) {
+            return {
+              hasChanged: true,
+              createDetails: `Unresolved skill reference(s): ${unresolved.join(", ")}`,
+              updateDetails: `Unresolved skill reference(s): ${unresolved.join(", ")}`
+            };
+          }
+          if (existingState?.id && await checkSkillAttachmentDrift(client, existingState.id, desiredSkillIds)) {
             return {
               hasChanged: true,
               createDetails: `Model: ${assistant.model}`,
@@ -4453,6 +4706,13 @@ async function previewAssistants(assistants, loader, stateManager, client) {
             };
           }
         }
+        if (configChanged) {
+          return {
+            hasChanged: true,
+            createDetails: `Model: ${assistant.model}`,
+            updateDetails: "Prompt or configuration changed"
+          };
+        }
         return {
           hasChanged: false,
           createDetails: `Model: ${assistant.model}`
@@ -4463,15 +4723,18 @@ async function previewAssistants(assistants, loader, stateManager, client) {
   }
   return changes;
 }
-function resolveDesiredSkillIds(skillNames, stateManager) {
+function resolveDesiredSkillIds(skillNames, stateManager, config) {
   const ids = [];
+  const unresolved = [];
   for (const name of skillNames) {
-    const skillState = stateManager.getSkillState(name);
-    if (skillState) {
-      ids.push(skillState.id);
+    const skillId = lookupSkillId(name, stateManager, config);
+    if (skillId) {
+      ids.push(skillId);
+    } else {
+      unresolved.push(name);
     }
   }
-  return ids;
+  return { ids, unresolved };
 }
 async function checkSkillAttachmentDrift(client, assistantId, desiredSkillIds) {
   try {
@@ -4575,7 +4838,7 @@ async function previewChanges(appConfig, existingClient) {
     changes.push(...skillChanges);
   }
   if (config.resources.assistants) {
-    const assistantChanges = await previewAssistants(config.resources.assistants, loader, stateManager, client);
+    const assistantChanges = await previewAssistants(config.resources.assistants, loader, stateManager, client, config);
     changes.push(...assistantChanges);
   }
   if (config.resources.datasources) {
@@ -4809,6 +5072,32 @@ var DependencyValidator = class {
     }
     return errors;
   }
+  /**
+   * Validate assistant skill references.
+   * Check that all skill names point to resources.skills or imported.skills entries.
+   */
+  static validateAssistantSkillReferences(assistants, managedSkills, importedSkills) {
+    const errors = [];
+    for (const managedSkill of managedSkills) {
+      const importedSkill = importedSkills.find((skill) => namesEqual(skill.name, managedSkill.name));
+      if (importedSkill) {
+        errors.push(
+          `Skill "${managedSkill.name}" is defined in both resources.skills and imported.skills. Keep project-owned skills in resources.skills or external skills in imported.skills, not both.`
+        );
+      }
+    }
+    const isSkillAvailable = (skillName) => managedSkills.some((skill) => namesEqual(skill.name, skillName)) || importedSkills.some((skill) => namesEqual(skill.name, skillName));
+    for (const assistant of assistants) {
+      for (const skillName of assistant.skills || []) {
+        if (!isSkillAvailable(skillName)) {
+          errors.push(
+            `Assistant "${assistant.name}": Skill reference "${skillName}" not found in resources.skills or imported.skills`
+          );
+        }
+      }
+    }
+    return errors;
+  }
 };
 
 // src/validate.ts
@@ -4892,6 +5181,12 @@ async function validateConfig(options) {
   if (config.resources.assistants && config.resources.assistants.length > 0) {
     const dependencyErrors = DependencyValidator.validateAssistantDependencies(config.resources.assistants);
     errors.push(...dependencyErrors);
+    const skillReferenceErrors = DependencyValidator.validateAssistantSkillReferences(
+      config.resources.assistants,
+      config.resources.skills || [],
+      config.imported?.skills || []
+    );
+    errors.push(...skillReferenceErrors);
   }
   if (config.resources.workflows && config.resources.workflows.length > 0) {
     const workflowsWithContent = config.resources.workflows.map((workflow) => {