@packmind/cli 0.23.0 → 0.24.0

package/main.cjs

@@ -371,32 +371,32 @@ var init_supports_color = __esm({
 });
 
 // node_modules/chalk/source/utilities.js
-function stringReplaceAll(string22, substring, replacer) {
-  let index = string22.indexOf(substring);
+function stringReplaceAll(string18, substring, replacer) {
+  let index = string18.indexOf(substring);
   if (index === -1) {
-    return string22;
+    return string18;
   }
   const substringLength = substring.length;
   let endIndex = 0;
   let returnValue = "";
   do {
-    returnValue += string22.slice(endIndex, index) + substring + replacer;
+    returnValue += string18.slice(endIndex, index) + substring + replacer;
     endIndex = index + substringLength;
-    index = string22.indexOf(substring, endIndex);
+    index = string18.indexOf(substring, endIndex);
   } while (index !== -1);
-  returnValue += string22.slice(endIndex);
+  returnValue += string18.slice(endIndex);
   return returnValue;
 }
-function stringEncaseCRLFWithFirstIndex(string22, prefix, postfix, index) {
+function stringEncaseCRLFWithFirstIndex(string18, prefix, postfix, index) {
   let endIndex = 0;
   let returnValue = "";
   do {
-    const gotCR = string22[index - 1] === "\r";
-    returnValue += string22.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    const gotCR = string18[index - 1] === "\r";
+    returnValue += string18.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
     endIndex = index + 1;
-    index = string22.indexOf("\n", endIndex);
+    index = string18.indexOf("\n", endIndex);
   } while (index !== -1);
-  returnValue += string22.slice(endIndex);
+  returnValue += string18.slice(endIndex);
   return returnValue;
 }
 var init_utilities = __esm({
@@ -555,26 +555,26 @@ var init_source = __esm({
       builder[IS_EMPTY] = _isEmpty;
       return builder;
     };
-    applyStyle = (self, string22) => {
-      if (self.level <= 0 || !string22) {
-        return self[IS_EMPTY] ? "" : string22;
+    applyStyle = (self, string18) => {
+      if (self.level <= 0 || !string18) {
+        return self[IS_EMPTY] ? "" : string18;
       }
       let styler = self[STYLER];
       if (styler === void 0) {
-        return string22;
+        return string18;
       }
       const { openAll, closeAll } = styler;
-      if (string22.includes("\x1B")) {
+      if (string18.includes("\x1B")) {
         while (styler !== void 0) {
-          string22 = stringReplaceAll(string22, styler.close, styler.open);
+          string18 = stringReplaceAll(string18, styler.close, styler.open);
           styler = styler.parent;
         }
       }
-      const lfIndex = string22.indexOf("\n");
+      const lfIndex = string18.indexOf("\n");
       if (lfIndex !== -1) {
-        string22 = stringEncaseCRLFWithFirstIndex(string22, closeAll, openAll, lfIndex);
+        string18 = stringEncaseCRLFWithFirstIndex(string18, closeAll, openAll, lfIndex);
       }
-      return openAll + string22 + closeAll;
+      return openAll + string18 + closeAll;
     };
     Object.defineProperties(createChalk.prototype, styles2);
     chalk = createChalk();
@@ -1578,11 +1578,11 @@ var strip_ansi_exports = {};
 __export(strip_ansi_exports, {
   default: () => stripAnsi
 });
-function stripAnsi(string22) {
-  if (typeof string22 !== "string") {
-    throw new TypeError(`Expected a \`string\`, got \`${typeof string22}\``);
+function stripAnsi(string18) {
+  if (typeof string18 !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string18}\``);
   }
-  return string22.replace(regex, "");
+  return string18.replace(regex, "");
 }
 var regex;
 var init_strip_ansi = __esm({
@@ -3084,8 +3084,8 @@ var require_tokenizer = __commonJS({
         tokens.push(token);
         overallIndex += token.raw.length;
       };
-      for (const [stringIndex, string22] of (0, utils_1.enumerate)(strings)) {
-        const chars = [...string22];
+      for (const [stringIndex, string18] of (0, utils_1.enumerate)(strings)) {
+        const chars = [...string18];
         for (let i = 0; i < chars.length; i++) {
           if (chars[i] === "-" && chars[i + 1] === "-") {
             push({ type: "longPrefix", raw: "--", index: overallIndex });
@@ -3852,11 +3852,12 @@ var require_package = __commonJS({
   "apps/cli/package.json"(exports2, module2) {
     module2.exports = {
       name: "@packmind/cli",
-      version: "0.23.0",
+      version: "0.24.0",
       description: "A command-line interface for Packmind linting and code quality checks",
       private: false,
       bin: {
-        "packmind-cli": "./main.cjs"
+        "packmind-cli": "./main.cjs",
+        packmind: "./main.cjs"
       },
       main: "./main.cjs",
       files: [
@@ -4186,6 +4187,31 @@ function resolveArtefactFromPath(filePath) {
   return null;
 }
 
+// packages/types/src/coding-agent/validateArtifactFileFormat.ts
+var ACCEPTED_ARTIFACT_EXTENSIONS = {
+  command: [".md"],
+  standard: [".md", ".mdc"],
+  skill: []
+};
+function validateArtifactFileFormat(filePath, artifactType) {
+  const extensions = ACCEPTED_ARTIFACT_EXTENSIONS[artifactType];
+  if (extensions.length === 0) {
+    return { valid: true };
+  }
+  const normalizedPath = filePath.toLowerCase();
+  const hasValidExtension = extensions.some(
+    (ext) => normalizedPath.endsWith(ext)
+  );
+  if (!hasValidExtension) {
+    const accepted = extensions.join(", ");
+    return {
+      valid: false,
+      reason: `Invalid file format for ${artifactType}. Accepted: ${accepted}`
+    };
+  }
+  return { valid: true };
+}
+
 // packages/types/src/recipes/RecipeId.ts
 var createRecipeId = brandedIdFactory();
 
@@ -4383,6 +4409,13 @@ var SpaceCreatedEvent = class extends UserEvent {
   }
 };
 
+// packages/types/src/spaces-management/events/PlaybookArtefactMovedEvent.ts
+var PlaybookArtefactMovedEvent = class extends UserEvent {
+  static {
+    this.eventName = "spaces.artefact.moved";
+  }
+};
+
 // packages/types/src/standards/StandardId.ts
 var createStandardId = brandedIdFactory();
 
@@ -4841,6 +4874,20 @@ var createDetectionProgramId = brandedIdFactory();
 // packages/types/src/linter/RuleDetectionAssessment.ts
 var createRuleDetectionAssessmentId = brandedIdFactory();
 
+// packages/types/src/linter/events/LinterCalledEvent.ts
+var LinterCalledEvent = class extends UserEvent {
+  static {
+    this.eventName = "linter.detection.called";
+  }
+};
+
+// packages/types/src/linter/events/LinterRuleSeverityUpdatedEvent.ts
+var LinterRuleSeverityUpdatedEvent = class extends UserEvent {
+  static {
+    this.eventName = "linter.rule.severity-updated";
+  }
+};
+
 // packages/types/src/llm/LLMProviderMetadata.ts
 var DEFAULT_OPENAI_MODELS = {
   model: "gpt-5.2",
@@ -5270,30 +5317,30 @@ var GitService = class {
     this.gitRunner = gitRunner;
     this.logger = logger2;
   }
-  getGitRepositoryRoot(path34) {
+  getGitRepositoryRoot(path33) {
     try {
       const { stdout } = this.gitRunner("rev-parse --show-toplevel", {
-        cwd: path34
+        cwd: path33
       });
       const gitRoot = stdout.trim();
       this.logger.debug("Resolved git repository root", {
-        inputPath: path34,
+        inputPath: path33,
         gitRoot
       });
       return gitRoot;
     } catch (error) {
       if (error instanceof Error) {
         throw new Error(
-          `Failed to get Git repository root. The path '${path34}' does not appear to be inside a Git repository.
+          `Failed to get Git repository root. The path '${path33}' does not appear to be inside a Git repository.
 ${error.message}`
         );
       }
       throw new Error("Failed to get Git repository root: Unknown error");
     }
   }
-  tryGetGitRepositoryRoot(path34) {
+  tryGetGitRepositoryRoot(path33) {
     try {
-      return this.getGitRepositoryRoot(path34);
+      return this.getGitRepositoryRoot(path33);
     } catch {
       return null;
     }
@@ -5772,7 +5819,6 @@ var ListFilesInDirectoryUseCase = class {
 };
 
 // apps/cli/src/application/useCases/LintFilesAgainstRuleUseCase.ts
-var import_minimatch = require("minimatch");
 var path4 = __toESM(require("path"));
 var fs2 = __toESM(require("fs/promises"));
 
@@ -5789,6 +5835,63 @@ function handleScope(scope) {
   );
 }
 
+// apps/cli/src/application/utils/scopeMatcher.ts
+var import_minimatch = require("minimatch");
+function buildEffectivePattern(targetPath, scope) {
+  const normalizedTarget = targetPath === "/" ? "/" : targetPath.replace(/\/$/, "");
+  if (!scope) {
+    return normalizedTarget === "/" ? "/**" : normalizedTarget + "/**";
+  }
+  if (scope.startsWith(normalizedTarget + "/") || scope === normalizedTarget) {
+    return scope.endsWith("/") ? scope + "**" : scope;
+  }
+  const cleanScope = scope.startsWith("/") ? scope.substring(1) : scope;
+  let pattern;
+  if (normalizedTarget === "/") {
+    pattern = "/" + cleanScope;
+  } else {
+    pattern = normalizedTarget + "/" + cleanScope;
+  }
+  if (pattern.endsWith("/")) {
+    pattern = pattern + "**";
+  }
+  return pattern;
+}
+function isNegativePattern(pattern) {
+  return pattern.startsWith("!");
+}
+function fileMatchesTargetAndScope(filePath, targetPath, scopePatterns) {
+  if (!scopePatterns || scopePatterns.length === 0) {
+    const effectivePattern = buildEffectivePattern(targetPath, null);
+    return (0, import_minimatch.minimatch)(filePath, effectivePattern, { matchBase: false });
+  }
+  const positivePatterns = scopePatterns.filter((p) => !isNegativePattern(p));
+  const negativePatterns = scopePatterns.filter((p) => isNegativePattern(p));
+  if (positivePatterns.length === 0) {
+    return false;
+  }
+  const matchesPositive = positivePatterns.some((scopePattern) => {
+    const effectivePattern = buildEffectivePattern(targetPath, scopePattern);
+    return (0, import_minimatch.minimatch)(filePath, effectivePattern, { matchBase: false });
+  });
+  if (!matchesPositive) {
+    return false;
+  }
+  if (negativePatterns.length > 0) {
+    const matchesNegative = negativePatterns.some((scopePattern) => {
+      const effectivePattern = buildEffectivePattern(
+        targetPath,
+        scopePattern.substring(1)
+      );
+      return (0, import_minimatch.minimatch)(filePath, effectivePattern, { matchBase: false });
+    });
+    if (matchesNegative) {
+      return false;
+    }
+  }
+  return true;
+}
+
 // apps/cli/src/application/useCases/LintFilesAgainstRuleUseCase.ts
 var origin2 = "LintFilesAgainstRuleUseCase";
 var LintFilesAgainstRuleUseCase = class {
@@ -5808,52 +5911,6 @@ var LintFilesAgainstRuleUseCase = class {
       };
     };
   }
-  fileMatchesTargetAndScope(filePath, targetPath, scopePatterns) {
-    if (!scopePatterns || scopePatterns.length === 0) {
-      const effectivePattern = this.buildEffectivePattern(targetPath, null);
-      const matches2 = (0, import_minimatch.minimatch)(filePath, effectivePattern, {
-        matchBase: false
-      });
-      this.logger.debug(
-        `File matching check: file="${filePath}", target="${targetPath}", scope=null, pattern="${effectivePattern}", matches=${matches2}`
-      );
-      return matches2;
-    }
-    const matches = scopePatterns.some((scopePattern) => {
-      const effectivePattern = this.buildEffectivePattern(
-        targetPath,
-        scopePattern
-      );
-      const patternMatches = (0, import_minimatch.minimatch)(filePath, effectivePattern, {
-        matchBase: false
-      });
-      this.logger.debug(
-        `File matching check: file="${filePath}", target="${targetPath}", scope="${scopePattern}", pattern="${effectivePattern}", matches=${patternMatches}`
-      );
-      return patternMatches;
-    });
-    return matches;
-  }
-  buildEffectivePattern(targetPath, scope) {
-    const normalizedTarget = targetPath === "/" ? "/" : targetPath.replace(/\/$/, "");
-    if (!scope) {
-      return normalizedTarget === "/" ? "/**" : normalizedTarget + "/**";
-    }
-    if (scope.startsWith(normalizedTarget + "/") || scope === normalizedTarget) {
-      return scope.endsWith("/") ? scope + "**" : scope;
-    }
-    const cleanScope = scope.startsWith("/") ? scope.substring(1) : scope;
-    let pattern;
-    if (normalizedTarget === "/") {
-      pattern = "/" + cleanScope;
-    } else {
-      pattern = normalizedTarget + "/" + cleanScope;
-    }
-    if (pattern.endsWith("/")) {
-      pattern = pattern + "**";
-    }
-    return pattern;
-  }
   async execute(command30) {
     const {
       path: userPath,
@@ -6053,7 +6110,7 @@ var LintFilesAgainstRuleUseCase = class {
           this.logger.debug(
             `Checking standard: name="${standard.name}", scope=${JSON.stringify(standard.scope)}, rulesCount=${standard.rules.length}`
           );
-          if (!this.fileMatchesTargetAndScope(
+          if (!fileMatchesTargetAndScope(
             normalizedFilePath,
             target.path,
             standard.scope
@@ -6193,7 +6250,6 @@ var LintFilesAgainstRuleUseCase = class {
 };
 
 // apps/cli/src/application/useCases/LintFilesFromConfigUseCase.ts
-var import_minimatch2 = require("minimatch");
 var path5 = __toESM(require("path"));
 var fs3 = __toESM(require("fs/promises"));
 var origin3 = "LintFilesFromConfigUseCase";
@@ -6204,39 +6260,6 @@ var LintFilesFromConfigUseCase = class {
     this.logger = logger2;
     this.detectionProgramsCache = /* @__PURE__ */ new Map();
   }
-  fileMatchesTargetAndScope(filePath, targetPath, scopePatterns) {
-    if (!scopePatterns || scopePatterns.length === 0) {
-      const effectivePattern = this.buildEffectivePattern(targetPath, null);
-      return (0, import_minimatch2.minimatch)(filePath, effectivePattern, { matchBase: false });
-    }
-    return scopePatterns.some((scopePattern) => {
-      const effectivePattern = this.buildEffectivePattern(
-        targetPath,
-        scopePattern
-      );
-      return (0, import_minimatch2.minimatch)(filePath, effectivePattern, { matchBase: false });
-    });
-  }
-  buildEffectivePattern(targetPath, scope) {
-    const normalizedTarget = targetPath === "/" ? "/" : targetPath.replace(/\/$/, "");
-    if (!scope) {
-      return normalizedTarget === "/" ? "/**" : normalizedTarget + "/**";
-    }
-    if (scope.startsWith(normalizedTarget + "/") || scope === normalizedTarget) {
-      return scope.endsWith("/") ? scope + "**" : scope;
-    }
-    const cleanScope = scope.startsWith("/") ? scope.substring(1) : scope;
-    let pattern;
-    if (normalizedTarget === "/") {
-      pattern = "/" + cleanScope;
-    } else {
-      pattern = normalizedTarget + "/" + cleanScope;
-    }
-    if (pattern.endsWith("/")) {
-      pattern = pattern + "**";
-    }
-    return pattern;
-  }
   async execute(command30) {
     const { path: userPath, diffMode, ignorePatterns } = command30;
     this.logger.debug(
@@ -6351,7 +6374,7 @@ var LintFilesFromConfigUseCase = class {
         const detectionPrograms = await this.getDetectionProgramsForTarget(targetConfig);
         for (const target of detectionPrograms.targets) {
           for (const standard of target.standards) {
-            if (!this.fileMatchesTargetAndScope(
+            if (!fileMatchesTargetAndScope(
               normalizedFilePath,
               targetConfig.targetPath,
               standard.scope
@@ -6566,10 +6589,10 @@ var PackmindHttpClient = class {
       return null;
     }
   }
-  async request(path34, options = {}) {
+  async request(path33, options = {}) {
     const { host } = this.getAuthContext();
     const { method = "GET", body } = options;
-    const url = `${host}${path34}`;
+    const url = `${host}${path33}`;
     try {
       const response = await fetch(url, {
         method,
@@ -6613,6 +6636,16 @@ var PackmindHttpClient = class {
   }
 };
 
+// apps/cli/src/domain/errors/CommunityEditionError.ts
+var CommunityEditionError = class extends Error {
+  constructor(feature) {
+    super(
+      `The "${feature}" feature is not available in Packmind Community Edition.`
+    );
+    this.name = "CommunityEditionError";
+  }
+};
+
 // apps/cli/src/infra/repositories/ChangeProposalGateway.ts
 var ChangeProposalGateway = class {
   constructor(httpClient) {
@@ -6623,7 +6656,12 @@ var ChangeProposalGateway = class {
         `/api/v0/organizations/${organizationId}/spaces/${command30.spaceId}/change-proposals/batch`,
         {
           method: "POST",
-          body: { proposals: command30.proposals }
+          body: { proposals: command30.proposals },
+          onError: (response) => {
+            if (response.status === 404) {
+              throw new CommunityEditionError("change proposals");
+            }
+          }
         }
       );
     };
@@ -6633,23 +6671,18 @@ var ChangeProposalGateway = class {
         `/api/v0/organizations/${organizationId}/spaces/${command30.spaceId}/change-proposals/check`,
         {
           method: "POST",
-          body: { proposals: command30.proposals }
+          body: { proposals: command30.proposals },
+          onError: (response) => {
+            if (response.status === 404) {
+              throw new CommunityEditionError("change proposals");
+            }
+          }
         }
       );
     };
   }
 };
 
-// apps/cli/src/domain/errors/CommunityEditionError.ts
-var CommunityEditionError = class extends Error {
-  constructor(feature) {
-    super(
-      `The "${feature}" feature is not available in Packmind Community Edition.`
-    );
-    this.name = "CommunityEditionError";
-  }
-};
-
 // apps/cli/src/infra/repositories/LinterGateway.ts
 var LinterGateway = class {
   constructor(httpClient) {
@@ -6882,12 +6915,12 @@ var PackagesGateway = class {
       );
     };
     this.getSummary = async ({
-      slug,
+      slug: slug2,
       spaceId
     }) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${spaceId}/packages/summary/${encodeURIComponent(slug)}`
+        `/api/v0/organizations/${organizationId}/spaces/${spaceId}/packages/summary/${encodeURIComponent(slug2)}`
       );
     };
     this.create = async (command30) => {
@@ -6922,13 +6955,13 @@ var DeploymentGateway = class {
       const { organizationId } = this.httpClient.getAuthContext();
       const queryParams = new URLSearchParams();
       if (command30.packagesSlugs && command30.packagesSlugs.length > 0) {
-        command30.packagesSlugs.forEach((slug) => {
-          queryParams.append("packageSlug", slug);
+        command30.packagesSlugs.forEach((slug2) => {
+          queryParams.append("packageSlug", slug2);
         });
       }
       if (command30.previousPackagesSlugs && command30.previousPackagesSlugs.length > 0) {
-        command30.previousPackagesSlugs.forEach((slug) => {
-          queryParams.append("previousPackageSlug", slug);
+        command30.previousPackagesSlugs.forEach((slug2) => {
+          queryParams.append("previousPackageSlug", slug2);
         });
       }
       if (command30.gitRemoteUrl) {
@@ -9851,7 +9884,8 @@ var InstallDefaultSkillsUseCase = class {
     const result = {
       filesCreated: 0,
       filesUpdated: 0,
-      errors: []
+      errors: [],
+      skippedSkillsCount: 0
     };
     const config = await this.repositories.configFileRepository.readConfig(baseDirectory);
     const agents = config?.agents;
@@ -9862,6 +9896,7 @@ var InstallDefaultSkillsUseCase = class {
         agents
       }
     );
+    result.skippedSkillsCount = response.skippedSkillsCount;
     try {
       for (const file of response.fileUpdates.createOrUpdate) {
         try {
@@ -10254,8 +10289,8 @@ var LogoutUseCase = class {
   constructor(deps) {
     this.deps = {
       getCredentialsPath: deps?.getCredentialsPath ?? getCredentialsPath,
-      fileExists: deps?.fileExists ?? ((path34) => fs7.existsSync(path34)),
-      deleteFile: deps?.deleteFile ?? ((path34) => fs7.unlinkSync(path34)),
+      fileExists: deps?.fileExists ?? ((path33) => fs7.existsSync(path33)),
+      deleteFile: deps?.deleteFile ?? ((path33) => fs7.unlinkSync(path33)),
       hasEnvVar: deps?.hasEnvVar ?? (() => !!process.env[ENV_VAR_NAME2])
     };
   }
@@ -10304,120 +10339,373 @@ var WhoamiUseCase = class {
   }
 };
 
-// apps/cli/src/application/useCases/SetupMcpUseCase.ts
-var ALL_AGENTS = [
-  { type: "claude", name: "Claude Code" },
-  { type: "cursor", name: "Cursor" },
-  { type: "vscode", name: "VS Code" },
-  { type: "continue", name: "Continue.dev" }
-];
-var SetupMcpUseCase = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  async execute(command30) {
-    const { agentTypes } = command30;
-    const [tokenResult, urlResult] = await Promise.all([
-      this.deps.gateway.mcp.getToken({}),
-      this.deps.gateway.mcp.getUrl({})
-    ]);
-    const config = {
-      url: urlResult.url,
-      accessToken: tokenResult.access_token
-    };
-    const results = [];
-    let hasFailure = false;
-    for (const agentType of agentTypes) {
-      const agentName = ALL_AGENTS.find((a) => a.type === agentType)?.name || agentType;
-      const installResult = this.deps.mcpConfigService.installForAgent(
-        agentType,
-        config
-      );
-      results.push({
-        agentType,
-        agentName,
-        success: installResult.success,
-        error: installResult.error
-      });
-      if (!installResult.success) {
-        hasFailure = true;
-      }
-    }
-    return {
-      results,
-      manualConfigJson: hasFailure ? this.deps.mcpConfigService.getClassicConfig(config) : void 0
-    };
-  }
-};
+// apps/cli/src/application/useCases/CheckCliVersionUseCase.ts
+var import_semver2 = __toESM(require("semver"));
 
-// apps/cli/src/application/services/McpConfigService.ts
-var fs8 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
-var os3 = __toESM(require("os"));
+// apps/cli/src/infra/commands/updateHandler.ts
+var import_path2 = __toESM(require("path"));
 var import_child_process2 = require("child_process");
-var McpConfigService = class {
-  constructor(projectDir = process.cwd()) {
-    this.projectDir = projectDir;
+var import_fs19 = require("fs");
+var import_promises = require("stream/promises");
+var import_stream = require("stream");
+var import_semver = __toESM(require("semver"));
+var GITHUB_REPO = "PackmindHub/packmind";
+var NPM_PACKAGE = "@packmind/cli";
+function getPlatformAssetSuffix(platform, arch) {
+  const osMap = {
+    linux: "linux",
+    darwin: "macos",
+    win32: "windows"
+  };
+  const osName = osMap[platform];
+  if (!osName) {
+    throw new Error(`Unsupported platform: ${platform}`);
   }
-  installForAgent(agent, config) {
-    switch (agent) {
-      case "claude":
-        return this.installClaudeMcp(config);
-      case "cursor":
-        return this.installCursorMcp(config);
-      case "vscode":
-        return this.installVSCodeMcp(config);
-      case "continue":
-        return this.installContinueMcp(config);
-      default:
-        return { success: false, error: `Unknown agent: ${agent}` };
+  const archName = platform === "darwin" && arch === "x64" ? "x64-baseline" : arch;
+  const ext = platform === "win32" ? ".exe" : "";
+  return `${osName}-${archName}${ext}`;
+}
+async function fetchLatestVersionFromNpm(fetchFn) {
+  const res = await fetchFn(`https://registry.npmjs.org/${NPM_PACKAGE}/latest`);
+  if (!res.ok) {
+    throw new Error(
+      `Failed to fetch from npm registry: ${res.status} ${res.statusText}`
+    );
+  }
+  const data = await res.json();
+  return data.version;
+}
+async function fetchLatestVersionFromGitHub(fetchFn) {
+  const res = await fetchFn(
+    `https://api.github.com/repos/${GITHUB_REPO}/releases?per_page=20`,
+    {
+      headers: { Accept: "application/vnd.github.v3+json" }
     }
+  );
+  if (!res.ok) {
+    throw new Error(
+      `Failed to fetch from GitHub API: ${res.status} ${res.statusText}`
+    );
   }
-  getClassicConfig(config) {
-    const mcpConfig = {
-      mcpServers: {
-        packmind: {
-          url: config.url,
-          headers: {
-            Authorization: `Bearer ${config.accessToken}`
-          }
-        }
-      }
-    };
-    return JSON.stringify(mcpConfig, null, 2);
+  const releases = await res.json();
+  const cliReleases = releases.filter((r) => r.tag_name?.startsWith("release-cli/")).map((r) => ({
+    ...r,
+    version: r.tag_name.replace("release-cli/", "")
+  })).filter((r) => import_semver.default.valid(r.version)).sort((a, b) => import_semver.default.rcompare(a.version, b.version));
+  if (cliReleases.length === 0) {
+    throw new Error("No CLI release found on GitHub");
   }
-  installClaudeMcp(config) {
-    const command30 = `claude mcp add --transport http packmind ${config.url} --header "Authorization: Bearer ${config.accessToken}"`;
-    try {
-      (0, import_child_process2.execSync)(command30, { stdio: "pipe" });
-      return { success: true };
-    } catch (error) {
-      const execError = error;
-      const errorMessage = execError.stderr ? execError.stderr.toString().trim() : execError.message || String(error);
-      return { success: false, error: errorMessage };
-    }
+  return cliReleases[0].version;
+}
+async function downloadExecutable(fetchFn, version2, platformSuffix, targetPath) {
+  const assetName = `packmind-cli-${platformSuffix}-${version2}`;
+  const url = `https://github.com/${GITHUB_REPO}/releases/download/release-cli/${version2}/${assetName}`;
+  logInfoConsole(`Downloading ${assetName}...`);
+  const res = await fetchFn(url, { redirect: "follow" });
+  if (!res.ok) {
+    throw new Error(
+      `Failed to download executable: ${res.status} ${res.statusText}
+URL: ${url}`
+    );
   }
-  installCursorMcp(config) {
-    try {
-      const cursorConfigPath = path9.join(os3.homedir(), ".cursor", "mcp.json");
-      const cursorConfig = this.buildCursorConfig(config);
-      const existingConfig = this.readExistingJsonConfig(cursorConfigPath);
-      const mergedConfig = this.mergeConfig(existingConfig, cursorConfig);
-      fs8.writeFileSync(cursorConfigPath, JSON.stringify(mergedConfig, null, 2));
-      return { success: true };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      return { success: false, error: errorMessage };
-    }
+  if (!res.body) {
+    throw new Error("No response body received");
   }
-  installVSCodeMcp(config) {
-    try {
-      const vscodeDir = path9.join(this.projectDir, ".vscode");
-      if (!fs8.existsSync(vscodeDir)) {
-        fs8.mkdirSync(vscodeDir, { recursive: true });
-      }
-      const vscodeConfigPath = path9.join(vscodeDir, "mcp.json");
-      const vscodeConfig = this.buildVSCodeConfig(config);
+  const nodeReadable = import_stream.Readable.fromWeb(res.body);
+  const fileStream = (0, import_fs19.createWriteStream)(targetPath);
+  await (0, import_promises.pipeline)(nodeReadable, fileStream);
+  const stats = (0, import_fs19.statSync)(targetPath);
+  if (stats.size < 1e6) {
+    (0, import_fs19.unlinkSync)(targetPath);
+    throw new Error(
+      `Downloaded file is too small (${stats.size} bytes). The download may have failed.`
+    );
+  }
+  logInfoConsole(
+    `Downloaded successfully (${(stats.size / 1048576).toFixed(1)} MB)`
+  );
+}
+function createForwardCompatSymlink(currentPath, platform) {
+  const dir = import_path2.default.dirname(currentPath);
+  const ext = platform === "win32" ? ".exe" : "";
+  const primaryName = `packmind-cli${ext}`;
+  const aliasName = `packmind${ext}`;
+  const currentBasename = import_path2.default.basename(currentPath);
+  if (currentBasename !== primaryName) {
+    return;
+  }
+  const targetName = primaryName;
+  const symlinkName = aliasName;
+  const symlinkPath = import_path2.default.join(dir, symlinkName);
+  try {
+    (0, import_fs19.unlinkSync)(symlinkPath);
+  } catch {
+  }
+  try {
+    (0, import_fs19.symlinkSync)(targetName, symlinkPath);
+    logInfoConsole(
+      `Created forward-compatible symlink: ${symlinkPath} -> ${targetName}`
+    );
+  } catch {
+  }
+}
+function updateViaNpm(version2) {
+  logInfoConsole(`Updating via npm to version ${version2}...`);
+  (0, import_child_process2.execSync)(`npm install -g ${NPM_PACKAGE}@${version2}`, {
+    stdio: "inherit"
+  });
+}
+async function updateViaExecutableReplace(deps, version2) {
+  const platformSuffix = getPlatformAssetSuffix(deps.platform, deps.arch);
+  const currentPath = deps.executablePath;
+  const tempPath = currentPath + ".update-tmp";
+  try {
+    await downloadExecutable(deps.fetchFn, version2, platformSuffix, tempPath);
+    (0, import_fs19.renameSync)(tempPath, currentPath);
+    if (deps.platform !== "win32") {
+      (0, import_fs19.chmodSync)(currentPath, 493);
+    }
+    createForwardCompatSymlink(currentPath, deps.platform);
+  } catch (error) {
+    try {
+      (0, import_fs19.unlinkSync)(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+function isLocalNpmPackage(scriptPath) {
+  if (!scriptPath) return false;
+  return scriptPath.includes(import_path2.default.join("node_modules", "@packmind", "cli"));
+}
+function isHomebrewInstall(executablePath) {
+  try {
+    const realPath = (0, import_fs19.realpathSync)(executablePath);
+    return realPath.includes("/Cellar/");
+  } catch {
+    return false;
+  }
+}
+async function updateHandler(deps) {
+  const execBasename = import_path2.default.basename(deps.executablePath).replace(/\.exe$/, "");
+  const jsRuntimes = ["node", "bun", "deno"];
+  if (jsRuntimes.includes(execBasename)) {
+    if (isLocalNpmPackage(deps.scriptPath)) {
+      logErrorConsole(
+        "Your CLI version is managed by your local package.json.\nTo update, run: npm update @packmind/cli"
+      );
+    } else {
+      logErrorConsole(
+        "The update command is not available when running the CLI via a JavaScript runtime.\nTo update, use the standalone executable or run: npm install -g @packmind/cli@latest"
+      );
+    }
+    process.exit(1);
+    return;
+  }
+  if (isHomebrewInstall(deps.executablePath)) {
+    logInfoConsole(
+      "This CLI was installed via Homebrew.\nTo update, run: brew upgrade packmind-cli"
+    );
+    process.exit(0);
+    return;
+  }
+  logInfoConsole(
+    `Current version: ${deps.currentVersion} (${deps.isExecutableMode ? "standalone executable" : "npm package"})`
+  );
+  let latestVersion;
+  try {
+    latestVersion = deps.isExecutableMode ? await fetchLatestVersionFromGitHub(deps.fetchFn) : await fetchLatestVersionFromNpm(deps.fetchFn);
+  } catch (error) {
+    logErrorConsole(
+      `Failed to check for updates: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+    return;
+  }
+  if (!import_semver.default.gt(latestVersion, deps.currentVersion)) {
+    logSuccessConsole(`Already up to date (v${deps.currentVersion})`);
+    return;
+  }
+  logConsole("");
+  logInfoConsole(
+    `New version available: ${deps.currentVersion} -> ${latestVersion}`
+  );
+  if (deps.checkOnly) {
+    process.exit(1);
+    return;
+  }
+  try {
+    if (deps.isExecutableMode) {
+      await updateViaExecutableReplace(deps, latestVersion);
+    } else {
+      updateViaNpm(latestVersion);
+    }
+    logConsole("");
+    logSuccessConsole(`Updated to v${latestVersion}`);
+    if (deps.isExecutableMode) {
+      logInfoConsole(`Binary location: ${deps.executablePath}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("EACCES") || message.includes("permission denied")) {
+      logErrorConsole(
+        `Permission denied. Try running with sudo:
+  sudo packmind-cli update`
+      );
+    } else {
+      logErrorConsole(`Update failed: ${message}`);
+    }
+    process.exit(1);
+  }
+}
+
+// apps/cli/src/application/useCases/CheckCliVersionUseCase.ts
+var VERSION_CHECK_TIMEOUT_MS = 5e3;
+var CheckCliVersionUseCase = class {
+  constructor(deps) {
+    this.deps = {
+      fetchLatestVersion: deps?.fetchLatestVersion ?? fetchLatestVersionFromGitHub,
+      fetchFn: deps?.fetchFn ?? fetch,
+      timeoutMs: deps?.timeoutMs ?? VERSION_CHECK_TIMEOUT_MS
+    };
+  }
+  async execute(command30) {
+    try {
+      const latestVersion = await Promise.race([
+        this.deps.fetchLatestVersion(this.deps.fetchFn),
+        new Promise(
+          (_, reject) => setTimeout(
+            () => reject(new Error("Version check timed out")),
+            this.deps.timeoutMs
+          )
+        )
+      ]);
+      const updateAvailable = import_semver2.default.gt(latestVersion, command30.currentVersion);
+      return {
+        currentVersion: command30.currentVersion,
+        latestVersion,
+        updateAvailable
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// apps/cli/src/application/useCases/SetupMcpUseCase.ts
+var ALL_AGENTS = [
+  { type: "claude", name: "Claude Code" },
+  { type: "cursor", name: "Cursor" },
+  { type: "vscode", name: "VS Code" },
+  { type: "continue", name: "Continue.dev" }
+];
+var SetupMcpUseCase = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async execute(command30) {
+    const { agentTypes } = command30;
+    const [tokenResult, urlResult] = await Promise.all([
+      this.deps.gateway.mcp.getToken({}),
+      this.deps.gateway.mcp.getUrl({})
+    ]);
+    const config = {
+      url: urlResult.url,
+      accessToken: tokenResult.access_token
+    };
+    const results = [];
+    let hasFailure = false;
+    for (const agentType of agentTypes) {
+      const agentName = ALL_AGENTS.find((a) => a.type === agentType)?.name || agentType;
+      const installResult = this.deps.mcpConfigService.installForAgent(
+        agentType,
+        config
+      );
+      results.push({
+        agentType,
+        agentName,
+        success: installResult.success,
+        error: installResult.error
+      });
+      if (!installResult.success) {
+        hasFailure = true;
+      }
+    }
+    return {
+      results,
+      manualConfigJson: hasFailure ? this.deps.mcpConfigService.getClassicConfig(config) : void 0
+    };
+  }
+};
+
+// apps/cli/src/application/services/McpConfigService.ts
+var fs8 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+var os3 = __toESM(require("os"));
+var import_child_process3 = require("child_process");
+var McpConfigService = class {
+  constructor(projectDir = process.cwd()) {
+    this.projectDir = projectDir;
+  }
+  installForAgent(agent, config) {
+    switch (agent) {
+      case "claude":
+        return this.installClaudeMcp(config);
+      case "cursor":
+        return this.installCursorMcp(config);
+      case "vscode":
+        return this.installVSCodeMcp(config);
+      case "continue":
+        return this.installContinueMcp(config);
+      default:
+        return { success: false, error: `Unknown agent: ${agent}` };
+    }
+  }
+  getClassicConfig(config) {
+    const mcpConfig = {
+      mcpServers: {
+        packmind: {
+          url: config.url,
+          headers: {
+            Authorization: `Bearer ${config.accessToken}`
+          }
+        }
+      }
+    };
+    return JSON.stringify(mcpConfig, null, 2);
+  }
+  installClaudeMcp(config) {
+    const command30 = `claude mcp add --transport http packmind ${config.url} --header "Authorization: Bearer ${config.accessToken}"`;
+    try {
+      (0, import_child_process3.execSync)(command30, { stdio: "pipe" });
+      return { success: true };
+    } catch (error) {
+      const execError = error;
+      const errorMessage = execError.stderr ? execError.stderr.toString().trim() : execError.message || String(error);
+      return { success: false, error: errorMessage };
+    }
+  }
+  installCursorMcp(config) {
+    try {
+      const cursorConfigPath = path10.join(os3.homedir(), ".cursor", "mcp.json");
+      const cursorConfig = this.buildCursorConfig(config);
+      const existingConfig = this.readExistingJsonConfig(cursorConfigPath);
+      const mergedConfig = this.mergeConfig(existingConfig, cursorConfig);
+      fs8.writeFileSync(cursorConfigPath, JSON.stringify(mergedConfig, null, 2));
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return { success: false, error: errorMessage };
+    }
+  }
+  installVSCodeMcp(config) {
+    try {
+      const vscodeDir = path10.join(this.projectDir, ".vscode");
+      if (!fs8.existsSync(vscodeDir)) {
+        fs8.mkdirSync(vscodeDir, { recursive: true });
+      }
+      const vscodeConfigPath = path10.join(vscodeDir, "mcp.json");
+      const vscodeConfig = this.buildVSCodeConfig(config);
       const existingConfig = this.readExistingJsonConfig(vscodeConfigPath);
       const mergedConfig = this.mergeVSCodeConfig(existingConfig, vscodeConfig);
       fs8.writeFileSync(vscodeConfigPath, JSON.stringify(mergedConfig, null, 2));
@@ -10429,12 +10717,12 @@ var McpConfigService = class {
   }
   installContinueMcp(config) {
     try {
-      const continueDir = path9.join(this.projectDir, ".continue");
-      const mcpServersDir = path9.join(continueDir, "mcpServers");
+      const continueDir = path10.join(this.projectDir, ".continue");
+      const mcpServersDir = path10.join(continueDir, "mcpServers");
       if (!fs8.existsSync(mcpServersDir)) {
         fs8.mkdirSync(mcpServersDir, { recursive: true });
       }
-      const continueConfigPath = path9.join(mcpServersDir, "packmind.yaml");
+      const continueConfigPath = path10.join(mcpServersDir, "packmind.yaml");
       const continueConfig = this.buildContinueYamlConfig(config);
       fs8.writeFileSync(continueConfigPath, continueConfig);
       return { success: true };
@@ -10519,7 +10807,7 @@ mcpServers:
 
 // apps/cli/src/infra/repositories/ConfigFileRepository.ts
 var fs9 = __toESM(require("fs/promises"));
-var path10 = __toESM(require("path"));
+var path11 = __toESM(require("path"));
 var ConfigFileRepository = class {
   constructor() {
     this.CONFIG_FILENAME = "packmind.json";
@@ -10583,7 +10871,7 @@ var ConfigFileRepository = class {
     }
   }
   getConfigPath(directory) {
-    return path10.join(directory, this.CONFIG_FILENAME);
+    return path11.join(directory, this.CONFIG_FILENAME);
   }
   async writeConfigToPath(configPath, config) {
     const configContent = JSON.stringify(config, null, 2) + "\n";
@@ -10594,7 +10882,7 @@ var ConfigFileRepository = class {
    * Excludes common build/dependency directories (node_modules, .git, dist, etc.)
    */
   async findDescendantConfigs(directory) {
-    const normalizedDir = normalizePath2(path10.resolve(directory));
+    const normalizedDir = normalizePath2(path11.resolve(directory));
     return this.searchDescendantsRecursively(normalizedDir);
   }
   async searchDescendantsRecursively(currentDir) {
@@ -10607,7 +10895,7 @@ var ConfigFileRepository = class {
       if (!entry.isDirectory() || this.isExcludedDirectory(entry.name)) {
         continue;
       }
-      const entryPath = normalizePath2(path10.join(currentDir, entry.name));
+      const entryPath = normalizePath2(path11.join(currentDir, entry.name));
       const config = await this.readConfig(entryPath);
       if (config) {
         results.push(entryPath);
@@ -10638,21 +10926,21 @@ var ConfigFileRepository = class {
   async readHierarchicalConfig(startDirectory, stopDirectory) {
     const configs = [];
     const configPaths = [];
-    const normalizedStart = normalizePath2(path10.resolve(startDirectory));
-    const normalizedStop = stopDirectory ? normalizePath2(path10.resolve(stopDirectory)) : null;
+    const normalizedStart = normalizePath2(path11.resolve(startDirectory));
+    const normalizedStop = stopDirectory ? normalizePath2(path11.resolve(stopDirectory)) : null;
     let currentDir = normalizedStart;
     while (true) {
       const config = await this.readConfig(currentDir);
       if (config) {
         configs.push(config);
         configPaths.push(
-          normalizePath2(path10.join(currentDir, this.CONFIG_FILENAME))
+          normalizePath2(path11.join(currentDir, this.CONFIG_FILENAME))
         );
       }
       if (normalizedStop !== null && currentDir === normalizedStop) {
         break;
       }
-      const parentDir = normalizePath2(path10.dirname(currentDir));
+      const parentDir = normalizePath2(path11.dirname(currentDir));
       if (parentDir === currentDir) {
         break;
       }
@@ -10660,9 +10948,9 @@ var ConfigFileRepository = class {
     }
     const mergedPackages = {};
     for (const config of configs) {
-      for (const [slug, version2] of Object.entries(config.packages)) {
-        if (!(slug in mergedPackages)) {
-          mergedPackages[slug] = version2;
+      for (const [slug2, version2] of Object.entries(config.packages)) {
+        if (!(slug2 in mergedPackages)) {
+          mergedPackages[slug2] = version2;
         }
       }
     }
@@ -10677,8 +10965,8 @@ var ConfigFileRepository = class {
    * and returns each config with its target path.
    */
   async findAllConfigsInTree(startDirectory, stopDirectory) {
-    const normalizedStart = normalizePath2(path10.resolve(startDirectory));
-    const normalizedStop = stopDirectory ? normalizePath2(path10.resolve(stopDirectory)) : null;
+    const normalizedStart = normalizePath2(path11.resolve(startDirectory));
+    const normalizedStop = stopDirectory ? normalizePath2(path11.resolve(stopDirectory)) : null;
     const basePath = normalizedStop ?? normalizedStart;
     const searchRoot = normalizedStop ?? normalizedStart;
     const configsMap = /* @__PURE__ */ new Map();
@@ -10704,7 +10992,7 @@ var ConfigFileRepository = class {
       if (stopDir !== null && currentDir === stopDir) {
         break;
       }
-      const parentDir = normalizePath2(path10.dirname(currentDir));
+      const parentDir = normalizePath2(path11.dirname(currentDir));
       if (parentDir === currentDir) {
         break;
       }
@@ -10776,9 +11064,9 @@ var ConfigFileRepository = class {
       parsed.packages = {};
     }
     const packages = parsed.packages;
-    for (const slug of newPackageSlugs) {
-      if (!(slug in packages)) {
-        packages[slug] = "*";
+    for (const slug2 of newPackageSlugs) {
+      if (!(slug2 in packages)) {
+        packages[slug2] = "*";
       }
     }
     await this.writeConfigToPath(configPath, parsed);
@@ -10828,8 +11116,8 @@ var ConfigFileRepository = class {
   }
   createConfigWithPackages(slugs) {
     const packages = {};
-    for (const slug of slugs) {
-      packages[slug] = "*";
+    for (const slug2 of slugs) {
+      packages[slug2] = "*";
     }
     return { packages };
   }
@@ -10837,7 +11125,7 @@ var ConfigFileRepository = class {
 
 // apps/cli/src/infra/repositories/LockFileRepository.ts
 var fs10 = __toESM(require("fs/promises"));
-var path11 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 var LockFileRepository = class {
   constructor() {
     this.LOCK_FILENAME = "packmind-lock.json";
@@ -10871,7 +11159,7 @@ var LockFileRepository = class {
     return typeof obj.installedAt === "string" && Array.isArray(obj.packageSlugs) && Array.isArray(obj.agents) && (obj.targetId === void 0 || typeof obj.targetId === "string") && typeof obj.artifacts === "object" && obj.artifacts !== null && !Array.isArray(obj.artifacts);
   }
   getLockFilePath(baseDirectory) {
-    return path11.join(baseDirectory, this.LOCK_FILENAME);
+    return path12.join(baseDirectory, this.LOCK_FILENAME);
   }
 };
 
@@ -10962,9 +11250,9 @@ var ListSkillsUseCase = class {
 };
 
 // apps/cli/src/infra/utils/readSkillDirectory.ts
-var import_promises = __toESM(require("fs/promises"));
-var import_path2 = __toESM(require("path"));
-var import_minimatch3 = require("minimatch");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_path3 = __toESM(require("path"));
+var import_minimatch2 = require("minimatch");
 
 // apps/cli/src/application/utils/normalizeLineEndings.ts
 function normalizeLineEndings(content) {
@@ -10972,7 +11260,7 @@ function normalizeLineEndings(content) {
 }
 
 // apps/cli/src/infra/utils/binaryDetection.ts
-var path12 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   // Images
   ".png",
@@ -11030,7 +11318,7 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".sqlite3"
 ]);
 function isBinaryExtension(filePath) {
-  const ext = path12.extname(filePath).toLowerCase();
+  const ext = path13.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 }
 function isBinaryBuffer(buffer) {
@@ -11054,30 +11342,30 @@ var BLACKLIST_PATTERNS = ["**/.DS_Store"];
 function isBlacklisted(relativePath) {
   const normalizedPath = relativePath.replace(/\\/g, "/");
   return BLACKLIST_PATTERNS.some(
-    (pattern) => (0, import_minimatch3.minimatch)(normalizedPath, pattern, { dot: true })
+    (pattern) => (0, import_minimatch2.minimatch)(normalizedPath, pattern, { dot: true })
   );
 }
 async function readSkillDirectory(dirPath) {
   const files = [];
   async function readDir(currentPath, basePath) {
-    const entries = await import_promises.default.readdir(currentPath, { withFileTypes: true });
+    const entries = await import_promises2.default.readdir(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = import_path2.default.join(currentPath, entry.name);
-      const relativePath = import_path2.default.relative(basePath, fullPath);
+      const fullPath = import_path3.default.join(currentPath, entry.name);
+      const relativePath = import_path3.default.relative(basePath, fullPath);
       if (isBlacklisted(relativePath)) {
         continue;
       }
       if (entry.isDirectory()) {
         await readDir(fullPath, basePath);
       } else if (entry.isFile()) {
-        const stat8 = await import_promises.default.stat(fullPath);
+        const stat8 = await import_promises2.default.stat(fullPath);
         if (stat8.size > MAX_FILE_SIZE_BYTES) {
           const fileSizeMB = (stat8.size / (1024 * 1024)).toFixed(2);
           throw new Error(
             `File "${relativePath}" is ${fileSizeMB} MB which exceeds the maximum allowed size of ${MAX_FILE_SIZE_MB} MB per file.`
           );
         }
-        const buffer = await import_promises.default.readFile(fullPath);
+        const buffer = await import_promises2.default.readFile(fullPath);
         const isBinary = isBinaryFile(fullPath, buffer);
         const normalizedPath = normalizePath3(relativePath);
         let content;
@@ -11173,7 +11461,7 @@ ${spaceList}`
 // apps/cli/src/application/useCases/diffStrategies/CommandDiffStrategy.ts
 var import_diff2 = require("diff");
 var fs12 = __toESM(require("fs/promises"));
-var path14 = __toESM(require("path"));
+var path15 = __toESM(require("path"));
 
 // apps/cli/src/application/utils/stripFrontmatter.ts
 var FRONTMATTER_DELIMITER2 = "---";
@@ -11200,7 +11488,7 @@ var CommandDiffStrategy = class {
     return file.artifactType === "command";
   }
   async diff(file, baseDirectory) {
-    const fullPath = path14.join(baseDirectory, file.path);
+    const fullPath = path15.join(baseDirectory, file.path);
     let localContent;
     try {
       localContent = await fs12.readFile(fullPath, "utf-8");
@@ -11236,7 +11524,7 @@ var CommandDiffStrategy = class {
 // apps/cli/src/application/useCases/diffStrategies/SkillDiffStrategy.ts
 var import_diff3 = require("diff");
 var fs13 = __toESM(require("fs/promises"));
-var path15 = __toESM(require("path"));
+var path16 = __toESM(require("path"));
 var SkillDiffStrategy = class {
   supports(file) {
     return file.artifactType === "skill";
@@ -11250,7 +11538,7 @@ var SkillDiffStrategy = class {
   async diffNewFiles(skillFolders, serverFiles, baseDirectory) {
     const diffs = [];
     for (const folder of skillFolders) {
-      const folderPath = path15.join(baseDirectory, folder);
+      const folderPath = path16.join(baseDirectory, folder);
       const localFiles = await this.listFilesRecursively(folderPath);
       const serverPathsInFolder = new Set(
         serverFiles.filter((f) => f.path.startsWith(folder + "/")).map((f) => f.path)
@@ -11269,7 +11557,7 @@ var SkillDiffStrategy = class {
         if (serverPathsInFolder.has(filePath)) {
           continue;
         }
-        const fullPath = path15.join(baseDirectory, filePath);
+        const fullPath = path16.join(baseDirectory, filePath);
         const localRead = await this.tryReadFileBinaryAware(fullPath);
         if (localRead === null) {
           continue;
@@ -11296,7 +11584,7 @@ var SkillDiffStrategy = class {
     return diffs;
   }
   async diffSkillMd(file, baseDirectory) {
-    const fullPath = path15.join(baseDirectory, file.path);
+    const fullPath = path16.join(baseDirectory, file.path);
     const localContent = await this.tryReadFile(fullPath);
     if (localContent === null) {
       return [];
@@ -11353,7 +11641,7 @@ var SkillDiffStrategy = class {
       return [];
     }
     const skillFileId = createSkillFileId(file.skillFileId);
-    const fullPath = path15.join(baseDirectory, file.path);
+    const fullPath = path16.join(baseDirectory, file.path);
     const localRead = await this.tryReadFileBinaryAware(fullPath);
     const fileRelativePath = this.computeRelativePath(file.path, skillFolders);
     if (localRead === null) {
@@ -11588,7 +11876,7 @@ var SkillDiffStrategy = class {
     }
     const files = [];
     for (const entry of entries) {
-      const fullPath = path15.join(dirPath, entry);
+      const fullPath = path16.join(dirPath, entry);
       const stat8 = await this.tryStatFile(fullPath);
       if (!stat8) {
         continue;
@@ -11633,7 +11921,7 @@ var SkillDiffStrategy = class {
 
 // apps/cli/src/application/useCases/diffStrategies/StandardDiffStrategy.ts
 var fs14 = __toESM(require("fs/promises"));
-var path16 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
 
 // apps/cli/src/application/utils/parseStandardMd.ts
 var DEPLOYER_PARSERS = [
@@ -11930,7 +12218,7 @@ var StandardDiffStrategy = class {
     return file.artifactType === "standard";
   }
   async diff(file, baseDirectory) {
-    const fullPath = path16.join(baseDirectory, file.path);
+    const fullPath = path17.join(baseDirectory, file.path);
     let localContent;
     try {
       localContent = await fs14.readFile(fullPath, "utf-8");
@@ -12342,6 +12630,7 @@ var PackmindCliHexaFactory = class {
       login: new LoginUseCase(),
       logout: new LogoutUseCase(),
       whoami: new WhoamiUseCase(),
+      checkCliVersion: new CheckCliVersionUseCase(),
       setupMcp: new SetupMcpUseCase({
         gateway: this.repositories.packmindGateway,
         mcpConfigService: new McpConfigService()
@@ -12468,8 +12757,8 @@ var PackmindCliHexa = class {
   }
   async writeConfig(baseDirectory, packagesSlugs) {
     const packages = {};
-    packagesSlugs.forEach((slug) => {
-      packages[slug] = "*";
+    packagesSlugs.forEach((slug2) => {
+      packages[slug2] = "*";
     });
     const existingConfig = await this.hexa.repositories.configFileRepository.readConfig(
       baseDirectory
@@ -12531,6 +12820,9 @@ var PackmindCliHexa = class {
   async whoami(command30) {
     return this.hexa.useCases.whoami.execute(command30);
   }
+  async checkCliVersion(command30) {
+    return this.hexa.useCases.checkCliVersion.execute(command30);
+  }
   async setupMcp(command30) {
     return this.hexa.useCases.setupMcp.execute(command30);
   }
@@ -12581,7 +12873,7 @@ var PackmindCliHexa = class {
     }
     const defaultSpace = await this.getDefaultSpace();
     return slugs.map(
-      (slug) => slug.startsWith("@") ? slug : `@${defaultSpace.slug}/${slug}`
+      (slug2) => slug2.startsWith("@") ? slug2 : `@${defaultSpace.slug}/${slug2}`
     );
   }
   getSpaceService() {
@@ -12673,26 +12965,26 @@ var pathModule = __toESM(require("path"));
 
 // apps/cli/src/application/services/PackmindIgnoreReader.ts
 var fs15 = __toESM(require("fs/promises"));
-var path17 = __toESM(require("path"));
+var path18 = __toESM(require("path"));
 var IGNORE_FILENAME = ".packmindignore";
 var PackmindIgnoreReader = class {
   async readIgnorePatterns(startDirectory, stopDirectory) {
     const patterns = [];
-    const normalizedStart = path17.resolve(startDirectory);
-    const normalizedStop = stopDirectory ? path17.resolve(stopDirectory) : null;
+    const normalizedStart = path18.resolve(startDirectory);
+    const normalizedStop = stopDirectory ? path18.resolve(stopDirectory) : null;
     if (normalizedStop === null) {
-      const ignoreFile = path17.join(normalizedStart, IGNORE_FILENAME);
+      const ignoreFile = path18.join(normalizedStart, IGNORE_FILENAME);
       return this.parseIgnoreFile(ignoreFile);
     }
     let currentDir = normalizedStart;
     while (true) {
-      const ignoreFile = path17.join(currentDir, IGNORE_FILENAME);
+      const ignoreFile = path18.join(currentDir, IGNORE_FILENAME);
       const filePatterns = await this.parseIgnoreFile(ignoreFile);
       patterns.push(...filePatterns);
       if (currentDir === normalizedStop) {
         break;
       }
-      const parentDir = path17.dirname(currentDir);
+      const parentDir = path18.dirname(currentDir);
       if (parentDir === currentDir) {
         break;
       }
@@ -12724,7 +13016,7 @@ function isNotLoggedInError(error) {
 }
 async function lintHandler(args2, deps) {
   const {
-    path: path34,
+    path: path33,
     draft,
     rule,
     language,
@@ -12746,7 +13038,7 @@ async function lintHandler(args2, deps) {
     throw new Error("option --rule is required to use --draft mode");
   }
   const startedAt = Date.now();
-  const targetPath = path34 ?? ".";
+  const targetPath = path33 ?? ".";
   const absolutePath = resolvePath(targetPath);
   let stats;
   try {
@@ -12858,7 +13150,7 @@ async function lintHandler(args2, deps) {
   }
 }
 
-// apps/cli/src/infra/commands/LinterCommand.ts
+// apps/cli/src/infra/commands/customParameters/Logger.ts
 var Logger = {
   from: async (input) => {
     switch (input) {
@@ -12872,6 +13164,8 @@ var Logger = {
     );
   }
 };
+
+// apps/cli/src/infra/commands/customParameters/RuleID.ts
 var RuleID = {
   from: async (input) => {
     const match = input.match(/^@([^/]+)\/(.+)$/);
@@ -12886,6 +13180,8 @@ var RuleID = {
     };
   }
 };
+
+// apps/cli/src/infra/commands/customParameters/DiffModeType.ts
 var DiffModeType = {
   from: async (input) => {
     switch (input) {
@@ -12899,6 +13195,8 @@ var DiffModeType = {
     );
   }
 };
+
+// apps/cli/src/infra/commands/customParameters/LevelType.ts
 var LevelType = {
   from: async (input) => {
     switch (input) {
@@ -12912,6 +13210,8 @@ var LevelType = {
     );
   }
 };
+
+// apps/cli/src/infra/commands/LinterCommand.ts
 var lintCommand = (0, import_cmd_ts.command)({
   name: "lint",
   description: "Lint code at the specified path",
@@ -13005,8 +13305,8 @@ var lintCommand = (0, import_cmd_ts.command)({
 });
 
 // apps/cli/src/wasm-runtime.ts
-var import_fs19 = require("fs");
-var import_path3 = require("path");
+var import_fs20 = require("fs");
+var import_path4 = require("path");
 var import_os = require("os");
 
 // apps/cli/src/embedded-wasm.ts
@@ -13037,20 +13337,20 @@ function hasEmbeddedWasmFiles() {
   return Object.keys(EMBEDDED_WASM_FILES).length > 0;
 }
 function extractWasmFiles() {
-  if (wasmExtractedDir && (0, import_fs19.existsSync)(wasmExtractedDir)) {
+  if (wasmExtractedDir && (0, import_fs20.existsSync)(wasmExtractedDir)) {
     return wasmExtractedDir;
   }
-  const tempDir = (0, import_path3.join)((0, import_os.tmpdir)(), `packmind-wasm-${process.pid}`);
-  if (!(0, import_fs19.existsSync)(tempDir)) {
-    (0, import_fs19.mkdirSync)(tempDir, { recursive: true });
+  const tempDir = (0, import_path4.join)((0, import_os.tmpdir)(), `packmind-wasm-${process.pid}`);
+  if (!(0, import_fs20.existsSync)(tempDir)) {
+    (0, import_fs20.mkdirSync)(tempDir, { recursive: true });
   }
   for (const [filename, base64Data] of Object.entries(EMBEDDED_WASM_FILES)) {
-    const wasmPath = (0, import_path3.join)(tempDir, filename);
-    if ((0, import_fs19.existsSync)(wasmPath)) {
+    const wasmPath = (0, import_path4.join)(tempDir, filename);
+    if ((0, import_fs20.existsSync)(wasmPath)) {
       continue;
     }
     const wasmBuffer = Buffer.from(base64Data, "base64");
-    (0, import_fs19.writeFileSync)(wasmPath, wasmBuffer);
+    (0, import_fs20.writeFileSync)(wasmPath, wasmBuffer);
   }
   wasmExtractedDir = tempDir;
   process.on("exit", () => {
@@ -13061,14 +13361,14 @@ function extractWasmFiles() {
 // apps/cli/src/main.ts
 var import_dotenv = require("dotenv");
 var fs26 = __toESM(require("fs"));
-var path33 = __toESM(require("path"));
+var path32 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/InstallCommand.ts
 var import_cmd_ts2 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/installPackagesHandler.ts
 var fs17 = __toESM(require("fs/promises"));
-var path18 = __toESM(require("path"));
+var path19 = __toESM(require("path"));
 var { version: CLI_VERSION } = require_package();
 async function notifyDistributionIfInGitRepo(params) {
   const { packmindCliHexa, cwd, packages, log, agents } = params;
@@ -13265,7 +13565,7 @@ async function executeInstallForDirectory(directory, deps) {
       };
     }
     const configSlugsWereNormalized = configPackages.some(
-      (slug, i) => slug !== normalizedConfigPackages[i]
+      (slug2, i) => slug2 !== normalizedConfigPackages[i]
     );
     if (configSlugsWereNormalized) {
       await packmindCliHexa.writeConfig(directory, normalizedConfigPackages);
@@ -13307,7 +13607,7 @@ async function installPackagesHandler(args2, deps) {
   const rawCwd = getCwd();
   let cwd = rawCwd;
   if (args2.path) {
-    const resolvedPath = path18.resolve(rawCwd, args2.path);
+    const resolvedPath = path19.resolve(rawCwd, args2.path);
     try {
       const stat8 = await fs17.stat(resolvedPath);
       if (!stat8.isDirectory()) {
@@ -13331,7 +13631,7 @@ async function installPackagesHandler(args2, deps) {
         notificationSent: false
       };
     }
-    const relativeToCwd = path18.relative(rawCwd, resolvedPath);
+    const relativeToCwd = path19.relative(rawCwd, resolvedPath);
     const displayPath = relativeToCwd ? `./${relativeToCwd}/packmind.json` : `./packmind.json`;
     log(`Installing in ${displayPath}...`);
   }
@@ -13478,10 +13778,10 @@ added ${result.filesCreated} files, changed ${result.filesUpdated} files, remove
       };
     }
     const configSlugsWereNormalized = configPackages.some(
-      (slug, i) => slug !== normalizedConfigSlugs[i]
+      (slug2, i) => slug2 !== normalizedConfigSlugs[i]
     );
     const newPackages = normalizedNewSlugs.filter(
-      (slug) => !normalizedConfigSlugs.includes(slug)
+      (slug2) => !normalizedConfigSlugs.includes(slug2)
     );
     if (configSlugsWereNormalized) {
       await packmindCliHexa.writeConfig(cwd, allPackages);
@@ -13661,7 +13961,7 @@ async function uninstallPackagesHandler(args2, deps) {
       originalKey
     );
   });
-  const packagesToUninstall = normalizedRequestedSlugs.filter((slug) => normalizedToOriginalConfigKey.has(slug)).map((slug) => normalizedToOriginalConfigKey.get(slug));
+  const packagesToUninstall = normalizedRequestedSlugs.filter((slug2) => normalizedToOriginalConfigKey.has(slug2)).map((slug2) => normalizedToOriginalConfigKey.get(slug2));
   const notInstalledPackages = packagesSlugs.filter(
     (_, i) => !normalizedToOriginalConfigKey.has(normalizedRequestedSlugs[i])
   );
@@ -13791,7 +14091,7 @@ async function recursiveInstallHandler(args2, deps) {
   };
   let startDirectory = cwd;
   if (args2.path) {
-    const resolvedPath = path18.resolve(cwd, args2.path);
+    const resolvedPath = path19.resolve(cwd, args2.path);
     try {
       const stat8 = await fs17.stat(resolvedPath);
       if (!stat8.isDirectory()) {
@@ -13894,8 +14194,8 @@ async function recursiveInstallHandler(args2, deps) {
 // apps/cli/src/infra/utils/spaceFilterUtils.ts
 function resolveSpaceFromArgs(spaceArg, spaces) {
   if (!spaceArg) return null;
-  const slug = spaceArg.startsWith("@") ? spaceArg.slice(1) : spaceArg;
-  return spaces.find((s) => s.slug === slug) ?? null;
+  const slug2 = spaceArg.startsWith("@") ? spaceArg.slice(1) : spaceArg;
+  return spaces.find((s) => s.slug === slug2) ?? null;
 }
 
 // apps/cli/src/infra/utils/urlBuilderUtils.ts
@@ -13969,8 +14269,7 @@ async function listPackagesHandler(args2, deps) {
     }
     const matchedSpace = resolveSpaceFromArgs(args2.space, allSpaces);
     if (args2.space && !matchedSpace) {
-      const slug = args2.space.startsWith("@") ? args2.space.slice(1) : args2.space;
-      logErrorConsole(`Space '@${slug}' not found.`);
+      logErrorConsole(`Space "@${args2.space}" not found.`);
       logInfoConsole(
         `Available spaces: ${allSpaces.map((s) => `@${s.slug}`).join(", ")}`
       );
@@ -13983,7 +14282,7 @@ async function listPackagesHandler(args2, deps) {
     const spaces = matchedSpace ? [matchedSpace] : allSpaces;
     if (packages.length === 0) {
       logConsole(
-        matchedSpace ? `No packages found in space '@${matchedSpace.slug}'.` : "No packages found."
+        matchedSpace ? `No packages found in space "@${matchedSpace.slug}".` : "No packages found."
       );
       exit(0);
       return;
@@ -14006,20 +14305,20 @@ async function listPackagesHandler(args2, deps) {
 }
 
 // apps/cli/src/infra/utils/packageSlugUtils.ts
-function parsePackageSlug(slug) {
-  if (!slug.startsWith("@")) return null;
-  const slash = slug.indexOf("/", 1);
+function parsePackageSlug(slug2) {
+  if (!slug2.startsWith("@")) return null;
+  const slash = slug2.indexOf("/", 1);
   if (slash === -1) return null;
-  return { spaceSlug: slug.slice(1, slash), pkgSlug: slug.slice(slash + 1) };
+  return { spaceSlug: slug2.slice(1, slash), pkgSlug: slug2.slice(slash + 1) };
 }
 
 // apps/cli/src/infra/commands/packages/showPackageHandler.ts
 function isNotFoundError(err) {
   return err instanceof Error && err.message.includes("does not exist");
 }
-async function resolvePackage(slug, packmindCliHexa) {
+async function resolvePackage(slug2, packmindCliHexa) {
   const allSpaces = await packmindCliHexa.getSpaces();
-  const parsed = parsePackageSlug(slug);
+  const parsed = parsePackageSlug(slug2);
   if (parsed) {
     const { spaceSlug, pkgSlug } = parsed;
     const matchedSpace = allSpaces.find((s) => s.slug === spaceSlug);
@@ -14045,7 +14344,7 @@ async function resolvePackage(slug, packmindCliHexa) {
   const results = await Promise.allSettled(
     allSpaces.map(async (space) => ({
       pkg: await packmindCliHexa.getPackageBySlug({
-        slug,
+        slug: slug2,
         spaceId: space.id
       }),
       spaceSlug: space.slug
@@ -14059,17 +14358,17 @@ async function resolvePackage(slug, packmindCliHexa) {
     if (realError) {
       throw realError.reason;
     }
-    throw new Error(`Package '${slug}' not found in any space.`);
+    throw new Error(`Package '${slug2}' not found in any space.`);
   }
   if (matches.length > 1) {
-    const example = `@${matches[0].spaceSlug}/${slug}`;
+    const example = `@${matches[0].spaceSlug}/${slug2}`;
     throw new Error(
-      `Package '${slug}' exists in multiple spaces (${matches.map((m) => `@${m.spaceSlug}`).join(", ")}). Please specify the space using the @space/package format (e.g. ${example}).`
+      `Package '${slug2}' exists in multiple spaces (${matches.map((m) => `@${m.spaceSlug}`).join(", ")}). Please specify the space using the @space/package format (e.g. ${example}).`
     );
   }
   return {
     pkg: matches[0].pkg,
-    fullSlug: `@${matches[0].spaceSlug}/${slug}`
+    fullSlug: `@${matches[0].spaceSlug}/${slug2}`
   };
 }
 async function showPackageHandler(args2, deps) {
@@ -14133,13 +14432,13 @@ ${pkg.name} (${fullSlug}):
 var crypto = __toESM(require("crypto"));
 var fs18 = __toESM(require("fs"));
 var os4 = __toESM(require("os"));
-var path19 = __toESM(require("path"));
+var path20 = __toESM(require("path"));
 var yaml = __toESM(require("yaml"));
 var PlaybookLocalRepository = class {
   constructor(repoRoot) {
     const normalized = this.normalizeRepoRoot(repoRoot);
     const hash = crypto.createHash("md5").update(normalized).digest("hex");
-    this.storagePath = path19.join(
+    this.storagePath = path20.join(
       os4.homedir(),
       ".packmind",
       hash,
@@ -14205,7 +14504,7 @@ var PlaybookLocalRepository = class {
     }
   }
   writeYaml(data) {
-    const dir = path19.dirname(this.storagePath);
+    const dir = path20.dirname(this.storagePath);
     fs18.mkdirSync(dir, { recursive: true });
     fs18.writeFileSync(this.storagePath, yaml.stringify(data), "utf-8");
   }
@@ -14249,7 +14548,7 @@ var installCommand = (0, import_cmd_ts2.command)({
       description: "Package slugs to install (e.g., backend frontend)"
     })
   },
-  handler: async ({ list, status, recursive, path: path34, show, packagesSlugs }) => {
+  handler: async ({ list, status, recursive, path: path33, show, packagesSlugs }) => {
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
     const repoRoot = await packmindCliHexa.tryGetGitRepositoryRoot(
@@ -14283,17 +14582,17 @@ var installCommand = (0, import_cmd_ts2.command)({
       logWarningConsole(
         "\u26A0\uFE0F  The --recursive flag is deprecated. Install is now recursive by default."
       );
-      await recursiveInstallHandler({ path: path34 || void 0 }, deps);
+      await recursiveInstallHandler({ path: path33 || void 0 }, deps);
       return;
     }
     if (packagesSlugs.length > 0) {
       await installPackagesHandler(
-        { packagesSlugs, path: path34 || void 0 },
+        { packagesSlugs, path: path33 || void 0 },
         deps
       );
       return;
     }
-    await recursiveInstallHandler({ path: path34 || void 0 }, deps);
+    await recursiveInstallHandler({ path: path33 || void 0 }, deps);
   }
 });
 
@@ -14422,6 +14721,20 @@ var logoutCommand = (0, import_cmd_ts5.command)({
 
 // apps/cli/src/infra/commands/WhoamiCommand.ts
 var import_cmd_ts6 = __toESM(require_cjs());
+
+// apps/cli/src/infra/commands/versionCheckNotice.ts
+function displayVersionNotice(result) {
+  if (!result?.updateAvailable) {
+    return;
+  }
+  logConsole("");
+  logWarningConsole(
+    `Update available: ${result.currentVersion} \u2192 ${result.latestVersion} \u2014 run \`packmind-cli update\` to upgrade`
+  );
+}
+
+// apps/cli/src/infra/commands/WhoamiCommand.ts
+var { version: CLI_VERSION2 } = require_package();
 function formatExpiresAt(expiresAt) {
   const now = /* @__PURE__ */ new Date();
   if (expiresAt < now) {
@@ -14464,6 +14777,9 @@ var whoamiCommand = (0, import_cmd_ts6.command)({
   handler: async () => {
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
+    const versionCheckPromise = packmindCliHexa.checkCliVersion({
+      currentVersion: CLI_VERSION2
+    });
     const result = await packmindCliHexa.whoami({});
     if (!result.isAuthenticated) {
       logErrorConsole("Not authenticated");
@@ -14483,6 +14799,7 @@ Credentials are loaded from (in order of priority):`);
       logSuccessConsole("Authenticated");
     }
     displayAuthInfo(result);
+    displayVersionNotice(await versionCheckPromise);
     if (result.isExpired) {
       process.exit(1);
     }
@@ -14497,9 +14814,9 @@ var inquirer = __toESM(require("inquirer"));
 
 // apps/cli/src/application/services/AgentDetectionService.ts
 var fs19 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 var os5 = __toESM(require("os"));
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var AgentDetectionService = class {
   constructor(projectDir = process.cwd()) {
     this.projectDir = projectDir;
@@ -14524,21 +14841,21 @@ var AgentDetectionService = class {
     return this.isCommandAvailable("claude");
   }
   isCursorAvailable() {
-    const cursorConfigDir = path20.join(os5.homedir(), ".cursor");
+    const cursorConfigDir = path21.join(os5.homedir(), ".cursor");
     return fs19.existsSync(cursorConfigDir);
   }
   isVSCodeAvailable() {
-    const vscodeDir = path20.join(this.projectDir, ".vscode");
+    const vscodeDir = path21.join(this.projectDir, ".vscode");
     return fs19.existsSync(vscodeDir);
   }
   isContinueAvailable() {
-    const continueDir = path20.join(this.projectDir, ".continue");
+    const continueDir = path21.join(this.projectDir, ".continue");
     return fs19.existsSync(continueDir);
   }
   isCommandAvailable(command30) {
     try {
       const whichCommand = process.platform === "win32" ? "where" : "which";
-      (0, import_child_process3.execSync)(`${whichCommand} ${command30}`, { stdio: "pipe" });
+      (0, import_child_process4.execSync)(`${whichCommand} ${command30}`, { stdio: "pipe" });
       return true;
     } catch {
       return false;
@@ -14546,7 +14863,7 @@ var AgentDetectionService = class {
   }
 };
 
-// apps/cli/src/infra/commands/SetupMcpCommand.ts
+// apps/cli/src/infra/commands/customParameters/AgentArgType.ts
 var VALID_AGENTS = ["copilot", "cursor", "claude", "continue"];
 var agentArgToType = {
   copilot: "vscode",
@@ -14565,6 +14882,8 @@ var AgentArgType = {
     );
   }
 };
+
+// apps/cli/src/infra/commands/SetupMcpCommand.ts
 var ALL_AGENTS2 = [
   { type: "claude", name: "Claude Code" },
   { type: "cursor", name: "Cursor" },
@@ -14747,6 +15066,13 @@ var originSkillOption = (0, import_cmd_ts8.option)({
   type: (0, import_cmd_ts8.optional)(import_cmd_ts8.string)
 });
 
+// apps/cli/src/infra/commands/customParameters/SpaceSlug.ts
+var SpaceSlug = {
+  from: async (input) => {
+    return input.startsWith("@") ? input.slice(1) : input;
+  }
+};
+
 // apps/cli/src/infra/commands/skills/AddSkillCommand.ts
 var addSkillCommand = (0, import_cmd_ts9.command)({
   name: "add",
@@ -14760,7 +15086,7 @@ var addSkillCommand = (0, import_cmd_ts9.command)({
     space: (0, import_cmd_ts9.option)({
       long: "space",
       description: "Slug of the space in which to add the skill (with or without leading @)",
-      type: (0, import_cmd_ts9.optional)(import_cmd_ts9.string)
+      type: (0, import_cmd_ts9.optional)(SpaceSlug)
     }),
     originSkill: originSkillOption
   },
@@ -14805,7 +15131,7 @@ Example: ${formatCommand(`packmind-cli skills add --space <slug> ${skillPath}`)}
 
 // apps/cli/src/infra/commands/skills/InstallDefaultSkillsCommand.ts
 var import_cmd_ts10 = __toESM(require_cjs());
-var { version: CLI_VERSION2 } = require_package();
+var { version: CLI_VERSION3 } = require_package();
 var installDefaultSkillsCommand = (0, import_cmd_ts10.command)({
   name: "install-default",
   description: "Install default Packmind skills for configured coding agents",
@@ -14822,8 +15148,13 @@ var installDefaultSkillsCommand = (0, import_cmd_ts10.command)({
       logInfoConsole("Installing default skills...");
       const result = await packmindCliHexa.installDefaultSkills({
         includeBeta,
-        cliVersion: includeBeta ? void 0 : CLI_VERSION2
+        cliVersion: includeBeta ? void 0 : CLI_VERSION3
       });
+      if (result.skippedSkillsCount > 0) {
+        logWarningConsole(
+          `${result.skippedSkillsCount} skill(s) were skipped because they require a newer version of packmind-cli. Run "${formatCommand("packmind-cli update")}" to get the latest version.`
+        );
+      }
       if (result.errors.length > 0) {
         for (const error of result.errors) {
           logErrorConsole(`Error: ${error}`);
@@ -14921,8 +15252,7 @@ async function listSkillsHandler(args2, deps) {
     const spaces = await packmindCliHexa.getSpaces();
     const matchedSpace = resolveSpaceFromArgs(args2.space, spaces);
     if (args2.space && !matchedSpace) {
-      const slug = args2.space.startsWith("@") ? args2.space.slice(1) : args2.space;
-      logErrorConsole(`Space "${slug}" not found.`);
+      logErrorConsole(`Space "@${args2.space}" not found.`);
       exit(1);
       return;
     }
@@ -14931,14 +15261,14 @@ async function listSkillsHandler(args2, deps) {
     );
     if (skills.length === 0) {
       logConsole(
-        matchedSpace ? `No skills found in space "${matchedSpace.slug}".` : "No skills found."
+        matchedSpace ? `No skills found in space "@${matchedSpace.slug}".` : "No skills found."
       );
       exit(0);
       return;
     }
     logConsole(formatHeader(`\u{1F4CB} Skills (${skills.length})
 `));
-    const buildUrl = resolveUrlBuilder((slug) => `skills/${slug}/files`);
+    const buildUrl = resolveUrlBuilder((slug2) => `skills/${slug2}/files`);
     displayGroupedSkills(skills, spaces, buildUrl);
     exit(0);
   } catch (err) {
@@ -14954,7 +15284,7 @@ var listSkillsCommand = (0, import_cmd_ts11.command)({
   description: "List available skills",
   args: {
     space: (0, import_cmd_ts11.option)({
-      type: (0, import_cmd_ts11.optional)(import_cmd_ts11.string),
+      type: (0, import_cmd_ts11.optional)(SpaceSlug),
       long: "space",
       description: "Filter skills by space slug"
     })
@@ -15121,8 +15451,8 @@ async function createStandardHandler(filePath, useCase, originSkill, spaceSlug)
 }
 
 // apps/cli/src/application/utils/spaceUtils.ts
-function resolveSpace(spaces, slug) {
-  const normalizedSlug = slug?.replace(/^@/, "");
+function resolveSpace(spaces, slug2) {
+  const normalizedSlug = slug2?.replace(/^@/, "");
   if (normalizedSlug) {
     const found = spaces.find((s) => s.slug === normalizedSlug);
     if (!found) {
@@ -15186,7 +15516,7 @@ var createStandardCommand = (0, import_cmd_ts13.command)({
     space: (0, import_cmd_ts13.option)({
       long: "space",
       description: "Slug of the space in which to create the standard (with or without leading @)",
-      type: (0, import_cmd_ts13.optional)(import_cmd_ts13.string)
+      type: (0, import_cmd_ts13.optional)(SpaceSlug)
     }),
     originSkill: originSkillOption
   },
@@ -15297,8 +15627,7 @@ async function listStandardsHandler(args2, deps) {
     const spaces = await packmindCliHexa.getSpaces();
     const matchedSpace = resolveSpaceFromArgs(args2.space, spaces);
     if (args2.space && !matchedSpace) {
-      const slug = args2.space.startsWith("@") ? args2.space.slice(1) : args2.space;
-      logErrorConsole(`Space "${slug}" not found.`);
+      logErrorConsole(`Space "@${args2.space}" not found.`);
       exit(1);
       return;
     }
@@ -15307,7 +15636,7 @@ async function listStandardsHandler(args2, deps) {
     );
     if (standards.length === 0) {
       logConsole(
-        matchedSpace ? `No standards found in space "${matchedSpace.slug}".` : "No standards found."
+        matchedSpace ? `No standards found in space "@${matchedSpace.slug}".` : "No standards found."
       );
       exit(0);
       return;
@@ -15330,7 +15659,7 @@ var listStandardsCommand = (0, import_cmd_ts14.command)({
   description: "List available coding standards",
   args: {
     space: (0, import_cmd_ts14.option)({
-      type: (0, import_cmd_ts14.optional)(import_cmd_ts14.string),
+      type: (0, import_cmd_ts14.optional)(SpaceSlug),
       long: "space",
       description: "Filter standards by space slug"
     })
@@ -15537,7 +15866,7 @@ var createCommandCommand = (0, import_cmd_ts16.command)({
     space: (0, import_cmd_ts16.option)({
       long: "space",
       description: "Slug of the space in which to create the command",
-      type: (0, import_cmd_ts16.optional)(import_cmd_ts16.string)
+      type: (0, import_cmd_ts16.optional)(SpaceSlug)
     }),
     originSkill: originSkillOption
   },
@@ -15642,8 +15971,7 @@ async function listCommandsHandler(args2, deps) {
     const spaces = await packmindCliHexa.getSpaces();
     const matchedSpace = resolveSpaceFromArgs(args2.space, spaces);
     if (args2.space && !matchedSpace) {
-      const slug = args2.space.startsWith("@") ? args2.space.slice(1) : args2.space;
-      logErrorConsole(`Space "${slug}" not found.`);
+      logErrorConsole(`Space "@${args2.space}" not found.`);
       exit(1);
       return;
     }
@@ -15652,7 +15980,7 @@ async function listCommandsHandler(args2, deps) {
     );
     if (commands.length === 0) {
       logConsole(
-        matchedSpace ? `No commands found in space "${matchedSpace.slug}".` : "No commands found."
+        matchedSpace ? `No commands found in space "@${matchedSpace.slug}".` : "No commands found."
       );
       exit(0);
       return;
@@ -15679,7 +16007,7 @@ var listCommandsCommand = (0, import_cmd_ts17.command)({
   description: "List available commands",
   args: {
     space: (0, import_cmd_ts17.option)({
-      type: (0, import_cmd_ts17.optional)(import_cmd_ts17.string),
+      type: (0, import_cmd_ts17.optional)(SpaceSlug),
       long: "space",
       description: "Filter commands by space slug"
     })
@@ -16150,7 +16478,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       description: "Subcommand and arguments (e.g., add <path>, remove <path>)"
     })
   },
-  handler: async ({ submit, includeSubmitted, message, path: path34, positionals }) => {
+  handler: async ({ submit, includeSubmitted, message, path: path33, positionals }) => {
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
     if (submit) {
@@ -16166,7 +16494,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       process.exit(1);
     }
     if (positionals[0] === "add") {
-      const addFilePath = path34 && positionals[1] ? `${path34}/${positionals[1]}`.replace(/\/+/g, "/") : positionals[1];
+      const addFilePath = path33 && positionals[1] ? `${path33}/${positionals[1]}`.replace(/\/+/g, "/") : positionals[1];
       const addCommand = `packmind-cli playbook add ${addFilePath}`;
       logErrorConsole("Deprecated: `packmind-cli diff add` has been removed");
       logInfoConsole("Use the following command instead:");
@@ -16174,7 +16502,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       process.exit(1);
     }
     if (positionals[0] === "remove" || positionals[0] === "rm") {
-      const removeFilePath = path34 && positionals[1] ? `${path34}/${positionals[1]}`.replace(/\/+/g, "/") : positionals[1];
+      const removeFilePath = path33 && positionals[1] ? `${path33}/${positionals[1]}`.replace(/\/+/g, "/") : positionals[1];
       const removeCommand = `packmind-cli playbook remove ${removeFilePath}`;
       logErrorConsole(
         "Deprecated: `packmind-cli diff remove` has been removed"
@@ -16183,7 +16511,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       logInfoConsole(` ${formatCommand(removeCommand)}`);
       process.exit(1);
     }
-    const diffCommand3 = `packmind-cli playbook diff${includeSubmitted ? " --include-submitted" : ""}${path34 ? ` --path ${path34}` : ""}`;
+    const diffCommand3 = `packmind-cli playbook diff${includeSubmitted ? " --include-submitted" : ""}${path33 ? ` --path ${path33}` : ""}`;
     logErrorConsole("Deprecated: `packmind-cli diff` will be removed");
     logInfoConsole("Use the following command instead:");
     logInfoConsole(` ${formatCommand(diffCommand3)}`);
@@ -16193,7 +16521,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       getCwd: () => process.cwd(),
       log: console.log,
       includeSubmitted,
-      path: path34
+      path: path33
     });
   }
 });
@@ -16317,7 +16645,7 @@ var createPackageCommand = (0, import_cmd_ts20.command)({
     space: (0, import_cmd_ts20.option)({
       long: "space",
       description: "Slug of the space in which to create the package",
-      type: (0, import_cmd_ts20.optional)(import_cmd_ts20.string)
+      type: (0, import_cmd_ts20.optional)(SpaceSlug)
     }),
     originSkill: originSkillOption
   },
@@ -16375,11 +16703,11 @@ var import_cmd_ts21 = __toESM(require_cjs());
 
 // apps/cli/src/domain/errors/ItemNotFoundError.ts
 var ItemNotFoundError = class extends Error {
-  constructor(itemType, slug, spaceSlug) {
-    const message = spaceSlug ? `${itemType} '${slug}' not found in space '@${spaceSlug}'` : `${itemType} '${slug}' not found`;
+  constructor(itemType, slug2, spaceSlug) {
+    const message = spaceSlug ? `${itemType} '${slug2}' not found in space '@${spaceSlug}'` : `${itemType} '${slug2}' not found`;
     super(message);
     this.itemType = itemType;
-    this.slug = slug;
+    this.slug = slug2;
     this.spaceSlug = spaceSlug;
     this.name = "ItemNotFoundError";
   }
@@ -16442,34 +16770,34 @@ var AddToPackageUseCase = class {
   async resolveSlugsToIds(itemType, slugs, spaceId, spaceSlug) {
     const ids = [];
     const idToSlugMap = /* @__PURE__ */ new Map();
-    for (const slug of slugs) {
+    for (const slug2 of slugs) {
       let item = null;
       if (itemType === "standard") {
-        item = await this.findStandardBySlug(slug, spaceId);
+        item = await this.findStandardBySlug(slug2, spaceId);
       } else if (itemType === "command") {
-        item = await this.findCommandBySlug(slug, spaceId);
+        item = await this.findCommandBySlug(slug2, spaceId);
       } else if (itemType === "skill") {
-        item = await this.findSkillBySlug(slug, spaceId);
+        item = await this.findSkillBySlug(slug2, spaceId);
       }
       if (!item) {
-        throw new ItemNotFoundError(itemType, slug, spaceSlug);
+        throw new ItemNotFoundError(itemType, slug2, spaceSlug);
       }
       ids.push(item.id);
-      idToSlugMap.set(item.id, slug);
+      idToSlugMap.set(item.id, slug2);
     }
     return { ids, idToSlugMap };
   }
-  async findStandardBySlug(slug, spaceId) {
+  async findStandardBySlug(slug2, spaceId) {
     const standards = await this.gateway.standards.list({ spaceId });
-    return standards.standards.find((standard) => standard.slug === slug) ?? null;
+    return standards.standards.find((standard) => standard.slug === slug2) ?? null;
   }
-  async findCommandBySlug(slug, spaceId) {
+  async findCommandBySlug(slug2, spaceId) {
     const commands = await this.gateway.commands.list({ spaceId });
-    return commands.recipes.find((command30) => command30.slug === slug) ?? null;
+    return commands.recipes.find((command30) => command30.slug === slug2) ?? null;
   }
-  async findSkillBySlug(slug, spaceId) {
+  async findSkillBySlug(slug2, spaceId) {
     const skills = await this.gateway.skills.list({ spaceId });
-    return skills.find((skill) => skill.slug === slug) ?? null;
+    return skills.find((skill) => skill.slug === slug2) ?? null;
   }
 };
 
@@ -16637,7 +16965,7 @@ var listPackagesCommand = (0, import_cmd_ts22.command)({
   description: "List available packages",
   args: {
     space: (0, import_cmd_ts22.option)({
-      type: (0, import_cmd_ts22.optional)(import_cmd_ts22.string),
+      type: (0, import_cmd_ts22.optional)(SpaceSlug),
       long: "space",
       description: "Filter packages by space slug"
     })
@@ -16665,10 +16993,10 @@ var showPackageCommand = (0, import_cmd_ts23.command)({
       description: "Package slug (e.g. backend or @my-space/backend)"
     })
   },
-  handler: async ({ slug }) => {
+  handler: async ({ slug: slug2 }) => {
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
-    await showPackageHandler({ slug }, { packmindCliHexa, exit: process.exit });
+    await showPackageHandler({ slug: slug2 }, { packmindCliHexa, exit: process.exit });
   }
 });
 
@@ -16688,16 +17016,17 @@ var packagesCommand = (0, import_cmd_ts24.subcommands)({
 var import_cmd_ts31 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/AddCommand.ts
-var import_fs20 = require("fs");
+var import_fs21 = require("fs");
 var import_cmd_ts25 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/addHandler.ts
 var fs24 = __toESM(require("fs"));
 var path25 = __toESM(require("path"));
 var yaml2 = __toESM(require("yaml"));
+var import_slug = __toESM(require("slug"));
 
 // apps/cli/src/application/utils/parseCommandFile.ts
-var path21 = __toESM(require("path"));
+var path22 = __toESM(require("path"));
 var FRONTMATTER_DELIMITER3 = "---";
 function parseCommandFile(content, filePath) {
   content = normalizeLineEndings(content);
@@ -16720,6 +17049,9 @@ ${FRONTMATTER_DELIMITER3}`
     const frontmatter = contentAfterOpening.slice(0, closingIndex);
     const name2 = resolveName(frontmatter, filePath);
     const body = contentAfterOpening.slice(closingIndex + FRONTMATTER_DELIMITER3.length + 1).replace(/^\n+/, "");
+    if (!body || body.trim().length === 0) {
+      return { success: false, error: "Command body is empty" };
+    }
     return { success: true, parsed: { name: name2, content: body } };
   }
   const name = humanizeSlug(extractFilenameSlug(filePath));
@@ -16750,7 +17082,7 @@ function stripYamlQuotes2(value) {
   return value;
 }
 function extractFilenameSlug(filePath) {
-  let basename2 = path21.basename(filePath);
+  let basename2 = path22.basename(filePath);
   if (basename2.endsWith(".prompt.md")) {
     basename2 = basename2.slice(0, -".prompt.md".length);
   } else if (basename2.endsWith(".md")) {
@@ -16758,37 +17090,84 @@ function extractFilenameSlug(filePath) {
   }
   return basename2;
 }
-function humanizeSlug(slug) {
-  const words = slug.replace(/[-_]/g, " ");
+function humanizeSlug(slug2) {
+  const words = slug2.replace(/[-_]/g, " ");
   return words.charAt(0).toUpperCase() + words.slice(1);
 }
 
 // apps/cli/src/application/utils/parseLenientStandard.ts
-var import_path4 = __toESM(require("path"));
-function parseLenientStandard(content, filePath) {
+function parseLenientStandard(content) {
   content = normalizeLineEndings(content);
   if (!content.trim()) {
     return null;
   }
-  const lines = content.split("\n");
-  let headingIndex = -1;
+  let lines = content.split("\n");
+  if (lines[0]?.trim() === "---") {
+    const closingIdx = lines.findIndex(
+      (line, i) => i > 0 && line.trim() === "---"
+    );
+    if (closingIdx !== -1) {
+      lines = lines.slice(closingIdx + 1);
+    }
+  }
+  let headingIdx = -1;
+  let name = "";
   for (let i = 0; i < lines.length; i++) {
-    if (lines[i].trim() === "") continue;
-    if (lines[i].startsWith("# ")) {
-      const name = lines[i].slice(2).trim();
-      if (name) {
-        headingIndex = i;
-        const description = lines.slice(headingIndex + 1).join("\n").trim();
-        return { name, description };
+    const line = lines[i];
+    if (line.startsWith("# Standard: ")) {
+      const text = line.slice("# Standard: ".length).trim();
+      if (text) {
+        name = text;
+        headingIdx = i;
+        break;
+      }
+    } else if (line.startsWith("# ")) {
+      const text = line.slice(2).trim();
+      if (text) {
+        name = text;
+        headingIdx = i;
+        break;
       }
     }
-    break;
   }
-  const stem = import_path4.default.basename(filePath, import_path4.default.extname(filePath));
-  return {
-    name: stem,
-    description: content.trim()
-  };
+  if (headingIdx === -1) {
+    return null;
+  }
+  const bodyLines = [];
+  for (let i = headingIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("#")) continue;
+    bodyLines.push({
+      line,
+      isBullet: line.startsWith("* ") || line.startsWith("- ")
+    });
+  }
+  const listGroups = [];
+  let currentGroup = null;
+  for (let i = 0; i < bodyLines.length; i++) {
+    if (bodyLines[i].isBullet) {
+      if (!currentGroup) {
+        currentGroup = { startIdx: i, endIdx: i, items: [] };
+        listGroups.push(currentGroup);
+      }
+      currentGroup.endIdx = i;
+      currentGroup.items.push(bodyLines[i].line.slice(2).trim());
+    } else {
+      currentGroup = null;
+    }
+  }
+  const joinAndClean = (bLines) => bLines.map((b) => b.line).join("\n").trim().replace(/\s*:\s*$/, "");
+  if (listGroups.length === 0) {
+    return { name, description: joinAndClean(bodyLines), rules: [] };
+  }
+  const lastGroup = listGroups[listGroups.length - 1];
+  const hasTextAfterLastList = bodyLines.slice(lastGroup.endIdx + 1).some((b) => !b.isBullet && b.line.trim() !== "");
+  if (hasTextAfterLastList) {
+    return { name, description: joinAndClean(bodyLines), rules: [] };
+  }
+  const rules = lastGroup.items;
+  const description = joinAndClean(bodyLines.slice(0, lastGroup.startIdx));
+  return { name, description, rules };
 }
 
 // apps/cli/src/application/utils/parseSkillDirectory.ts
@@ -17086,6 +17465,15 @@ async function playbookAddHandler(deps) {
     artifactType = artefactResult.artifactType;
     codingAgent = artefactResult.codingAgent;
   }
+  const formatValidation = validateArtifactFileFormat(
+    absolutePath,
+    artifactType
+  );
+  if (!formatValidation.valid) {
+    logErrorConsole(formatValidation.reason);
+    exit(1);
+    return;
+  }
   let localContent;
   let artifactName;
   let serializedContent;
@@ -17152,9 +17540,15 @@ async function playbookAddHandler(deps) {
       if (parsed) {
         artifactName = parsed.name;
       } else {
-        const lenient = parseLenientStandard(localContent, absolutePath);
+        const lenient = parseLenientStandard(localContent);
         if (!lenient) {
-          logErrorConsole("File is empty.");
+          logErrorConsole(
+            `${filePath} is not a valid artifact. Expected format:
+
+# My standard name
+
+Content goes here...`
+          );
           exit(1);
           return;
         }
@@ -17186,11 +17580,10 @@ async function playbookAddHandler(deps) {
   let spaceName;
   const allSpaces = await packmindCliHexa.getSpaces();
   if (spaceSlug) {
-    const normalizedSlug = spaceSlug.startsWith("@") ? spaceSlug.slice(1) : spaceSlug;
-    const matchedSpace = allSpaces.find((s) => s.slug === normalizedSlug);
+    const matchedSpace = allSpaces.find((s) => s.slug === spaceSlug);
     if (!matchedSpace) {
       logErrorConsole(
-        `Space "${spaceSlug}" not found. Available spaces:
+        `Space "@${spaceSlug}" not found. Available spaces:
 ${formatSpaceList(allSpaces)}`
       );
       exit(1);
@@ -17202,10 +17595,9 @@ ${formatSpaceList(allSpaces)}`
     spaceId = allSpaces[0].id;
     spaceName = allSpaces[0].name;
   } else {
-    const isExistingArtifact = earlyLockFile && findLockFileEntryForPath(normalizedFilePath, earlyLockFile.artifacts);
-    const deployedSpaceId = deployedContext?.spaceId;
-    if (isExistingArtifact && deployedSpaceId) {
-      spaceId = deployedSpaceId;
+    const existingLockEntry = earlyLockFile && findLockFileEntryForPath(normalizedFilePath, earlyLockFile.artifacts);
+    if (existingLockEntry) {
+      spaceId = existingLockEntry.spaceId;
       spaceName = allSpaces.find((s) => s.id === spaceId)?.name;
     } else {
       logErrorConsole(
@@ -17228,6 +17620,32 @@ Example: packmind-cli playbook add --space ${allSpaces[0].slug} <path>`
       changeType = "updated";
     }
   }
+  if (changeType === "created") {
+    try {
+      const existingNames = await listExistingArtifactNames(
+        packmindCliHexa,
+        artifactType,
+        spaceId
+      );
+      const nameExists = existingNames.some(
+        (name) => (0, import_slug.default)(name) === (0, import_slug.default)(artifactName)
+      );
+      if (nameExists) {
+        logErrorConsole(
+          `A ${artifactType} named "${artifactName}" already exists in Packmind.`
+        );
+        exit(1);
+        return;
+      }
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      logErrorConsole(
+        `Failed to check for existing ${artifactType}s: ${errorMessage}`
+      );
+      exit(1);
+      return;
+    }
+  }
   if (changeType === "updated" && earlyLockFile) {
     const deployedFiles = await fetchDeployedFiles(
       packmindCliHexa.getPackmindGateway(),
@@ -17278,6 +17696,28 @@ Example: packmind-cli playbook add --space ${allSpaces[0].slug} <path>`
   );
   exit(0);
 }
+async function listExistingArtifactNames(packmindCliHexa, artifactType, spaceId) {
+  switch (artifactType) {
+    case "skill": {
+      const skills = await packmindCliHexa.listSkills({
+        spaceId
+      });
+      return skills.map((s) => s.name);
+    }
+    case "command": {
+      const commands = await packmindCliHexa.listCommands({
+        spaceId
+      });
+      return commands.map((c) => c.name);
+    }
+    case "standard": {
+      const standards = await packmindCliHexa.listStandards({
+        spaceId
+      });
+      return standards.map((s) => s.name);
+    }
+  }
+}
 function formatSpaceList(spaces) {
   const maxSlugLength = Math.max(...spaces.map((s) => s.slug.length));
   return spaces.map((s) => `  ${s.slug.padEnd(maxSlugLength)}  (${s.name})`).join("\n");
@@ -17294,7 +17734,7 @@ var addPlaybookCommand = (0, import_cmd_ts25.command)({
       description: "Path to the artifact file or directory to stage"
     }),
     space: (0, import_cmd_ts25.option)({
-      type: (0, import_cmd_ts25.optional)(import_cmd_ts25.string),
+      type: (0, import_cmd_ts25.optional)(SpaceSlug),
       long: "space",
       description: "Target space slug"
     })
@@ -17314,7 +17754,7 @@ var addPlaybookCommand = (0, import_cmd_ts25.command)({
       spaceSlug: space,
       exit: process.exit,
       cwd: process.cwd(),
-      readFile: (p) => (0, import_fs20.readFileSync)(p, "utf-8"),
+      readFile: (p) => (0, import_fs21.readFileSync)(p, "utf-8"),
       readSkillDirectory,
       playbookLocalRepository,
       lockFileRepository
@@ -17521,13 +17961,10 @@ async function playbookUnstageHandler(deps) {
     return;
   }
   if (spaceSlug) {
-    const normalizedSlug = spaceSlug.startsWith("@") ? spaceSlug.slice(1) : spaceSlug;
-    const entry = matchingEntries.find(
-      (c) => c.spaceName === normalizedSlug || c.spaceId === normalizedSlug
-    );
+    const entry = matchingEntries.find((c) => c.spaceName === spaceSlug);
     if (!entry) {
       logErrorConsole(
-        `No staged change found for ${normalizedFilePath} in space "${spaceSlug}"`
+        `No staged change found for ${normalizedFilePath} in space "@${spaceSlug}"`
       );
       exit(1);
       return;
@@ -17569,7 +18006,7 @@ var unstagePlaybookCommand = (0, import_cmd_ts27.command)({
       description: "Path to the artifact file or directory to unstage"
     }),
     space: (0, import_cmd_ts27.option)({
-      type: (0, import_cmd_ts27.optional)(import_cmd_ts27.string),
+      type: (0, import_cmd_ts27.optional)(SpaceSlug),
       long: "space",
       description: "Target space slug (required when artifact is staged for multiple spaces)"
     })
@@ -17594,15 +18031,15 @@ var unstagePlaybookCommand = (0, import_cmd_ts27.command)({
 });
 
 // apps/cli/src/infra/commands/playbook/StatusCommand.ts
-var import_fs22 = require("fs");
+var import_fs23 = require("fs");
 var import_cmd_ts28 = __toESM(require_cjs());
 
 // apps/cli/src/infra/utils/listDirectoryFiles.ts
-var import_fs21 = require("fs");
+var import_fs22 = require("fs");
 var path28 = __toESM(require("path"));
 function listDirectoryFiles(dirPath) {
   const results = [];
-  const entries = (0, import_fs21.readdirSync)(dirPath, { withFileTypes: true });
+  const entries = (0, import_fs22.readdirSync)(dirPath, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = path28.join(dirPath, entry.name);
     if (entry.isDirectory()) {
@@ -17896,11 +18333,11 @@ var statusPlaybookCommand = (0, import_cmd_ts28.command)({
       lockFileRepository,
       cwd: process.cwd(),
       exit: process.exit,
-      readFile: (p) => (0, import_fs22.readFileSync)(p, "utf-8"),
+      readFile: (p) => (0, import_fs23.readFileSync)(p, "utf-8"),
       listDirectoryFiles,
       getFileMode: (p) => {
         try {
-          return (0, import_fs22.statSync)(p).mode;
+          return (0, import_fs23.statSync)(p).mode;
         } catch {
           return null;
         }
@@ -17910,8 +18347,8 @@ var statusPlaybookCommand = (0, import_cmd_ts28.command)({
 });
 
 // apps/cli/src/infra/commands/playbook/SubmitCommand.ts
-var import_fs23 = require("fs");
-var import_child_process4 = require("child_process");
+var import_fs24 = require("fs");
+var import_child_process5 = require("child_process");
 var import_os2 = require("os");
 var import_path5 = require("path");
 var import_cmd_ts29 = __toESM(require_cjs());
@@ -17919,6 +18356,204 @@ var import_cmd_ts29 = __toESM(require_cjs());
 // apps/cli/src/infra/commands/playbook/submitHandler.ts
 var path30 = __toESM(require("path"));
 var yaml3 = __toESM(require("yaml"));
+
+// apps/cli/src/application/utils/artifactComparison.ts
+function compareStandardFields(localContent, deployedContent, filePath) {
+  const localParsed = parseStandardMd(localContent, filePath);
+  const serverParsed = parseStandardMd(deployedContent, filePath);
+  if (!localParsed || !serverParsed) return [];
+  const changes = [];
+  if (serverParsed.frontmatterName && localParsed.frontmatterName && serverParsed.frontmatterName !== localParsed.frontmatterName) {
+    changes.push({
+      type: "updateStandardName" /* updateStandardName */,
+      payload: {
+        oldValue: serverParsed.frontmatterName,
+        newValue: localParsed.frontmatterName
+      }
+    });
+  }
+  if (serverParsed.name !== localParsed.name) {
+    changes.push({
+      type: "updateStandardName" /* updateStandardName */,
+      payload: {
+        oldValue: serverParsed.name,
+        newValue: localParsed.name
+      }
+    });
+  }
+  if (serverParsed.frontmatterDescription && localParsed.frontmatterDescription && serverParsed.frontmatterDescription !== localParsed.frontmatterDescription) {
+    changes.push({
+      type: "updateStandardDescription" /* updateStandardDescription */,
+      payload: {
+        oldValue: serverParsed.frontmatterDescription,
+        newValue: localParsed.frontmatterDescription
+      }
+    });
+  }
+  if (serverParsed.description !== localParsed.description) {
+    changes.push({
+      type: "updateStandardDescription" /* updateStandardDescription */,
+      payload: {
+        oldValue: serverParsed.description,
+        newValue: localParsed.description
+      }
+    });
+  }
+  if (serverParsed.scope !== localParsed.scope) {
+    changes.push({
+      type: "updateStandardScope" /* updateStandardScope */,
+      payload: {
+        oldValue: serverParsed.scope,
+        newValue: localParsed.scope
+      }
+    });
+  }
+  const serverRules = new Set(serverParsed.rules);
+  const localRules = new Set(localParsed.rules);
+  const deletedRules = [...serverRules].filter((r) => !localRules.has(r));
+  const addedRules = [...localRules].filter((r) => !serverRules.has(r));
+  const { updates, remainingDeleted, remainingAdded } = matchUpdatedRules(
+    deletedRules,
+    addedRules
+  );
+  for (const update of updates) {
+    const ruleId = createRuleId("unresolved");
+    changes.push({
+      type: "updateRule" /* updateRule */,
+      payload: {
+        targetId: ruleId,
+        oldValue: update.oldValue,
+        newValue: update.newValue
+      }
+    });
+  }
+  for (const rule of remainingDeleted) {
+    const ruleId = createRuleId("unresolved");
+    changes.push({
+      type: "deleteRule" /* deleteRule */,
+      payload: {
+        targetId: ruleId,
+        item: { id: ruleId, content: rule }
+      }
+    });
+  }
+  for (const rule of remainingAdded) {
+    changes.push({
+      type: "addRule" /* addRule */,
+      payload: {
+        item: { content: rule }
+      }
+    });
+  }
+  return changes;
+}
+function compareCommandFields(localContent, deployedContent, filePath) {
+  const localParsed = parseCommandFile(localContent, filePath);
+  if (!localParsed.success) return [];
+  const serverParsed = parseCommandFile(deployedContent, filePath);
+  if (!serverParsed.success) return [];
+  const changes = [];
+  if (serverParsed.parsed.name !== localParsed.parsed.name) {
+    changes.push({
+      type: "updateCommandName" /* updateCommandName */,
+      payload: {
+        oldValue: serverParsed.parsed.name,
+        newValue: localParsed.parsed.name
+      }
+    });
+  }
+  if (serverParsed.parsed.content !== localParsed.parsed.content) {
+    changes.push({
+      type: "updateCommandDescription" /* updateCommandDescription */,
+      payload: {
+        oldValue: serverParsed.parsed.content,
+        newValue: localParsed.parsed.content
+      }
+    });
+  }
+  return changes;
+}
+function compareSkillDefinitionFields(local, deployed) {
+  const changes = [];
+  if (local.name !== deployed.name) {
+    changes.push({
+      type: "updateSkillName" /* updateSkillName */,
+      payload: { oldValue: deployed.name, newValue: local.name }
+    });
+  }
+  if (local.description !== deployed.description) {
+    changes.push({
+      type: "updateSkillDescription" /* updateSkillDescription */,
+      payload: { oldValue: deployed.description, newValue: local.description }
+    });
+  }
+  if (local.prompt !== deployed.body) {
+    changes.push({
+      type: "updateSkillPrompt" /* updateSkillPrompt */,
+      payload: { oldValue: deployed.body, newValue: local.prompt }
+    });
+  }
+  const localLicense = local.license ?? "";
+  if (localLicense !== deployed.license) {
+    changes.push({
+      type: "updateSkillLicense" /* updateSkillLicense */,
+      payload: { oldValue: deployed.license, newValue: localLicense }
+    });
+  }
+  const localCompatibility = local.compatibility ?? "";
+  if (localCompatibility !== deployed.compatibility) {
+    changes.push({
+      type: "updateSkillCompatibility" /* updateSkillCompatibility */,
+      payload: {
+        oldValue: deployed.compatibility,
+        newValue: localCompatibility
+      }
+    });
+  }
+  const localAllowedTools = local.allowedTools ?? "";
+  if (localAllowedTools !== deployed.allowedTools) {
+    changes.push({
+      type: "updateSkillAllowedTools" /* updateSkillAllowedTools */,
+      payload: {
+        oldValue: deployed.allowedTools,
+        newValue: localAllowedTools
+      }
+    });
+  }
+  const localMetadataJson = local.metadata && Object.keys(local.metadata).length > 0 ? serializeSkillMetadata(local.metadata) : "{}";
+  if (localMetadataJson !== deployed.metadataJson) {
+    changes.push({
+      type: "updateSkillMetadata" /* updateSkillMetadata */,
+      payload: {
+        oldValue: deployed.metadataJson,
+        newValue: localMetadataJson
+      }
+    });
+  }
+  const localAdditionalProps = local.additionalProperties ?? {};
+  const deployedAdditionalProps = deployed.additionalProperties;
+  const allKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(localAdditionalProps),
+    ...Object.keys(deployedAdditionalProps)
+  ]);
+  for (const key of allKeys) {
+    const localValue = key in localAdditionalProps ? canonicalJsonStringify(localAdditionalProps[key]) : "";
+    const deployedValue = deployedAdditionalProps[key] ?? "null";
+    if (localValue !== deployedValue) {
+      changes.push({
+        type: "updateSkillAdditionalProperty" /* updateSkillAdditionalProperty */,
+        payload: {
+          targetId: key,
+          oldValue: deployedValue,
+          newValue: localValue
+        }
+      });
+    }
+  }
+  return changes;
+}
+
+// apps/cli/src/infra/commands/playbook/submitHandler.ts
 function buildEditorPrefill(changes) {
   const lines = [
     "",
@@ -17963,7 +18598,7 @@ function buildCreatedStandardProposals(entry) {
       }
     ];
   }
-  const lenient = parseLenientStandard(entry.content, entry.filePath);
+  const lenient = parseLenientStandard(entry.content);
   if (lenient) {
     return [
       {
@@ -17973,7 +18608,7 @@ function buildCreatedStandardProposals(entry) {
           name: lenient.name,
           description: lenient.description,
           scope: "",
-          rules: []
+          rules: lenient.rules.map((r) => ({ content: r }))
         },
         targetId: entry.targetId,
         spaceId: entry.spaceId
@@ -18022,143 +18657,53 @@ function buildCreatedSkillProposals(entry) {
 }
 function buildUpdatedStandardProposals(entry, artifactId, deployedContent) {
   if (!artifactId) return [];
-  const localParsed = parseStandardMd(entry.content, entry.filePath);
-  if (!localParsed) return [];
-  const serverParsed = deployedContent ? parseStandardMd(deployedContent, entry.filePath) : null;
-  const proposals = [];
   const base = {
     artefactId: artifactId,
     targetId: entry.targetId,
     spaceId: entry.spaceId
   };
-  if (serverParsed) {
-    if (serverParsed.frontmatterName && localParsed.frontmatterName && serverParsed.frontmatterName !== localParsed.frontmatterName) {
-      proposals.push({
-        ...base,
-        type: "updateStandardName" /* updateStandardName */,
-        payload: {
-          oldValue: serverParsed.frontmatterName,
-          newValue: localParsed.frontmatterName
-        }
-      });
-    }
-    if (serverParsed.name !== localParsed.name) {
-      proposals.push({
-        ...base,
-        type: "updateStandardName" /* updateStandardName */,
-        payload: {
-          oldValue: serverParsed.name,
-          newValue: localParsed.name
-        }
-      });
-    }
-    if (serverParsed.frontmatterDescription && localParsed.frontmatterDescription && serverParsed.frontmatterDescription !== localParsed.frontmatterDescription) {
-      proposals.push({
-        ...base,
-        type: "updateStandardDescription" /* updateStandardDescription */,
-        payload: {
-          oldValue: serverParsed.frontmatterDescription,
-          newValue: localParsed.frontmatterDescription
-        }
-      });
-    }
-    if (serverParsed.description !== localParsed.description) {
-      proposals.push({
-        ...base,
-        type: "updateStandardDescription" /* updateStandardDescription */,
-        payload: {
-          oldValue: serverParsed.description,
-          newValue: localParsed.description
-        }
-      });
-    }
-    if (serverParsed.scope !== localParsed.scope) {
-      proposals.push({
-        ...base,
-        type: "updateStandardScope" /* updateStandardScope */,
-        payload: {
-          oldValue: serverParsed.scope,
-          newValue: localParsed.scope
-        }
-      });
-    }
-  }
-  const serverRules = new Set(serverParsed?.rules ?? []);
-  const localRules = new Set(localParsed.rules);
-  const deletedRules = [...serverRules].filter((r) => !localRules.has(r));
-  const addedRules = [...localRules].filter((r) => !serverRules.has(r));
-  const { updates, remainingDeleted, remainingAdded } = matchUpdatedRules(
-    deletedRules,
-    addedRules
-  );
-  for (const update of updates) {
-    const ruleId = createRuleId("unresolved");
-    proposals.push({
-      ...base,
-      type: "updateRule" /* updateRule */,
-      payload: {
-        targetId: ruleId,
-        oldValue: update.oldValue,
-        newValue: update.newValue
-      }
-    });
-  }
-  for (const rule of remainingDeleted) {
-    const ruleId = createRuleId("unresolved");
-    proposals.push({
+  if (deployedContent) {
+    const fieldChanges = compareStandardFields(
+      entry.content,
+      deployedContent,
+      entry.filePath
+    );
+    return fieldChanges.map((change) => ({
       ...base,
-      type: "deleteRule" /* deleteRule */,
-      payload: {
-        targetId: ruleId,
-        item: { id: ruleId, content: rule }
-      }
-    });
+      type: change.type,
+      payload: change.payload
+    }));
   }
-  for (const rule of remainingAdded) {
+  const localParsed = parseStandardMd(entry.content, entry.filePath);
+  if (!localParsed) return [];
+  const proposals = [];
+  const localRules = new Set(localParsed.rules);
+  for (const rule of localRules) {
     proposals.push({
       ...base,
       type: "addRule" /* addRule */,
-      payload: {
-        item: { content: rule }
-      }
+      payload: { item: { content: rule } }
     });
   }
   return proposals;
 }
 function buildUpdatedCommandProposals(entry, artifactId, deployedContent) {
-  if (!artifactId) return [];
-  const localParsed = parseCommandFile(entry.content, entry.filePath);
-  if (!localParsed.success) return [];
-  const serverParsed = deployedContent ? parseCommandFile(deployedContent, entry.filePath) : null;
-  const proposals = [];
+  if (!artifactId || !deployedContent) return [];
+  const fieldChanges = compareCommandFields(
+    entry.content,
+    deployedContent,
+    entry.filePath
+  );
   const base = {
     artefactId: artifactId,
     targetId: entry.targetId,
     spaceId: entry.spaceId
   };
-  if (serverParsed?.success) {
-    if (serverParsed.parsed.name !== localParsed.parsed.name) {
-      proposals.push({
-        ...base,
-        type: "updateCommandName" /* updateCommandName */,
-        payload: {
-          oldValue: serverParsed.parsed.name,
-          newValue: localParsed.parsed.name
-        }
-      });
-    }
-    if (serverParsed.parsed.content !== localParsed.parsed.content) {
-      proposals.push({
-        ...base,
-        type: "updateCommandDescription" /* updateCommandDescription */,
-        payload: {
-          oldValue: serverParsed.parsed.content,
-          newValue: localParsed.parsed.content
-        }
-      });
-    }
-  }
-  return proposals;
+  return fieldChanges.map((change) => ({
+    ...base,
+    type: change.type,
+    payload: change.payload
+  }));
 }
 function buildUpdatedSkillProposals(entry, artifactId, deployedFiles) {
   if (!artifactId) return [];
@@ -18185,7 +18730,14 @@ function buildUpdatedSkillProposals(entry, artifactId, deployedFiles) {
   if (skillMdFile?.content) {
     const deployed = parseSkillMd(skillMdFile.content);
     if (deployed) {
-      proposals.push(...diffSkillDefinition(local, deployed, base));
+      const fieldChanges = compareSkillDefinitionFields(local, deployed);
+      proposals.push(
+        ...fieldChanges.map((change) => ({
+          ...base,
+          type: change.type,
+          payload: change.payload
+        }))
+      );
     } else {
       proposals.push({
         ...base,
@@ -18237,123 +18789,36 @@ function buildUpdatedSkillProposals(entry, artifactId, deployedFiles) {
       });
     }
     const localPermissions = localFile?.permissions ?? "rw-r--r--";
-    const deployedPermissions = deployed.skillFilePermissions ?? "read";
-    if (localFile && localPermissions !== deployedPermissions) {
-      proposals.push({
-        ...base,
-        type: "updateSkillFilePermissions" /* updateSkillFilePermissions */,
-        payload: {
-          targetId: deployed.skillFileId,
-          oldValue: deployedPermissions,
-          newValue: localPermissions
-        }
-      });
-    }
-  }
-  const deployedRelativePaths = new Set(
-    deployedHelperFiles.map(
-      (f) => normalizePath2(f.path).slice(normalizedEntryPath.length + 1)
-    )
-  );
-  for (const localFile of localFiles) {
-    if (!deployedRelativePaths.has(localFile.path)) {
-      proposals.push({
-        ...base,
-        type: "addSkillFile" /* addSkillFile */,
-        payload: {
-          item: {
-            path: localFile.path,
-            content: localFile.content,
-            permissions: localFile.permissions ?? "rw-r--r--",
-            isBase64: localFile.isBase64 ?? false
-          }
-        }
-      });
-    }
-  }
-  return proposals;
-}
-function diffSkillDefinition(local, deployed, base) {
-  const proposals = [];
-  if (local.name !== deployed.name) {
-    proposals.push({
-      ...base,
-      type: "updateSkillName" /* updateSkillName */,
-      payload: { oldValue: deployed.name, newValue: local.name }
-    });
-  }
-  if (local.description !== deployed.description) {
-    proposals.push({
-      ...base,
-      type: "updateSkillDescription" /* updateSkillDescription */,
-      payload: { oldValue: deployed.description, newValue: local.description }
-    });
-  }
-  if (local.prompt !== deployed.body) {
-    proposals.push({
-      ...base,
-      type: "updateSkillPrompt" /* updateSkillPrompt */,
-      payload: { oldValue: deployed.body, newValue: local.prompt }
-    });
-  }
-  const localLicense = local.license ?? "";
-  if (localLicense !== deployed.license) {
-    proposals.push({
-      ...base,
-      type: "updateSkillLicense" /* updateSkillLicense */,
-      payload: { oldValue: deployed.license, newValue: localLicense }
-    });
-  }
-  const localCompatibility = local.compatibility ?? "";
-  if (localCompatibility !== deployed.compatibility) {
-    proposals.push({
-      ...base,
-      type: "updateSkillCompatibility" /* updateSkillCompatibility */,
-      payload: {
-        oldValue: deployed.compatibility,
-        newValue: localCompatibility
-      }
-    });
-  }
-  const localAllowedTools = local.allowedTools ?? "";
-  if (localAllowedTools !== deployed.allowedTools) {
-    proposals.push({
-      ...base,
-      type: "updateSkillAllowedTools" /* updateSkillAllowedTools */,
-      payload: {
-        oldValue: deployed.allowedTools,
-        newValue: localAllowedTools
-      }
-    });
-  }
-  const localMetadataJson = local.metadata && Object.keys(local.metadata).length > 0 ? serializeSkillMetadata(local.metadata) : "{}";
-  if (localMetadataJson !== deployed.metadataJson) {
-    proposals.push({
-      ...base,
-      type: "updateSkillMetadata" /* updateSkillMetadata */,
-      payload: {
-        oldValue: deployed.metadataJson,
-        newValue: localMetadataJson
-      }
-    });
+    const deployedPermissions = deployed.skillFilePermissions ?? "read";
+    if (localFile && localPermissions !== deployedPermissions) {
+      proposals.push({
+        ...base,
+        type: "updateSkillFilePermissions" /* updateSkillFilePermissions */,
+        payload: {
+          targetId: deployed.skillFileId,
+          oldValue: deployedPermissions,
+          newValue: localPermissions
+        }
+      });
+    }
   }
-  const localAdditionalProps = local.additionalProperties ?? {};
-  const deployedAdditionalProps = deployed.additionalProperties;
-  const allKeys = /* @__PURE__ */ new Set([
-    ...Object.keys(localAdditionalProps),
-    ...Object.keys(deployedAdditionalProps)
-  ]);
-  for (const key of allKeys) {
-    const localValue = key in localAdditionalProps ? canonicalJsonStringify(localAdditionalProps[key]) : "";
-    const deployedValue = deployedAdditionalProps[key] ?? "null";
-    if (localValue !== deployedValue) {
+  const deployedRelativePaths = new Set(
+    deployedHelperFiles.map(
+      (f) => normalizePath2(f.path).slice(normalizedEntryPath.length + 1)
+    )
+  );
+  for (const localFile of localFiles) {
+    if (!deployedRelativePaths.has(localFile.path)) {
       proposals.push({
         ...base,
-        type: "updateSkillAdditionalProperty" /* updateSkillAdditionalProperty */,
+        type: "addSkillFile" /* addSkillFile */,
         payload: {
-          targetId: key,
-          oldValue: deployedValue,
-          newValue: localValue
+          item: {
+            path: localFile.path,
+            content: localFile.content,
+            permissions: localFile.permissions ?? "rw-r--r--",
+            isBase64: localFile.isBase64 ?? false
+          }
         }
       });
     }
@@ -18385,6 +18850,64 @@ function findDeployedContentForPath(filePath, deployedFiles) {
   const match = deployedFiles.find((f) => normalizePath2(f.path) === normalized);
   return match?.content ?? null;
 }
+async function checkForDuplicateNames(createdEntries, packmindGateway) {
+  const errors = [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of createdEntries) {
+    const key = `${entry.spaceId}:${entry.artifactType}`;
+    const existing = groups.get(key) ?? [];
+    existing.push(entry);
+    groups.set(key, existing);
+  }
+  for (const [, entries] of groups) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const lowerName = entry.artifactName.toLowerCase();
+      if (seen.has(lowerName)) {
+        errors.push(
+          `A ${entry.artifactType} named "${entry.artifactName}" is staged multiple times. Remove the duplicate with "playbook unstage" or rename the artifact.`
+        );
+      } else {
+        seen.set(lowerName, entry.artifactName);
+      }
+    }
+  }
+  for (const [key, entries] of groups) {
+    const [rawSpaceId, artifactType] = key.split(":");
+    const typedSpaceId = rawSpaceId;
+    try {
+      let existingNames = [];
+      if (artifactType === "standard") {
+        const response = await packmindGateway.standards.list({
+          spaceId: typedSpaceId
+        });
+        existingNames = response.standards.map((s) => s.name);
+      } else if (artifactType === "command") {
+        const response = await packmindGateway.commands.list({
+          spaceId: typedSpaceId
+        });
+        existingNames = response.recipes.map((r) => r.name);
+      } else if (artifactType === "skill") {
+        const response = await packmindGateway.skills.list({
+          spaceId: typedSpaceId
+        });
+        existingNames = response.map((s) => s.name);
+      }
+      const existingNamesLower = new Set(
+        existingNames.map((n) => n.toLowerCase())
+      );
+      for (const entry of entries) {
+        if (existingNamesLower.has(entry.artifactName.toLowerCase())) {
+          errors.push(
+            `A ${entry.artifactType} named "${entry.artifactName}" already exists in this space. Use "playbook unstage" to remove it or rename the artifact.`
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  return errors;
+}
 async function playbookSubmitHandler(deps) {
   const {
     packmindCliHexa,
@@ -18420,6 +18943,20 @@ async function playbookSubmitHandler(deps) {
     }
     resolvedMessage = stripped;
   }
+  const createdEntries = changes.filter((c) => c.changeType === "created");
+  if (createdEntries.length > 0) {
+    const duplicateErrors = await checkForDuplicateNames(
+      createdEntries,
+      packmindCliHexa.getPackmindGateway()
+    );
+    if (duplicateErrors.length > 0) {
+      for (const error of duplicateErrors) {
+        logErrorConsole(error);
+      }
+      exit(1);
+      return;
+    }
+  }
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
   const targetContextCache = /* @__PURE__ */ new Map();
   async function getTargetContext(entry) {
@@ -18652,16 +19189,16 @@ function openEditorForMessage(prefill) {
   const editor = process.env.VISUAL || process.env.EDITOR || "vi";
   const tmpFile = (0, import_path5.join)((0, import_os2.tmpdir)(), `packmind-submit-${Date.now()}.md`);
   try {
-    (0, import_fs23.writeFileSync)(tmpFile, prefill, "utf-8");
-    (0, import_child_process4.execSync)(`${editor} "${tmpFile}"`, { stdio: "inherit" });
-    const content = (0, import_fs23.readFileSync)(tmpFile, "utf-8");
+    (0, import_fs24.writeFileSync)(tmpFile, prefill, "utf-8");
+    (0, import_child_process5.execSync)(`${editor} "${tmpFile}"`, { stdio: "inherit" });
+    const content = (0, import_fs24.readFileSync)(tmpFile, "utf-8");
     const stripped = content.split("\n").filter((line) => !line.startsWith("#")).join("\n").trim();
     return stripped || null;
   } catch {
     return null;
   } finally {
     try {
-      (0, import_fs23.unlinkSync)(tmpFile);
+      (0, import_fs24.unlinkSync)(tmpFile);
     } catch {
     }
   }
@@ -18694,8 +19231,8 @@ var submitPlaybookCommand = (0, import_cmd_ts29.command)({
       exit: process.exit,
       message,
       openEditor: (prefill) => openEditorForMessage(prefill),
-      unlinkSync: (p) => (0, import_fs23.unlinkSync)(p),
-      rmSync: (p, opts) => (0, import_fs23.rmSync)(p, opts)
+      unlinkSync: (p) => (0, import_fs24.unlinkSync)(p),
+      rmSync: (p, opts) => (0, import_fs24.rmSync)(p, opts)
     });
   }
 });
@@ -18717,7 +19254,7 @@ var diffCommand2 = (0, import_cmd_ts30.command)({
       type: (0, import_cmd_ts30.optional)(import_cmd_ts30.string)
     })
   },
-  handler: async ({ includeSubmitted, path: path34 }) => {
+  handler: async ({ includeSubmitted, path: path33 }) => {
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
     await diffArtefactsHandler({
@@ -18726,7 +19263,7 @@ var diffCommand2 = (0, import_cmd_ts30.command)({
       getCwd: () => process.cwd(),
       log: console.log,
       includeSubmitted,
-      path: path34
+      path: path33
     });
   }
 });
@@ -19034,6 +19571,11 @@ async function initHandler(deps) {
     };
   }
   const totalFiles = result.filesCreated + result.filesUpdated;
+  if (result.skippedSkillsCount > 0) {
+    logWarningConsole(
+      `${result.skippedSkillsCount} skill(s) were skipped because they require a newer version of packmind-cli. Run "${formatCommand("packmind-cli update")}" to get the latest version.`
+    );
+  }
   if (totalFiles === 0) {
     logInfoConsole("Default skills are already up to date.");
   } else {
@@ -19057,7 +19599,7 @@ async function initHandler(deps) {
 }
 
 // apps/cli/src/infra/commands/InitCommand.ts
-var { version: CLI_VERSION3 } = require_package();
+var { version: CLI_VERSION4 } = require_package();
 var initCommand = (0, import_cmd_ts36.command)({
   name: "init",
   description: "Initialize Packmind in the current project",
@@ -19074,7 +19616,7 @@ var initCommand = (0, import_cmd_ts36.command)({
       packmindGateway: packmindCliHexa.getPackmindGateway(),
       baseDirectory,
       installDefaultSkills: packmindCliHexa.installDefaultSkills.bind(packmindCliHexa),
-      cliVersion: CLI_VERSION3
+      cliVersion: CLI_VERSION4
     });
     if (!result.success) {
       for (const error of result.errors) {
@@ -19087,201 +19629,7 @@ var initCommand = (0, import_cmd_ts36.command)({
 
 // apps/cli/src/infra/commands/UpdateCommand.ts
 var import_cmd_ts37 = __toESM(require_cjs());
-
-// apps/cli/src/infra/commands/updateHandler.ts
-var import_path6 = __toESM(require("path"));
-var import_child_process5 = require("child_process");
-var import_fs24 = require("fs");
-var import_promises2 = require("stream/promises");
-var import_stream = require("stream");
-var import_semver = __toESM(require("semver"));
-var GITHUB_REPO = "PackmindHub/packmind";
-var NPM_PACKAGE = "@packmind/cli";
-function getPlatformAssetSuffix(platform, arch) {
-  const osMap = {
-    linux: "linux",
-    darwin: "macos",
-    win32: "windows"
-  };
-  const osName = osMap[platform];
-  if (!osName) {
-    throw new Error(`Unsupported platform: ${platform}`);
-  }
-  const archName = platform === "darwin" && arch === "x64" ? "x64-baseline" : arch;
-  const ext = platform === "win32" ? ".exe" : "";
-  return `${osName}-${archName}${ext}`;
-}
-async function fetchLatestVersionFromNpm(fetchFn) {
-  const res = await fetchFn(`https://registry.npmjs.org/${NPM_PACKAGE}/latest`);
-  if (!res.ok) {
-    throw new Error(
-      `Failed to fetch from npm registry: ${res.status} ${res.statusText}`
-    );
-  }
-  const data = await res.json();
-  return data.version;
-}
-async function fetchLatestVersionFromGitHub(fetchFn) {
-  const res = await fetchFn(
-    `https://api.github.com/repos/${GITHUB_REPO}/releases?per_page=20`,
-    {
-      headers: { Accept: "application/vnd.github.v3+json" }
-    }
-  );
-  if (!res.ok) {
-    throw new Error(
-      `Failed to fetch from GitHub API: ${res.status} ${res.statusText}`
-    );
-  }
-  const releases = await res.json();
-  const cliReleases = releases.filter((r) => r.tag_name?.startsWith("release-cli/")).map((r) => ({
-    ...r,
-    version: r.tag_name.replace("release-cli/", "")
-  })).filter((r) => import_semver.default.valid(r.version)).sort((a, b) => import_semver.default.rcompare(a.version, b.version));
-  if (cliReleases.length === 0) {
-    throw new Error("No CLI release found on GitHub");
-  }
-  return cliReleases[0].version;
-}
-async function downloadExecutable(fetchFn, version2, platformSuffix, targetPath) {
-  const assetName = `packmind-cli-${platformSuffix}-${version2}`;
-  const url = `https://github.com/${GITHUB_REPO}/releases/download/release-cli/${version2}/${assetName}`;
-  logInfoConsole(`Downloading ${assetName}...`);
-  const res = await fetchFn(url, { redirect: "follow" });
-  if (!res.ok) {
-    throw new Error(
-      `Failed to download executable: ${res.status} ${res.statusText}
-URL: ${url}`
-    );
-  }
-  if (!res.body) {
-    throw new Error("No response body received");
-  }
-  const nodeReadable = import_stream.Readable.fromWeb(res.body);
-  const fileStream = (0, import_fs24.createWriteStream)(targetPath);
-  await (0, import_promises2.pipeline)(nodeReadable, fileStream);
-  const stats = (0, import_fs24.statSync)(targetPath);
-  if (stats.size < 1e6) {
-    (0, import_fs24.unlinkSync)(targetPath);
-    throw new Error(
-      `Downloaded file is too small (${stats.size} bytes). The download may have failed.`
-    );
-  }
-  logInfoConsole(
-    `Downloaded successfully (${(stats.size / 1048576).toFixed(1)} MB)`
-  );
-}
-function updateViaNpm(version2) {
-  logInfoConsole(`Updating via npm to version ${version2}...`);
-  (0, import_child_process5.execSync)(`npm install -g ${NPM_PACKAGE}@${version2}`, {
-    stdio: "inherit"
-  });
-}
-async function updateViaExecutableReplace(deps, version2) {
-  const platformSuffix = getPlatformAssetSuffix(deps.platform, deps.arch);
-  const currentPath = deps.executablePath;
-  const tempPath = currentPath + ".update-tmp";
-  try {
-    await downloadExecutable(deps.fetchFn, version2, platformSuffix, tempPath);
-    (0, import_fs24.renameSync)(tempPath, currentPath);
-    if (deps.platform !== "win32") {
-      (0, import_fs24.chmodSync)(currentPath, 493);
-    }
-  } catch (error) {
-    try {
-      (0, import_fs24.unlinkSync)(tempPath);
-    } catch {
-    }
-    throw error;
-  }
-}
-function isLocalNpmPackage(scriptPath) {
-  if (!scriptPath) return false;
-  return scriptPath.includes(import_path6.default.join("node_modules", "@packmind", "cli"));
-}
-function isHomebrewInstall(executablePath) {
-  try {
-    const realPath = (0, import_fs24.realpathSync)(executablePath);
-    return realPath.includes("/Cellar/");
-  } catch {
-    return false;
-  }
-}
-async function updateHandler(deps) {
-  const execBasename = import_path6.default.basename(deps.executablePath).replace(/\.exe$/, "");
-  const jsRuntimes = ["node", "bun", "deno"];
-  if (jsRuntimes.includes(execBasename)) {
-    if (isLocalNpmPackage(deps.scriptPath)) {
-      logErrorConsole(
-        "Your CLI version is managed by your local package.json.\nTo update, run: npm update @packmind/cli"
-      );
-    } else {
-      logErrorConsole(
-        "The update command is not available when running the CLI via a JavaScript runtime.\nTo update, use the standalone executable or run: npm install -g @packmind/cli@latest"
-      );
-    }
-    process.exit(1);
-    return;
-  }
-  if (isHomebrewInstall(deps.executablePath)) {
-    logInfoConsole(
-      "This CLI was installed via Homebrew.\nTo update, run: brew upgrade packmind-cli"
-    );
-    process.exit(0);
-    return;
-  }
-  logInfoConsole(
-    `Current version: ${deps.currentVersion} (${deps.isExecutableMode ? "standalone executable" : "npm package"})`
-  );
-  let latestVersion;
-  try {
-    latestVersion = deps.isExecutableMode ? await fetchLatestVersionFromGitHub(deps.fetchFn) : await fetchLatestVersionFromNpm(deps.fetchFn);
-  } catch (error) {
-    logErrorConsole(
-      `Failed to check for updates: ${error instanceof Error ? error.message : String(error)}`
-    );
-    process.exit(1);
-    return;
-  }
-  if (!import_semver.default.gt(latestVersion, deps.currentVersion)) {
-    logSuccessConsole(`Already up to date (v${deps.currentVersion})`);
-    return;
-  }
-  logConsole("");
-  logInfoConsole(
-    `New version available: ${deps.currentVersion} -> ${latestVersion}`
-  );
-  if (deps.checkOnly) {
-    process.exit(1);
-    return;
-  }
-  try {
-    if (deps.isExecutableMode) {
-      await updateViaExecutableReplace(deps, latestVersion);
-    } else {
-      updateViaNpm(latestVersion);
-    }
-    logConsole("");
-    logSuccessConsole(`Updated to v${latestVersion}`);
-    if (deps.isExecutableMode) {
-      logInfoConsole(`Binary location: ${deps.executablePath}`);
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes("EACCES") || message.includes("permission denied")) {
-      logErrorConsole(
-        `Permission denied. Try running with sudo:
-  sudo packmind-cli update`
-      );
-    } else {
-      logErrorConsole(`Update failed: ${message}`);
-    }
-    process.exit(1);
-  }
-}
-
-// apps/cli/src/infra/commands/UpdateCommand.ts
-var { version: CLI_VERSION4 } = require_package();
+var { version: CLI_VERSION5 } = require_package();
 var updateCommand = (0, import_cmd_ts37.command)({
   name: "update",
   description: "Update packmind-cli to the latest version",
@@ -19293,7 +19641,7 @@ var updateCommand = (0, import_cmd_ts37.command)({
   },
   handler: async ({ check }) => {
     await updateHandler({
-      currentVersion: CLI_VERSION4,
+      currentVersion: CLI_VERSION5,
       isExecutableMode: hasEmbeddedWasmFiles(),
       executablePath: process.execPath,
       scriptPath: require.main?.filename,
@@ -19306,17 +19654,17 @@ var updateCommand = (0, import_cmd_ts37.command)({
 });
 
 // apps/cli/src/main.ts
-var { version: CLI_VERSION5 } = require_package();
+var { version: CLI_VERSION6 } = require_package();
 function findEnvFile() {
   const currentDir = process.cwd();
   const gitService = new GitService();
   const gitRoot = gitService.getGitRepositoryRootSync(currentDir);
-  const filesystemRoot = path33.parse(currentDir).root;
+  const filesystemRoot = path32.parse(currentDir).root;
   const stopDir = gitRoot ?? filesystemRoot;
   let searchDir = currentDir;
-  let parentDir = path33.dirname(searchDir);
+  let parentDir = path32.dirname(searchDir);
   while (searchDir !== parentDir) {
-    const envPath2 = path33.join(searchDir, ".env");
+    const envPath2 = path32.join(searchDir, ".env");
     if (fs26.existsSync(envPath2)) {
       return envPath2;
     }
@@ -19324,7 +19672,7 @@ function findEnvFile() {
       return null;
     }
     searchDir = parentDir;
-    parentDir = path33.dirname(searchDir);
+    parentDir = path32.dirname(searchDir);
   }
   return null;
 }
@@ -19341,7 +19689,7 @@ if (hasEmbeddedWasmFiles()) {
 }
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
-  logConsole(`packmind-cli version ${CLI_VERSION5}`);
+  logConsole(`packmind-cli version ${CLI_VERSION6}`);
   process.exit(0);
 }
 var app = (0, import_cmd_ts38.subcommands)({