@packmind/cli 0.16.1 → 0.17.0

package/main.cjs

@@ -234,9 +234,9 @@ var init_ansi_styles = __esm({
 });
 
 // node_modules/chalk/source/vendor/supports-color/index.js
-function hasFlag(flag4, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
-  const prefix = flag4.startsWith("-") ? "" : flag4.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag4);
+function hasFlag(flag5, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
+  const prefix = flag5.startsWith("-") ? "" : flag5.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag5);
   const terminatorPosition = argv.indexOf("--");
   return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 }
@@ -935,7 +935,7 @@ var require_flag = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.boolean = void 0;
     exports2.fullFlag = fullFlag;
-    exports2.flag = flag4;
+    exports2.flag = flag5;
     var chalk_1 = __importDefault((init_source(), __toCommonJS(source_exports)));
     var Result = __importStar(require_Result());
     var findOption_1 = require_findOption();
@@ -1084,7 +1084,7 @@ var require_flag = __commonJS({
         }
       };
     }
-    function flag4(config) {
+    function flag5(config) {
       return fullFlag({
         type: types_1.boolean,
         ...config
@@ -1698,12 +1698,12 @@ var require_command = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.command = command20;
+    exports2.command = command21;
     var chalk_1 = __importDefault((init_source(), __toCommonJS(source_exports)));
     var Result = __importStar(require_Result());
     var circuitbreaker_1 = require_circuitbreaker();
     var utils_1 = require_utils();
-    function command20(config) {
+    function command21(config) {
       const argEntries = (0, utils_1.entries)(config.args);
       const circuitbreaker = (0, circuitbreaker_1.createCircuitBreaker)(!!config.version);
       return {
@@ -2574,9 +2574,9 @@ var require_browser = __commonJS({
 var require_has_flag = __commonJS({
   "node_modules/has-flag/index.js"(exports2, module2) {
     "use strict";
-    module2.exports = (flag4, argv = process.argv) => {
-      const prefix = flag4.startsWith("-") ? "" : flag4.length === 1 ? "-" : "--";
-      const position = argv.indexOf(prefix + flag4);
+    module2.exports = (flag5, argv = process.argv) => {
+      const prefix = flag5.startsWith("-") ? "" : flag5.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag5);
       const terminatorPosition = argv.indexOf("--");
       return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
     };
@@ -3852,7 +3852,7 @@ var require_package = __commonJS({
   "apps/cli/package.json"(exports2, module2) {
     module2.exports = {
       name: "@packmind/cli",
-      version: "0.16.1",
+      version: "0.17.0",
       description: "A command-line interface for Packmind linting and code quality checks",
       private: false,
       bin: {
@@ -3895,7 +3895,7 @@ var require_package = __commonJS({
 });
 
 // apps/cli/src/main.ts
-var import_cmd_ts26 = __toESM(require_cjs());
+var import_cmd_ts27 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/LinterCommand.ts
 var import_cmd_ts = __toESM(require_cjs());
@@ -4059,6 +4059,13 @@ var OrganizationCreatedEvent = class extends UserEvent {
   }
 };
 
+// packages/types/src/accounts/events/UserSignedInEvent.ts
+var UserSignedInEvent = class extends UserEvent {
+  static {
+    this.eventName = "accounts.user.signed-in";
+  }
+};
+
 // packages/types/src/accounts/TrialActivationToken.ts
 var createTrialActivationTokenId = brandedIdFactory();
 var createTrialActivationToken = brandedIdFactory();
@@ -4969,6 +4976,29 @@ var createAIProviderId = brandedIdFactory();
 // packages/types/src/playbookChangeManagement/ChangeProposalId.ts
 var createChangeProposalId = brandedIdFactory();
 
+// packages/types/src/playbookChangeManagement/ChangeProposalTypeLabels.ts
+var CHANGE_PROPOSAL_TYPE_LABELS = {
+  ["updateCommandName" /* updateCommandName */]: "Name",
+  ["updateCommandDescription" /* updateCommandDescription */]: "Instructions updated",
+  ["updateStandardName" /* updateStandardName */]: "Name",
+  ["updateStandardDescription" /* updateStandardDescription */]: "Description",
+  ["updateStandardScope" /* updateStandardScope */]: "Scope",
+  ["addRule" /* addRule */]: "Rule (add)",
+  ["updateRule" /* updateRule */]: "Rule (update)",
+  ["deleteRule" /* deleteRule */]: "Rule (delete)",
+  ["updateSkillName" /* updateSkillName */]: "Name",
+  ["updateSkillDescription" /* updateSkillDescription */]: "Description",
+  ["updateSkillPrompt" /* updateSkillPrompt */]: "Prompt",
+  ["updateSkillMetadata" /* updateSkillMetadata */]: "Metadata",
+  ["updateSkillLicense" /* updateSkillLicense */]: "License",
+  ["updateSkillCompatibility" /* updateSkillCompatibility */]: "Compatibility",
+  ["updateSkillAllowedTools" /* updateSkillAllowedTools */]: "Allowed Tools",
+  ["addSkillFile" /* addSkillFile */]: "File (add)",
+  ["updateSkillFileContent" /* updateSkillFileContent */]: "File content",
+  ["updateSkillFilePermissions" /* updateSkillFilePermissions */]: "File permissions",
+  ["deleteSkillFile" /* deleteSkillFile */]: "File (delete)"
+};
+
 // apps/cli/src/application/useCases/ExecuteSingleFileAstUseCase.ts
 var ExecuteSingleFileAstUseCase = class _ExecuteSingleFileAstUseCase {
   constructor(linterExecutionUseCase) {
@@ -4980,8 +5010,8 @@ var ExecuteSingleFileAstUseCase = class _ExecuteSingleFileAstUseCase {
   static {
     this.fallbackRuleContent = "adhoc-rule";
   }
-  async execute(command20) {
-    const { program, fileContent, language } = command20;
+  async execute(command21) {
+    const { program, fileContent, language } = command21;
     const result = await this.linterExecutionUseCase.execute({
       filePath: "cli-single-file",
       fileContent,
@@ -4992,7 +5022,8 @@ var ExecuteSingleFileAstUseCase = class _ExecuteSingleFileAstUseCase {
           ruleContent: _ExecuteSingleFileAstUseCase.fallbackRuleContent,
           standardSlug: _ExecuteSingleFileAstUseCase.fallbackStandardSlug,
           sourceCodeState: "AST",
-          language
+          language,
+          severity: "error" /* ERROR */
         }
       ]
     });
@@ -5031,30 +5062,30 @@ var GitService = class {
     this.gitRunner = gitRunner;
     this.logger = logger2;
   }
-  getGitRepositoryRoot(path14) {
+  getGitRepositoryRoot(path18) {
     try {
       const { stdout } = this.gitRunner("rev-parse --show-toplevel", {
-        cwd: path14
+        cwd: path18
       });
       const gitRoot = stdout.trim();
       this.logger.debug("Resolved git repository root", {
-        inputPath: path14,
+        inputPath: path18,
         gitRoot
       });
       return gitRoot;
     } catch (error) {
       if (error instanceof Error) {
         throw new Error(
-          `Failed to get Git repository root. The path '${path14}' does not appear to be inside a Git repository.
+          `Failed to get Git repository root. The path '${path18}' does not appear to be inside a Git repository.
 ${error.message}`
         );
       }
       throw new Error("Failed to get Git repository root: Unknown error");
     }
   }
-  tryGetGitRepositoryRoot(path14) {
+  tryGetGitRepositoryRoot(path18) {
     try {
-      return this.getGitRepositoryRoot(path14);
+      return this.getGitRepositoryRoot(path18);
     } catch {
       return null;
     }
@@ -5361,8 +5392,8 @@ var GetGitRemoteUrlUseCase = class {
   constructor(gitRemoteUrlService = new GitService()) {
     this.gitRemoteUrlService = gitRemoteUrlService;
   }
-  async execute(command20) {
-    const { path: repoPath, origin: origin9 } = command20;
+  async execute(command21) {
+    const { path: repoPath, origin: origin9 } = command21;
     return this.gitRemoteUrlService.getGitRemoteUrl(repoPath, origin9);
   }
 };
@@ -5398,6 +5429,9 @@ function formatLabel(text) {
 function formatError(text) {
   return source_default.red(text);
 }
+function formatWarning(text) {
+  return source_default.yellow(text);
+}
 function formatBold(text) {
   return source_default.bold(text);
 }
@@ -5504,8 +5538,8 @@ var ListFilesInDirectoryUseCase = class {
   constructor(listFiles = new ListFiles()) {
     this.listFiles = listFiles;
   }
-  async execute(command20) {
-    const { path: directoryPath, extensions, excludes = [] } = command20;
+  async execute(command21) {
+    const { path: directoryPath, extensions, excludes = [] } = command21;
     const files = await this.listFiles.listFilesInDirectory(
       directoryPath,
       extensions,
@@ -5552,6 +5586,17 @@ var LintFilesAgainstRuleUseCase = class {
     this.services = services;
     this.repositories = repositories;
     this.logger = logger2;
+    this.mapToActiveDetectionProgram = (item, fallbackLanguage) => {
+      return {
+        language: item.language ?? fallbackLanguage,
+        severity: item.severity,
+        detectionProgram: {
+          mode: item.mode,
+          code: item.code,
+          sourceCodeState: item.sourceCodeState
+        }
+      };
+    };
   }
   fileMatchesTargetAndScope(filePath, targetPath, scopePatterns) {
     if (!scopePatterns || scopePatterns.length === 0) {
@@ -5599,7 +5644,7 @@ var LintFilesAgainstRuleUseCase = class {
     }
     return pattern;
   }
-  async execute(command20) {
+  async execute(command21) {
     const {
       path: userPath,
       draftMode,
@@ -5607,7 +5652,7 @@ var LintFilesAgainstRuleUseCase = class {
       ruleId,
       language,
       diffMode
-    } = command20;
+    } = command21;
     this.logger.debug(
       `Starting linting: path="${userPath}", draftMode=${!!draftMode}, standardSlug="${standardSlug || "N/A"}", ruleId="${ruleId || "N/A"}", language="${language || "N/A"}", diffMode="${diffMode ?? "none"}"`
     );
@@ -5715,14 +5760,7 @@ var LintFilesAgainstRuleUseCase = class {
                   {
                     content: draftProgramsResult.ruleContent || "Draft Rule",
                     activeDetectionPrograms: draftProgramsResult.programs.map(
-                      (program) => ({
-                        language: program.language,
-                        detectionProgram: {
-                          mode: program.mode,
-                          code: program.code,
-                          sourceCodeState: program.sourceCodeState
-                        }
-                      })
+                      (item) => this.mapToActiveDetectionProgram(item, language)
                     )
                   }
                 ]
@@ -5759,14 +5797,7 @@ var LintFilesAgainstRuleUseCase = class {
                   {
                     content: activeProgramsResult.ruleContent || "Active Rule",
                     activeDetectionPrograms: activeProgramsResult.programs.map(
-                      (program) => ({
-                        language: program.language,
-                        detectionProgram: {
-                          mode: program.mode,
-                          code: program.code,
-                          sourceCodeState: program.sourceCodeState
-                        }
-                      })
+                      (item) => this.mapToActiveDetectionProgram(item, language)
                     )
                   }
                 ]
@@ -5842,7 +5873,8 @@ var LintFilesAgainstRuleUseCase = class {
                   ruleContent: rule.content,
                   standardSlug: standard.slug,
                   sourceCodeState: activeProgram.detectionProgram.sourceCodeState,
-                  language: fileLanguage
+                  language: fileLanguage,
+                  severity: activeProgram.severity ?? "error" /* ERROR */
                 });
                 programsByLanguage.set(programLanguage, programsForLanguage);
               } catch (error) {
@@ -5925,8 +5957,8 @@ var LintFilesAgainstRuleUseCase = class {
       return null;
     }
   }
-  async executeProgramsForFile(command20) {
-    const result = await this.services.linterExecutionUseCase.execute(command20);
+  async executeProgramsForFile(command21) {
+    const result = await this.services.linterExecutionUseCase.execute(command21);
     return result.violations;
   }
   extractExtensionFromFile(filePath) {
@@ -5983,8 +6015,8 @@ var LintFilesFromConfigUseCase = class {
     }
     return pattern;
   }
-  async execute(command20) {
-    const { path: userPath, diffMode } = command20;
+  async execute(command21) {
+    const { path: userPath, diffMode } = command21;
     this.logger.debug(
       `Starting local linting: path="${userPath}", diffMode="${diffMode ?? "none"}"`
     );
@@ -6088,6 +6120,7 @@ var LintFilesFromConfigUseCase = class {
         allConfigs.configs
       );
       const programsByLanguage = /* @__PURE__ */ new Map();
+      const seenPrograms = /* @__PURE__ */ new Set();
       for (const targetConfig of matchingTargets) {
         const detectionPrograms = await this.getDetectionProgramsForTarget(targetConfig);
         for (const target of detectionPrograms.targets) {
@@ -6109,13 +6142,19 @@ var LintFilesFromConfigUseCase = class {
                   if (!programLanguage || programLanguage !== fileLanguage) {
                     continue;
                   }
+                  const programKey = `${standard.slug}:${rule.content}:${activeProgram.language}`;
+                  if (seenPrograms.has(programKey)) {
+                    continue;
+                  }
+                  seenPrograms.add(programKey);
                   const programsForLanguage = programsByLanguage.get(programLanguage) ?? [];
                   programsForLanguage.push({
                     code: activeProgram.detectionProgram.code,
                     ruleContent: rule.content,
                     standardSlug: standard.slug,
                     sourceCodeState: activeProgram.detectionProgram.sourceCodeState,
-                    language: fileLanguage
+                    language: fileLanguage,
+                    severity: activeProgram.severity ?? "error" /* ERROR */
                   });
                   programsByLanguage.set(programLanguage, programsForLanguage);
                 } catch (error) {
@@ -6233,8 +6272,8 @@ var LintFilesFromConfigUseCase = class {
       return null;
     }
   }
-  async executeProgramsForFile(command20) {
-    const result = await this.services.linterExecutionUseCase.execute(command20);
+  async executeProgramsForFile(command21) {
+    const result = await this.services.linterExecutionUseCase.execute(command21);
     return result.violations;
   }
   extractExtensionFromFile(filePath) {
@@ -6300,10 +6339,10 @@ var PackmindHttpClient = class {
       return null;
     }
   }
-  async request(path14, options = {}) {
+  async request(path18, options = {}) {
     const { host } = this.getAuthContext();
     const { method = "GET", body } = options;
-    const url = `${host}${path14}`;
+    const url = `${host}${path18}`;
     try {
       const response = await fetch(url, {
         method,
@@ -6346,6 +6385,23 @@ var PackmindHttpClient = class {
   }
 };
 
+// apps/cli/src/infra/repositories/ChangeProposalGateway.ts
+var ChangeProposalGateway = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+    this.batchCreate = async (command21) => {
+      const { organizationId } = this.httpClient.getAuthContext();
+      return this.httpClient.request(
+        `/api/v0/organizations/${organizationId}/spaces/${command21.spaceId}/change-proposals/batch`,
+        {
+          method: "POST",
+          body: { proposals: command21.proposals }
+        }
+      );
+    };
+  }
+};
+
 // apps/cli/src/domain/errors/CommunityEditionError.ts
 var CommunityEditionError = class extends Error {
   constructor(feature) {
@@ -6360,13 +6416,13 @@ var CommunityEditionError = class extends Error {
 var LinterGateway = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
-    this.getDraftDetectionProgramsForRule = async (command20) => {
+    this.getDraftDetectionProgramsForRule = async (command21) => {
       const payload = {
-        standardSlug: command20.standardSlug,
-        ruleId: command20.ruleId
+        standardSlug: command21.standardSlug,
+        ruleId: command21.ruleId
       };
-      if (command20.language) {
-        payload.language = command20.language;
+      if (command21.language) {
+        payload.language = command21.language;
       }
       return this.httpClient.request("/api/v0/list-draft-detection-program", {
         method: "POST",
@@ -6378,13 +6434,13 @@ var LinterGateway = class {
         }
       });
     };
-    this.getActiveDetectionProgramsForRule = async (command20) => {
+    this.getActiveDetectionProgramsForRule = async (command21) => {
       const payload = {
-        standardSlug: command20.standardSlug,
-        ruleId: command20.ruleId
+        standardSlug: command21.standardSlug,
+        ruleId: command21.ruleId
       };
-      if (command20.language) {
-        payload.language = command20.language;
+      if (command21.language) {
+        payload.language = command21.language;
       }
       return this.httpClient.request("/api/v0/list-active-detection-program", {
         method: "POST",
@@ -6396,13 +6452,13 @@ var LinterGateway = class {
         }
       });
     };
-    this.getDetectionProgramsForPackages = async (command20) => {
+    this.getDetectionProgramsForPackages = async (command21) => {
       const response = await this.httpClient.request(
         "/api/v0/detection-programs-for-packages",
         {
           method: "POST",
           body: {
-            packagesSlugs: command20.packagesSlugs
+            packagesSlugs: command21.packagesSlugs
           },
           onError: (response2) => {
             if (response2.status === 404) {
@@ -6413,10 +6469,10 @@ var LinterGateway = class {
       );
       return handleScopeInTargetsResponse(response);
     };
-    this.trackLinterExecution = async (command20) => {
+    this.trackLinterExecution = async (command21) => {
       return this.httpClient.request(`/api/v0/track-execution`, {
         method: "POST",
-        body: command20
+        body: command21
       });
     };
   }
@@ -6474,27 +6530,27 @@ var SpacesGateway = class {
 var SkillsGateway = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
-    this.upload = async (command20) => {
+    this.upload = async (command21) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command20.spaceId}/skills/upload`,
+        `/api/v0/organizations/${organizationId}/spaces/${command21.spaceId}/skills/upload`,
         {
           method: "POST",
-          body: command20
+          body: command21
         }
       );
     };
-    this.getDefaults = async (command20) => {
+    this.getDefaults = async (command21) => {
       const { organizationId } = this.httpClient.getAuthContext();
       const queryParams = new URLSearchParams();
-      if (command20.includeBeta) {
+      if (command21.includeBeta) {
         queryParams.set("includeBeta", "true");
-      } else if (command20.cliVersion) {
-        queryParams.set("cliVersion", command20.cliVersion);
+      } else if (command21.cliVersion) {
+        queryParams.set("cliVersion", command21.cliVersion);
       }
-      if (command20.agents !== void 0) {
+      if (command21.agents !== void 0) {
         queryParams.append("agentsConfigOverride", "true");
-        command20.agents.forEach((agent) => {
+        command21.agents.forEach((agent) => {
           queryParams.append("agent", agent);
         });
       }
@@ -6503,10 +6559,10 @@ var SkillsGateway = class {
         `/api/v0/organizations/${organizationId}/skills/default${queryString ? `?${queryString}` : ""}`
       );
     };
-    this.list = async (command20) => {
+    this.list = async (command21) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command20.spaceId}/skills`
+        `/api/v0/organizations/${organizationId}/spaces/${command21.spaceId}/skills`
       );
     };
   }
@@ -6516,17 +6572,17 @@ var SkillsGateway = class {
 var CommandsGateway = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
-    this.create = async (command20) => {
+    this.create = async (command21) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command20.spaceId}/recipes`,
-        { method: "POST", body: command20 }
+        `/api/v0/organizations/${organizationId}/spaces/${command21.spaceId}/recipes`,
+        { method: "POST", body: command21 }
       );
     };
-    this.list = async (command20) => {
+    this.list = async (command21) => {
       const { organizationId } = this.httpClient.getAuthContext();
       const listRecipesResponse = await this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command20.spaceId}/recipes`
+        `/api/v0/organizations/${organizationId}/spaces/${command21.spaceId}/recipes`
       );
       if (listRecipesResponse instanceof Array) {
         return { recipes: listRecipesResponse };
@@ -6568,10 +6624,10 @@ var StandardsGateway = class {
         }
       );
     };
-    this.list = async (command20) => {
+    this.list = async (command21) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command20.spaceId}/standards`
+        `/api/v0/organizations/${organizationId}/spaces/${command21.spaceId}/standards`
       );
     };
   }
@@ -6594,24 +6650,24 @@ var PackagesGateway = class {
         `/api/v0/organizations/${organizationId}/packages/${encodeURIComponent(slug)}`
       );
     };
-    this.create = async (command20) => {
+    this.create = async (command21) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command20.spaceId}/packages`,
+        `/api/v0/organizations/${organizationId}/spaces/${command21.spaceId}/packages`,
         {
           method: "POST",
-          body: command20
+          body: command21
         }
       );
     };
-    this.addArtefacts = async (command20) => {
+    this.addArtefacts = async (command21) => {
       const { organizationId } = this.httpClient.getAuthContext();
-      const { packageId, spaceId } = command20;
+      const { packageId, spaceId } = command21;
       return this.httpClient.request(
         `/api/v0/organizations/${organizationId}/spaces/${spaceId}/packages/${packageId}/add-artifacts`,
         {
           method: "POST",
-          body: command20
+          body: command21
         }
       );
     };
@@ -6622,31 +6678,31 @@ var PackagesGateway = class {
 var DeploymentGateway = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
-    this.pull = async (command20) => {
+    this.pull = async (command21) => {
       const { organizationId } = this.httpClient.getAuthContext();
       const queryParams = new URLSearchParams();
-      if (command20.packagesSlugs && command20.packagesSlugs.length > 0) {
-        command20.packagesSlugs.forEach((slug) => {
+      if (command21.packagesSlugs && command21.packagesSlugs.length > 0) {
+        command21.packagesSlugs.forEach((slug) => {
           queryParams.append("packageSlug", slug);
         });
       }
-      if (command20.previousPackagesSlugs && command20.previousPackagesSlugs.length > 0) {
-        command20.previousPackagesSlugs.forEach((slug) => {
+      if (command21.previousPackagesSlugs && command21.previousPackagesSlugs.length > 0) {
+        command21.previousPackagesSlugs.forEach((slug) => {
           queryParams.append("previousPackageSlug", slug);
         });
       }
-      if (command20.gitRemoteUrl) {
-        queryParams.append("gitRemoteUrl", command20.gitRemoteUrl);
+      if (command21.gitRemoteUrl) {
+        queryParams.append("gitRemoteUrl", command21.gitRemoteUrl);
       }
-      if (command20.gitBranch) {
-        queryParams.append("gitBranch", command20.gitBranch);
+      if (command21.gitBranch) {
+        queryParams.append("gitBranch", command21.gitBranch);
       }
-      if (command20.relativePath) {
-        queryParams.append("relativePath", command20.relativePath);
+      if (command21.relativePath) {
+        queryParams.append("relativePath", command21.relativePath);
       }
-      if (command20.agents !== void 0) {
+      if (command21.agents !== void 0) {
         queryParams.append("agentsConfigOverride", "true");
-        command20.agents.forEach((agent) => {
+        command21.agents.forEach((agent) => {
           queryParams.append("agent", agent);
         });
       }
@@ -6654,13 +6710,29 @@ var DeploymentGateway = class {
         `/api/v0/organizations/${organizationId}/pull?${queryParams.toString()}`
       );
     };
-    this.notifyDistribution = async (command20) => {
+    this.getDeployed = async (command21) => {
+      const { organizationId } = this.httpClient.getAuthContext();
+      return this.httpClient.request(
+        `/api/v0/organizations/${organizationId}/deployed-content`,
+        {
+          method: "POST",
+          body: {
+            packagesSlugs: command21.packagesSlugs,
+            gitRemoteUrl: command21.gitRemoteUrl,
+            gitBranch: command21.gitBranch,
+            relativePath: command21.relativePath,
+            ...command21.agents !== void 0 && { agents: command21.agents }
+          }
+        }
+      );
+    };
+    this.notifyDistribution = async (command21) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
         `/api/v0/organizations/${organizationId}/deployments`,
         {
           method: "POST",
-          body: command20
+          body: command21
         }
       );
     };
@@ -6678,6 +6750,7 @@ var PackmindGateway = class {
   constructor(apiKey) {
     this.apiKey = apiKey;
     this.httpClient = new PackmindHttpClient(apiKey);
+    this.changeProposals = new ChangeProposalGateway(this.httpClient);
     this.linter = new LinterGateway(this.httpClient);
     this.mcp = new McpGateway(this.httpClient);
     this.spaces = new SpacesGateway(this.httpClient);
@@ -8429,8 +8502,8 @@ var ExecuteLinterProgramsUseCase = class {
     this.linterAstAdapter = linterAstAdapter;
     this.logger = logger2;
   }
-  async execute(command20) {
-    const { filePath, fileContent, language, programs } = command20;
+  async execute(command21) {
+    const { filePath, fileContent, language, programs } = command21;
     if (programs.length === 0) {
       return {
         file: filePath,
@@ -8573,7 +8646,8 @@ var ExecuteLinterProgramsUseCase = class {
       line,
       character,
       rule: ruleName,
-      standard: program.standardSlug
+      standard: program.standardSlug,
+      severity: program.severity
     };
   }
   isViolationLike(value) {
@@ -9100,15 +9174,114 @@ function removeTrailingSlash(url) {
   return url.endsWith("/") ? url.slice(0, -1) : url;
 }
 
+// packages/node-utils/src/skillMd/parseSkillMdContent.ts
+var import_yaml = require("yaml");
+var FRONTMATTER_DELIMITER = "---";
+function serializeSkillMetadata(fields) {
+  const sorted = Object.keys(fields).sort((a, b) => a.localeCompare(b)).reduce(
+    (acc, key) => {
+      acc[key] = fields[key];
+      return acc;
+    },
+    {}
+  );
+  return JSON.stringify(sorted);
+}
+function parseSkillMdContent(content) {
+  try {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith(FRONTMATTER_DELIMITER)) {
+      return null;
+    }
+    const afterOpening = trimmed.slice(FRONTMATTER_DELIMITER.length);
+    const closingIndex = afterOpening.indexOf(`
+${FRONTMATTER_DELIMITER}`);
+    if (closingIndex === -1) {
+      return null;
+    }
+    const frontmatter = afterOpening.slice(0, closingIndex).trim();
+    const body = afterOpening.slice(closingIndex + FRONTMATTER_DELIMITER.length + 1).trim();
+    const parsed = (0, import_yaml.parse)(frontmatter);
+    if (parsed === null || typeof parsed !== "object") {
+      return null;
+    }
+    const { "allowed-tools": allowedTools, ...rest } = parsed;
+    const properties = {
+      ...rest,
+      ...allowedTools !== void 0 && { allowedTools }
+    };
+    return { properties, body };
+  } catch {
+    return null;
+  }
+}
+
+// packages/node-utils/src/skillMd/parseSkillMd.ts
+function parseSkillMd(content) {
+  const parsed = parseSkillMdContent(content);
+  if (!parsed) {
+    return null;
+  }
+  const { properties, body } = parsed;
+  const name = String(properties["name"] ?? "");
+  const description = String(properties["description"] ?? "");
+  const license = String(properties["license"] ?? "");
+  const compatibility = String(properties["compatibility"] ?? "");
+  const allowedTools = String(properties["allowedTools"] ?? "");
+  const metadata = properties["metadata"];
+  const metadataJson = metadata != null && typeof metadata === "object" ? serializeSkillMetadata(metadata) : "{}";
+  return {
+    name,
+    description,
+    body,
+    license,
+    compatibility,
+    allowedTools,
+    metadataJson
+  };
+}
+
 // apps/cli/src/application/useCases/InstallPackagesUseCase.ts
 var fs4 = __toESM(require("fs/promises"));
 var path5 = __toESM(require("path"));
+
+// apps/cli/src/infra/utils/permissions.ts
+var DEFAULT_PERMISSIONS = "rw-r--r--";
+function supportsUnixPermissions() {
+  return process.platform !== "win32";
+}
+function modeToPermissionString(mode) {
+  const perms = mode & 511;
+  const chars = "rwx";
+  let result = "";
+  for (let i = 8; i >= 0; i--) {
+    result += perms & 1 << i ? chars[(8 - i) % 3] : "-";
+  }
+  return result;
+}
+function modeToPermissionStringOrDefault(mode) {
+  if (!supportsUnixPermissions()) {
+    return DEFAULT_PERMISSIONS;
+  }
+  return modeToPermissionString(mode);
+}
+function parsePermissionString(permString) {
+  let mode = 0;
+  for (let i = 0; i < 9; i++) {
+    if (permString[i] !== "-") {
+      mode |= 1 << 8 - i;
+    }
+  }
+  return mode;
+}
+
+// apps/cli/src/application/useCases/InstallPackagesUseCase.ts
 var InstallPackagesUseCase = class {
   constructor(packmindGateway) {
     this.packmindGateway = packmindGateway;
   }
-  async execute(command20) {
-    const baseDirectory = command20.baseDirectory || process.cwd();
+  async execute(command21) {
+    const baseDirectory = command21.baseDirectory || process.cwd();
     const result = {
       filesCreated: 0,
       filesUpdated: 0,
@@ -9120,12 +9293,12 @@ var InstallPackagesUseCase = class {
       skillDirectoriesDeleted: 0
     };
     const response = await this.packmindGateway.deployment.pull({
-      packagesSlugs: command20.packagesSlugs,
-      previousPackagesSlugs: command20.previousPackagesSlugs,
-      gitRemoteUrl: command20.gitRemoteUrl,
-      gitBranch: command20.gitBranch,
-      relativePath: command20.relativePath,
-      agents: command20.agents
+      packagesSlugs: command21.packagesSlugs,
+      previousPackagesSlugs: command21.previousPackagesSlugs,
+      gitRemoteUrl: command21.gitRemoteUrl,
+      gitBranch: command21.gitBranch,
+      relativePath: command21.relativePath,
+      agents: command21.agents
     });
     const filteredCreateOrUpdate = response.fileUpdates.createOrUpdate.filter(
       (file) => file.path !== "packmind.json"
@@ -9151,7 +9324,12 @@ var InstallPackagesUseCase = class {
       );
       for (const file of uniqueFiles) {
         try {
-          await this.createOrUpdateFile(baseDirectory, file, result);
+          await this.createOrUpdateFile(
+            baseDirectory,
+            file,
+            result,
+            file.skillFilePermissions
+          );
         } catch (error) {
           const errorMsg = error instanceof Error ? error.message : String(error);
           result.errors.push(
@@ -9173,7 +9351,7 @@ var InstallPackagesUseCase = class {
     }
     return result;
   }
-  async createOrUpdateFile(baseDirectory, file, result) {
+  async createOrUpdateFile(baseDirectory, file, result, skillFilePermissions) {
     const fullPath = path5.join(baseDirectory, file.path);
     const directory = path5.dirname(fullPath);
     await fs4.mkdir(directory, { recursive: true });
@@ -9195,6 +9373,9 @@ var InstallPackagesUseCase = class {
         baseDirectory
       );
     }
+    if (skillFilePermissions && supportsUnixPermissions()) {
+      await fs4.chmod(fullPath, parsePermissionString(skillFilePermissions));
+    }
   }
   async handleFullContentUpdate(fullPath, content, fileExists, result, isBase64) {
     if (isBase64) {
@@ -9255,12 +9436,12 @@ var InstallPackagesUseCase = class {
   }
   async deleteFile(baseDirectory, filePath, result) {
     const fullPath = path5.join(baseDirectory, filePath);
-    const stat4 = await fs4.stat(fullPath).catch(() => null);
-    if (stat4?.isDirectory()) {
+    const stat5 = await fs4.stat(fullPath).catch(() => null);
+    if (stat5?.isDirectory()) {
       await fs4.rm(fullPath, { recursive: true, force: true });
       result.filesDeleted++;
       await this.removeEmptyParentDirectories(fullPath, baseDirectory);
-    } else if (stat4?.isFile()) {
+    } else if (stat5?.isFile()) {
       await fs4.unlink(fullPath);
       result.filesDeleted++;
       await this.removeEmptyParentDirectories(fullPath, baseDirectory);
@@ -9403,8 +9584,8 @@ var InstallDefaultSkillsUseCase = class {
   constructor(repositories) {
     this.repositories = repositories;
   }
-  async execute(command20) {
-    const baseDirectory = command20.baseDirectory || process.cwd();
+  async execute(command21) {
+    const baseDirectory = command21.baseDirectory || process.cwd();
     const result = {
       filesCreated: 0,
       filesUpdated: 0,
@@ -9414,8 +9595,8 @@ var InstallDefaultSkillsUseCase = class {
     const agents = config?.agents;
     const response = await this.repositories.packmindGateway.skills.getDefaults(
       {
-        cliVersion: command20.cliVersion,
-        includeBeta: command20.includeBeta,
+        cliVersion: command21.cliVersion,
+        includeBeta: command21.includeBeta,
         agents
       }
     );
@@ -9480,8 +9661,8 @@ var GetPackageSummaryUseCase = class {
   constructor(gateway) {
     this.gateway = gateway;
   }
-  async execute(command20) {
-    return this.gateway.packages.getSummary(command20);
+  async execute(command21) {
+    return this.gateway.packages.getSummary(command21);
   }
 };
 
@@ -9760,8 +9941,8 @@ var LoginUseCase = class {
       startCallbackServer: deps?.startCallbackServer ?? defaultStartCallbackServer
     };
   }
-  async execute(command20) {
-    const { host, code: providedCode } = command20;
+  async execute(command21) {
+    const { host, code: providedCode } = command21;
     let code;
     if (providedCode) {
       code = providedCode;
@@ -9799,8 +9980,8 @@ var LogoutUseCase = class {
   constructor(deps) {
     this.deps = {
       getCredentialsPath: deps?.getCredentialsPath ?? getCredentialsPath,
-      fileExists: deps?.fileExists ?? ((path14) => fs7.existsSync(path14)),
-      deleteFile: deps?.deleteFile ?? ((path14) => fs7.unlinkSync(path14)),
+      fileExists: deps?.fileExists ?? ((path18) => fs7.existsSync(path18)),
+      deleteFile: deps?.deleteFile ?? ((path18) => fs7.unlinkSync(path18)),
       hasEnvVar: deps?.hasEnvVar ?? (() => !!process.env[ENV_VAR_NAME2])
     };
   }
@@ -9860,8 +10041,8 @@ var SetupMcpUseCase = class {
   constructor(deps) {
     this.deps = deps;
   }
-  async execute(command20) {
-    const { agentTypes } = command20;
+  async execute(command21) {
+    const { agentTypes } = command21;
     const [tokenResult, urlResult] = await Promise.all([
       this.deps.gateway.mcp.getToken({}),
       this.deps.gateway.mcp.getUrl({})
@@ -9932,9 +10113,9 @@ var McpConfigService = class {
     return JSON.stringify(mcpConfig, null, 2);
   }
   installClaudeMcp(config) {
-    const command20 = `claude mcp add --transport http packmind ${config.url} --header "Authorization: Bearer ${config.accessToken}"`;
+    const command21 = `claude mcp add --transport http packmind ${config.url} --header "Authorization: Bearer ${config.accessToken}"`;
     try {
-      (0, import_child_process2.execSync)(command20, { stdio: "pipe" });
+      (0, import_child_process2.execSync)(command21, { stdio: "pipe" });
       return { success: true };
     } catch (error) {
       const execError = error;
@@ -10430,16 +10611,9 @@ var ListSkillsUseCase = class {
 var import_promises = __toESM(require("fs/promises"));
 var import_path2 = __toESM(require("path"));
 var import_minimatch3 = require("minimatch");
-function normalizePath2(filePath) {
-  let normalized = filePath.replace(/\\/g, "/");
-  if (normalized.startsWith("/") || normalized.startsWith("\\")) {
-    normalized = normalized.substring(1);
-  }
-  return normalized;
-}
-function normalizeLineEndings(content) {
-  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
+
+// apps/cli/src/infra/utils/binaryDetection.ts
+var path10 = __toESM(require("path"));
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   // Images
   ".png",
@@ -10497,7 +10671,7 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".sqlite3"
 ]);
 function isBinaryExtension(filePath) {
-  const ext = import_path2.default.extname(filePath).toLowerCase();
+  const ext = path10.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 }
 function isBinaryBuffer(buffer) {
@@ -10506,6 +10680,18 @@ function isBinaryBuffer(buffer) {
 function isBinaryFile(filePath, buffer) {
   return isBinaryExtension(filePath) || isBinaryBuffer(buffer);
 }
+
+// apps/cli/src/infra/utils/readSkillDirectory.ts
+function normalizePath2(filePath) {
+  let normalized = filePath.replace(/\\/g, "/");
+  if (normalized.startsWith("/") || normalized.startsWith("\\")) {
+    normalized = normalized.substring(1);
+  }
+  return normalized;
+}
+function normalizeLineEndings(content) {
+  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
 var MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
 var MAX_FILE_SIZE_MB = 10;
 var BLACKLIST_PATTERNS = ["**/.DS_Store"];
@@ -10528,9 +10714,9 @@ async function readSkillDirectory(dirPath) {
       if (entry.isDirectory()) {
         await readDir(fullPath, basePath);
       } else if (entry.isFile()) {
-        const stat4 = await import_promises.default.stat(fullPath);
-        if (stat4.size > MAX_FILE_SIZE_BYTES) {
-          const fileSizeMB = (stat4.size / (1024 * 1024)).toFixed(2);
+        const stat5 = await import_promises.default.stat(fullPath);
+        if (stat5.size > MAX_FILE_SIZE_BYTES) {
+          const fileSizeMB = (stat5.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.`
           );
@@ -10549,8 +10735,7 @@ async function readSkillDirectory(dirPath) {
           relativePath: normalizedPath,
           content,
           size: Buffer.byteLength(content, isBinary ? "base64" : "utf-8"),
-          permissions: "rw-r--r--",
-          // Simple default
+          permissions: modeToPermissionStringOrDefault(stat5.mode),
           isBase64: isBinary
         });
       }
@@ -10565,8 +10750,8 @@ var UploadSkillUseCase = class {
   constructor(deps) {
     this.deps = deps;
   }
-  async execute(command20) {
-    const files = await readSkillDirectory(command20.skillPath);
+  async execute(command21) {
+    const files = await readSkillDirectory(command21.skillPath);
     if (!files.find((f) => f.relativePath === "SKILL.md")) {
       throw new Error("SKILL.md not found in skill directory");
     }
@@ -10592,7 +10777,7 @@ var UploadSkillUseCase = class {
     const uploadSkillResponse = await this.deps.gateway.skills.upload({
       spaceId: createSpaceId(space.id),
       files: payload.files,
-      originSkill: command20.originSkill
+      originSkill: command21.originSkill
     });
     return {
       skillId: uploadSkillResponse.skill.id,
@@ -10606,123 +10791,1007 @@ var UploadSkillUseCase = class {
   }
 };
 
-// apps/cli/src/PackmindCliHexaFactory.ts
-var PackmindCliHexaFactory = class {
-  constructor() {
-    this.repositories = {
-      packmindGateway: new PackmindGateway(loadApiKey()),
-      configFileRepository: new ConfigFileRepository()
-    };
-    this.services = {
-      listFiles: new ListFiles(),
-      gitRemoteUrlService: new GitService(),
-      linterExecutionUseCase: new ExecuteLinterProgramsUseCase(),
-      diffViolationFilterService: new DiffViolationFilterService()
-    };
-    this.useCases = {
-      executeSingleFileAst: new ExecuteSingleFileAstUseCase(
-        this.services.linterExecutionUseCase
-      ),
-      getGitRemoteUrl: new GetGitRemoteUrlUseCase(),
-      listFilesInDirectoryUseCase: new ListFilesInDirectoryUseCase(),
-      lintFilesAgainstRule: new LintFilesAgainstRuleUseCase(
-        this.services,
-        this.repositories
-      ),
-      lintFilesFromConfig: new LintFilesFromConfigUseCase(
-        this.services,
-        this.repositories
-      ),
-      installPackages: new InstallPackagesUseCase(
-        this.repositories.packmindGateway
-      ),
-      installDefaultSkills: new InstallDefaultSkillsUseCase(this.repositories),
-      listPackages: new ListPackagesUseCase(this.repositories.packmindGateway),
-      getPackageBySlug: new GetPackageSummaryUseCase(
-        this.repositories.packmindGateway
-      ),
-      login: new LoginUseCase(),
-      logout: new LogoutUseCase(),
-      whoami: new WhoamiUseCase(),
-      setupMcp: new SetupMcpUseCase({
-        gateway: this.repositories.packmindGateway,
-        mcpConfigService: new McpConfigService()
-      }),
-      listStandards: new ListStandardsUseCase(
-        this.repositories.packmindGateway
-      ),
-      listCommands: new ListCommandsUseCase(this.repositories.packmindGateway),
-      listSkills: new ListSkillsUseCase(this.repositories.packmindGateway),
-      uploadSkill: new UploadSkillUseCase({
-        gateway: this.repositories.packmindGateway
-      })
-    };
+// apps/cli/src/application/useCases/diffStrategies/CommandDiffStrategy.ts
+var import_diff = require("diff");
+var fs11 = __toESM(require("fs/promises"));
+var path12 = __toESM(require("path"));
+
+// apps/cli/src/application/utils/stripFrontmatter.ts
+var FRONTMATTER_DELIMITER2 = "---";
+function stripFrontmatter(content) {
+  if (!content.startsWith(`${FRONTMATTER_DELIMITER2}
+`)) {
+    return content;
+  }
+  const contentAfterOpening = content.slice(FRONTMATTER_DELIMITER2.length + 1);
+  const closingIndex = contentAfterOpening.indexOf(
+    `
+${FRONTMATTER_DELIMITER2}`
+  );
+  if (closingIndex === -1) {
+    return content;
   }
-};
+  return contentAfterOpening.slice(closingIndex + FRONTMATTER_DELIMITER2.length + 1).trimStart();
+}
 
-// apps/cli/src/PackmindCliHexa.ts
-var origin8 = "PackmindCliHexa";
-var PackmindCliHexa = class {
-  constructor(logger2 = new PackmindLogger(origin8)) {
-    this.notifyDistribution = async (command20) => {
-      return this.hexa.repositories.packmindGateway.deployment.notifyDistribution(
-        command20
-      );
-    };
-    this.logger = logger2;
+// apps/cli/src/application/useCases/diffStrategies/CommandDiffStrategy.ts
+var CommandDiffStrategy = class {
+  supports(file) {
+    return file.artifactType === "command";
+  }
+  async diff(file, baseDirectory) {
+    const fullPath = path12.join(baseDirectory, file.path);
+    let localContent;
     try {
-      this.hexa = new PackmindCliHexaFactory();
-    } catch (error) {
-      this.logger.error("Failed to initialize PackmindCliHexa", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
+      localContent = await fs11.readFile(fullPath, "utf-8");
+    } catch {
+      return [];
     }
+    const serverBody = stripFrontmatter(file.content);
+    const localBody = stripFrontmatter(localContent);
+    const changes = (0, import_diff.diffLines)(serverBody, localBody);
+    const hasDifferences = changes.some(
+      (change) => change.added || change.removed
+    );
+    if (!hasDifferences) {
+      return [];
+    }
+    return [
+      {
+        filePath: file.path,
+        type: "updateCommandDescription" /* updateCommandDescription */,
+        payload: {
+          oldValue: serverBody,
+          newValue: localBody
+        },
+        artifactName: file.artifactName,
+        artifactType: file.artifactType,
+        artifactId: file.artifactId,
+        spaceId: file.spaceId
+      }
+    ];
   }
-  /**
-   * Destroys the DeploymentsHexa and cleans up resources
-   */
-  destroy() {
-    this.logger.info("Destroying PackmindCliHexa");
-    this.logger.info("PackmindCliHexa destroyed");
-  }
-  async getGitRemoteUrl(command20) {
-    return this.hexa.useCases.getGitRemoteUrl.execute(command20);
+};
+
+// apps/cli/src/application/useCases/diffStrategies/SkillDiffStrategy.ts
+var import_diff2 = require("diff");
+var fs12 = __toESM(require("fs/promises"));
+var path13 = __toESM(require("path"));
+var SkillDiffStrategy = class {
+  supports(file) {
+    return file.artifactType === "skill";
   }
-  async executeSingleFileAst(command20) {
-    return this.hexa.useCases.executeSingleFileAst.execute(command20);
+  async diff(file, baseDirectory, context) {
+    if (file.path.endsWith("/SKILL.md")) {
+      return this.diffSkillMd(file, baseDirectory);
+    }
+    return this.diffSkillFile(file, baseDirectory, context?.skillFolders ?? []);
   }
-  async listFilesInDirectory(command20) {
-    return this.hexa.useCases.listFilesInDirectoryUseCase.execute(command20);
+  async diffNewFiles(skillFolders, serverFiles, baseDirectory) {
+    const diffs = [];
+    for (const folder of skillFolders) {
+      const folderPath = path13.join(baseDirectory, folder);
+      const localFiles = await this.listFilesRecursively(folderPath);
+      const serverPathsInFolder = new Set(
+        serverFiles.filter((f) => f.path.startsWith(folder + "/")).map((f) => f.path)
+      );
+      const skillMdFile = serverFiles.find(
+        (f) => f.path === `${folder}/SKILL.md` && f.artifactType === "skill"
+      );
+      if (!skillMdFile) {
+        continue;
+      }
+      for (const relativePath of localFiles) {
+        if (relativePath === "SKILL.md") {
+          continue;
+        }
+        const filePath = `${folder}/${relativePath}`;
+        if (serverPathsInFolder.has(filePath)) {
+          continue;
+        }
+        const fullPath = path13.join(baseDirectory, filePath);
+        const localRead = await this.tryReadFileBinaryAware(fullPath);
+        if (localRead === null) {
+          continue;
+        }
+        const permissions = await this.tryGetPermissions(fullPath) ?? "rw-r--r--";
+        diffs.push({
+          filePath,
+          type: "addSkillFile" /* addSkillFile */,
+          payload: {
+            item: {
+              path: relativePath,
+              content: localRead.content,
+              permissions,
+              isBase64: localRead.isBase64
+            }
+          },
+          artifactName: skillMdFile.artifactName,
+          artifactType: "skill",
+          artifactId: skillMdFile.artifactId,
+          spaceId: skillMdFile.spaceId
+        });
+      }
+    }
+    return diffs;
   }
-  async lintFilesAgainstRule(command20) {
-    return this.hexa.useCases.lintFilesAgainstRule.execute(command20);
+  async diffSkillMd(file, baseDirectory) {
+    const fullPath = path13.join(baseDirectory, file.path);
+    const localContent = await this.tryReadFile(fullPath);
+    if (localContent === null) {
+      return [];
+    }
+    const serverParsed = parseSkillMd(file.content);
+    const localParsed = parseSkillMd(localContent);
+    if (!serverParsed || !localParsed) {
+      const serverBody = stripFrontmatter(file.content);
+      const localBody = stripFrontmatter(localContent);
+      const changes = (0, import_diff2.diffLines)(serverBody, localBody);
+      const hasDifferences = changes.some(
+        (change) => change.added || change.removed
+      );
+      if (!hasDifferences) {
+        return [];
+      }
+      return [
+        {
+          filePath: file.path,
+          type: "updateSkillPrompt" /* updateSkillPrompt */,
+          payload: { oldValue: serverBody, newValue: localBody },
+          artifactName: file.artifactName,
+          artifactType: file.artifactType,
+          artifactId: file.artifactId,
+          spaceId: file.spaceId
+        }
+      ];
+    }
+    const baseDiff = {
+      filePath: file.path,
+      artifactName: file.artifactName,
+      artifactType: file.artifactType,
+      artifactId: file.artifactId,
+      spaceId: file.spaceId
+    };
+    const checks = [
+      this.checkUpdateSkillName(serverParsed, localParsed, baseDiff),
+      this.checkUpdateSkillDescription(serverParsed, localParsed, baseDiff),
+      this.checkUpdateSkillPrompt(serverParsed, localParsed, baseDiff),
+      this.checkUpdateSkillMetadata(serverParsed, localParsed, baseDiff),
+      this.checkUpdateSkillLicense(serverParsed, localParsed, baseDiff),
+      this.checkUpdateSkillCompatibility(serverParsed, localParsed, baseDiff),
+      this.checkUpdateSkillAllowedTools(serverParsed, localParsed, baseDiff)
+    ];
+    return checks.filter((d) => d !== null);
   }
-  async lintFilesFromConfig(command20) {
-    return this.hexa.useCases.lintFilesFromConfig.execute(command20);
+  async diffSkillFile(file, baseDirectory, skillFolders) {
+    if (!file.skillFileId) {
+      return [];
+    }
+    const skillFileId = createSkillFileId(file.skillFileId);
+    const fullPath = path13.join(baseDirectory, file.path);
+    const localRead = await this.tryReadFileBinaryAware(fullPath);
+    const fileRelativePath = this.computeRelativePath(file.path, skillFolders);
+    if (localRead === null) {
+      return [
+        {
+          filePath: file.path,
+          type: "deleteSkillFile" /* deleteSkillFile */,
+          payload: {
+            targetId: skillFileId,
+            item: {
+              id: skillFileId,
+              path: fileRelativePath,
+              content: file.content,
+              permissions: file.skillFilePermissions ?? "read",
+              isBase64: file.isBase64 ?? false
+            }
+          },
+          artifactName: file.artifactName,
+          artifactType: file.artifactType,
+          artifactId: file.artifactId,
+          spaceId: file.spaceId
+        }
+      ];
+    }
+    const baseDiff = {
+      filePath: file.path,
+      artifactName: file.artifactName,
+      artifactType: file.artifactType,
+      artifactId: file.artifactId,
+      spaceId: file.spaceId
+    };
+    const checks = await Promise.all([
+      this.checkUpdateSkillFileContent(
+        file,
+        localRead.content,
+        localRead.isBase64,
+        skillFileId,
+        baseDiff
+      ),
+      this.checkUpdateSkillFilePermissions(
+        file,
+        fullPath,
+        skillFileId,
+        baseDiff
+      )
+    ]);
+    return checks.filter((d) => d !== null);
   }
-  async installPackages(command20) {
-    return this.hexa.useCases.installPackages.execute(command20);
+  checkUpdateSkillName(serverParsed, localParsed, baseDiff) {
+    if (serverParsed.name === localParsed.name) {
+      return null;
+    }
+    return {
+      ...baseDiff,
+      type: "updateSkillName" /* updateSkillName */,
+      payload: { oldValue: serverParsed.name, newValue: localParsed.name }
+    };
   }
-  async listPackages(command20) {
-    return this.hexa.useCases.listPackages.execute(command20);
+  checkUpdateSkillDescription(serverParsed, localParsed, baseDiff) {
+    if (serverParsed.description === localParsed.description) {
+      return null;
+    }
+    return {
+      ...baseDiff,
+      type: "updateSkillDescription" /* updateSkillDescription */,
+      payload: {
+        oldValue: serverParsed.description,
+        newValue: localParsed.description
+      }
+    };
   }
-  async getPackageBySlug(command20) {
-    return this.hexa.useCases.getPackageBySlug.execute(command20);
+  checkUpdateSkillPrompt(serverParsed, localParsed, baseDiff) {
+    if (serverParsed.body === localParsed.body) {
+      return null;
+    }
+    return {
+      ...baseDiff,
+      type: "updateSkillPrompt" /* updateSkillPrompt */,
+      payload: { oldValue: serverParsed.body, newValue: localParsed.body }
+    };
   }
-  async listStandards(command20) {
-    return this.hexa.useCases.listStandards.execute(command20);
+  checkUpdateSkillMetadata(serverParsed, localParsed, baseDiff) {
+    if (serverParsed.metadataJson === localParsed.metadataJson) {
+      return null;
+    }
+    return {
+      ...baseDiff,
+      type: "updateSkillMetadata" /* updateSkillMetadata */,
+      payload: {
+        oldValue: serverParsed.metadataJson,
+        newValue: localParsed.metadataJson
+      }
+    };
   }
-  async listCommands(command20) {
-    return this.hexa.useCases.listCommands.execute(command20);
+  checkUpdateSkillLicense(serverParsed, localParsed, baseDiff) {
+    if (serverParsed.license === localParsed.license) {
+      return null;
+    }
+    return {
+      ...baseDiff,
+      type: "updateSkillLicense" /* updateSkillLicense */,
+      payload: {
+        oldValue: serverParsed.license,
+        newValue: localParsed.license
+      }
+    };
   }
-  async listSkills(command20) {
-    return this.hexa.useCases.listSkills.execute(command20);
+  checkUpdateSkillCompatibility(serverParsed, localParsed, baseDiff) {
+    if (serverParsed.compatibility === localParsed.compatibility) {
+      return null;
+    }
+    return {
+      ...baseDiff,
+      type: "updateSkillCompatibility" /* updateSkillCompatibility */,
+      payload: {
+        oldValue: serverParsed.compatibility,
+        newValue: localParsed.compatibility
+      }
+    };
   }
-  async configExists(baseDirectory) {
-    return await this.hexa.repositories.configFileRepository.configExists(
-      baseDirectory
-    );
+  checkUpdateSkillAllowedTools(serverParsed, localParsed, baseDiff) {
+    if (serverParsed.allowedTools === localParsed.allowedTools) {
+      return null;
+    }
+    return {
+      ...baseDiff,
+      type: "updateSkillAllowedTools" /* updateSkillAllowedTools */,
+      payload: {
+        oldValue: serverParsed.allowedTools,
+        newValue: localParsed.allowedTools
+      }
+    };
+  }
+  checkUpdateSkillFileContent(file, localContent, localIsBase64, skillFileId, baseDiff) {
+    const isBinary = localIsBase64 || (file.isBase64 ?? false);
+    if (isBinary) {
+      if (localContent === file.content) {
+        return null;
+      }
+      return {
+        ...baseDiff,
+        type: "updateSkillFileContent" /* updateSkillFileContent */,
+        payload: {
+          targetId: skillFileId,
+          oldValue: file.content,
+          newValue: localContent,
+          isBase64: true
+        }
+      };
+    }
+    if (localContent === file.content) {
+      return null;
+    }
+    return {
+      ...baseDiff,
+      type: "updateSkillFileContent" /* updateSkillFileContent */,
+      payload: {
+        targetId: skillFileId,
+        oldValue: file.content,
+        newValue: localContent,
+        isBase64: false
+      }
+    };
+  }
+  async checkUpdateSkillFilePermissions(file, fullPath, skillFileId, baseDiff) {
+    if (!file.skillFilePermissions) {
+      return null;
+    }
+    const localPermissions = await this.tryGetPermissions(fullPath);
+    if (!localPermissions || localPermissions === file.skillFilePermissions) {
+      return null;
+    }
+    return {
+      ...baseDiff,
+      type: "updateSkillFilePermissions" /* updateSkillFilePermissions */,
+      payload: {
+        targetId: skillFileId,
+        oldValue: file.skillFilePermissions,
+        newValue: localPermissions
+      }
+    };
+  }
+  async tryReadFile(filePath) {
+    try {
+      return await fs12.readFile(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  async tryReadFileBinaryAware(filePath) {
+    try {
+      const buffer = await fs12.readFile(filePath);
+      if (isBinaryFile(filePath, buffer)) {
+        return { content: buffer.toString("base64"), isBase64: true };
+      }
+      return { content: buffer.toString("utf-8"), isBase64: false };
+    } catch {
+      return null;
+    }
+  }
+  async listFilesRecursively(dirPath, prefix = "") {
+    let entries;
+    try {
+      entries = await fs12.readdir(dirPath);
+    } catch {
+      return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+      const fullPath = path13.join(dirPath, entry);
+      const stat5 = await this.tryStatFile(fullPath);
+      if (!stat5) {
+        continue;
+      }
+      const relativePath = prefix ? `${prefix}/${entry}` : entry;
+      if (stat5.isDirectory) {
+        const subFiles = await this.listFilesRecursively(
+          fullPath,
+          relativePath
+        );
+        files.push(...subFiles);
+      } else {
+        files.push(relativePath);
+      }
+    }
+    return files;
+  }
+  async tryStatFile(filePath) {
+    try {
+      const stat5 = await fs12.stat(filePath);
+      return { isDirectory: stat5.isDirectory() };
+    } catch {
+      return null;
+    }
+  }
+  async tryGetPermissions(filePath) {
+    try {
+      const stat5 = await fs12.stat(filePath);
+      return modeToPermissionStringOrDefault(stat5.mode);
+    } catch {
+      return null;
+    }
+  }
+  computeRelativePath(filePath, skillFolders) {
+    const skillFolder = skillFolders.find((f) => filePath.startsWith(f + "/"));
+    if (skillFolder) {
+      return filePath.slice(skillFolder.length + 1);
+    }
+    return filePath.split("/").slice(3).join("/");
+  }
+};
+
+// apps/cli/src/application/useCases/diffStrategies/StandardDiffStrategy.ts
+var fs13 = __toESM(require("fs/promises"));
+var path14 = __toESM(require("path"));
+
+// apps/cli/src/application/utils/parseStandardMd.ts
+var DEPLOYER_PARSERS = [
+  { pattern: ".packmind/standards/", parse: parsePackmindStandard },
+  { pattern: ".claude/rules/packmind/standard-", parse: parseClaudeStandard },
+  { pattern: ".cursor/rules/packmind/standard-", parse: parseCursorStandard },
+  {
+    pattern: ".continue/rules/packmind/standard-",
+    parse: parseContinueStandard
+  },
+  { pattern: ".github/instructions/packmind-", parse: parseCopilotStandard }
+];
+function parseStandardMd(content, filePath) {
+  const deployer = DEPLOYER_PARSERS.find((d) => filePath.includes(d.pattern));
+  if (!deployer) {
+    return null;
+  }
+  return deployer.parse(content);
+}
+function parsePackmindStandard(content) {
+  const lines = content.split("\n");
+  let name = null;
+  let nameLineIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith("# ") && !lines[i].startsWith("## ")) {
+      const extracted = lines[i].slice(2).trim();
+      if (extracted) {
+        name = extracted;
+        nameLineIndex = i;
+        break;
+      }
+    }
+  }
+  if (!name) {
+    return null;
+  }
+  let rulesLineIndex = -1;
+  for (let i = nameLineIndex + 1; i < lines.length; i++) {
+    if (lines[i].trim() === "## Rules") {
+      rulesLineIndex = i;
+      break;
+    }
+  }
+  const descriptionLines = [];
+  let rulesStartIndex = -1;
+  if (rulesLineIndex >= 0) {
+    for (let i = nameLineIndex + 1; i < rulesLineIndex; i++) {
+      descriptionLines.push(lines[i]);
+    }
+    rulesStartIndex = rulesLineIndex + 1;
+  } else {
+    for (let i = nameLineIndex + 1; i < lines.length; i++) {
+      if (lines[i].startsWith("* ") || lines[i].startsWith("- ")) {
+        rulesStartIndex = i;
+        break;
+      }
+      descriptionLines.push(lines[i]);
+    }
+  }
+  const rules = extractRulesList(lines, rulesStartIndex);
+  return {
+    name,
+    description: descriptionLines.join("\n").trim(),
+    scope: "",
+    rules
+  };
+}
+function parseClaudeStandard(content) {
+  const { frontmatter, body } = extractFrontmatter(content);
+  const scope = extractScopeFromKey(frontmatter, "paths");
+  const parsed = parseIdeStandardBody(body, scope);
+  if (!parsed) return null;
+  return addFrontmatterFields(parsed, frontmatter);
+}
+function parseCursorStandard(content) {
+  const { frontmatter, body } = extractFrontmatter(content);
+  const scope = extractScopeFromKey(frontmatter, "globs");
+  return parseIdeStandardBody(body, scope);
+}
+function parseContinueStandard(content) {
+  const { frontmatter, body } = extractFrontmatter(content);
+  const scope = extractScopeFromKey(frontmatter, "globs");
+  const parsed = parseIdeStandardBody(body, scope);
+  if (!parsed) return null;
+  return addFrontmatterFields(parsed, frontmatter);
+}
+function parseCopilotStandard(content) {
+  const { frontmatter, body } = extractFrontmatter(content);
+  const rawScope = extractFrontmatterValue(frontmatter, "applyTo");
+  let scope = "";
+  if (rawScope) {
+    const stripped = rawScope.replace(/(?:^['"])|(?:['"]$)/g, "");
+    scope = stripped === "**" ? "" : stripped;
+  }
+  return parseIdeStandardBody(body, scope);
+}
+var RULES_FALLBACK = "No rules defined yet.";
+function extractRulesList(lines, startIndex) {
+  if (startIndex < 0) return [];
+  const rules = [];
+  for (let i = startIndex; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("* ") || line.startsWith("- ")) {
+      const content = line.slice(2).trim();
+      if (content && content !== RULES_FALLBACK) {
+        rules.push(content);
+      }
+    } else if (line.startsWith("Full standard is available")) {
+      break;
+    } else if (line.startsWith("## ")) {
+      break;
+    }
+  }
+  return rules;
+}
+function extractFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (!match) {
+    return { frontmatter: "", body: content };
+  }
+  return {
+    frontmatter: match[1],
+    body: content.slice(match[0].length)
+  };
+}
+function parseIdeStandardBody(body, scope) {
+  const lines = body.split("\n");
+  let name = null;
+  let nameLineIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith("## Standard: ")) {
+      const extracted = lines[i].slice("## Standard: ".length).trim();
+      if (extracted) {
+        name = extracted;
+        nameLineIndex = i;
+        break;
+      }
+    }
+  }
+  if (!name) {
+    return null;
+  }
+  const descriptionLines = [];
+  let rulesStartIndex = -1;
+  for (let i = nameLineIndex + 1; i < lines.length; i++) {
+    if (lines[i].startsWith("* ") || lines[i].startsWith("- ")) {
+      rulesStartIndex = i;
+      break;
+    }
+    if (lines[i].startsWith("Full standard is available")) break;
+    descriptionLines.push(lines[i]);
+  }
+  let description = descriptionLines.join("\n").trim();
+  if (description.endsWith(" :")) {
+    description = description.slice(0, -2).trim();
+  }
+  const rules = extractRulesList(lines, rulesStartIndex);
+  return { name, description, scope, rules };
+}
+function addFrontmatterFields(parsed, frontmatter) {
+  const fmName = extractFrontmatterValue(frontmatter, "name");
+  const fmDescription = extractFrontmatterValue(frontmatter, "description");
+  return {
+    ...parsed,
+    ...fmName ? { frontmatterName: fmName } : {},
+    ...fmDescription ? { frontmatterDescription: fmDescription } : {}
+  };
+}
+function extractFrontmatterValue(frontmatter, key) {
+  if (!frontmatter) return "";
+  for (const line of frontmatter.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(`${key}:`)) {
+      const raw = trimmed.slice(key.length + 1).trim();
+      return stripYamlQuotes(raw);
+    }
+  }
+  return "";
+}
+function stripYamlQuotes(value) {
+  if (value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
+    return value.slice(1, -1).replace(/''/g, "'");
+  }
+  if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function extractScopeFromKey(frontmatter, key) {
+  const rawValue = extractFrontmatterValue(frontmatter, key);
+  if (!rawValue) return "";
+  return normalizeScopeValue(rawValue);
+}
+function normalizeScopeValue(rawValue) {
+  if (!rawValue) return "";
+  if (rawValue.startsWith("[")) {
+    const inner = rawValue.slice(1, -1);
+    const items = inner.split(",").map((item) => item.trim().replace(/(?:^["'])|(?:["']$)/g, ""));
+    return items.join(", ");
+  }
+  return rawValue.replace(/(?:^["'])|(?:["']$)/g, "");
+}
+
+// apps/cli/src/application/useCases/diffStrategies/StandardDiffStrategy.ts
+var StandardDiffStrategy = class {
+  supports(file) {
+    return file.artifactType === "standard";
+  }
+  async diff(file, baseDirectory) {
+    const fullPath = path14.join(baseDirectory, file.path);
+    let localContent;
+    try {
+      localContent = await fs13.readFile(fullPath, "utf-8");
+    } catch {
+      return [];
+    }
+    const serverParsed = parseStandardMd(file.content, file.path);
+    const localParsed = parseStandardMd(localContent, file.path);
+    if (!serverParsed || !localParsed) {
+      return [];
+    }
+    const diffs = [];
+    const diffBase = {
+      filePath: file.path,
+      artifactName: file.artifactName,
+      artifactType: file.artifactType,
+      artifactId: file.artifactId,
+      spaceId: file.spaceId
+    };
+    if (serverParsed.frontmatterName && localParsed.frontmatterName && serverParsed.frontmatterName !== localParsed.frontmatterName) {
+      diffs.push({
+        ...diffBase,
+        type: "updateStandardName" /* updateStandardName */,
+        payload: {
+          oldValue: serverParsed.frontmatterName,
+          newValue: localParsed.frontmatterName
+        }
+      });
+    }
+    if (serverParsed.name !== localParsed.name) {
+      diffs.push({
+        ...diffBase,
+        type: "updateStandardName" /* updateStandardName */,
+        payload: {
+          oldValue: serverParsed.name,
+          newValue: localParsed.name
+        }
+      });
+    }
+    if (serverParsed.frontmatterDescription && localParsed.frontmatterDescription && serverParsed.frontmatterDescription !== localParsed.frontmatterDescription) {
+      diffs.push({
+        ...diffBase,
+        type: "updateStandardDescription" /* updateStandardDescription */,
+        payload: {
+          oldValue: serverParsed.frontmatterDescription,
+          newValue: localParsed.frontmatterDescription
+        }
+      });
+    }
+    if (serverParsed.description !== localParsed.description) {
+      diffs.push({
+        ...diffBase,
+        type: "updateStandardDescription" /* updateStandardDescription */,
+        payload: {
+          oldValue: serverParsed.description,
+          newValue: localParsed.description
+        }
+      });
+    }
+    if (serverParsed.scope !== localParsed.scope) {
+      diffs.push({
+        ...diffBase,
+        type: "updateStandardScope" /* updateStandardScope */,
+        payload: {
+          oldValue: serverParsed.scope,
+          newValue: localParsed.scope
+        }
+      });
+    }
+    const serverRules = new Set(serverParsed.rules);
+    const localRules = new Set(localParsed.rules);
+    for (const rule of serverRules) {
+      if (!localRules.has(rule)) {
+        const ruleId = createRuleId("unresolved");
+        diffs.push({
+          ...diffBase,
+          type: "deleteRule" /* deleteRule */,
+          payload: {
+            targetId: ruleId,
+            item: { id: ruleId, content: rule }
+          }
+        });
+      }
+    }
+    for (const rule of localRules) {
+      if (!serverRules.has(rule)) {
+        diffs.push({
+          ...diffBase,
+          type: "addRule" /* addRule */,
+          payload: {
+            item: { content: rule }
+          }
+        });
+      }
+    }
+    return diffs;
+  }
+};
+
+// apps/cli/src/application/useCases/DiffArtefactsUseCase.ts
+var DiffArtefactsUseCase = class {
+  constructor(packmindGateway) {
+    this.packmindGateway = packmindGateway;
+    this.strategies = [
+      new CommandDiffStrategy(),
+      new SkillDiffStrategy(),
+      new StandardDiffStrategy()
+    ];
+  }
+  async execute(command21) {
+    const baseDirectory = command21.baseDirectory || process.cwd();
+    const response = await this.packmindGateway.deployment.getDeployed({
+      packagesSlugs: command21.packagesSlugs,
+      gitRemoteUrl: command21.gitRemoteUrl,
+      gitBranch: command21.gitBranch,
+      relativePath: command21.relativePath,
+      agents: command21.agents
+    });
+    const filteredFiles = response.fileUpdates.createOrUpdate.filter(
+      (file) => file.path !== "packmind.json"
+    );
+    const uniqueFilesMap = /* @__PURE__ */ new Map();
+    for (const file of filteredFiles) {
+      uniqueFilesMap.set(file.path, file);
+    }
+    const diffableFiles = Array.from(uniqueFilesMap.values()).filter(
+      (file) => !!file.artifactType && !!file.artifactName && file.content !== void 0
+    );
+    const prefixedSkillFolders = this.prefixSkillFolders(
+      response.skillFolders,
+      command21.relativePath
+    );
+    const diffs = [];
+    for (const file of diffableFiles) {
+      const strategy = this.strategies.find((s) => s.supports(file));
+      if (strategy) {
+        const fileDiffs = await strategy.diff(file, baseDirectory, {
+          skillFolders: prefixedSkillFolders
+        });
+        diffs.push(...fileDiffs);
+      }
+    }
+    for (const strategy of this.strategies) {
+      if (strategy.diffNewFiles) {
+        const newFileDiffs = await strategy.diffNewFiles(
+          prefixedSkillFolders,
+          diffableFiles,
+          baseDirectory
+        );
+        diffs.push(...newFileDiffs);
+      }
+    }
+    return diffs;
+  }
+  prefixSkillFolders(skillFolders, relativePath) {
+    if (!relativePath) return skillFolders;
+    let normalized = relativePath;
+    while (normalized.startsWith("/")) normalized = normalized.slice(1);
+    while (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+    if (!normalized) return skillFolders;
+    return skillFolders.map((folder) => `${normalized}/${folder}`);
+  }
+};
+
+// apps/cli/src/application/useCases/SubmitDiffsUseCase.ts
+var SUPPORTED_ARTIFACT_TYPES = /* @__PURE__ */ new Set(["command", "skill", "standard"]);
+var SubmitDiffsUseCase = class {
+  constructor(packmindGateway) {
+    this.packmindGateway = packmindGateway;
+  }
+  async execute(command21) {
+    const { groupedDiffs } = command21;
+    const skipped = [];
+    const validDiffs = [];
+    for (const group of groupedDiffs) {
+      const firstDiff = group[0];
+      if (!firstDiff) {
+        continue;
+      }
+      if (!SUPPORTED_ARTIFACT_TYPES.has(firstDiff.artifactType)) {
+        skipped.push({
+          name: firstDiff.artifactName,
+          reason: "Only commands, skills, and standards are supported"
+        });
+        continue;
+      }
+      for (const diff of group) {
+        if (!diff.artifactId || !diff.spaceId) {
+          skipped.push({
+            name: diff.artifactName,
+            reason: "Missing artifact metadata"
+          });
+          continue;
+        }
+        validDiffs.push(diff);
+      }
+    }
+    const diffsBySpaceId = /* @__PURE__ */ new Map();
+    for (const diff of validDiffs) {
+      const existing = diffsBySpaceId.get(diff.spaceId) ?? [];
+      existing.push(diff);
+      diffsBySpaceId.set(diff.spaceId, existing);
+    }
+    let submitted = 0;
+    let alreadySubmitted = 0;
+    const errors = [];
+    for (const [spaceId, diffs] of diffsBySpaceId) {
+      const response = await this.packmindGateway.changeProposals.batchCreate({
+        spaceId,
+        proposals: diffs.map((diff) => ({
+          type: diff.type,
+          artefactId: diff.artifactId,
+          payload: diff.payload,
+          captureMode: "commit" /* commit */
+        }))
+      });
+      submitted += response.created;
+      alreadySubmitted += response.skipped;
+      for (const error of response.errors) {
+        errors.push({
+          name: diffs[error.index].artifactName,
+          message: error.message,
+          code: error.code,
+          artifactType: diffs[error.index].artifactType
+        });
+      }
+    }
+    return { submitted, alreadySubmitted, skipped, errors };
+  }
+};
+
+// apps/cli/src/PackmindCliHexaFactory.ts
+var PackmindCliHexaFactory = class {
+  constructor() {
+    this.repositories = {
+      packmindGateway: new PackmindGateway(loadApiKey()),
+      configFileRepository: new ConfigFileRepository()
+    };
+    this.services = {
+      listFiles: new ListFiles(),
+      gitRemoteUrlService: new GitService(),
+      linterExecutionUseCase: new ExecuteLinterProgramsUseCase(),
+      diffViolationFilterService: new DiffViolationFilterService()
+    };
+    this.useCases = {
+      executeSingleFileAst: new ExecuteSingleFileAstUseCase(
+        this.services.linterExecutionUseCase
+      ),
+      getGitRemoteUrl: new GetGitRemoteUrlUseCase(),
+      listFilesInDirectoryUseCase: new ListFilesInDirectoryUseCase(),
+      lintFilesAgainstRule: new LintFilesAgainstRuleUseCase(
+        this.services,
+        this.repositories
+      ),
+      lintFilesFromConfig: new LintFilesFromConfigUseCase(
+        this.services,
+        this.repositories
+      ),
+      installPackages: new InstallPackagesUseCase(
+        this.repositories.packmindGateway
+      ),
+      installDefaultSkills: new InstallDefaultSkillsUseCase(this.repositories),
+      listPackages: new ListPackagesUseCase(this.repositories.packmindGateway),
+      getPackageBySlug: new GetPackageSummaryUseCase(
+        this.repositories.packmindGateway
+      ),
+      login: new LoginUseCase(),
+      logout: new LogoutUseCase(),
+      whoami: new WhoamiUseCase(),
+      setupMcp: new SetupMcpUseCase({
+        gateway: this.repositories.packmindGateway,
+        mcpConfigService: new McpConfigService()
+      }),
+      listStandards: new ListStandardsUseCase(
+        this.repositories.packmindGateway
+      ),
+      listCommands: new ListCommandsUseCase(this.repositories.packmindGateway),
+      listSkills: new ListSkillsUseCase(this.repositories.packmindGateway),
+      uploadSkill: new UploadSkillUseCase({
+        gateway: this.repositories.packmindGateway
+      }),
+      diffArtefacts: new DiffArtefactsUseCase(
+        this.repositories.packmindGateway
+      ),
+      submitDiffs: new SubmitDiffsUseCase(this.repositories.packmindGateway)
+    };
+  }
+};
+
+// apps/cli/src/PackmindCliHexa.ts
+var origin8 = "PackmindCliHexa";
+var PackmindCliHexa = class {
+  constructor(logger2 = new PackmindLogger(origin8)) {
+    this.notifyDistribution = async (command21) => {
+      return this.hexa.repositories.packmindGateway.deployment.notifyDistribution(
+        command21
+      );
+    };
+    this.logger = logger2;
+    try {
+      this.hexa = new PackmindCliHexaFactory();
+    } catch (error) {
+      this.logger.error("Failed to initialize PackmindCliHexa", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Destroys the DeploymentsHexa and cleans up resources
+   */
+  destroy() {
+    this.logger.info("Destroying PackmindCliHexa");
+    this.logger.info("PackmindCliHexa destroyed");
+  }
+  async getGitRemoteUrl(command21) {
+    return this.hexa.useCases.getGitRemoteUrl.execute(command21);
+  }
+  async executeSingleFileAst(command21) {
+    return this.hexa.useCases.executeSingleFileAst.execute(command21);
+  }
+  async listFilesInDirectory(command21) {
+    return this.hexa.useCases.listFilesInDirectoryUseCase.execute(command21);
+  }
+  async lintFilesAgainstRule(command21) {
+    return this.hexa.useCases.lintFilesAgainstRule.execute(command21);
+  }
+  async lintFilesFromConfig(command21) {
+    return this.hexa.useCases.lintFilesFromConfig.execute(command21);
+  }
+  async installPackages(command21) {
+    return this.hexa.useCases.installPackages.execute(command21);
+  }
+  async diffArtefacts(command21) {
+    return this.hexa.useCases.diffArtefacts.execute(command21);
+  }
+  async submitDiffs(groupedDiffs) {
+    return this.hexa.useCases.submitDiffs.execute({ groupedDiffs });
+  }
+  async listPackages(command21) {
+    return this.hexa.useCases.listPackages.execute(command21);
+  }
+  async getPackageBySlug(command21) {
+    return this.hexa.useCases.getPackageBySlug.execute(command21);
+  }
+  async listStandards(command21) {
+    return this.hexa.useCases.listStandards.execute(command21);
+  }
+  async listCommands(command21) {
+    return this.hexa.useCases.listCommands.execute(command21);
+  }
+  async listSkills(command21) {
+    return this.hexa.useCases.listSkills.execute(command21);
+  }
+  async configExists(baseDirectory) {
+    return await this.hexa.repositories.configFileRepository.configExists(
+      baseDirectory
+    );
   }
   async readConfig(baseDirectory) {
     const config = await this.hexa.repositories.configFileRepository.readConfig(
@@ -10804,17 +11873,17 @@ var PackmindCliHexa = class {
       directory
     );
   }
-  async login(command20) {
-    return this.hexa.useCases.login.execute(command20);
+  async login(command21) {
+    return this.hexa.useCases.login.execute(command21);
   }
-  async logout(command20) {
-    return this.hexa.useCases.logout.execute(command20);
+  async logout(command21) {
+    return this.hexa.useCases.logout.execute(command21);
   }
-  async whoami(command20) {
-    return this.hexa.useCases.whoami.execute(command20);
+  async whoami(command21) {
+    return this.hexa.useCases.whoami.execute(command21);
   }
-  async setupMcp(command20) {
-    return this.hexa.useCases.setupMcp.execute(command20);
+  async setupMcp(command21) {
+    return this.hexa.useCases.setupMcp.execute(command21);
   }
   getCurrentBranch(repoPath) {
     return this.hexa.services.gitRemoteUrlService.getCurrentBranch(repoPath).branch;
@@ -10822,11 +11891,11 @@ var PackmindCliHexa = class {
   getGitRemoteUrlFromPath(repoPath) {
     return this.hexa.services.gitRemoteUrlService.getGitRemoteUrl(repoPath).gitRemoteUrl;
   }
-  async uploadSkill(command20) {
-    return this.hexa.useCases.uploadSkill.execute(command20);
+  async uploadSkill(command21) {
+    return this.hexa.useCases.uploadSkill.execute(command21);
   }
-  async installDefaultSkills(command20) {
-    return this.hexa.useCases.installDefaultSkills.execute(command20);
+  async installDefaultSkills(command21) {
+    return this.hexa.useCases.installDefaultSkills.execute(command21);
   }
   getPackmindGateway() {
     return this.hexa.repositories.packmindGateway;
@@ -10858,39 +11927,70 @@ var IDELintLogger = class {
     });
   }
   logViolation(violation) {
-    violation.violations.forEach(({ line, character, standard, rule }) => {
-      logConsole(
-        `${violation.file}:${line}:${character}:error:@${standard}/${rule}`
-      );
-    });
+    violation.violations.forEach(
+      ({ line, character, standard, rule, severity }) => {
+        const label = (severity ?? "error" /* ERROR */) === "warning" /* WARNING */ ? "warning" : "error";
+        logConsole(
+          `${violation.file}:${line}:${character}:${label}:@${standard}/${rule}`
+        );
+      }
+    );
   }
 };
 
 // apps/cli/src/infra/repositories/HumanReadableLogger.ts
 var HumanReadableLogger = class {
+  effectiveSeverity(s) {
+    return s ?? "error" /* ERROR */;
+  }
   logViolations(violations) {
     violations.forEach((violation) => {
       this.logViolation(violation);
     });
-    if (violations.length > 0) {
-      const totalViolationCount = violations.reduce(
-        (acc, violation) => acc + violation.violations.length,
-        0
-      );
+    if (violations.length === 0) {
+      logSuccessConsole(`\u2705 No violations found`);
+      return;
+    }
+    const allDetails = violations.flatMap((v) => v.violations);
+    const errorCount = allDetails.filter(
+      (d) => this.effectiveSeverity(d.severity) === "error" /* ERROR */
+    ).length;
+    const warningCount = allDetails.filter(
+      (d) => this.effectiveSeverity(d.severity) === "warning" /* WARNING */
+    ).length;
+    const errorFileCount = violations.filter(
+      (v) => v.violations.some(
+        (d) => this.effectiveSeverity(d.severity) === "error" /* ERROR */
+      )
+    ).length;
+    const warningFileCount = violations.filter(
+      (v) => v.violations.some(
+        (d) => this.effectiveSeverity(d.severity) === "warning" /* WARNING */
+      )
+    ).length;
+    if (errorCount > 0) {
       logErrorConsole(
-        `\u274C Found ${formatBold(String(totalViolationCount))} violation(s) in ${formatBold(String(violations.length))} file(s)`
+        `\u274C  Found ${formatBold(String(errorCount))} error(s) in ${formatBold(String(errorFileCount))} file(s)`
+      );
+    }
+    if (warningCount > 0) {
+      logWarningConsole(
+        `\u26A0\uFE0F Found ${formatBold(String(warningCount))} warning(s) in ${formatBold(String(warningFileCount))} file(s)`
       );
-    } else {
-      logSuccessConsole(`\u2705 No violations found`);
     }
   }
   logViolation(violation) {
     logConsole(formatFilePath(violation.file));
-    violation.violations.forEach(({ line, character, standard, rule }) => {
-      logConsole(
-        formatError(`	${line}:${character}	error	@${standard}/${rule}`)
-      );
-    });
+    violation.violations.forEach(
+      ({ line, character, standard, rule, severity }) => {
+        const effective = this.effectiveSeverity(severity);
+        const label = effective === "warning" /* WARNING */ ? "warning" : "error";
+        const format = effective === "warning" /* WARNING */ ? formatWarning : formatError;
+        logConsole(
+          format(`	${line}:${character}	${label}	@${standard}/${rule}`)
+        );
+      }
+    );
   }
 };
 
@@ -10898,19 +11998,24 @@ var HumanReadableLogger = class {
 var pathModule = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/lintHandler.ts
+var SEVERITY_LEVELS = {
+  ["warning" /* WARNING */]: 0,
+  ["error" /* ERROR */]: 1
+};
 function isNotLoggedInError(error) {
   return error instanceof NotLoggedInError;
 }
 async function lintHandler(args2, deps) {
   const {
-    path: path14,
+    path: path18,
     draft,
     rule,
     language,
     logger: logger2,
     continueOnError,
     continueOnMissingKey,
-    diff
+    diff,
+    level
   } = args2;
   const {
     packmindCliHexa,
@@ -10923,7 +12028,7 @@ async function lintHandler(args2, deps) {
     throw new Error("option --rule is required to use --draft mode");
   }
   const startedAt = Date.now();
-  const targetPath = path14 ?? ".";
+  const targetPath = path18 ?? ".";
   const absolutePath = resolvePath(targetPath);
   if (diff) {
     const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(absolutePath);
@@ -10978,14 +12083,27 @@ async function lintHandler(args2, deps) {
     }
     throw error;
   }
+  const effectiveSeverity = (s) => s ?? "error" /* ERROR */;
+  const filteredViolations = level ? violations.map((v) => ({
+    ...v,
+    violations: v.violations.filter(
+      (d) => SEVERITY_LEVELS[effectiveSeverity(d.severity)] >= SEVERITY_LEVELS[level]
+    )
+  })).filter((v) => v.violations.length > 0) : violations;
   (logger2 === "ide" /* ide */ ? ideLintLogger : humanReadableLogger).logViolations(
-    violations
+    filteredViolations
+  );
+  const hasErrors = filteredViolations.some(
+    (v) => v.violations.some(
+      (d) => effectiveSeverity(d.severity) === "error" /* ERROR */
+    )
   );
   const durationSeconds = (Date.now() - startedAt) / 1e3;
-  logInfoConsole(`Lint completed in ${durationSeconds.toFixed(2)}s`);
-  if (violations.length > 0 && !continueOnError) {
+  if (hasErrors && !continueOnError) {
+    logErrorConsole(`Lint failed in ${durationSeconds.toFixed(2)}s`);
     exit(1);
   } else {
+    logInfoConsole(`Lint completed in ${durationSeconds.toFixed(2)}s`);
     exit(0);
   }
 }
@@ -11031,6 +12149,19 @@ var DiffModeType = {
     );
   }
 };
+var LevelType = {
+  from: async (input) => {
+    switch (input) {
+      case "error":
+        return "error" /* ERROR */;
+      case "warning":
+        return "warning" /* WARNING */;
+    }
+    throw new Error(
+      `${input} is not a valid value for the --level option. Expected values are: error, warning`
+    );
+  }
+};
 var lintCommand = (0, import_cmd_ts.command)({
   name: "lint",
   description: "Lint code at the specified path",
@@ -11085,6 +12216,11 @@ var lintCommand = (0, import_cmd_ts.command)({
     changedLines: (0, import_cmd_ts.flag)({
       long: "changed-lines",
       description: "Only lint lines that have changed"
+    }),
+    level: (0, import_cmd_ts.option)({
+      long: "level",
+      description: "Minimum severity level to display (error | warning)",
+      type: (0, import_cmd_ts.optional)(LevelType)
     })
   },
   handler: async (args2) => {
@@ -11174,8 +12310,8 @@ function extractWasmFiles() {
 
 // apps/cli/src/main.ts
 var import_dotenv = require("dotenv");
-var fs16 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/InstallCommand.ts
 var import_cmd_ts2 = __toESM(require_cjs());
@@ -12250,13 +13386,13 @@ Credentials are loaded from (in order of priority):`);
 
 // apps/cli/src/infra/commands/SetupMcpCommand.ts
 var import_cmd_ts7 = __toESM(require_cjs());
-var fs12 = __toESM(require("fs"));
+var fs15 = __toESM(require("fs"));
 var readline2 = __toESM(require("readline"));
 var inquirer = __toESM(require("inquirer"));
 
 // apps/cli/src/application/services/AgentDetectionService.ts
-var fs11 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 var os4 = __toESM(require("os"));
 var import_child_process3 = require("child_process");
 var AgentDetectionService = class {
@@ -12283,21 +13419,21 @@ var AgentDetectionService = class {
     return this.isCommandAvailable("claude");
   }
   isCursorAvailable() {
-    const cursorConfigDir = path11.join(os4.homedir(), ".cursor");
-    return fs11.existsSync(cursorConfigDir);
+    const cursorConfigDir = path15.join(os4.homedir(), ".cursor");
+    return fs14.existsSync(cursorConfigDir);
   }
   isVSCodeAvailable() {
-    const vscodeDir = path11.join(this.projectDir, ".vscode");
-    return fs11.existsSync(vscodeDir);
+    const vscodeDir = path15.join(this.projectDir, ".vscode");
+    return fs14.existsSync(vscodeDir);
   }
   isContinueAvailable() {
-    const continueDir = path11.join(this.projectDir, ".continue");
-    return fs11.existsSync(continueDir);
+    const continueDir = path15.join(this.projectDir, ".continue");
+    return fs14.existsSync(continueDir);
   }
-  isCommandAvailable(command20) {
+  isCommandAvailable(command21) {
     try {
       const whichCommand = process.platform === "win32" ? "where" : "which";
-      (0, import_child_process3.execSync)(`${whichCommand} ${command20}`, { stdio: "pipe" });
+      (0, import_child_process3.execSync)(`${whichCommand} ${command21}`, { stdio: "pipe" });
       return true;
     } catch {
       return false;
@@ -12331,8 +13467,8 @@ var ALL_AGENTS2 = [
   { type: "continue", name: "Continue.dev" }
 ];
 async function promptAgentsWithReadline(choices) {
-  const input = fs12.createReadStream("/dev/tty");
-  const output = fs12.createWriteStream("/dev/tty");
+  const input = fs15.createReadStream("/dev/tty");
+  const output = fs15.createWriteStream("/dev/tty");
   const rl = readline2.createInterface({
     input,
     output
@@ -12700,7 +13836,7 @@ var import_cmd_ts15 = __toESM(require_cjs());
 var import_cmd_ts13 = __toESM(require_cjs());
 
 // apps/cli/src/infra/utils/readPlaybookFile.ts
-var fs13 = __toESM(require("fs/promises"));
+var fs16 = __toESM(require("fs/promises"));
 
 // apps/cli/src/domain/entities/PlaybookDTO.ts
 var import_zod = require("zod");
@@ -12739,7 +13875,7 @@ function validatePlaybook(data) {
 // apps/cli/src/infra/utils/readPlaybookFile.ts
 async function readPlaybookFile(filePath) {
   try {
-    const content = await fs13.readFile(filePath, "utf-8");
+    const content = await fs16.readFile(filePath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(content);
@@ -12955,7 +14091,7 @@ var import_cmd_ts18 = __toESM(require_cjs());
 var import_cmd_ts16 = __toESM(require_cjs());
 
 // apps/cli/src/infra/utils/readCommandPlaybookFile.ts
-var fs14 = __toESM(require("fs/promises"));
+var fs17 = __toESM(require("fs/promises"));
 
 // apps/cli/src/domain/entities/CommandPlaybookDTO.ts
 var import_zod2 = require("zod");
@@ -12993,7 +14129,7 @@ function validateCommandPlaybook(data) {
 // apps/cli/src/infra/utils/readCommandPlaybookFile.ts
 async function readCommandPlaybookFile(filePath) {
   try {
-    const content = await fs14.readFile(filePath, "utf-8");
+    const content = await fs17.readFile(filePath, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(content);
@@ -13072,7 +14208,7 @@ var CreateCommandFromPlaybookUseCase = class {
   }
   async execute(playbook) {
     const space = await this.gateway.spaces.getGlobal();
-    const command20 = await this.gateway.commands.create({
+    const command21 = await this.gateway.commands.create({
       spaceId: space.id,
       name: playbook.name,
       summary: playbook.summary,
@@ -13086,9 +14222,9 @@ var CreateCommandFromPlaybookUseCase = class {
       originSkill: playbook.originSkill
     });
     return {
-      commandId: command20.id,
-      name: command20.name,
-      slug: command20.slug
+      commandId: command21.id,
+      name: command21.name,
+      slug: command21.slug
     };
   }
 };
@@ -13215,11 +14351,322 @@ var commandsCommand = (0, import_cmd_ts18.subcommands)({
   }
 });
 
+// apps/cli/src/infra/commands/DiffCommand.ts
+var import_cmd_ts19 = __toESM(require_cjs());
+
+// apps/cli/src/infra/utils/diffFormatter.ts
+var import_diff3 = require("diff");
+init_source();
+function formatContentDiff(oldContent, newContent) {
+  const changes = (0, import_diff3.diffLines)(oldContent, newContent);
+  const lines = [];
+  for (const change of changes) {
+    const trimmedValue = change.value.replace(/\n$/, "");
+    const changeLines = trimmedValue.split("\n");
+    if (change.added) {
+      for (const line of changeLines) {
+        lines.push(source_default.green(`    + ${line}`));
+      }
+    } else if (change.removed) {
+      for (const line of changeLines) {
+        lines.push(source_default.red(`    - ${line}`));
+      }
+    }
+  }
+  return {
+    lines,
+    hasChanges: lines.length > 0
+  };
+}
+
+// apps/cli/src/infra/commands/diffArtefactsHandler.ts
+init_source();
+var ARTIFACT_TYPE_LABELS = {
+  command: "Command",
+  standard: "Standard",
+  skill: "Skill"
+};
+function subGroupByChangeContent(diffs) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const diff of diffs) {
+    const key = JSON.stringify({ type: diff.type, payload: diff.payload });
+    const group = groups.get(key) ?? [];
+    group.push(diff);
+    groups.set(key, group);
+  }
+  return Array.from(groups.values());
+}
+function groupDiffsByArtefact(diffs) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const diff of diffs) {
+    const key = `${diff.artifactType}:${diff.artifactName}`;
+    const group = groups.get(key) ?? [];
+    group.push(diff);
+    groups.set(key, group);
+  }
+  return groups;
+}
+function formatDiffPayload(diff, log) {
+  const payload = diff.payload;
+  if (diff.type === "addSkillFile" /* addSkillFile */) {
+    const item = payload.item;
+    if (item.isBase64) {
+      log(source_default.green("    + [binary file]"));
+    } else {
+      for (const line of item.content.split("\n")) {
+        log(source_default.green(`    + ${line}`));
+      }
+    }
+    return;
+  }
+  if (diff.type === "deleteSkillFile" /* deleteSkillFile */) {
+    const item = payload.item;
+    if (item.isBase64) {
+      log(source_default.red("    - [binary file]"));
+    } else {
+      const lines2 = item.content.split("\n");
+      const MAX_DELETED_LINES = 3;
+      const preview = lines2.slice(0, MAX_DELETED_LINES);
+      for (const line of preview) {
+        log(source_default.red(`    - ${line}`));
+      }
+      if (lines2.length > MAX_DELETED_LINES) {
+        const remaining = lines2.length - MAX_DELETED_LINES;
+        log(source_default.red(`    ... and ${remaining} more lines deleted`));
+      }
+    }
+    return;
+  }
+  if (diff.type === "updateSkillFileContent" /* updateSkillFileContent */) {
+    const typedPayload = payload;
+    if (typedPayload.isBase64) {
+      log(source_default.green("    ~ [binary content changed]"));
+      return;
+    }
+  }
+  if (diff.type === "addRule" /* addRule */) {
+    const item = payload.item;
+    log(source_default.green(`    + ${item.content}`));
+    return;
+  }
+  if (diff.type === "deleteRule" /* deleteRule */) {
+    const item = payload.item;
+    log(source_default.red(`    - ${item.content}`));
+    return;
+  }
+  const oldValue = payload.oldValue;
+  const newValue = payload.newValue;
+  const { lines } = formatContentDiff(oldValue, newValue);
+  for (const line of lines) {
+    log(line);
+  }
+}
+async function diffArtefactsHandler(deps) {
+  const { packmindCliHexa, exit, getCwd, log, error, submit } = deps;
+  const cwd = getCwd();
+  let configPackages;
+  let configAgents;
+  try {
+    const fullConfig = await packmindCliHexa.readFullConfig(cwd);
+    if (fullConfig) {
+      configPackages = Object.keys(fullConfig.packages);
+      configAgents = fullConfig.agents;
+    } else {
+      configPackages = [];
+    }
+  } catch (err) {
+    error("ERROR Failed to parse packmind.json");
+    if (err instanceof Error) {
+      error(`ERROR ${err.message}`);
+    } else {
+      error(`ERROR ${String(err)}`);
+    }
+    error("\n\u{1F4A1} Please fix the packmind.json file or delete it to continue.");
+    exit(1);
+    return { diffsFound: 0 };
+  }
+  if (configPackages.length === 0) {
+    log("Usage: packmind-cli diff");
+    log("");
+    log("Compare local command files against the server.");
+    log("Configure packages in packmind.json first.");
+    exit(0);
+    return { diffsFound: 0 };
+  }
+  try {
+    let gitRemoteUrl;
+    let gitBranch;
+    let relativePath;
+    const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
+    if (gitRoot) {
+      try {
+        gitRemoteUrl = packmindCliHexa.getGitRemoteUrlFromPath(gitRoot);
+        gitBranch = packmindCliHexa.getCurrentBranch(gitRoot);
+        relativePath = cwd.startsWith(gitRoot) ? cwd.slice(gitRoot.length) : "/";
+        if (!relativePath.startsWith("/")) {
+          relativePath = "/" + relativePath;
+        }
+        if (!relativePath.endsWith("/")) {
+          relativePath = relativePath + "/";
+        }
+      } catch (err) {
+        logWarningConsole(
+          `Failed to collect git info: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    if (!gitRemoteUrl || !gitBranch || !relativePath) {
+      error(
+        "\n\u274C Could not determine git repository info. The diff command requires a git repository with a remote configured."
+      );
+      exit(1);
+      return { diffsFound: 0 };
+    }
+    const packageCount = configPackages.length;
+    const packageWord = packageCount === 1 ? "package" : "packages";
+    logInfoConsole(
+      `Comparing ${packageCount} ${packageWord}: ${configPackages.join(", ")}...`
+    );
+    const diffs = await packmindCliHexa.diffArtefacts({
+      baseDirectory: cwd,
+      packagesSlugs: configPackages,
+      gitRemoteUrl,
+      gitBranch,
+      relativePath,
+      agents: configAgents
+    });
+    if (diffs.length === 0) {
+      log("No changes found.");
+      if (submit) {
+        logInfoConsole("No changes to submit.");
+      }
+      exit(0);
+      return { diffsFound: 0 };
+    }
+    log(formatHeader(`
+Changes found:
+`));
+    const groups = groupDiffsByArtefact(diffs);
+    for (const [, groupDiffs] of groups) {
+      const { artifactType, artifactName } = groupDiffs[0];
+      const typeLabel = ARTIFACT_TYPE_LABELS[artifactType];
+      log(formatBold(`${typeLabel} "${artifactName}"`));
+      const subGroups = subGroupByChangeContent(groupDiffs);
+      for (const subGroup of subGroups) {
+        for (const diff of subGroup) {
+          log(`  ${formatFilePath(diff.filePath)}`);
+        }
+        const label = CHANGE_PROPOSAL_TYPE_LABELS[subGroup[0].type] ?? "content changed";
+        log(`  - ${label}`);
+        formatDiffPayload(subGroup[0], log);
+      }
+      log("");
+    }
+    const changeCount = diffs.length;
+    const changeWord = changeCount === 1 ? "change" : "changes";
+    const typeSortOrder = {
+      command: 0,
+      skill: 1,
+      standard: 2
+    };
+    const uniqueArtefacts = /* @__PURE__ */ new Map();
+    for (const [key, groupDiffs] of groups) {
+      if (!uniqueArtefacts.has(key)) {
+        uniqueArtefacts.set(key, {
+          type: groupDiffs[0].artifactType,
+          name: groupDiffs[0].artifactName
+        });
+      }
+    }
+    const sortedArtefacts = Array.from(uniqueArtefacts.values()).sort(
+      (a, b) => typeSortOrder[a.type] - typeSortOrder[b.type] || a.name.localeCompare(b.name, void 0, { sensitivity: "base" })
+    );
+    const artefactCount = sortedArtefacts.length;
+    const artefactWord = artefactCount === 1 ? "artefact" : "artefacts";
+    logWarningConsole(
+      `Summary: ${changeCount} ${changeWord} found on ${artefactCount} ${artefactWord}:`
+    );
+    for (const artefact of sortedArtefacts) {
+      const typeLabel = ARTIFACT_TYPE_LABELS[artefact.type];
+      logWarningConsole(`* ${typeLabel} "${artefact.name}"`);
+    }
+    if (submit) {
+      const groupedDiffs = Array.from(groupDiffsByArtefact(diffs).values());
+      const result = await packmindCliHexa.submitDiffs(groupedDiffs);
+      for (const err of result.errors) {
+        if (err.code === "ChangeProposalPayloadMismatchError") {
+          logErrorConsole(
+            `Failed to submit "${err.name}": ${err.artifactType ?? "artifact"} is outdated, please run \`packmind-cli install\` to update it`
+          );
+        } else {
+          logErrorConsole(`Failed to submit "${err.name}": ${err.message}`);
+        }
+      }
+      const summaryParts = [];
+      if (result.submitted > 0) {
+        summaryParts.push(`${result.submitted} submitted`);
+      }
+      if (result.alreadySubmitted > 0) {
+        summaryParts.push(`${result.alreadySubmitted} already submitted`);
+      }
+      if (result.errors.length > 0) {
+        const errorWord = result.errors.length === 1 ? "error" : "errors";
+        summaryParts.push(`${result.errors.length} ${errorWord}`);
+      }
+      if (summaryParts.length > 0) {
+        const summaryMessage = `Summary: ${summaryParts.join(", ")}`;
+        if (result.errors.length === 0 && result.alreadySubmitted === 0) {
+          logSuccessConsole(summaryMessage);
+        } else if (result.errors.length > 0 && result.submitted > 0 || result.alreadySubmitted > 0) {
+          logWarningConsole(summaryMessage);
+        } else {
+          logErrorConsole(summaryMessage);
+        }
+      }
+    }
+    exit(0);
+    return { diffsFound: changeCount };
+  } catch (err) {
+    error("\n\u274C Failed to diff:");
+    if (err instanceof Error) {
+      error(`   ${err.message}`);
+    } else {
+      error(`   ${String(err)}`);
+    }
+    exit(1);
+    return { diffsFound: 0 };
+  }
+}
+
+// apps/cli/src/infra/commands/DiffCommand.ts
+var diffCommand = (0, import_cmd_ts19.command)({
+  name: "diff",
+  description: "Show differences between local command files and server content",
+  args: {
+    submit: (0, import_cmd_ts19.flag)({
+      long: "submit",
+      description: "Submit detected changes as change proposals"
+    })
+  },
+  handler: async ({ submit }) => {
+    const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
+    const packmindCliHexa = new PackmindCliHexa(packmindLogger);
+    await diffArtefactsHandler({
+      packmindCliHexa,
+      exit: process.exit,
+      getCwd: () => process.cwd(),
+      log: console.log,
+      error: console.error,
+      submit
+    });
+  }
+});
+
 // apps/cli/src/infra/commands/PackagesCommand.ts
-var import_cmd_ts22 = __toESM(require_cjs());
+var import_cmd_ts23 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/CreatePackageCommand.ts
-var import_cmd_ts19 = __toESM(require_cjs());
+var import_cmd_ts20 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/createPackageHandler.ts
 function buildWebappUrl2(host, orgSlug, packageId) {
@@ -13268,15 +14715,15 @@ var CreatePackageUseCase = class {
   constructor(gateway) {
     this.gateway = gateway;
   }
-  async execute(command20) {
+  async execute(command21) {
     const space = await this.gateway.spaces.getGlobal();
     const result = await this.gateway.packages.create({
       spaceId: space.id,
-      name: command20.name,
-      description: command20.description ?? "",
+      name: command21.name,
+      description: command21.description ?? "",
       recipeIds: [],
       standardIds: [],
-      originSkill: command20.originSkill
+      originSkill: command21.originSkill
     });
     return {
       packageId: result.package.id,
@@ -13287,20 +14734,20 @@ var CreatePackageUseCase = class {
 };
 
 // apps/cli/src/infra/commands/CreatePackageCommand.ts
-var createPackageCommand = (0, import_cmd_ts19.command)({
+var createPackageCommand = (0, import_cmd_ts20.command)({
   name: "create",
   description: "Create a new package",
   args: {
-    name: (0, import_cmd_ts19.positional)({
+    name: (0, import_cmd_ts20.positional)({
       displayName: "name",
       description: "Name of the package to create",
-      type: import_cmd_ts19.string
+      type: import_cmd_ts20.string
     }),
-    description: (0, import_cmd_ts19.option)({
+    description: (0, import_cmd_ts20.option)({
       long: "description",
       short: "d",
       description: "Description of the package (optional)",
-      type: (0, import_cmd_ts19.optional)(import_cmd_ts19.string)
+      type: (0, import_cmd_ts20.optional)(import_cmd_ts20.string)
     }),
     originSkill: originSkillOption
   },
@@ -13349,7 +14796,7 @@ var createPackageCommand = (0, import_cmd_ts19.command)({
 });
 
 // apps/cli/src/infra/commands/AddToPackageCommand.ts
-var import_cmd_ts20 = __toESM(require_cjs());
+var import_cmd_ts21 = __toESM(require_cjs());
 
 // apps/cli/src/domain/errors/ItemNotFoundError.ts
 var ItemNotFoundError = class extends Error {
@@ -13366,8 +14813,8 @@ var AddToPackageUseCase = class {
   constructor(gateway) {
     this.gateway = gateway;
   }
-  async execute(command20) {
-    const { packageSlug, itemType, itemSlugs } = command20;
+  async execute(command21) {
+    const { packageSlug, itemType, itemSlugs } = command21;
     const space = await this.gateway.spaces.getGlobal();
     const packages = await this.gateway.packages.list({});
     const pkg = packages.packages.find((pkg2) => pkg2.slug === packageSlug);
@@ -13384,7 +14831,7 @@ var AddToPackageUseCase = class {
       standardIds: [],
       recipeIds: [],
       skillIds: [],
-      originSkill: command20.originSkill
+      originSkill: command21.originSkill
     };
     if (itemType === "standard") {
       addCommand.standardIds = ids.map(createStandardId);
@@ -13429,7 +14876,7 @@ var AddToPackageUseCase = class {
   }
   async findCommandBySlug(slug, spaceId) {
     const commands = await this.gateway.commands.list({ spaceId });
-    return commands.recipes.find((command20) => command20.slug === slug) ?? null;
+    return commands.recipes.find((command21) => command21.slug === slug) ?? null;
   }
   async findSkillBySlug(slug, spaceId) {
     const skills = await this.gateway.skills.list({ spaceId });
@@ -13485,29 +14932,29 @@ async function addToPackageHandler(packageSlug, itemType, itemSlugs, useCase, or
 }
 
 // apps/cli/src/infra/commands/AddToPackageCommand.ts
-var addToPackageCommand = (0, import_cmd_ts20.command)({
+var addToPackageCommand = (0, import_cmd_ts21.command)({
   name: "add",
   description: "Add standards, commands, or skills to a package",
   args: {
-    to: (0, import_cmd_ts20.option)({
+    to: (0, import_cmd_ts21.option)({
       long: "to",
       description: "Target package slug",
-      type: import_cmd_ts20.string
+      type: import_cmd_ts21.string
     }),
-    standards: (0, import_cmd_ts20.multioption)({
+    standards: (0, import_cmd_ts21.multioption)({
       long: "standard",
       description: "Standard slug(s) to add",
-      type: (0, import_cmd_ts20.array)(import_cmd_ts20.string)
+      type: (0, import_cmd_ts21.array)(import_cmd_ts21.string)
     }),
-    commands: (0, import_cmd_ts20.multioption)({
+    commands: (0, import_cmd_ts21.multioption)({
       long: "command",
       description: "Command slug(s) to add",
-      type: (0, import_cmd_ts20.array)(import_cmd_ts20.string)
+      type: (0, import_cmd_ts21.array)(import_cmd_ts21.string)
     }),
-    skills: (0, import_cmd_ts20.multioption)({
+    skills: (0, import_cmd_ts21.multioption)({
       long: "skill",
       description: "Skill slug(s) to add",
-      type: (0, import_cmd_ts20.array)(import_cmd_ts20.string)
+      type: (0, import_cmd_ts21.array)(import_cmd_ts21.string)
     }),
     originSkill: originSkillOption
   },
@@ -13551,8 +14998,8 @@ var addToPackageCommand = (0, import_cmd_ts20.command)({
 });
 
 // apps/cli/src/infra/commands/listPackagesCommand.ts
-var import_cmd_ts21 = __toESM(require_cjs());
-var listPackagesCommand = (0, import_cmd_ts21.command)({
+var import_cmd_ts22 = __toESM(require_cjs());
+var listPackagesCommand = (0, import_cmd_ts22.command)({
   name: "list",
   description: "List available packages",
   args: {},
@@ -13571,7 +15018,7 @@ var listPackagesCommand = (0, import_cmd_ts21.command)({
 });
 
 // apps/cli/src/infra/commands/PackagesCommand.ts
-var packagesCommand = (0, import_cmd_ts22.subcommands)({
+var packagesCommand = (0, import_cmd_ts23.subcommands)({
   name: "packages",
   description: "Manage packages",
   cmds: {
@@ -13582,14 +15029,14 @@ var packagesCommand = (0, import_cmd_ts22.subcommands)({
 });
 
 // apps/cli/src/infra/commands/config/ConfigCommand.ts
-var import_cmd_ts24 = __toESM(require_cjs());
+var import_cmd_ts25 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/config/ConfigAgentsCommand.ts
-var import_cmd_ts23 = __toESM(require_cjs());
+var import_cmd_ts24 = __toESM(require_cjs());
 
 // apps/cli/src/application/services/AgentArtifactDetectionService.ts
-var fs15 = __toESM(require("fs/promises"));
-var path12 = __toESM(require("path"));
+var fs18 = __toESM(require("fs/promises"));
+var path16 = __toESM(require("path"));
 var AGENT_ARTIFACT_CHECKS = [
   { agent: "claude", paths: [".claude"] },
   { agent: "cursor", paths: [".cursor"] },
@@ -13607,7 +15054,7 @@ var AgentArtifactDetectionService = class {
     const detected = [];
     for (const check of AGENT_ARTIFACT_CHECKS) {
       for (const relativePath of check.paths) {
-        const fullPath = path12.join(baseDirectory, relativePath);
+        const fullPath = path16.join(baseDirectory, relativePath);
         const exists = await this.pathExists(fullPath);
         if (exists) {
           detected.push({
@@ -13622,7 +15069,7 @@ var AgentArtifactDetectionService = class {
   }
   async pathExists(filePath) {
     try {
-      await fs15.access(filePath);
+      await fs18.access(filePath);
       return true;
     } catch {
       return false;
@@ -13745,7 +15192,7 @@ async function getPreselectedAgents(deps) {
 }
 
 // apps/cli/src/infra/commands/config/ConfigAgentsCommand.ts
-var configAgentsCommand = (0, import_cmd_ts23.command)({
+var configAgentsCommand = (0, import_cmd_ts24.command)({
   name: "agents",
   description: "Configure which coding agents to generate artifacts for",
   args: {},
@@ -13765,7 +15212,7 @@ var configAgentsCommand = (0, import_cmd_ts23.command)({
 });
 
 // apps/cli/src/infra/commands/config/ConfigCommand.ts
-var configCommand = (0, import_cmd_ts24.subcommands)({
+var configCommand = (0, import_cmd_ts25.subcommands)({
   name: "config",
   description: "Manage Packmind configuration",
   cmds: {
@@ -13774,7 +15221,7 @@ var configCommand = (0, import_cmd_ts24.subcommands)({
 });
 
 // apps/cli/src/infra/commands/InitCommand.ts
-var import_cmd_ts25 = __toESM(require_cjs());
+var import_cmd_ts26 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/initHandler.ts
 async function initHandler(deps) {
@@ -13831,7 +15278,7 @@ async function initHandler(deps) {
 
 // apps/cli/src/infra/commands/InitCommand.ts
 var { version: CLI_VERSION3 } = require_package();
-var initCommand = (0, import_cmd_ts25.command)({
+var initCommand = (0, import_cmd_ts26.command)({
   name: "init",
   description: "Initialize Packmind in the current project",
   args: {},
@@ -13864,20 +15311,20 @@ function findEnvFile() {
   const currentDir = process.cwd();
   const gitService = new GitService();
   const gitRoot = gitService.getGitRepositoryRootSync(currentDir);
-  const filesystemRoot = path13.parse(currentDir).root;
+  const filesystemRoot = path17.parse(currentDir).root;
   const stopDir = gitRoot ?? filesystemRoot;
   let searchDir = currentDir;
-  let parentDir = path13.dirname(searchDir);
+  let parentDir = path17.dirname(searchDir);
   while (searchDir !== parentDir) {
-    const envPath2 = path13.join(searchDir, ".env");
-    if (fs16.existsSync(envPath2)) {
+    const envPath2 = path17.join(searchDir, ".env");
+    if (fs19.existsSync(envPath2)) {
       return envPath2;
     }
     if (searchDir === stopDir) {
       return null;
     }
     searchDir = parentDir;
-    parentDir = path13.dirname(searchDir);
+    parentDir = path17.dirname(searchDir);
   }
   return null;
 }
@@ -13897,12 +15344,13 @@ if (args.includes("--version") || args.includes("-v")) {
   logConsole(`packmind-cli version ${CLI_VERSION4}`);
   process.exit(0);
 }
-var app = (0, import_cmd_ts26.subcommands)({
+var app = (0, import_cmd_ts27.subcommands)({
   name: "packmind-cli",
   description: "Packmind CLI tool",
   cmds: {
     commands: commandsCommand,
     config: configCommand,
+    diff: diffCommand,
     init: initCommand,
     install: installCommand,
     lint: lintCommand,
@@ -13918,7 +15366,7 @@ var app = (0, import_cmd_ts26.subcommands)({
     whoami: whoamiCommand
   }
 });
-(0, import_cmd_ts26.run)(app, args).catch((error) => {
+(0, import_cmd_ts27.run)(app, args).catch((error) => {
   logErrorConsole(error.message);
   process.exit(1);
 });