@packmind/cli 0.26.0 → 0.27.0

package/main.cjs

@@ -843,7 +843,7 @@ var require_types = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.boolean = exports2.string = exports2.number = void 0;
     exports2.optional = optional17;
-    exports2.array = array3;
+    exports2.array = array2;
     var type_1 = require_type();
     exports2.number = {
       async from(str) {
@@ -877,7 +877,7 @@ var require_types = __commonJS({
         }
       };
     }
-    function array3(t) {
+    function array2(t) {
       return {
         ...t,
         async from(inputs) {
@@ -1526,9 +1526,9 @@ Did you mean ${chalk_1.default.italic(option22)}?`;
         }
       };
     }
-    function flatMap(array3, f) {
+    function flatMap(array2, f) {
       const rs = [];
-      for (const item of array3) {
+      for (const item of array2) {
         rs.push(...f(item));
       }
       return rs;
@@ -1582,6 +1582,9 @@ function stripAnsi(string21) {
   if (typeof string21 !== "string") {
     throw new TypeError(`Expected a \`string\`, got \`${typeof string21}\``);
   }
+  if (!string21.includes("\x1B") && !string21.includes("\x9B")) {
+    return string21;
+  }
   return string21.replace(regex, "");
 }
 var regex;
@@ -1698,12 +1701,12 @@ var require_command = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.command = command33;
+    exports2.command = command32;
     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 command33(config) {
+    function command32(config) {
       const argEntries = (0, utils_1.entries)(config.args);
       const circuitbreaker = (0, circuitbreaker_1.createCircuitBreaker)(!!config.version);
       return {
@@ -2587,7 +2590,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os6 = require("os");
+    var os4 = require("os");
     var tty2 = require("tty");
     var hasFlag2 = require_has_flag();
     var { env: env2 } = process;
@@ -2635,7 +2638,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os6.release().split(".");
+        const osRelease = os4.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -3427,11 +3430,11 @@ var require_multioption = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.multioption = multioption3;
+    exports2.multioption = multioption2;
     var chalk_1 = __importDefault((init_source(), __toCommonJS(source_exports)));
     var Result = __importStar(require_Result());
     var findOption_1 = require_findOption();
-    function multioption3(config) {
+    function multioption2(config) {
       return {
         helpTopics() {
           var _a, _b;
@@ -3852,7 +3855,7 @@ var require_package = __commonJS({
   "apps/cli/package.json"(exports2, module2) {
     module2.exports = {
       name: "@packmind/cli",
-      version: "0.26.0",
+      version: "0.27.0",
       description: "A command-line interface for Packmind linting and code quality checks",
       private: false,
       bin: {
@@ -3898,7 +3901,7 @@ var require_package = __commonJS({
 });
 
 // apps/cli/src/main.ts
-var import_cmd_ts42 = __toESM(require_cjs());
+var import_cmd_ts41 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/LinterCommand.ts
 var import_cmd_ts = __toESM(require_cjs());
@@ -4448,6 +4451,20 @@ var SpaceMembersRoleUpdatedEvent = class extends UserEvent {
   }
 };
 
+// packages/types/src/spaces/events/SpacePinnedEvent.ts
+var SpacePinnedEvent = class extends UserEvent {
+  static {
+    this.eventName = "spaces.space.pinned";
+  }
+};
+
+// packages/types/src/spaces/events/SpaceUnpinnedEvent.ts
+var SpaceUnpinnedEvent = class extends UserEvent {
+  static {
+    this.eventName = "spaces.space.unpinned";
+  }
+};
+
 // packages/types/src/spaces/events/SpaceVisibilityUpdatedEvent.ts
 var SpaceVisibilityUpdatedEvent = class extends UserEvent {
   static {
@@ -5303,8 +5320,8 @@ var ExecuteSingleFileAstUseCase = class _ExecuteSingleFileAstUseCase {
   static {
     this.fallbackRuleContent = "adhoc-rule";
   }
-  async execute(command33) {
-    const { program, fileContent, language } = command33;
+  async execute(command32) {
+    const { program, fileContent, language } = command32;
     const result = await this.linterExecutionUseCase.execute({
       filePath: "cli-single-file",
       fileContent,
@@ -5363,30 +5380,30 @@ var GitService = class {
     this.gitRunner = gitRunner;
     this.logger = logger2;
   }
-  getGitRepositoryRoot(path37) {
+  getGitRepositoryRoot(path35) {
     try {
       const { stdout } = this.gitRunner("rev-parse --show-toplevel", {
-        cwd: path37
+        cwd: path35
       });
       const gitRoot = stdout.trim();
       this.logger.debug("Resolved git repository root", {
-        inputPath: path37,
+        inputPath: path35,
         gitRoot
       });
       return gitRoot;
     } catch (error) {
       if (error instanceof Error) {
         throw new Error(
-          `Failed to get Git repository root. The path '${path37}' does not appear to be inside a Git repository.
+          `Failed to get Git repository root. The path '${path35}' does not appear to be inside a Git repository.
 ${error.message}`
         );
       }
       throw new Error("Failed to get Git repository root: Unknown error");
     }
   }
-  tryGetGitRepositoryRoot(path37) {
+  tryGetGitRepositoryRoot(path35) {
     try {
-      return this.getGitRepositoryRoot(path37);
+      return this.getGitRepositoryRoot(path35);
     } catch {
       return null;
     }
@@ -5688,8 +5705,8 @@ var GetGitRemoteUrlUseCase = class {
   constructor(gitRemoteUrlService = new GitService()) {
     this.gitRemoteUrlService = gitRemoteUrlService;
   }
-  async execute(command33) {
-    const { path: repoPath, origin: origin9 } = command33;
+  async execute(command32) {
+    const { path: repoPath, origin: origin9 } = command32;
     return this.gitRemoteUrlService.getGitRemoteUrl(repoPath, origin9);
   }
 };
@@ -5841,8 +5858,8 @@ var ListFilesInDirectoryUseCase = class {
   constructor(listFiles = new ListFiles()) {
     this.listFiles = listFiles;
   }
-  async execute(command33) {
-    const { path: directoryPath, extensions, excludes = [] } = command33;
+  async execute(command32) {
+    const { path: directoryPath, extensions, excludes = [] } = command32;
     const files = await this.listFiles.listFilesInDirectory(
       directoryPath,
       extensions,
@@ -5957,7 +5974,7 @@ var LintFilesAgainstRuleUseCase = class {
       };
     };
   }
-  async execute(command33) {
+  async execute(command32) {
     const {
       path: userPath,
       draftMode,
@@ -5966,7 +5983,7 @@ var LintFilesAgainstRuleUseCase = class {
       language,
       diffMode,
       ignorePatterns
-    } = command33;
+    } = command32;
     this.logger.debug(
       `Starting linting: path="${userPath}", draftMode=${!!draftMode}, standardSlug="${standardSlug || "N/A"}", ruleId="${ruleId || "N/A"}", language="${language || "N/A"}", diffMode="${diffMode ?? "none"}"`
     );
@@ -6282,8 +6299,8 @@ var LintFilesAgainstRuleUseCase = class {
       return null;
     }
   }
-  async executeProgramsForFile(command33) {
-    const result = await this.services.linterExecutionUseCase.execute(command33);
+  async executeProgramsForFile(command32) {
+    const result = await this.services.linterExecutionUseCase.execute(command32);
     return result.violations;
   }
   extractExtensionFromFile(filePath) {
@@ -6306,8 +6323,8 @@ var LintFilesFromConfigUseCase = class {
     this.logger = logger2;
     this.detectionProgramsCache = /* @__PURE__ */ new Map();
   }
-  async execute(command33) {
-    const { path: userPath, diffMode, ignorePatterns } = command33;
+  async execute(command32) {
+    const { path: userPath, diffMode, ignorePatterns } = command32;
     this.logger.debug(
       `Starting local linting: path="${userPath}", diffMode="${diffMode ?? "none"}"`
     );
@@ -6567,8 +6584,8 @@ var LintFilesFromConfigUseCase = class {
       return null;
     }
   }
-  async executeProgramsForFile(command33) {
-    const result = await this.services.linterExecutionUseCase.execute(command33);
+  async executeProgramsForFile(command32) {
+    const result = await this.services.linterExecutionUseCase.execute(command32);
     return result.violations;
   }
   extractExtensionFromFile(filePath) {
@@ -6651,10 +6668,10 @@ var PackmindHttpClient = class {
       return null;
     }
   }
-  async request(path37, options = {}) {
+  async request(path35, options = {}) {
     const { host } = this.getAuthContext();
     const { method = "GET", body } = options;
-    const url = `${host}${path37}`;
+    const url = `${host}${path35}`;
     try {
       const response = await fetch(url, {
         method,
@@ -6705,13 +6722,13 @@ var PackmindHttpClient = class {
 var ChangeProposalGateway = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
-    this.batchCreate = async (command33) => {
+    this.batchCreate = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command33.spaceId}/change-proposals/batch`,
+        `/api/v0/organizations/${organizationId}/spaces/${command32.spaceId}/change-proposals/batch`,
         {
           method: "POST",
-          body: { proposals: command33.proposals },
+          body: { proposals: command32.proposals },
           onError: (response) => {
             if (response.status === 404) {
               throw new CommunityEditionError("change proposals");
@@ -6720,29 +6737,29 @@ var ChangeProposalGateway = class {
         }
       );
     };
-    this.batchApply = async (command33) => {
+    this.batchApply = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
         `/api/v0/organizations/${organizationId}/playbook/apply`,
         {
           method: "POST",
           body: {
-            proposals: command33.proposals,
-            message: command33.message,
-            ...command33.directUpdate !== void 0 && {
-              directUpdate: command33.directUpdate
+            proposals: command32.proposals,
+            message: command32.message,
+            ...command32.directUpdate !== void 0 && {
+              directUpdate: command32.directUpdate
             }
           }
         }
       );
     };
-    this.check = async (command33) => {
+    this.check = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command33.spaceId}/change-proposals/check`,
+        `/api/v0/organizations/${organizationId}/spaces/${command32.spaceId}/change-proposals/check`,
         {
           method: "POST",
-          body: { proposals: command33.proposals },
+          body: { proposals: command32.proposals },
           onError: (response) => {
             if (response.status === 404) {
               throw new CommunityEditionError("change proposals");
@@ -6758,13 +6775,13 @@ var ChangeProposalGateway = class {
 var LinterGateway = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
-    this.getDraftDetectionProgramsForRule = async (command33) => {
+    this.getDraftDetectionProgramsForRule = async (command32) => {
       const payload = {
-        standardSlug: command33.standardSlug,
-        ruleId: command33.ruleId
+        standardSlug: command32.standardSlug,
+        ruleId: command32.ruleId
       };
-      if (command33.language) {
-        payload.language = command33.language;
+      if (command32.language) {
+        payload.language = command32.language;
       }
       return this.httpClient.request("/api/v0/list-draft-detection-program", {
         method: "POST",
@@ -6776,13 +6793,13 @@ var LinterGateway = class {
         }
       });
     };
-    this.getActiveDetectionProgramsForRule = async (command33) => {
+    this.getActiveDetectionProgramsForRule = async (command32) => {
       const payload = {
-        standardSlug: command33.standardSlug,
-        ruleId: command33.ruleId
+        standardSlug: command32.standardSlug,
+        ruleId: command32.ruleId
       };
-      if (command33.language) {
-        payload.language = command33.language;
+      if (command32.language) {
+        payload.language = command32.language;
       }
       return this.httpClient.request("/api/v0/list-active-detection-program", {
         method: "POST",
@@ -6794,13 +6811,13 @@ var LinterGateway = class {
         }
       });
     };
-    this.getDetectionProgramsForPackages = async (command33) => {
+    this.getDetectionProgramsForPackages = async (command32) => {
       const response = await this.httpClient.request(
         "/api/v0/detection-programs-for-packages",
         {
           method: "POST",
           body: {
-            packagesSlugs: command33.packagesSlugs
+            packagesSlugs: command32.packagesSlugs
           },
           onError: (response2) => {
             if (response2.status === 404) {
@@ -6811,10 +6828,10 @@ var LinterGateway = class {
       );
       return handleScopeInTargetsResponse(response);
     };
-    this.trackLinterExecution = async (command33) => {
+    this.trackLinterExecution = async (command32) => {
       return this.httpClient.request(`/api/v0/track-execution`, {
         method: "POST",
-        body: command33
+        body: command32
       });
     };
   }
@@ -6836,25 +6853,6 @@ function handleScopeInTargetsResponse(response) {
   };
 }
 
-// apps/cli/src/infra/repositories/McpGateway.ts
-var McpGateway = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
-    this.getToken = async () => {
-      const { organizationId } = this.httpClient.getAuthContext();
-      return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/mcp/token`
-      );
-    };
-    this.getUrl = async () => {
-      const { organizationId } = this.httpClient.getAuthContext();
-      return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/mcp/url`
-      );
-    };
-  }
-};
-
 // apps/cli/src/infra/repositories/SpacesGateway.ts
 var SpacesGateway = class {
   constructor(httpClient) {
@@ -6887,27 +6885,27 @@ var SpacesGateway = class {
 var SkillsGateway = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
-    this.upload = async (command33) => {
+    this.upload = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command33.spaceId}/skills/upload`,
+        `/api/v0/organizations/${organizationId}/spaces/${command32.spaceId}/skills/upload`,
         {
           method: "POST",
-          body: command33
+          body: command32
         }
       );
     };
-    this.getDefaults = async (command33) => {
+    this.getDefaults = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       const queryParams = new URLSearchParams();
-      if (command33.includeBeta) {
+      if (command32.includeBeta) {
         queryParams.set("includeBeta", "true");
-      } else if (command33.cliVersion) {
-        queryParams.set("cliVersion", command33.cliVersion);
+      } else if (command32.cliVersion) {
+        queryParams.set("cliVersion", command32.cliVersion);
       }
-      if (command33.agents !== void 0) {
+      if (command32.agents !== void 0) {
         queryParams.append("agentsConfigOverride", "true");
-        command33.agents.forEach((agent) => {
+        command32.agents.forEach((agent) => {
           queryParams.append("agent", agent);
         });
       }
@@ -6916,10 +6914,10 @@ var SkillsGateway = class {
         `/api/v0/organizations/${organizationId}/skills/default${queryString ? `?${queryString}` : ""}`
       );
     };
-    this.list = async (command33) => {
+    this.list = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command33.spaceId}/skills`
+        `/api/v0/organizations/${organizationId}/spaces/${command32.spaceId}/skills`
       );
     };
   }
@@ -6929,17 +6927,17 @@ var SkillsGateway = class {
 var CommandsGateway = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
-    this.create = async (command33) => {
+    this.create = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command33.spaceId}/recipes`,
-        { method: "POST", body: command33 }
+        `/api/v0/organizations/${organizationId}/spaces/${command32.spaceId}/recipes`,
+        { method: "POST", body: command32 }
       );
     };
-    this.list = async (command33) => {
+    this.list = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       const listRecipesResponse = await this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command33.spaceId}/recipes`
+        `/api/v0/organizations/${organizationId}/spaces/${command32.spaceId}/recipes`
       );
       if (listRecipesResponse instanceof Array) {
         return { recipes: listRecipesResponse };
@@ -6980,10 +6978,10 @@ var StandardsGateway = class {
         }
       );
     };
-    this.list = async (command33) => {
+    this.list = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command33.spaceId}/standards`
+        `/api/v0/organizations/${organizationId}/spaces/${command32.spaceId}/standards`
       );
     };
   }
@@ -6994,10 +6992,10 @@ var PackagesGateway = class {
   constructor(apiKey, httpClient) {
     this.apiKey = apiKey;
     this.httpClient = httpClient;
-    this.list = async (command33) => {
+    this.list = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command33.spaceId}/packages`
+        `/api/v0/organizations/${organizationId}/spaces/${command32.spaceId}/packages`
       );
     };
     this.getSummary = async ({
@@ -7009,24 +7007,24 @@ var PackagesGateway = class {
         `/api/v0/organizations/${organizationId}/spaces/${spaceId}/packages/summary/${encodeURIComponent(slug3)}`
       );
     };
-    this.create = async (command33) => {
+    this.create = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
-        `/api/v0/organizations/${organizationId}/spaces/${command33.spaceId}/packages`,
+        `/api/v0/organizations/${organizationId}/spaces/${command32.spaceId}/packages`,
         {
           method: "POST",
-          body: command33
+          body: command32
         }
       );
     };
-    this.addArtefacts = async (command33) => {
+    this.addArtefacts = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
-      const { packageId, spaceId } = command33;
+      const { packageId, spaceId } = command32;
       return this.httpClient.request(
         `/api/v0/organizations/${organizationId}/spaces/${spaceId}/packages/${packageId}/add-artifacts`,
         {
           method: "POST",
-          body: command33
+          body: command32
         }
       );
     };
@@ -7037,31 +7035,31 @@ var PackagesGateway = class {
 var DeploymentGateway = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
-    this.pull = async (command33) => {
+    this.pull = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       const queryParams = new URLSearchParams();
-      if (command33.packagesSlugs && command33.packagesSlugs.length > 0) {
-        command33.packagesSlugs.forEach((slug3) => {
+      if (command32.packagesSlugs && command32.packagesSlugs.length > 0) {
+        command32.packagesSlugs.forEach((slug3) => {
           queryParams.append("packageSlug", slug3);
         });
       }
-      if (command33.previousPackagesSlugs && command33.previousPackagesSlugs.length > 0) {
-        command33.previousPackagesSlugs.forEach((slug3) => {
+      if (command32.previousPackagesSlugs && command32.previousPackagesSlugs.length > 0) {
+        command32.previousPackagesSlugs.forEach((slug3) => {
           queryParams.append("previousPackageSlug", slug3);
         });
       }
-      if (command33.gitRemoteUrl) {
-        queryParams.append("gitRemoteUrl", command33.gitRemoteUrl);
+      if (command32.gitRemoteUrl) {
+        queryParams.append("gitRemoteUrl", command32.gitRemoteUrl);
       }
-      if (command33.gitBranch) {
-        queryParams.append("gitBranch", command33.gitBranch);
+      if (command32.gitBranch) {
+        queryParams.append("gitBranch", command32.gitBranch);
       }
-      if (command33.relativePath) {
-        queryParams.append("relativePath", command33.relativePath);
+      if (command32.relativePath) {
+        queryParams.append("relativePath", command32.relativePath);
       }
-      if (command33.agents !== void 0) {
+      if (command32.agents !== void 0) {
         queryParams.append("agentsConfigOverride", "true");
-        command33.agents.forEach((agent) => {
+        command32.agents.forEach((agent) => {
           queryParams.append("agent", agent);
         });
       }
@@ -7069,71 +7067,71 @@ var DeploymentGateway = class {
         `/api/v0/organizations/${organizationId}/pull?${queryParams.toString()}`
       );
     };
-    this.install = async (command33) => {
+    this.install = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
         `/api/v0/organizations/${organizationId}/install`,
         {
           method: "POST",
           body: {
-            packagesSlugs: command33.packagesSlugs,
-            packmindLockFile: command33.packmindLockFile,
-            ...command33.relativePath && { relativePath: command33.relativePath },
-            ...command33.agents !== void 0 && { agents: command33.agents }
+            packagesSlugs: command32.packagesSlugs,
+            packmindLockFile: command32.packmindLockFile,
+            ...command32.relativePath && { relativePath: command32.relativePath },
+            ...command32.agents !== void 0 && { agents: command32.agents }
           }
         }
       );
     };
-    this.getDeployed = async (command33) => {
+    this.getDeployed = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
         `/api/v0/organizations/${organizationId}/deployed-content`,
         {
           method: "POST",
           body: {
-            packagesSlugs: command33.packagesSlugs,
-            gitRemoteUrl: command33.gitRemoteUrl,
-            gitBranch: command33.gitBranch,
-            relativePath: command33.relativePath,
-            ...command33.agents !== void 0 && { agents: command33.agents }
+            packagesSlugs: command32.packagesSlugs,
+            gitRemoteUrl: command32.gitRemoteUrl,
+            gitBranch: command32.gitBranch,
+            relativePath: command32.relativePath,
+            ...command32.agents !== void 0 && { agents: command32.agents }
           }
         }
       );
     };
-    this.getContentByVersions = async (command33) => {
+    this.getContentByVersions = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
         `/api/v0/organizations/${organizationId}/content-by-versions`,
         {
           method: "POST",
           body: {
-            artifacts: command33.artifacts,
-            ...command33.agents !== void 0 && { agents: command33.agents }
+            artifacts: command32.artifacts,
+            ...command32.agents !== void 0 && { agents: command32.agents }
           }
         }
       );
     };
-    this.notifyDistribution = async (command33) => {
+    this.notifyDistribution = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
         `/api/v0/organizations/${organizationId}/deployments`,
         {
           method: "POST",
-          body: command33
+          body: command32
         }
       );
     };
-    this.notifyArtefactsDistribution = async (command33) => {
+    this.notifyArtefactsDistribution = async (command32) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
         `/api/v0/organizations/${organizationId}/deployments/notify-artifacts-distribution`,
         {
           method: "POST",
           body: {
-            gitRemoteUrl: command33.gitRemoteUrl,
-            gitBranch: command33.gitBranch,
-            relativePath: command33.relativePath,
-            packmindLockFile: command33.packmindLockFile
+            gitRemoteUrl: command32.gitRemoteUrl,
+            gitBranch: command32.gitBranch,
+            relativePath: command32.relativePath,
+            packmindLockFile: command32.packmindLockFile
           }
         }
       );
@@ -7184,7 +7182,6 @@ var PackmindGateway = class {
     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);
     this.skills = new SkillsGateway(this.httpClient);
     this.commands = new CommandsGateway(this.httpClient);
@@ -8935,8 +8932,8 @@ var ExecuteLinterProgramsUseCase = class {
     this.linterAstAdapter = linterAstAdapter;
     this.logger = logger2;
   }
-  async execute(command33) {
-    const { filePath, fileContent, language, programs } = command33;
+  async execute(command32) {
+    const { filePath, fileContent, language, programs } = command32;
     if (programs.length === 0) {
       return {
         file: filePath,
@@ -9722,8 +9719,8 @@ var InstallPackagesUseCase = class {
   constructor(packmindGateway) {
     this.packmindGateway = packmindGateway;
   }
-  async execute(command33) {
-    const baseDirectory = command33.baseDirectory || process.cwd();
+  async execute(command32) {
+    const baseDirectory = command32.baseDirectory || process.cwd();
     const result = {
       filesCreated: 0,
       filesUpdated: 0,
@@ -9735,12 +9732,12 @@ var InstallPackagesUseCase = class {
       skillDirectoriesDeleted: 0
     };
     const response = await this.packmindGateway.deployment.pull({
-      packagesSlugs: command33.packagesSlugs,
-      previousPackagesSlugs: command33.previousPackagesSlugs,
-      gitRemoteUrl: command33.gitRemoteUrl,
-      gitBranch: command33.gitBranch,
-      relativePath: command33.relativePath,
-      agents: command33.agents
+      packagesSlugs: command32.packagesSlugs,
+      previousPackagesSlugs: command32.previousPackagesSlugs,
+      gitRemoteUrl: command32.gitRemoteUrl,
+      gitBranch: command32.gitBranch,
+      relativePath: command32.relativePath,
+      agents: command32.agents
     });
     const filteredCreateOrUpdate = response.fileUpdates.createOrUpdate.filter(
       (file) => file.path !== "packmind.json"
@@ -10047,8 +10044,8 @@ var InstallUseCase = class {
     this.configFileRepository = configFileRepository;
     this.spaceService = spaceService;
   }
-  async execute(command33) {
-    const baseDirectory = command33.baseDirectory || process.cwd();
+  async execute(command32) {
+    const baseDirectory = command32.baseDirectory || process.cwd();
     const result = {
       filesCreated: 0,
       filesUpdated: 0,
@@ -10066,7 +10063,7 @@ var InstallUseCase = class {
       skillDirectoriesDeleted: 0,
       missingAccess: []
     };
-    const hasExplicitPackages = command33.packages && command33.packages.length > 0;
+    const hasExplicitPackages = command32.packages && command32.packages.length > 0;
     const lockFile = await this.lockFileRepository.read(baseDirectory);
     const config = await this.configFileRepository.readConfig(baseDirectory);
     if (!config && !hasExplicitPackages) {
@@ -10090,7 +10087,7 @@ var InstallUseCase = class {
     let packagesSlugs;
     let normalizedPackages = [];
     if (hasExplicitPackages) {
-      normalizedPackages = await this.normalizePackageSlugs(command33.packages);
+      normalizedPackages = await this.normalizePackageSlugs(command32.packages);
       await this.validatePackageAccess(normalizedPackages);
       const normalizedConfigPackages = config ? await this.normalizeAndSaveConfigPackages(baseDirectory, config) : [];
       packagesSlugs = [
@@ -10475,8 +10472,8 @@ var UninstallUseCase = class {
     this.spaceService = spaceService;
     this.installUseCase = installUseCase;
   }
-  async execute(command33) {
-    const baseDirectory = command33.baseDirectory || process.cwd();
+  async execute(command32) {
+    const baseDirectory = command32.baseDirectory || process.cwd();
     const config = await this.configFileRepository.readConfig(baseDirectory);
     if (!config) {
       const configFileExists = await this.configFileRepository.configExists(baseDirectory);
@@ -10490,7 +10487,7 @@ var UninstallUseCase = class {
       );
     }
     const normalized = await normalizePackageSlugs(
-      command33.packages,
+      command32.packages,
       this.spaceService
     );
     const notInstalled = normalized.filter((pkg) => !(pkg in config.packages));
@@ -10531,8 +10528,8 @@ var InstallDefaultSkillsUseCase = class {
   constructor(repositories) {
     this.repositories = repositories;
   }
-  async execute(command33) {
-    const baseDirectory = command33.baseDirectory || process.cwd();
+  async execute(command32) {
+    const baseDirectory = command32.baseDirectory || process.cwd();
     const result = {
       filesCreated: 0,
       filesUpdated: 0,
@@ -10545,17 +10542,17 @@ var InstallDefaultSkillsUseCase = class {
     const agents = config?.agents;
     const response = await this.repositories.packmindGateway.skills.getDefaults(
       {
-        cliVersion: command33.cliVersion,
-        includeBeta: command33.includeBeta,
+        cliVersion: command32.cliVersion,
+        includeBeta: command32.includeBeta,
         agents
       }
     );
     result.skippedSkillsCount = response.skippedSkillsCount;
     const incompatibleInstalledMap = /* @__PURE__ */ new Map();
     const incompatibleSkillDirs = /* @__PURE__ */ new Map();
-    if (command33.cliVersion) {
+    if (command32.cliVersion) {
       for (const file of response.fileUpdates.createOrUpdate) {
-        if (path8.basename(file.path) === "SKILL.md" && file.content && this.isVersionConstraintViolated(file.content, command33.cliVersion)) {
+        if (path8.basename(file.path) === "SKILL.md" && file.content && this.isVersionConstraintViolated(file.content, command32.cliVersion)) {
           const dir = path8.dirname(file.path);
           const skillName = this.getSkillName(file.content) ?? path8.basename(dir);
           incompatibleSkillDirs.set(dir, skillName);
@@ -10566,12 +10563,15 @@ var InstallDefaultSkillsUseCase = class {
       for (const file of response.fileUpdates.createOrUpdate) {
         try {
           if (!file.content) continue;
-          const isIncompatible = command33.cliVersion && (this.isVersionConstraintViolated(
+          const isIncompatible = command32.cliVersion && (this.isVersionConstraintViolated(
             file.content,
-            command33.cliVersion
-          ) || incompatibleSkillDirs.has(path8.dirname(file.path)));
+            command32.cliVersion
+          ) || this.isUnderIncompatibleSkillDir(
+            file.path,
+            incompatibleSkillDirs
+          ));
           if (isIncompatible) {
-            const skillName = this.getSkillName(file.content) ?? incompatibleSkillDirs.get(path8.dirname(file.path)) ?? path8.basename(file.path);
+            const skillName = this.getSkillName(file.content) ?? this.getSkillNameForPath(file.path, incompatibleSkillDirs) ?? path8.basename(file.path);
             const fullPath = path8.join(baseDirectory, file.path);
             const fileAlreadyInstalled = await this.fileExists(fullPath);
             if (fileAlreadyInstalled) {
@@ -10631,6 +10631,25 @@ var InstallDefaultSkillsUseCase = class {
       return false;
     }
   }
+  /**
+   * Returns true if the given file path is inside one of the incompatible skill
+   * directories, including nested subdirectories (e.g. `scripts/`).
+   */
+  isUnderIncompatibleSkillDir(filePath, incompatibleSkillDirs) {
+    return this.getSkillNameForPath(filePath, incompatibleSkillDirs) !== null;
+  }
+  /**
+   * Returns the skill name for the given file path by finding the incompatible
+   * skill directory that contains it (including nested subdirectories).
+   */
+  getSkillNameForPath(filePath, incompatibleSkillDirs) {
+    for (const [dir, skillName] of incompatibleSkillDirs.entries()) {
+      if (filePath === dir || filePath.startsWith(dir + "/") || filePath.startsWith(dir + path8.sep)) {
+        return skillName;
+      }
+    }
+    return null;
+  }
   /**
    * Returns true if the skill's `metadata.packmind-cli-version` constraint
    * is present AND the given CLI version does NOT satisfy it (i.e. the skill
@@ -10661,10 +10680,10 @@ var ListPackagesUseCase = class {
     this.packmindGateway = packmindGateway;
     this.spaceService = spaceService;
   }
-  async execute(command33) {
-    if (command33.spaceId) {
+  async execute(command32) {
+    if (command32.spaceId) {
       const response = await this.packmindGateway.packages.list({
-        spaceId: command33.spaceId
+        spaceId: command32.spaceId
       });
       return response.packages;
     }
@@ -10683,8 +10702,8 @@ var GetPackageSummaryUseCase = class {
   constructor(gateway) {
     this.gateway = gateway;
   }
-  async execute(command33) {
-    return this.gateway.packages.getSummary(command33);
+  async execute(command32) {
+    return this.gateway.packages.getSummary(command32);
   }
 };
 
@@ -10963,8 +10982,8 @@ var LoginUseCase = class {
       startCallbackServer: deps?.startCallbackServer ?? defaultStartCallbackServer
     };
   }
-  async execute(command33) {
-    const { host, code: providedCode } = command33;
+  async execute(command32) {
+    const { host, code: providedCode } = command32;
     let code;
     if (providedCode) {
       code = providedCode;
@@ -11002,8 +11021,8 @@ var LogoutUseCase = class {
   constructor(deps) {
     this.deps = {
       getCredentialsPath: deps?.getCredentialsPath ?? getCredentialsPath,
-      fileExists: deps?.fileExists ?? ((path37) => fs8.existsSync(path37)),
-      deleteFile: deps?.deleteFile ?? ((path37) => fs8.unlinkSync(path37)),
+      fileExists: deps?.fileExists ?? ((path35) => fs8.existsSync(path35)),
+      deleteFile: deps?.deleteFile ?? ((path35) => fs8.unlinkSync(path35)),
       hasEnvVar: deps?.hasEnvVar ?? (() => !!process.env[ENV_VAR_NAME2])
     };
   }
@@ -11282,7 +11301,7 @@ var CheckCliVersionUseCase = class {
       timeoutMs: deps?.timeoutMs ?? VERSION_CHECK_TIMEOUT_MS
     };
   }
-  async execute(command33) {
+  async execute(command32) {
     try {
       const latestVersion = await Promise.race([
         this.deps.fetchLatestVersion(this.deps.fetchFn),
@@ -11293,9 +11312,9 @@ var CheckCliVersionUseCase = class {
           )
         )
       ]);
-      const updateAvailable = import_semver3.default.gt(latestVersion, command33.currentVersion);
+      const updateAvailable = import_semver3.default.gt(latestVersion, command32.currentVersion);
       return {
-        currentVersion: command33.currentVersion,
+        currentVersion: command32.currentVersion,
         latestVersion,
         updateAvailable
       };
@@ -11305,222 +11324,9 @@ var CheckCliVersionUseCase = class {
   }
 };
 
-// apps/cli/src/application/useCases/SetupMcpUseCase.ts
-var ALL_AGENTS = [
-  { type: "claude", name: "Claude Code" },
-  { type: "cursor", name: "Cursor" },
-  { type: "vscode", name: "VS Code" },
-  { type: "continue", name: "Continue.dev" }
-];
-var SetupMcpUseCase = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  async execute(command33) {
-    const { agentTypes } = command33;
-    const [tokenResult, urlResult] = await Promise.all([
-      this.deps.gateway.mcp.getToken({}),
-      this.deps.gateway.mcp.getUrl({})
-    ]);
-    const config = {
-      url: urlResult.url,
-      accessToken: tokenResult.access_token
-    };
-    const results = [];
-    let hasFailure = false;
-    for (const agentType of agentTypes) {
-      const agentName = ALL_AGENTS.find((a) => a.type === agentType)?.name || agentType;
-      const installResult = this.deps.mcpConfigService.installForAgent(
-        agentType,
-        config
-      );
-      results.push({
-        agentType,
-        agentName,
-        success: installResult.success,
-        error: installResult.error
-      });
-      if (!installResult.success) {
-        hasFailure = true;
-      }
-    }
-    return {
-      results,
-      manualConfigJson: hasFailure ? this.deps.mcpConfigService.getClassicConfig(config) : void 0
-    };
-  }
-};
-
-// apps/cli/src/application/services/McpConfigService.ts
-var fs9 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
-var os3 = __toESM(require("os"));
-var import_child_process3 = require("child_process");
-var McpConfigService = class {
-  constructor(projectDir = process.cwd()) {
-    this.projectDir = projectDir;
-  }
-  installForAgent(agent, config) {
-    switch (agent) {
-      case "claude":
-        return this.installClaudeMcp(config);
-      case "cursor":
-        return this.installCursorMcp(config);
-      case "vscode":
-        return this.installVSCodeMcp(config);
-      case "continue":
-        return this.installContinueMcp(config);
-      default:
-        return { success: false, error: `Unknown agent: ${agent}` };
-    }
-  }
-  getClassicConfig(config) {
-    const mcpConfig = {
-      mcpServers: {
-        packmind: {
-          url: config.url,
-          headers: {
-            Authorization: `Bearer ${config.accessToken}`
-          }
-        }
-      }
-    };
-    return JSON.stringify(mcpConfig, null, 2);
-  }
-  installClaudeMcp(config) {
-    const command33 = `claude mcp add --transport http packmind ${config.url} --header "Authorization: Bearer ${config.accessToken}"`;
-    try {
-      (0, import_child_process3.execSync)(command33, { stdio: "pipe" });
-      return { success: true };
-    } catch (error) {
-      const execError = error;
-      const errorMessage = execError.stderr ? execError.stderr.toString().trim() : execError.message || String(error);
-      return { success: false, error: errorMessage };
-    }
-  }
-  installCursorMcp(config) {
-    try {
-      const cursorConfigPath = path11.join(os3.homedir(), ".cursor", "mcp.json");
-      const cursorConfig = this.buildCursorConfig(config);
-      const existingConfig = this.readExistingJsonConfig(cursorConfigPath);
-      const mergedConfig = this.mergeConfig(existingConfig, cursorConfig);
-      fs9.writeFileSync(cursorConfigPath, JSON.stringify(mergedConfig, null, 2));
-      return { success: true };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      return { success: false, error: errorMessage };
-    }
-  }
-  installVSCodeMcp(config) {
-    try {
-      const vscodeDir = path11.join(this.projectDir, ".vscode");
-      if (!fs9.existsSync(vscodeDir)) {
-        fs9.mkdirSync(vscodeDir, { recursive: true });
-      }
-      const vscodeConfigPath = path11.join(vscodeDir, "mcp.json");
-      const vscodeConfig = this.buildVSCodeConfig(config);
-      const existingConfig = this.readExistingJsonConfig(vscodeConfigPath);
-      const mergedConfig = this.mergeVSCodeConfig(existingConfig, vscodeConfig);
-      fs9.writeFileSync(vscodeConfigPath, JSON.stringify(mergedConfig, null, 2));
-      return { success: true };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      return { success: false, error: errorMessage };
-    }
-  }
-  installContinueMcp(config) {
-    try {
-      const continueDir = path11.join(this.projectDir, ".continue");
-      const mcpServersDir = path11.join(continueDir, "mcpServers");
-      if (!fs9.existsSync(mcpServersDir)) {
-        fs9.mkdirSync(mcpServersDir, { recursive: true });
-      }
-      const continueConfigPath = path11.join(mcpServersDir, "packmind.yaml");
-      const continueConfig = this.buildContinueYamlConfig(config);
-      fs9.writeFileSync(continueConfigPath, continueConfig);
-      return { success: true };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      return { success: false, error: errorMessage };
-    }
-  }
-  buildCursorConfig(config) {
-    return {
-      mcpServers: {
-        packmind: {
-          url: config.url,
-          headers: {
-            Authorization: `Bearer ${config.accessToken}`
-          }
-        }
-      }
-    };
-  }
-  buildVSCodeConfig(config) {
-    return {
-      servers: {
-        "packmind-mcp-vscode": {
-          url: config.url,
-          type: "http",
-          headers: {
-            Authorization: `Bearer ${config.accessToken}`
-          }
-        }
-      },
-      inputs: []
-    };
-  }
-  buildContinueYamlConfig(config) {
-    return `name: Packmind MCP Server
-version: 0.0.1
-schema: v1
-mcpServers:
-  - name: Packmind
-    type: streamable-http
-    url: ${config.url}
-    requestOptions:
-      headers:
-        Authorization: "Bearer ${config.accessToken}"
-`;
-  }
-  readExistingJsonConfig(filePath) {
-    try {
-      if (fs9.existsSync(filePath)) {
-        const content = fs9.readFileSync(filePath, "utf-8");
-        return JSON.parse(content);
-      }
-    } catch {
-    }
-    return {};
-  }
-  mergeConfig(existing, newConfig) {
-    const existingServers = existing["mcpServers"] || {};
-    const newServers = newConfig["mcpServers"] || {};
-    return {
-      ...existing,
-      mcpServers: {
-        ...existingServers,
-        ...newServers
-      }
-    };
-  }
-  mergeVSCodeConfig(existing, newConfig) {
-    const existingServers = existing["servers"] || {};
-    const newServers = newConfig["servers"] || {};
-    return {
-      ...existing,
-      servers: {
-        ...existingServers,
-        ...newServers
-      },
-      inputs: existing["inputs"] || newConfig["inputs"] || []
-    };
-  }
-};
-
 // apps/cli/src/infra/repositories/ConfigFileRepository.ts
-var fs10 = __toESM(require("fs/promises"));
-var path12 = __toESM(require("path"));
+var fs9 = __toESM(require("fs/promises"));
+var path11 = __toESM(require("path"));
 var ConfigFileRepository = class {
   constructor() {
     this.CONFIG_FILENAME = "packmind.json";
@@ -11541,7 +11347,7 @@ var ConfigFileRepository = class {
   async configExists(baseDirectory) {
     const configPath = this.getConfigPath(baseDirectory);
     try {
-      await fs10.access(configPath);
+      await fs9.access(configPath);
       return true;
     } catch {
       return false;
@@ -11550,7 +11356,7 @@ var ConfigFileRepository = class {
   async readConfig(baseDirectory) {
     const configPath = this.getConfigPath(baseDirectory);
     try {
-      const configContent = await fs10.readFile(configPath, "utf-8");
+      const configContent = await fs9.readFile(configPath, "utf-8");
       const rawConfig = JSON.parse(configContent);
       if (!rawConfig.packages || typeof rawConfig.packages !== "object") {
         throw new Error(
@@ -11584,18 +11390,18 @@ var ConfigFileRepository = class {
     }
   }
   getConfigPath(directory) {
-    return path12.join(directory, this.CONFIG_FILENAME);
+    return path11.join(directory, this.CONFIG_FILENAME);
   }
   async writeConfigToPath(configPath, config) {
     const configContent = JSON.stringify(config, null, 2) + "\n";
-    await fs10.writeFile(configPath, configContent, "utf-8");
+    await fs9.writeFile(configPath, configContent, "utf-8");
   }
   /**
    * Recursively finds all directories containing packmind.json in descendant folders.
    * Excludes common build/dependency directories (node_modules, .git, dist, etc.)
    */
   async findDescendantConfigs(directory) {
-    const normalizedDir = normalizePath2(path12.resolve(directory));
+    const normalizedDir = normalizePath2(path11.resolve(directory));
     return this.searchDescendantsRecursively(normalizedDir);
   }
   async searchDescendantsRecursively(currentDir) {
@@ -11608,7 +11414,7 @@ var ConfigFileRepository = class {
       if (!entry.isDirectory() || this.isExcludedDirectory(entry.name)) {
         continue;
       }
-      const entryPath = normalizePath2(path12.join(currentDir, entry.name));
+      const entryPath = normalizePath2(path11.join(currentDir, entry.name));
       const config = await this.readConfig(entryPath);
       if (config) {
         results.push(entryPath);
@@ -11620,7 +11426,7 @@ var ConfigFileRepository = class {
   }
   async tryReadDirectory(directory) {
     try {
-      return await fs10.readdir(directory, { withFileTypes: true });
+      return await fs9.readdir(directory, { withFileTypes: true });
     } catch {
       return null;
     }
@@ -11639,21 +11445,21 @@ var ConfigFileRepository = class {
   async readHierarchicalConfig(startDirectory, stopDirectory) {
     const configs = [];
     const configPaths = [];
-    const normalizedStart = normalizePath2(path12.resolve(startDirectory));
-    const normalizedStop = stopDirectory ? normalizePath2(path12.resolve(stopDirectory)) : null;
+    const normalizedStart = normalizePath2(path11.resolve(startDirectory));
+    const normalizedStop = stopDirectory ? normalizePath2(path11.resolve(stopDirectory)) : null;
     let currentDir = normalizedStart;
     while (true) {
       const config = await this.readConfig(currentDir);
       if (config) {
         configs.push(config);
         configPaths.push(
-          normalizePath2(path12.join(currentDir, this.CONFIG_FILENAME))
+          normalizePath2(path11.join(currentDir, this.CONFIG_FILENAME))
         );
       }
       if (normalizedStop !== null && currentDir === normalizedStop) {
         break;
       }
-      const parentDir = normalizePath2(path12.dirname(currentDir));
+      const parentDir = normalizePath2(path11.dirname(currentDir));
       if (parentDir === currentDir) {
         break;
       }
@@ -11678,8 +11484,8 @@ var ConfigFileRepository = class {
    * and returns each config with its target path.
    */
   async findAllConfigsInTree(startDirectory, stopDirectory) {
-    const normalizedStart = normalizePath2(path12.resolve(startDirectory));
-    const normalizedStop = stopDirectory ? normalizePath2(path12.resolve(stopDirectory)) : null;
+    const normalizedStart = normalizePath2(path11.resolve(startDirectory));
+    const normalizedStop = stopDirectory ? normalizePath2(path11.resolve(stopDirectory)) : null;
     const basePath = normalizedStop ?? normalizedStart;
     const searchRoot = normalizedStop ?? normalizedStart;
     const configsMap = /* @__PURE__ */ new Map();
@@ -11705,7 +11511,7 @@ var ConfigFileRepository = class {
       if (stopDir !== null && currentDir === stopDir) {
         break;
       }
-      const parentDir = normalizePath2(path12.dirname(currentDir));
+      const parentDir = normalizePath2(path11.dirname(currentDir));
       if (parentDir === currentDir) {
         break;
       }
@@ -11836,7 +11642,7 @@ var ConfigFileRepository = class {
   }
   async tryReadFile(filePath) {
     try {
-      return await fs10.readFile(filePath, "utf-8");
+      return await fs9.readFile(filePath, "utf-8");
     } catch (error) {
       if (error.code === "ENOENT") {
         return null;
@@ -11854,8 +11660,8 @@ var ConfigFileRepository = class {
 };
 
 // apps/cli/src/infra/repositories/LockFileRepository.ts
-var fs11 = __toESM(require("fs/promises"));
-var path13 = __toESM(require("path"));
+var fs10 = __toESM(require("fs/promises"));
+var path12 = __toESM(require("path"));
 var LockFileRepository = class {
   constructor() {
     this.LOCK_FILENAME = "packmind-lock.json";
@@ -11863,7 +11669,7 @@ var LockFileRepository = class {
   async read(baseDirectory) {
     const lockFilePath = this.getLockFilePath(baseDirectory);
     try {
-      const content = await fs11.readFile(lockFilePath, "utf-8");
+      const content = await fs10.readFile(lockFilePath, "utf-8");
       const parsed = JSON.parse(content);
       if (!this.isValidLockFile(parsed)) {
         logWarningConsole(`Malformed lock file: ${lockFilePath}`);
@@ -11889,7 +11695,7 @@ var LockFileRepository = class {
     return typeof obj.installedAt === "string" && Array.isArray(obj.packageSlugs) && Array.isArray(obj.agents) && (obj.targetId === void 0 || typeof obj.targetId === "string") && typeof obj.artifacts === "object" && obj.artifacts !== null && !Array.isArray(obj.artifacts);
   }
   getLockFilePath(baseDirectory) {
-    return path13.join(baseDirectory, this.LOCK_FILENAME);
+    return path12.join(baseDirectory, this.LOCK_FILENAME);
   }
 };
 
@@ -11899,22 +11705,17 @@ var ListStandardsUseCase = class {
     this.packmindGateway = packmindGateway;
     this.spaceService = spaceService;
   }
-  async execute(command33) {
-    if (command33.spaceId) {
+  async execute(command32) {
+    if (command32.spaceId) {
       const response = await this.packmindGateway.standards.list({
-        spaceId: command33.spaceId
+        spaceId: command32.spaceId
       });
-      return response.standards.map((s) => ({
-        ...s,
-        spaceId: command33.spaceId
-      }));
+      return response.standards;
     }
     const spaces = await this.spaceService.getSpaces();
     const results = await Promise.all(
       spaces.map(
-        (space) => this.packmindGateway.standards.list({ spaceId: space.id }).then(
-          (r) => r.standards.map((s) => ({ ...s, spaceId: space.id }))
-        )
+        (space) => this.packmindGateway.standards.list({ spaceId: space.id }).then((r) => r.standards)
       )
     );
     return results.flat();
@@ -11927,10 +11728,10 @@ var ListCommandsUseCase = class {
     this.packmindGateway = packmindGateway;
     this.spaceService = spaceService;
   }
-  async execute(command33) {
-    if (command33.spaceId) {
+  async execute(command32) {
+    if (command32.spaceId) {
       const response = await this.packmindGateway.commands.list({
-        spaceId: command33.spaceId
+        spaceId: command32.spaceId
       });
       return response.recipes;
     }
@@ -11950,16 +11751,16 @@ var ListSkillsUseCase = class {
     this.packmindGateway = packmindGateway;
     this.spaceService = spaceService;
   }
-  async execute(command33) {
-    if (command33.spaceId) {
+  async execute(command32) {
+    if (command32.spaceId) {
       const skills = await this.packmindGateway.skills.list({
-        spaceId: command33.spaceId
+        spaceId: command32.spaceId
       });
       return skills.map((s) => ({
         slug: s.slug,
         name: s.name,
         description: s.description,
-        spaceId: command33.spaceId
+        spaceId: s.spaceId
       }));
     }
     const spaces = await this.spaceService.getSpaces();
@@ -11990,7 +11791,7 @@ function normalizeLineEndings(content) {
 }
 
 // apps/cli/src/infra/utils/binaryDetection.ts
-var path14 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   // Images
   ".png",
@@ -12048,7 +11849,7 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".sqlite3"
 ]);
 function isBinaryExtension(filePath) {
-  const ext = path14.extname(filePath).toLowerCase();
+  const ext = path13.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 }
 function isBinaryBuffer(buffer) {
@@ -12068,7 +11869,11 @@ function normalizePath3(filePath) {
 }
 var MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
 var MAX_FILE_SIZE_MB = 10;
-var BLACKLIST_PATTERNS = ["**/.DS_Store"];
+var BLACKLIST_PATTERNS = [
+  "**/.DS_Store",
+  "**/node_modules",
+  "**/node_modules/**"
+];
 function isBlacklisted(relativePath) {
   const normalizedPath = relativePath.replace(/\\/g, "/");
   return BLACKLIST_PATTERNS.some(
@@ -12124,8 +11929,8 @@ var UploadSkillUseCase = class {
   constructor(deps) {
     this.deps = deps;
   }
-  async execute(command33) {
-    const files = await readSkillDirectory(command33.skillPath);
+  async execute(command32) {
+    const files = await readSkillDirectory(command32.skillPath);
     if (!files.find((f) => f.relativePath === "SKILL.md")) {
       throw new Error("SKILL.md not found in skill directory");
     }
@@ -12139,7 +11944,7 @@ var UploadSkillUseCase = class {
     if (totalSize > 10 * 1024 * 1024) {
       throw new Error(`Skill size (${totalSize} bytes) exceeds 10MB limit`);
     }
-    const space = await this.getSpace(command33.spaceSlug);
+    const space = await this.getSpace(command32.spaceSlug);
     const payload = {
       files: files.map((f) => ({
         path: f.relativePath,
@@ -12151,7 +11956,7 @@ var UploadSkillUseCase = class {
     const uploadSkillResponse = await this.deps.gateway.skills.upload({
       spaceId: createSpaceId(space.id),
       files: payload.files,
-      originSkill: command33.originSkill
+      originSkill: command32.originSkill
     });
     return {
       skillId: uploadSkillResponse.skill.id,
@@ -12190,17 +11995,17 @@ ${spaceList}`
 
 // apps/cli/src/application/useCases/diffStrategies/CommandDiffStrategy.ts
 var import_diff2 = require("diff");
-var fs13 = __toESM(require("fs/promises"));
-var path16 = __toESM(require("path"));
+var fs12 = __toESM(require("fs/promises"));
+var path15 = __toESM(require("path"));
 var CommandDiffStrategy = class {
   supports(file) {
     return file.artifactType === "command";
   }
   async diff(file, baseDirectory) {
-    const fullPath = path16.join(baseDirectory, file.path);
+    const fullPath = path15.join(baseDirectory, file.path);
     let localContent;
     try {
-      localContent = await fs13.readFile(fullPath, "utf-8");
+      localContent = await fs12.readFile(fullPath, "utf-8");
     } catch {
       return [];
     }
@@ -12230,8 +12035,8 @@ var CommandDiffStrategy = class {
 
 // apps/cli/src/application/useCases/diffStrategies/SkillDiffStrategy.ts
 var import_diff3 = require("diff");
-var fs14 = __toESM(require("fs/promises"));
-var path17 = __toESM(require("path"));
+var fs13 = __toESM(require("fs/promises"));
+var path16 = __toESM(require("path"));
 
 // apps/cli/src/application/utils/stripFrontmatter.ts
 var FRONTMATTER_DELIMITER2 = "---";
@@ -12266,7 +12071,7 @@ var SkillDiffStrategy = class {
   async diffNewFiles(skillFolders, serverFiles, baseDirectory) {
     const diffs = [];
     for (const folder of skillFolders) {
-      const folderPath = path17.join(baseDirectory, folder);
+      const folderPath = path16.join(baseDirectory, folder);
       const localFiles = await this.listFilesRecursively(folderPath);
       const serverPathsInFolder = new Set(
         serverFiles.filter((f) => f.path.startsWith(folder + "/")).map((f) => f.path)
@@ -12285,7 +12090,7 @@ var SkillDiffStrategy = class {
         if (serverPathsInFolder.has(filePath)) {
           continue;
         }
-        const fullPath = path17.join(baseDirectory, filePath);
+        const fullPath = path16.join(baseDirectory, filePath);
         const localRead = await this.tryReadFileBinaryAware(fullPath);
         if (localRead === null) {
           continue;
@@ -12312,7 +12117,7 @@ var SkillDiffStrategy = class {
     return diffs;
   }
   async diffSkillMd(file, baseDirectory) {
-    const fullPath = path17.join(baseDirectory, file.path);
+    const fullPath = path16.join(baseDirectory, file.path);
     const localContent = await this.tryReadFile(fullPath);
     if (localContent === null) {
       return [];
@@ -12369,7 +12174,7 @@ var SkillDiffStrategy = class {
       return [];
     }
     const skillFileId = createSkillFileId(file.skillFileId);
-    const fullPath = path17.join(baseDirectory, file.path);
+    const fullPath = path16.join(baseDirectory, file.path);
     const localRead = await this.tryReadFileBinaryAware(fullPath);
     const fileRelativePath = this.computeRelativePath(file.path, skillFolders);
     if (localRead === null) {
@@ -12579,14 +12384,14 @@ var SkillDiffStrategy = class {
   }
   async tryReadFile(filePath) {
     try {
-      return await fs14.readFile(filePath, "utf-8");
+      return await fs13.readFile(filePath, "utf-8");
     } catch {
       return null;
     }
   }
   async tryReadFileBinaryAware(filePath) {
     try {
-      const buffer = await fs14.readFile(filePath);
+      const buffer = await fs13.readFile(filePath);
       if (isBinaryFile(filePath, buffer)) {
         return { content: buffer.toString("base64"), isBase64: true };
       }
@@ -12598,13 +12403,13 @@ var SkillDiffStrategy = class {
   async listFilesRecursively(dirPath, prefix = "") {
     let entries;
     try {
-      entries = await fs14.readdir(dirPath);
+      entries = await fs13.readdir(dirPath);
     } catch {
       return [];
     }
     const files = [];
     for (const entry of entries) {
-      const fullPath = path17.join(dirPath, entry);
+      const fullPath = path16.join(dirPath, entry);
       const stat9 = await this.tryStatFile(fullPath);
       if (!stat9) {
         continue;
@@ -12624,7 +12429,7 @@ var SkillDiffStrategy = class {
   }
   async tryStatFile(filePath) {
     try {
-      const stat9 = await fs14.stat(filePath);
+      const stat9 = await fs13.stat(filePath);
       return { isDirectory: stat9.isDirectory() };
     } catch {
       return null;
@@ -12632,7 +12437,7 @@ var SkillDiffStrategy = class {
   }
   async tryGetPermissions(filePath) {
     try {
-      const stat9 = await fs14.stat(filePath);
+      const stat9 = await fs13.stat(filePath);
       return modeToPermissionStringOrDefault(stat9.mode);
     } catch {
       return null;
@@ -12648,8 +12453,8 @@ var SkillDiffStrategy = class {
 };
 
 // apps/cli/src/application/useCases/diffStrategies/StandardDiffStrategy.ts
-var fs15 = __toESM(require("fs/promises"));
-var path18 = __toESM(require("path"));
+var fs14 = __toESM(require("fs/promises"));
+var path17 = __toESM(require("path"));
 
 // apps/cli/src/application/utils/parseStandardMd.ts
 var DEPLOYER_PARSERS = [
@@ -12957,10 +12762,10 @@ var StandardDiffStrategy = class {
     return file.artifactType === "standard";
   }
   async diff(file, baseDirectory) {
-    const fullPath = path18.join(baseDirectory, file.path);
+    const fullPath = path17.join(baseDirectory, file.path);
     let localContent;
     try {
-      localContent = await fs15.readFile(fullPath, "utf-8");
+      localContent = await fs14.readFile(fullPath, "utf-8");
     } catch {
       return [];
     }
@@ -13084,9 +12889,9 @@ var DiffArtefactsUseCase = class {
       new StandardDiffStrategy()
     ];
   }
-  async execute(command33) {
-    const baseDirectory = command33.baseDirectory || process.cwd();
-    const response = await this.fetchContent(command33, baseDirectory);
+  async execute(command32) {
+    const baseDirectory = command32.baseDirectory || process.cwd();
+    const response = await this.fetchContent(command32, baseDirectory);
     const filteredFiles = response.fileUpdates.createOrUpdate.filter(
       (file) => file.path !== "packmind.json"
     );
@@ -13099,7 +12904,7 @@ var DiffArtefactsUseCase = class {
     );
     const prefixedSkillFolders = this.prefixSkillFolders(
       response.skillFolders,
-      command33.relativePath
+      command32.relativePath
     );
     const diffs = [];
     for (const file of diffableFiles) {
@@ -13126,7 +12931,7 @@ var DiffArtefactsUseCase = class {
       targetId: response.targetId ? createTargetId(response.targetId) : void 0
     }));
   }
-  async fetchContent(command33, baseDirectory) {
+  async fetchContent(command32, baseDirectory) {
     const lockFile = await this.lockFileRepository.read(baseDirectory);
     if (lockFile) {
       try {
@@ -13146,11 +12951,11 @@ var DiffArtefactsUseCase = class {
       }
     }
     return this.packmindGateway.deployment.getDeployed({
-      packagesSlugs: command33.packagesSlugs,
-      gitRemoteUrl: command33.gitRemoteUrl,
-      gitBranch: command33.gitBranch,
-      relativePath: command33.relativePath,
-      agents: command33.agents
+      packagesSlugs: command32.packagesSlugs,
+      gitRemoteUrl: command32.gitRemoteUrl,
+      gitBranch: command32.gitBranch,
+      relativePath: command32.relativePath,
+      agents: command32.agents
     });
   }
   prefixSkillFolders(skillFolders, relativePath) {
@@ -13174,8 +12979,8 @@ var SubmitDiffsUseCase = class {
   constructor(packmindGateway) {
     this.packmindGateway = packmindGateway;
   }
-  async execute(command33) {
-    const { groupedDiffs, message } = command33;
+  async execute(command32) {
+    const { groupedDiffs, message } = command32;
     const skipped = [];
     const validDiffs = [];
     for (const group of groupedDiffs) {
@@ -13250,8 +13055,8 @@ var CheckDiffsUseCase = class {
   constructor(packmindGateway) {
     this.packmindGateway = packmindGateway;
   }
-  async execute(command33) {
-    const { groupedDiffs } = command33;
+  async execute(command32) {
+    const { groupedDiffs } = command32;
     const results = [];
     const validDiffs = [];
     const invalidDiffs = [];
@@ -13332,13 +13137,151 @@ var SpaceService = class {
   }
 };
 
+// apps/cli/src/infra/repositories/CliOutput.ts
+init_source();
+var import_log_update = __toESM(require("log-update"));
+var CLI_PREFIX2 = "packmind-cli";
+var CliFormatter = class {
+  static success(message) {
+    return `${source_default.bgGreen.bold(CLI_PREFIX2)} ${source_default.green.bold(message)}`;
+  }
+  static info(message) {
+    return `${source_default.bgBlue.bold(CLI_PREFIX2)} ${source_default.blue(message)}`;
+  }
+  static warning(message) {
+    return `${source_default.bgYellow.bold(CLI_PREFIX2)} ${source_default.yellow.bold(message)}`;
+  }
+  static error(message) {
+    return `${source_default.bgRed.bold(CLI_PREFIX2)} ${source_default.red(message)}`;
+  }
+  static command(command32) {
+    return source_default.yellow(command32);
+  }
+  static loader(text) {
+    return source_default.dim.italic(text);
+  }
+  static header(title) {
+    return source_default.bold.underline(title);
+  }
+  static subHeader(title) {
+    return source_default.bold(title);
+  }
+  static slug(slug3) {
+    return source_default.blue.bold(slug3);
+  }
+  static label(label) {
+    return source_default.dim(label);
+  }
+};
+var CliOutput = class {
+  constructor(logger2 = console) {
+    this.logger = logger2;
+  }
+  notifySuccess(message, help) {
+    this.notifyMessage(
+      CliFormatter.success(message),
+      (msg) => this.logger.log(msg),
+      help
+    );
+  }
+  notifyInfo(message, help) {
+    this.notifyMessage(
+      CliFormatter.info(message),
+      (msg) => this.logger.log(msg),
+      help
+    );
+  }
+  notifyWarning(message, help) {
+    this.notifyMessage(
+      CliFormatter.warning(message),
+      (msg) => this.logger.warn(msg),
+      help
+    );
+  }
+  notifyError(message, help) {
+    this.notifyMessage(
+      CliFormatter.error(message),
+      (msg) => this.logger.error(msg),
+      help
+    );
+  }
+  showLoader(message) {
+    this.logger.log(CliFormatter.loader(message));
+  }
+  async withLoader(message, loader) {
+    (0, import_log_update.default)(CliFormatter.loader(message));
+    try {
+      return loader();
+    } finally {
+      import_log_update.default.clear();
+    }
+  }
+  showArtefact(artefact, help) {
+    this.logger.log(CliFormatter.label(artefact.slug));
+    this.logger.log(CliFormatter.header(artefact.title));
+    if (artefact.url) {
+      this.logger.log(CliFormatter.label(artefact.url));
+    }
+    this.logger.log("");
+    if (artefact.description) {
+      this.logger.log(artefact.description);
+    }
+    this.logger.log("");
+    this.displayHelp((msg) => this.logger.log(msg), help);
+  }
+  listArtefacts(title, artefacts, help) {
+    this.logger.log(CliFormatter.header(title));
+    this.logger.log("");
+    this.displayList(artefacts);
+    this.displayHelp((msg) => this.logger.log(msg), help);
+  }
+  listScopedArtefacts(title, scopedArtefacts, help) {
+    this.logger.log(CliFormatter.header(title));
+    this.logger.log("");
+    for (const { title: title2, artefacts } of scopedArtefacts) {
+      this.logger.log(CliFormatter.subHeader(title2));
+      this.logger.log("");
+      this.displayList(artefacts);
+    }
+    this.displayHelp((msg) => this.logger.log(msg), help);
+  }
+  notifyMessage(message, output, help) {
+    output(message);
+    this.displayHelp(output, help);
+  }
+  displayList(artefacts) {
+    for (const artefact of artefacts) {
+      this.logger.log(`- ${CliFormatter.label(artefact.slug)}`);
+      this.logger.log(` Name: ${CliFormatter.header(artefact.title)}`);
+      if (artefact.url) {
+        this.logger.log(` ${CliFormatter.label(artefact.url)}`);
+      }
+      this.logger.log("");
+    }
+  }
+  displayHelp(output, help) {
+    if (help) {
+      output(help.content);
+      if (help.exampleCommand) {
+        output(`
+  Example: ${CliFormatter.command(help.exampleCommand)}`);
+      }
+      if (help.command) {
+        output(`
+  ${CliFormatter.command(help.command)}`);
+      }
+    }
+  }
+};
+
 // apps/cli/src/PackmindCliHexaFactory.ts
 var PackmindCliHexaFactory = class {
   constructor() {
     this.repositories = {
       packmindGateway: new PackmindGateway(loadApiKey()),
       configFileRepository: new ConfigFileRepository(),
-      lockFileRepository: new LockFileRepository()
+      lockFileRepository: new LockFileRepository(),
+      output: new CliOutput()
     };
     this.services = {
       listFiles: new ListFiles(),
@@ -13388,10 +13331,6 @@ var PackmindCliHexaFactory = class {
       logout: new LogoutUseCase(),
       whoami: new WhoamiUseCase(),
       checkCliVersion: new CheckCliVersionUseCase(),
-      setupMcp: new SetupMcpUseCase({
-        gateway: this.repositories.packmindGateway,
-        mcpConfigService: new McpConfigService()
-      }),
       listStandards: new ListStandardsUseCase(
         this.repositories.packmindGateway,
         this.services.spaceService
@@ -13422,14 +13361,14 @@ var PackmindCliHexaFactory = class {
 var origin8 = "PackmindCliHexa";
 var PackmindCliHexa = class {
   constructor(logger2 = new PackmindLogger(origin8)) {
-    this.notifyDistribution = async (command33) => {
+    this.notifyDistribution = async (command32) => {
       return this.hexa.repositories.packmindGateway.deployment.notifyDistribution(
-        command33
+        command32
       );
     };
-    this.notifyArtefactsDistribution = async (command33) => {
+    this.notifyArtefactsDistribution = async (command32) => {
       return this.hexa.repositories.packmindGateway.deployment.notifyArtefactsDistribution(
-        command33
+        command32
       );
     };
     this.logger = logger2;
@@ -13449,29 +13388,32 @@ var PackmindCliHexa = class {
     this.logger.info("Destroying PackmindCliHexa");
     this.logger.info("PackmindCliHexa destroyed");
   }
-  async getGitRemoteUrl(command33) {
-    return this.hexa.useCases.getGitRemoteUrl.execute(command33);
+  get output() {
+    return this.hexa.repositories.output;
+  }
+  async getGitRemoteUrl(command32) {
+    return this.hexa.useCases.getGitRemoteUrl.execute(command32);
   }
-  async listFilesInDirectory(command33) {
-    return this.hexa.useCases.listFilesInDirectoryUseCase.execute(command33);
+  async listFilesInDirectory(command32) {
+    return this.hexa.useCases.listFilesInDirectoryUseCase.execute(command32);
   }
-  async lintFilesAgainstRule(command33) {
-    return this.hexa.useCases.lintFilesAgainstRule.execute(command33);
+  async lintFilesAgainstRule(command32) {
+    return this.hexa.useCases.lintFilesAgainstRule.execute(command32);
   }
-  async lintFilesFromConfig(command33) {
-    return this.hexa.useCases.lintFilesFromConfig.execute(command33);
+  async lintFilesFromConfig(command32) {
+    return this.hexa.useCases.lintFilesFromConfig.execute(command32);
   }
-  async installPackages(command33) {
-    return this.hexa.useCases.installPackages.execute(command33);
+  async installPackages(command32) {
+    return this.hexa.useCases.installPackages.execute(command32);
   }
-  async install(command33) {
-    return this.hexa.useCases.install.execute(command33);
+  async install(command32) {
+    return this.hexa.useCases.install.execute(command32);
   }
-  async uninstall(command33) {
-    return this.hexa.useCases.uninstall.execute(command33);
+  async uninstall(command32) {
+    return this.hexa.useCases.uninstall.execute(command32);
   }
-  async diffArtefacts(command33) {
-    return this.hexa.useCases.diffArtefacts.execute(command33);
+  async diffArtefacts(command32) {
+    return this.hexa.useCases.diffArtefacts.execute(command32);
   }
   async submitDiffs(groupedDiffs, message) {
     return this.hexa.useCases.submitDiffs.execute({ groupedDiffs, message });
@@ -13479,20 +13421,20 @@ var PackmindCliHexa = class {
   async checkDiffs(groupedDiffs) {
     return this.hexa.useCases.checkDiffs.execute({ groupedDiffs });
   }
-  async listPackages(command33) {
-    return this.hexa.useCases.listPackages.execute(command33);
+  async listPackages(command32) {
+    return this.hexa.useCases.listPackages.execute(command32);
   }
-  async getPackageBySlug(command33) {
-    return this.hexa.useCases.getPackageBySlug.execute(command33);
+  async getPackageBySlug(command32) {
+    return this.hexa.useCases.getPackageBySlug.execute(command32);
   }
-  async listStandards(command33) {
-    return this.hexa.useCases.listStandards.execute(command33);
+  async listStandards(command32) {
+    return this.hexa.useCases.listStandards.execute(command32);
   }
-  async listCommands(command33) {
-    return this.hexa.useCases.listCommands.execute(command33);
+  async listCommands(command32) {
+    return this.hexa.useCases.listCommands.execute(command32);
   }
-  async listSkills(command33) {
-    return this.hexa.useCases.listSkills.execute(command33);
+  async listSkills(command32) {
+    return this.hexa.useCases.listSkills.execute(command32);
   }
   async configExists(baseDirectory) {
     return await this.hexa.repositories.configFileRepository.configExists(
@@ -13579,20 +13521,17 @@ var PackmindCliHexa = class {
       directory
     );
   }
-  async login(command33) {
-    return this.hexa.useCases.login.execute(command33);
+  async login(command32) {
+    return this.hexa.useCases.login.execute(command32);
   }
-  async logout(command33) {
-    return this.hexa.useCases.logout.execute(command33);
+  async logout(command32) {
+    return this.hexa.useCases.logout.execute(command32);
   }
-  async whoami(command33) {
-    return this.hexa.useCases.whoami.execute(command33);
+  async whoami(command32) {
+    return this.hexa.useCases.whoami.execute(command32);
   }
-  async checkCliVersion(command33) {
-    return this.hexa.useCases.checkCliVersion.execute(command33);
-  }
-  async setupMcp(command33) {
-    return this.hexa.useCases.setupMcp.execute(command33);
+  async checkCliVersion(command32) {
+    return this.hexa.useCases.checkCliVersion.execute(command32);
   }
   getCurrentBranch(repoPath) {
     return this.hexa.services.gitRemoteUrlService.getCurrentBranch(repoPath).branch;
@@ -13600,11 +13539,11 @@ var PackmindCliHexa = class {
   getGitRemoteUrlFromPath(repoPath) {
     return this.hexa.services.gitRemoteUrlService.getGitRemoteUrl(repoPath).gitRemoteUrl;
   }
-  async uploadSkill(command33) {
-    return this.hexa.useCases.uploadSkill.execute(command33);
+  async uploadSkill(command32) {
+    return this.hexa.useCases.uploadSkill.execute(command32);
   }
-  async installDefaultSkills(command33) {
-    return this.hexa.useCases.installDefaultSkills.execute(command33);
+  async installDefaultSkills(command32) {
+    return this.hexa.useCases.installDefaultSkills.execute(command32);
   }
   getPackmindGateway() {
     return this.hexa.repositories.packmindGateway;
@@ -13728,31 +13667,31 @@ var HumanReadableLogger = class {
 var pathModule2 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/lintHandler.ts
-var fs17 = __toESM(require("fs/promises"));
+var fs16 = __toESM(require("fs/promises"));
 var pathModule = __toESM(require("path"));
 
 // apps/cli/src/application/services/PackmindIgnoreReader.ts
-var fs16 = __toESM(require("fs/promises"));
-var path19 = __toESM(require("path"));
+var fs15 = __toESM(require("fs/promises"));
+var path18 = __toESM(require("path"));
 var IGNORE_FILENAME = ".packmindignore";
 var PackmindIgnoreReader = class {
   async readIgnorePatterns(startDirectory, stopDirectory) {
     const patterns = [];
-    const normalizedStart = path19.resolve(startDirectory);
-    const normalizedStop = stopDirectory ? path19.resolve(stopDirectory) : null;
+    const normalizedStart = path18.resolve(startDirectory);
+    const normalizedStop = stopDirectory ? path18.resolve(stopDirectory) : null;
     if (normalizedStop === null) {
-      const ignoreFile = path19.join(normalizedStart, IGNORE_FILENAME);
+      const ignoreFile = path18.join(normalizedStart, IGNORE_FILENAME);
       return this.parseIgnoreFile(ignoreFile);
     }
     let currentDir = normalizedStart;
     while (true) {
-      const ignoreFile = path19.join(currentDir, IGNORE_FILENAME);
+      const ignoreFile = path18.join(currentDir, IGNORE_FILENAME);
       const filePatterns = await this.parseIgnoreFile(ignoreFile);
       patterns.push(...filePatterns);
       if (currentDir === normalizedStop) {
         break;
       }
-      const parentDir = path19.dirname(currentDir);
+      const parentDir = path18.dirname(currentDir);
       if (parentDir === currentDir) {
         break;
       }
@@ -13763,7 +13702,7 @@ var PackmindIgnoreReader = class {
   async parseIgnoreFile(filePath) {
     let content;
     try {
-      content = await fs16.readFile(filePath, "utf-8");
+      content = await fs15.readFile(filePath, "utf-8");
     } catch (err) {
       if (err.code === "ENOENT") {
         return [];
@@ -13784,7 +13723,7 @@ function isNotLoggedInError(error) {
 }
 async function lintHandler(args2, deps) {
   const {
-    path: path37,
+    path: path35,
     draft,
     rule,
     language,
@@ -13806,11 +13745,11 @@ async function lintHandler(args2, deps) {
     throw new Error("option --rule is required to use --draft mode");
   }
   const startedAt = Date.now();
-  const targetPath = path37 ?? ".";
+  const targetPath = path35 ?? ".";
   const absolutePath = resolvePath(targetPath);
   let stats;
   try {
-    stats = await fs17.stat(absolutePath);
+    stats = await fs16.stat(absolutePath);
   } catch (err) {
     const isNotFound = err.code === "ENOENT";
     const message = isNotFound ? `File or directory "${absolutePath}" does not exist` : `Cannot access "${absolutePath}": ${err.message}`;
@@ -14128,13 +14067,13 @@ function extractWasmFiles() {
 
 // apps/cli/src/main.ts
 var import_dotenv = require("dotenv");
-var fs28 = __toESM(require("fs"));
-var path36 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var path34 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/InstallCommand.ts
 var import_cmd_ts2 = __toESM(require_cjs());
-var path20 = __toESM(require("path"));
-var fs18 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
 
 // apps/cli/src/infra/commands/installPackagesHandler.ts
 function formatOverviewRow(configPath, packages, pathColumnWidth) {
@@ -14211,18 +14150,19 @@ ${uniqueCount} unique ${packageWord} currently installed.`);
 }
 
 // apps/cli/src/infra/commands/InstallCommand.ts
+var { version: CLI_VERSION } = require_package();
 function findSubDirectoriesWithPackmindJson(dirPath, recursive) {
   const result = [];
   let entries;
   try {
-    entries = fs18.readdirSync(dirPath, { withFileTypes: true });
+    entries = fs17.readdirSync(dirPath, { withFileTypes: true });
   } catch {
     return result;
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const subDir = path20.join(dirPath, entry.name);
-    if (fs18.existsSync(path20.join(subDir, "packmind.json"))) {
+    const subDir = path19.join(dirPath, entry.name);
+    if (fs17.existsSync(path19.join(subDir, "packmind.json"))) {
       result.push(subDir);
     }
     if (recursive) {
@@ -14299,8 +14239,8 @@ async function notifyArtefactsDistributionIfInGitRepo(params) {
   try {
     const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(dir);
     if (!gitRoot) return;
-    const lockFilePath = path20.join(dir, "packmind-lock.json");
-    const content = fs18.readFileSync(lockFilePath, "utf-8");
+    const lockFilePath = path19.join(dir, "packmind-lock.json");
+    const content = fs17.readFileSync(lockFilePath, "utf-8");
     const packmindLockFile = JSON.parse(content);
     const gitRemoteUrl = packmindCliHexa.getGitRemoteUrlFromPath(gitRoot);
     const gitBranch = packmindCliHexa.getCurrentBranch(gitRoot);
@@ -14320,6 +14260,34 @@ async function notifyArtefactsDistributionIfInGitRepo(params) {
   } catch {
   }
 }
+async function installDefaultSkillsIfAtGitRoot(params) {
+  const { packmindCliHexa, cwd } = params;
+  const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
+  if (!gitRoot || cwd !== gitRoot) {
+    return;
+  }
+  try {
+    logConsole("\nInstalling default skills...");
+    const skillsResult = await packmindCliHexa.installDefaultSkills({
+      cliVersion: CLI_VERSION,
+      baseDirectory: cwd
+    });
+    if (skillsResult.errors.length > 0) {
+      skillsResult.errors.forEach((err) => {
+        logWarningConsole(`Warning: ${err}`);
+      });
+    }
+    const totalSkillFiles = skillsResult.filesCreated + skillsResult.filesUpdated;
+    if (totalSkillFiles > 0) {
+      logConsole(
+        `Default skills: added ${skillsResult.filesCreated} files, changed ${skillsResult.filesUpdated} files`
+      );
+    } else if (skillsResult.errors.length === 0) {
+      logConsole("Default skills are already up to date");
+    }
+  } catch {
+  }
+}
 async function installHandler({
   installPath,
   packages,
@@ -14351,14 +14319,14 @@ async function installHandler({
     logConsole(`Use ${formatCommand(showCommand)} instead.`);
     process.exit(1);
   }
-  const cwd = installPath ? path20.resolve(process.cwd(), installPath) : process.cwd();
+  const cwd = installPath ? path19.resolve(process.cwd(), installPath) : process.cwd();
   if (installPath) {
-    if (!fs18.existsSync(cwd)) {
+    if (!fs17.existsSync(cwd)) {
       logErrorConsole(`Path does not exist: ${cwd}`);
       process.exit(1);
       return;
     }
-    if (!fs18.statSync(cwd).isDirectory()) {
+    if (!fs17.statSync(cwd).isDirectory()) {
       logErrorConsole(`Path is not a directory: ${cwd}`);
       process.exit(1);
       return;
@@ -14371,7 +14339,7 @@ async function installHandler({
     targetDirs = [cwd];
   } else {
     targetDirs = [];
-    if (fs18.existsSync(path20.join(cwd, "packmind.json"))) {
+    if (fs17.existsSync(path19.join(cwd, "packmind.json"))) {
       targetDirs.push(cwd);
     }
     targetDirs.push(...findSubDirectoriesWithPackmindJson(cwd, true));
@@ -14412,6 +14380,7 @@ async function installHandler({
     logWarningConsole(warning);
   }
   logConsole(buildInstallSummary(combined));
+  await installDefaultSkillsIfAtGitRoot({ packmindCliHexa, cwd });
   const allErrors = [...combined.errors, ...thrownErrors];
   if (allErrors.length > 0) {
     logWarningConsole(`Encountered ${allErrors.length} error(s):`);
@@ -14627,7 +14596,7 @@ function displayVersionNotice(result) {
 }
 
 // apps/cli/src/infra/commands/WhoamiCommand.ts
-var { version: CLI_VERSION } = require_package();
+var { version: CLI_VERSION2 } = require_package();
 function formatExpiresAt(expiresAt) {
   const now = /* @__PURE__ */ new Date();
   if (expiresAt < now) {
@@ -14671,7 +14640,7 @@ var whoamiCommand = (0, import_cmd_ts6.command)({
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
     const versionCheckPromise = packmindCliHexa.checkCliVersion({
-      currentVersion: CLI_VERSION
+      currentVersion: CLI_VERSION2
     });
     const result = await packmindCliHexa.whoami({});
     if (!result.isAuthenticated) {
@@ -14699,308 +14668,65 @@ Credentials are loaded from (in order of priority):`);
   }
 });
 
-// apps/cli/src/infra/commands/SetupMcpCommand.ts
-var import_cmd_ts7 = __toESM(require_cjs());
-var fs20 = __toESM(require("fs"));
-var readline2 = __toESM(require("readline"));
-var inquirer = __toESM(require("inquirer"));
+// apps/cli/src/infra/commands/SkillsCommand.ts
+var import_cmd_ts11 = __toESM(require_cjs());
 
-// apps/cli/src/application/services/AgentDetectionService.ts
-var fs19 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
-var os4 = __toESM(require("os"));
-var import_child_process4 = require("child_process");
-var AgentDetectionService = class {
-  constructor(projectDir = process.cwd()) {
-    this.projectDir = projectDir;
-  }
-  detectAgents() {
-    const agents = [];
-    if (this.isClaudeAvailable()) {
-      agents.push({ type: "claude", name: "Claude Code" });
-    }
-    if (this.isCursorAvailable()) {
-      agents.push({ type: "cursor", name: "Cursor" });
-    }
-    if (this.isVSCodeAvailable()) {
-      agents.push({ type: "vscode", name: "VS Code" });
-    }
-    if (this.isContinueAvailable()) {
-      agents.push({ type: "continue", name: "Continue.dev" });
-    }
-    return agents;
-  }
-  isClaudeAvailable() {
-    return this.isCommandAvailable("claude");
-  }
-  isCursorAvailable() {
-    const cursorConfigDir = path21.join(os4.homedir(), ".cursor");
-    return fs19.existsSync(cursorConfigDir);
-  }
-  isVSCodeAvailable() {
-    const vscodeDir = path21.join(this.projectDir, ".vscode");
-    return fs19.existsSync(vscodeDir);
-  }
-  isContinueAvailable() {
-    const continueDir = path21.join(this.projectDir, ".continue");
-    return fs19.existsSync(continueDir);
-  }
-  isCommandAvailable(command33) {
-    try {
-      const whichCommand = process.platform === "win32" ? "where" : "which";
-      (0, import_child_process4.execSync)(`${whichCommand} ${command33}`, { stdio: "pipe" });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
+// apps/cli/src/infra/commands/skills/AddSkillCommand.ts
+var import_cmd_ts8 = __toESM(require_cjs());
 
-// apps/cli/src/infra/commands/customParameters/AgentArgType.ts
-var VALID_AGENTS = Object.keys(CodingAgents).filter(
-  (a) => a !== "packmind"
-);
-var agentArgToType = {
-  copilot: "vscode",
-  cursor: "cursor",
-  claude: "claude",
-  continue: "continue"
-};
-var AgentArgType = {
+// apps/cli/src/infra/commands/sharedOptions.ts
+var import_cmd_ts7 = __toESM(require_cjs());
+var originSkillOption = (0, import_cmd_ts7.option)({
+  long: "origin-skill",
+  description: "Name of the skill that triggered this command",
+  type: (0, import_cmd_ts7.optional)(import_cmd_ts7.string)
+});
+
+// apps/cli/src/infra/commands/customParameters/SpaceSlug.ts
+var SpaceSlug = {
   from: async (input) => {
-    const normalized = input.toLowerCase();
-    if (VALID_AGENTS.includes(normalized)) {
-      return normalized;
-    }
-    throw new Error(
-      `Invalid agent '${input}'. Valid options are: ${VALID_AGENTS.join(", ")}`
-    );
+    return input.startsWith("@") ? input.slice(1) : input;
   }
 };
 
-// apps/cli/src/infra/commands/SetupMcpCommand.ts
-var ALL_AGENTS2 = [
-  { type: "claude", name: "Claude Code" },
-  { type: "cursor", name: "Cursor" },
-  { type: "vscode", name: "VS Code" },
-  { type: "continue", name: "Continue.dev" }
-];
-async function promptAgentsWithReadline(choices) {
-  const input = fs20.createReadStream("/dev/tty");
-  const output = fs20.createWriteStream("/dev/tty");
-  const rl = readline2.createInterface({
-    input,
-    output
-  });
-  output.write("Select agents to configure:\n");
-  choices.forEach((choice, index) => {
-    const marker = choice.checked ? "*" : " ";
-    output.write(`  ${index + 1}. [${marker}] ${choice.name}
-`);
-  });
-  output.write("\n");
-  const preselected = choices.map((c, i) => c.checked ? i + 1 : null).filter((i) => i !== null);
-  const defaultValue = preselected.length > 0 ? preselected.join(",") : "1,2,3";
-  return new Promise((resolve15) => {
-    rl.question(
-      `Enter numbers separated by commas (default: ${defaultValue}): `,
-      (answer) => {
-        rl.close();
-        input.destroy();
-        output.destroy();
-        const trimmed = answer.trim();
-        const numbersStr = trimmed === "" ? defaultValue : trimmed;
-        const numbers = numbersStr.split(",").map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n) && n >= 1 && n <= choices.length);
-        const selectedAgents = numbers.map((n) => choices[n - 1].value);
-        resolve15(selectedAgents);
-      }
-    );
-  });
-}
-var setupMcpCommand = (0, import_cmd_ts7.command)({
-  name: "setup-mcp",
-  description: "Configure MCP (Model Context Protocol) for AI coding agents",
-  args: {
-    targets: (0, import_cmd_ts7.multioption)({
-      type: (0, import_cmd_ts7.array)(AgentArgType),
-      long: "target",
-      short: "t",
-      description: "Target agent(s) to configure (copilot, cursor, claude, or continue). Can be specified multiple times. If omitted, interactive mode is used."
-    })
-  },
-  handler: async ({ targets }) => {
-    const credentials = loadCredentials();
-    if (!credentials) {
-      logErrorConsole("Not authenticated");
-      logConsole("\nNo credentials found. You can authenticate by either:");
-      logConsole("  1. Running `packmind-cli login`");
-      logConsole("  2. Setting PACKMIND_API_KEY_V3 environment variable");
-      logConsole(`
-Credentials are loaded from (in order of priority):`);
-      logConsole(`  1. PACKMIND_API_KEY_V3 environment variable`);
-      logConsole(`  2. ${getCredentialsPath()}`);
-      process.exit(1);
-    }
-    if (credentials.isExpired) {
-      logErrorConsole("Credentials expired");
-      logConsole("\nRun `packmind-cli login` to re-authenticate.");
-      process.exit(1);
-    }
-    const agentDetectionService = new AgentDetectionService();
-    let selectedAgents;
-    if (targets.length > 0) {
-      selectedAgents = targets.map((t) => agentArgToType[t]).filter((a) => a !== void 0);
-    } else {
-      logConsole("\nDetecting installed AI agents...\n");
-      const detectedAgents = agentDetectionService.detectAgents();
-      if (detectedAgents.length > 0) {
-        logConsole("Found agents:");
-        detectedAgents.forEach((detectedAgent) => {
-          logConsole(`  - ${detectedAgent.name}`);
-        });
-        logConsole("");
-      } else {
-        logConsole("No supported agents detected.\n");
-      }
-      const detectedTypes = new Set(detectedAgents.map((a) => a.type));
-      const choices = ALL_AGENTS2.map((agentInfo) => ({
-        name: agentInfo.name,
-        value: agentInfo.type,
-        checked: detectedTypes.has(agentInfo.type)
-      }));
-      let promptedAgents;
-      const useSimplePrompt = process.env.PACKMIND_SIMPLE_PROMPT === "1" || !process.stdin.isTTY;
-      if (useSimplePrompt) {
-        promptedAgents = await promptAgentsWithReadline(choices);
-      } else {
-        const result2 = await inquirer.default.prompt([
-          {
-            type: "checkbox",
-            name: "selectedAgents",
-            message: "Select agents to configure (use space to select):",
-            choices
-          }
-        ]);
-        promptedAgents = result2.selectedAgents;
-      }
-      if (promptedAgents.length === 0) {
-        logConsole("\nNo agents selected. Exiting.");
-        process.exit(0);
-      }
-      selectedAgents = promptedAgents;
-    }
-    logConsole("\nFetching MCP configuration...\n");
-    const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
-    const packmindCliHexa = new PackmindCliHexa(packmindLogger);
-    let result;
-    try {
-      result = await packmindCliHexa.setupMcp({ agentTypes: selectedAgents });
-    } catch (error) {
-      logErrorConsole("Failed to fetch MCP configuration from server.");
-      if (error instanceof Error) {
-        logConsole(`  ${error.message}`);
-      }
-      process.exit(1);
-    }
-    let successCount = 0;
-    const failedAgents = [];
-    for (const agentResult of result.results) {
-      logConsole(`Installing MCP for ${agentResult.agentName}...`);
-      if (agentResult.success) {
-        logSuccessConsole(`  ${agentResult.agentName} configured successfully`);
-        successCount++;
-      } else {
-        logErrorConsole(`  Failed to configure ${agentResult.agentName}`);
-        failedAgents.push({
-          name: agentResult.agentName,
-          error: agentResult.error || ""
-        });
-      }
-    }
-    logConsole("");
-    if (failedAgents.length > 0) {
-      for (const failed of failedAgents) {
-        logWarningConsole(`Failed to configure ${failed.name}:`);
-        logConsole(`
-  Error: ${failed.error}`);
-        if (failed.error.includes("ENOENT") || failed.error.includes("not found") || failed.error.includes("command not found")) {
-          logConsole(
-            `
-  Hint: Make sure the agent CLI is installed and available in your PATH.`
-          );
-        }
-        logConsole(`
-  Manual configuration:`);
-        logConsole(result.manualConfigJson ?? "undefined");
-        logConsole("");
-      }
-    }
-    if (successCount > 0) {
-      const agentWord = successCount === 1 ? "agent" : "agents";
-      logConsole(
-        formatBold(`Done! MCP configured for ${successCount} ${agentWord}.`)
-      );
-    }
-    if (failedAgents.length > 0) {
-      process.exit(1);
-    }
-  }
-});
-
-// apps/cli/src/infra/commands/SkillsCommand.ts
-var import_cmd_ts12 = __toESM(require_cjs());
-
 // apps/cli/src/infra/commands/skills/AddSkillCommand.ts
-var import_cmd_ts9 = __toESM(require_cjs());
-
-// apps/cli/src/infra/commands/sharedOptions.ts
-var import_cmd_ts8 = __toESM(require_cjs());
-var originSkillOption = (0, import_cmd_ts8.option)({
-  long: "origin-skill",
-  description: "Name of the skill that triggered this command",
-  type: (0, import_cmd_ts8.optional)(import_cmd_ts8.string)
-});
-
-// apps/cli/src/infra/commands/customParameters/SpaceSlug.ts
-var SpaceSlug = {
-  from: async (input) => {
-    return input.startsWith("@") ? input.slice(1) : input;
-  }
-};
-
-// apps/cli/src/infra/commands/skills/AddSkillCommand.ts
-var addSkillCommand = (0, import_cmd_ts9.command)({
+var addSkillCommand = (0, import_cmd_ts8.command)({
   name: "add",
   description: "[Deprecated] Add a skill from a local directory to a Packmind organization",
   args: {
-    skillPath: (0, import_cmd_ts9.positional)({
-      type: import_cmd_ts9.string,
+    skillPath: (0, import_cmd_ts8.positional)({
+      type: import_cmd_ts8.string,
       displayName: "path",
       description: "Path to skill directory containing SKILL.md"
     }),
-    space: (0, import_cmd_ts9.option)({
+    space: (0, import_cmd_ts8.option)({
       long: "space",
       description: "Slug of the space in which to add the skill (with or without leading @)",
-      type: (0, import_cmd_ts9.optional)(SpaceSlug)
+      type: (0, import_cmd_ts8.optional)(SpaceSlug)
     }),
     originSkill: originSkillOption
   },
   handler: async () => {
-    logErrorConsole('Command "packmind-cli skills add" has been removed.');
-    logConsole(
-      `Use ${formatCommand("packmind-cli playbook add <path>")} instead.`
+    const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
+    const packmindCliHexa = new PackmindCliHexa(packmindLogger);
+    packmindCliHexa.output.notifyError(
+      'Command "packmind-cli skills add" has been removed.',
+      {
+        content: 'Use the "playbook add" command instead:',
+        exampleCommand: "packmind-cli playbook add .packmind/commands/my-command.md"
+      }
     );
     process.exit(1);
   }
 });
 
 // apps/cli/src/infra/commands/skills/InstallDefaultSkillsCommand.ts
-var import_cmd_ts10 = __toESM(require_cjs());
-var readline3 = __toESM(require("readline"));
+var import_cmd_ts9 = __toESM(require_cjs());
+var readline2 = __toESM(require("readline"));
 
 // apps/cli/src/infra/commands/skills/incompatibleSkillsHandler.ts
-var fs21 = __toESM(require("fs/promises"));
-var path22 = __toESM(require("path"));
+var fs18 = __toESM(require("fs/promises"));
+var path20 = __toESM(require("path"));
 async function handleIncompatibleInstalledSkills(skills, baseDirectory, confirm) {
   const skillNames = skills.map((s) => s.skillName).join(", ");
   logWarningConsole(
@@ -15013,10 +14739,10 @@ async function handleIncompatibleInstalledSkills(skills, baseDirectory, confirm)
     return;
   }
   for (const skill of skills) {
-    const skillRootDirs = skill.filePaths.filter((p) => path22.basename(p) === "SKILL.md").map((p) => path22.dirname(p));
+    const skillRootDirs = skill.filePaths.filter((p) => path20.basename(p) === "SKILL.md").map((p) => path20.dirname(p));
     for (const dir of skillRootDirs) {
       try {
-        await fs21.rm(path22.join(baseDirectory, dir), {
+        await fs18.rm(path20.join(baseDirectory, dir), {
           recursive: true,
           force: true
         });
@@ -15029,7 +14755,7 @@ async function handleIncompatibleInstalledSkills(skills, baseDirectory, confirm)
     for (const relativePath of skill.filePaths) {
       if (!skillRootDirs.some((dir) => relativePath.startsWith(dir + "/"))) {
         try {
-          await fs21.unlink(path22.join(baseDirectory, relativePath));
+          await fs18.unlink(path20.join(baseDirectory, relativePath));
         } catch (error) {
           logErrorConsole(
             `Failed to delete "${relativePath}": ${error instanceof Error ? error.message : String(error)}`
@@ -15042,12 +14768,12 @@ async function handleIncompatibleInstalledSkills(skills, baseDirectory, confirm)
 }
 
 // apps/cli/src/infra/commands/skills/InstallDefaultSkillsCommand.ts
-var { version: CLI_VERSION2 } = require_package();
-var installDefaultSkillsCommand = (0, import_cmd_ts10.command)({
+var { version: CLI_VERSION3 } = require_package();
+var installDefaultSkillsCommand = (0, import_cmd_ts9.command)({
   name: "install-default",
   description: "Install default Packmind skills for configured coding agents",
   args: {
-    includeBeta: (0, import_cmd_ts10.flag)({
+    includeBeta: (0, import_cmd_ts9.flag)({
       long: "include-beta",
       description: "Include unreleased/beta skills"
     })
@@ -15060,7 +14786,7 @@ var installDefaultSkillsCommand = (0, import_cmd_ts10.command)({
       const baseDirectory = process.cwd();
       const result = await packmindCliHexa.installDefaultSkills({
         includeBeta,
-        cliVersion: includeBeta ? void 0 : CLI_VERSION2,
+        cliVersion: includeBeta ? void 0 : CLI_VERSION3,
         baseDirectory
       });
       if (result.skippedSkillsCount > 0) {
@@ -15068,13 +14794,6 @@ var installDefaultSkillsCommand = (0, import_cmd_ts10.command)({
           `${result.skippedSkillsCount} skill(s) were skipped because they require a newer version of packmind-cli. Run "${formatCommand("packmind-cli update")}" to get the latest version.`
         );
       }
-      if (result.skippedIncompatibleSkillNames.length > 0) {
-        for (const skillName of result.skippedIncompatibleSkillNames) {
-          logWarningConsole(
-            `Skill "${skillName}" was not installed because it is not compatible with this version of packmind-cli.`
-          );
-        }
-      }
       if (result.incompatibleInstalledSkills.length > 0) {
         await handleIncompatibleInstalledSkillsWithPrompt(
           result.incompatibleInstalledSkills,
@@ -15117,7 +14836,7 @@ async function handleIncompatibleInstalledSkillsWithPrompt(skills, baseDirectory
   );
 }
 async function promptConfirmation(question) {
-  const rl = readline3.createInterface({
+  const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout
   });
@@ -15130,7 +14849,7 @@ async function promptConfirmation(question) {
 }
 
 // apps/cli/src/infra/commands/ListSkillsCommand.ts
-var import_cmd_ts11 = __toESM(require_cjs());
+var import_cmd_ts10 = __toESM(require_cjs());
 
 // apps/cli/src/infra/utils/spaceFilterUtils.ts
 function resolveSpaceFromArgs(spaceArg, spaces) {
@@ -15149,104 +14868,89 @@ function resolveUrlBuilder(buildArtifactPath) {
   return (spaceSlug, artifactId) => `${decoded.host}/org/${orgSlug}/space/${spaceSlug}/${buildArtifactPath(artifactId)}`;
 }
 
-// apps/cli/src/infra/commands/skills/listSkillsHandler.ts
-function groupSkillsBySpace(skills, spaces) {
-  const spaceMap = new Map(
+// apps/cli/src/infra/utils/groupArtefactsBySpaces.ts
+function groupArtefactBySpaces(artefacts, spaces) {
+  const spacesById = new Map(
     spaces.map((s) => [s.id, s])
   );
-  const groupsMap = /* @__PURE__ */ new Map();
-  const orphaned = [];
-  for (const skill of skills) {
-    const space = spaceMap.get(skill.spaceId);
-    if (!space) {
-      orphaned.push(skill);
-      continue;
-    }
-    let group = groupsMap.get(space.id);
-    if (!group) {
-      group = { space, items: [] };
-      groupsMap.set(space.id, group);
-    }
-    group.items.push(skill);
-  }
-  const groups = [...groupsMap.values()].sort(
-    (a, b) => a.space.name.localeCompare(b.space.name)
-  );
-  return { groups, orphaned };
-}
-function displayGroupedSkills(skills, spaces, buildUrl) {
-  const { groups, orphaned } = groupSkillsBySpace(skills, spaces);
-  for (const { space, items } of groups) {
-    logConsole(`Space "${space.name}":
-`);
-    for (const skill of [...items].sort(
-      (a, b) => a.slug.localeCompare(b.slug)
-    )) {
-      logConsole(`  ${formatSlug(skill.slug)}`);
-      logConsole(`  ${formatLabel("Name:")}  ${skill.name}`);
-      if (skill.description) {
-        const descriptionLines = skill.description.trim().split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-        const firstLine = descriptionLines[0];
-        if (firstLine) {
-          const truncated = firstLine.length > 80 ? firstLine.slice(0, 77) + "..." : firstLine;
-          logConsole(`  ${formatLabel("Desc:")}  ${truncated}`);
-        }
-      }
-      const url = buildUrl(space.slug, skill.slug);
-      if (url) {
-        logConsole(`  ${formatLabel("Link:")}  ${url}`);
-      }
-      logConsole("");
+  const groupedArtefacts = artefacts.reduce((acc, artefact) => {
+    const space = spacesById.get(artefact.spaceId);
+    if (space) {
+      const group = acc.get(artefact.spaceId) ?? { space, artefacts: [] };
+      acc.set(artefact.spaceId, {
+        space,
+        artefacts: [...group.artefacts, artefact]
+      });
     }
-  }
-  for (const skill of [...orphaned].sort(
-    (a, b) => a.slug.localeCompare(b.slug)
-  )) {
-    logConsole(`  ${formatSlug(skill.slug)}`);
-    logConsole(`  ${formatLabel("Name:")}  ${skill.name}`);
-    logConsole("");
-  }
+    return acc;
+  }, /* @__PURE__ */ new Map());
+  return [...groupedArtefacts.values()].map(({ space, artefacts: artefacts2 }) => ({
+    space,
+    artefacts: [...artefacts2].sort((a, b) => a.slug.localeCompare(b.slug))
+  })).sort((a, b) => a.space.name.localeCompare(b.space.name));
 }
+
+// apps/cli/src/infra/commands/skills/listSkillsHandler.ts
 async function listSkillsHandler(args2, deps) {
   const { packmindCliHexa, exit } = deps;
   try {
-    logConsole("Fetching skills...\n");
-    const spaces = await packmindCliHexa.getSpaces();
+    const spaces = await packmindCliHexa.output.withLoader(
+      "Fetching spaces",
+      () => packmindCliHexa.getSpaces()
+    );
     const matchedSpace = resolveSpaceFromArgs(args2.space, spaces);
     if (args2.space && !matchedSpace) {
-      logErrorConsole(`Space "@${args2.space}" not found.`);
+      const availableSpaces = spaces.map((s) => ` - @${s.slug}`).join("\n");
+      packmindCliHexa.output.notifyError(`Space "@${args2.space}" not found.`, {
+        content: `Available spaces:
+${availableSpaces}`
+      });
       exit(1);
       return;
     }
-    const skills = await packmindCliHexa.listSkills(
-      matchedSpace ? { spaceId: matchedSpace.id } : {}
+    const skills = await packmindCliHexa.output.withLoader(
+      "Fetching skills",
+      () => packmindCliHexa.listSkills(
+        matchedSpace ? { spaceId: matchedSpace.id } : {}
+      )
     );
     if (skills.length === 0) {
-      logConsole(
+      packmindCliHexa.output.notifyInfo(
         matchedSpace ? `No skills found in space "@${matchedSpace.slug}".` : "No skills found."
       );
       exit(0);
       return;
     }
-    logConsole(formatHeader(`\u{1F4CB} Skills (${skills.length})
-`));
     const buildUrl = resolveUrlBuilder((slug3) => `skills/${slug3}/files`);
-    displayGroupedSkills(skills, spaces, buildUrl);
+    const groups = groupArtefactBySpaces(skills, spaces);
+    packmindCliHexa.output.listScopedArtefacts(
+      `\u{1F4CB} Skills (${skills.length})`,
+      groups.map(({ space, artefacts }) => ({
+        title: `Space: ${space.name}`,
+        artefacts: artefacts.map((skill) => ({
+          title: skill.name,
+          slug: skill.slug,
+          description: skill.description ?? void 0,
+          url: buildUrl(space.slug, skill.slug)
+        }))
+      }))
+    );
     exit(0);
   } catch (err) {
-    logErrorConsole("Failed to list skills:");
-    logErrorConsole(err instanceof Error ? err.message : String(err));
+    packmindCliHexa.output.notifyError("Failed to list skills:", {
+      content: err instanceof Error ? err.message : String(err)
+    });
     exit(1);
   }
 }
 
 // apps/cli/src/infra/commands/ListSkillsCommand.ts
-var listSkillsCommand = (0, import_cmd_ts11.command)({
+var listSkillsCommand = (0, import_cmd_ts10.command)({
   name: "list",
   description: "List available skills",
   args: {
-    space: (0, import_cmd_ts11.option)({
-      type: (0, import_cmd_ts11.optional)(SpaceSlug),
+    space: (0, import_cmd_ts10.option)({
+      type: (0, import_cmd_ts10.optional)(SpaceSlug),
       long: "space",
       description: "Filter skills by space slug"
     })
@@ -15265,7 +14969,7 @@ var listSkillsCommand = (0, import_cmd_ts11.command)({
 });
 
 // apps/cli/src/infra/commands/SkillsCommand.ts
-var skillsCommand = (0, import_cmd_ts12.subcommands)({
+var skillsCommand = (0, import_cmd_ts11.subcommands)({
   name: "skills",
   description: "Manage skills in your Packmind organization",
   cmds: {
@@ -15276,138 +14980,104 @@ var skillsCommand = (0, import_cmd_ts12.subcommands)({
 });
 
 // apps/cli/src/infra/commands/StandardsCommand.ts
-var import_cmd_ts15 = __toESM(require_cjs());
+var import_cmd_ts14 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/CreateStandardCommand.ts
-var import_cmd_ts13 = __toESM(require_cjs());
-var createStandardCommand = (0, import_cmd_ts13.command)({
+var import_cmd_ts12 = __toESM(require_cjs());
+var createStandardCommand = (0, import_cmd_ts12.command)({
   name: "create",
   description: "[Deprecated] Create a coding standard from a playbook JSON file or stdin",
   args: {
-    file: (0, import_cmd_ts13.positional)({
+    file: (0, import_cmd_ts12.positional)({
       displayName: "file",
       description: "Path to the playbook JSON file (reads from stdin if omitted)",
-      type: (0, import_cmd_ts13.optional)(import_cmd_ts13.string)
+      type: (0, import_cmd_ts12.optional)(import_cmd_ts12.string)
     }),
-    space: (0, import_cmd_ts13.option)({
+    space: (0, import_cmd_ts12.option)({
       long: "space",
       description: "Slug of the space in which to create the standard (with or without leading @)",
-      type: (0, import_cmd_ts13.optional)(SpaceSlug)
+      type: (0, import_cmd_ts12.optional)(SpaceSlug)
     }),
     originSkill: originSkillOption
   },
   handler: async () => {
-    logErrorConsole(
-      'Command "packmind-cli standards create" has been removed.'
-    );
-    logConsole(
-      `Use ${formatCommand("packmind-cli playbook add <path>")} instead.`
+    const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
+    const packmindCliHexa = new PackmindCliHexa(packmindLogger);
+    packmindCliHexa.output.notifyError(
+      'Command "packmind-cli standards create" has been removed.',
+      {
+        content: 'Use the "playbook add" command instead:',
+        exampleCommand: "packmind-cli playbook add .packmind/standards/my-standard.md"
+      }
     );
     process.exit(1);
   }
 });
 
 // apps/cli/src/infra/commands/ListStandardsCommand.ts
-var import_cmd_ts14 = __toESM(require_cjs());
+var import_cmd_ts13 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/standards/listStandardsHandler.ts
-function groupStandardsBySpace(standards, spaces) {
-  const spaceMap = new Map(
-    spaces.map((s) => [s.id, s])
-  );
-  const groupsMap = /* @__PURE__ */ new Map();
-  const orphaned = [];
-  for (const standard of standards) {
-    const space = spaceMap.get(standard.spaceId);
-    if (!space) {
-      orphaned.push(standard);
-      continue;
-    }
-    let group = groupsMap.get(space.id);
-    if (!group) {
-      group = { space, items: [] };
-      groupsMap.set(space.id, group);
-    }
-    group.items.push(standard);
-  }
-  const groups = [...groupsMap.values()].sort(
-    (a, b) => a.space.name.localeCompare(b.space.name)
-  );
-  return { groups, orphaned };
-}
-function displayGroupedStandards(standards, spaces, buildUrl) {
-  const { groups, orphaned } = groupStandardsBySpace(standards, spaces);
-  for (const { space, items } of groups) {
-    logConsole(`Space "${space.name}":
-`);
-    for (const standard of [...items].sort(
-      (a, b) => a.slug.localeCompare(b.slug)
-    )) {
-      logConsole(`  ${formatSlug(standard.slug)}`);
-      logConsole(`  ${formatLabel("Name:")}  ${standard.name}`);
-      if (standard.description) {
-        const descriptionLines = standard.description.trim().split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-        const firstLine = descriptionLines[0];
-        if (firstLine) {
-          const truncated = firstLine.length > 80 ? firstLine.slice(0, 77) + "..." : firstLine;
-          logConsole(`  ${formatLabel("Desc:")}  ${truncated}`);
-        }
-      }
-      const url = buildUrl(space.slug, standard.id);
-      if (url) {
-        logConsole(`  ${formatLabel("Link:")}  ${url}`);
-      }
-      logConsole("");
-    }
-  }
-  for (const standard of [...orphaned].sort(
-    (a, b) => a.slug.localeCompare(b.slug)
-  )) {
-    logConsole(`  ${formatSlug(standard.slug)}`);
-    logConsole(`  ${formatLabel("Name:")}  ${standard.name}`);
-    logConsole("");
-  }
-}
 async function listStandardsHandler(args2, deps) {
   const { packmindCliHexa, exit } = deps;
   try {
-    logConsole("Fetching standards...\n");
-    const spaces = await packmindCliHexa.getSpaces();
+    const spaces = await packmindCliHexa.output.withLoader(
+      "Fetching spaces",
+      () => packmindCliHexa.getSpaces()
+    );
     const matchedSpace = resolveSpaceFromArgs(args2.space, spaces);
     if (args2.space && !matchedSpace) {
-      logErrorConsole(`Space "@${args2.space}" not found.`);
+      const availableSpaces = spaces.map((space) => ` - @${space.slug}`).join("\n");
+      packmindCliHexa.output.notifyError(`Space "@${args2.space}" not found.`, {
+        content: `Available spaces:
+${availableSpaces}`
+      });
       exit(1);
       return;
     }
-    const standards = await packmindCliHexa.listStandards(
-      matchedSpace ? { spaceId: matchedSpace.id } : {}
+    const standards = await packmindCliHexa.output.withLoader(
+      "Fetching standards",
+      () => packmindCliHexa.listStandards(
+        matchedSpace ? { spaceId: matchedSpace.id } : {}
+      )
     );
     if (standards.length === 0) {
-      logConsole(
+      packmindCliHexa.output.notifyInfo(
         matchedSpace ? `No standards found in space "@${matchedSpace.slug}".` : "No standards found."
       );
       exit(0);
       return;
     }
-    logConsole(formatHeader(`\u{1F4CB} Standards (${standards.length})
-`));
+    const groupedStandards = groupArtefactBySpaces(standards, spaces);
     const buildUrl = resolveUrlBuilder((id) => `standards/${id}/summary`);
-    displayGroupedStandards(standards, spaces, buildUrl);
+    const scopedArtefacts = groupedStandards.map(({ space, artefacts }) => ({
+      title: `Space: ${space.name}`,
+      artefacts: artefacts.map((s) => ({
+        title: s.name,
+        slug: s.slug,
+        url: buildUrl(space.slug, s.id)
+      }))
+    }));
+    packmindCliHexa.output.listScopedArtefacts(
+      `\u{1F4CB} Standards (${standards.length})`,
+      scopedArtefacts
+    );
     exit(0);
   } catch (err) {
-    logErrorConsole("Failed to list standards:");
-    logErrorConsole(err instanceof Error ? err.message : String(err));
+    packmindCliHexa.output.notifyError("Failed to list standards:", {
+      content: err instanceof Error ? err.message : String(err)
+    });
     exit(1);
   }
 }
 
 // apps/cli/src/infra/commands/ListStandardsCommand.ts
-var listStandardsCommand = (0, import_cmd_ts14.command)({
+var listStandardsCommand = (0, import_cmd_ts13.command)({
   name: "list",
   description: "List available coding standards",
   args: {
-    space: (0, import_cmd_ts14.option)({
-      type: (0, import_cmd_ts14.optional)(SpaceSlug),
+    space: (0, import_cmd_ts13.option)({
+      type: (0, import_cmd_ts13.optional)(SpaceSlug),
       long: "space",
       description: "Filter standards by space slug"
     })
@@ -15426,7 +15096,7 @@ var listStandardsCommand = (0, import_cmd_ts14.command)({
 });
 
 // apps/cli/src/infra/commands/StandardsCommand.ts
-var standardsCommand = (0, import_cmd_ts15.subcommands)({
+var standardsCommand = (0, import_cmd_ts14.subcommands)({
   name: "standards",
   description: "Manage coding standards",
   cmds: {
@@ -15436,130 +15106,103 @@ var standardsCommand = (0, import_cmd_ts15.subcommands)({
 });
 
 // apps/cli/src/infra/commands/CommandsCommand.ts
-var import_cmd_ts18 = __toESM(require_cjs());
+var import_cmd_ts17 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/CreateCommandCommand.ts
-var import_cmd_ts16 = __toESM(require_cjs());
-var createCommandCommand = (0, import_cmd_ts16.command)({
+var import_cmd_ts15 = __toESM(require_cjs());
+var createCommandCommand = (0, import_cmd_ts15.command)({
   name: "create",
   description: "[Deprecated] Create a command from a playbook JSON file or stdin",
   args: {
-    file: (0, import_cmd_ts16.positional)({
+    file: (0, import_cmd_ts15.positional)({
       displayName: "file",
       description: "Path to the command playbook JSON file (reads from stdin if omitted)",
-      type: (0, import_cmd_ts16.optional)(import_cmd_ts16.string)
+      type: (0, import_cmd_ts15.optional)(import_cmd_ts15.string)
     }),
-    space: (0, import_cmd_ts16.option)({
+    space: (0, import_cmd_ts15.option)({
       long: "space",
       description: "Slug of the space in which to create the command",
-      type: (0, import_cmd_ts16.optional)(SpaceSlug)
+      type: (0, import_cmd_ts15.optional)(SpaceSlug)
     }),
     originSkill: originSkillOption
   },
   handler: async () => {
-    logErrorConsole('Command "packmind-cli commands create" has been removed.');
-    logConsole(
-      `Use ${formatCommand("packmind-cli playbook add <path>")} instead.`
+    const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
+    const packmindCliHexa = new PackmindCliHexa(packmindLogger);
+    packmindCliHexa.output.notifyError(
+      'Command "packmind-cli commands create" has been removed.',
+      {
+        content: 'Use the "playbook add" command instead:',
+        exampleCommand: "packmind-cli playbook add .packmind/commands/my-command.md"
+      }
     );
     process.exit(1);
   }
 });
 
 // apps/cli/src/infra/commands/ListCommandsCommand.ts
-var import_cmd_ts17 = __toESM(require_cjs());
+var import_cmd_ts16 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/commands/listCommandsHandler.ts
-function groupCommandsBySpace(commands, spaces) {
-  const spaceMap = new Map(
-    spaces.map((s) => [s.id, s])
-  );
-  const groupsMap = /* @__PURE__ */ new Map();
-  const orphaned = [];
-  for (const cmd of commands) {
-    const space = spaceMap.get(cmd.spaceId);
-    if (!space) {
-      orphaned.push(cmd);
-      continue;
-    }
-    let group = groupsMap.get(space.id);
-    if (!group) {
-      group = { space, cmds: [] };
-      groupsMap.set(space.id, group);
-    }
-    group.cmds.push(cmd);
-  }
-  const groups = [...groupsMap.values()].sort(
-    (a, b) => a.space.name.localeCompare(b.space.name)
-  );
-  return { groups, orphaned };
-}
-function displayGroupedCommands(commands, spaces, buildUrl) {
-  const { groups, orphaned } = groupCommandsBySpace(commands, spaces);
-  for (const { space, cmds } of groups) {
-    logConsole(`Space "${space.name}":
-`);
-    for (const cmd of [...cmds].sort((a, b) => a.slug.localeCompare(b.slug))) {
-      logConsole(`  ${formatSlug(cmd.slug)}`);
-      logConsole(`  ${formatLabel("Name:")}  ${cmd.name}`);
-      const url = buildUrl(space.slug, cmd.id);
-      if (url) {
-        logConsole(`  ${formatLabel("Link:")}  ${url}`);
-      }
-      logConsole("");
-    }
-  }
-  for (const cmd of [...orphaned].sort(
-    (a, b) => a.slug.localeCompare(b.slug)
-  )) {
-    logConsole(`  ${formatSlug(cmd.slug)}`);
-    logConsole(`  ${formatLabel("Name:")}  ${cmd.name}`);
-    logConsole("");
-  }
-}
 async function listCommandsHandler(args2, deps) {
   const { packmindCliHexa, exit } = deps;
   try {
-    logConsole("Fetching commands...\n");
-    const spaces = await packmindCliHexa.getSpaces();
+    const spaces = await packmindCliHexa.output.withLoader(
+      "Fetching spaces",
+      () => packmindCliHexa.getSpaces()
+    );
     const matchedSpace = resolveSpaceFromArgs(args2.space, spaces);
     if (args2.space && !matchedSpace) {
-      logErrorConsole(`Space "@${args2.space}" not found.`);
+      const availableSpaces = spaces.map((space) => ` - @${space.slug}`).join("\n");
+      packmindCliHexa.output.notifyError(`Space "@${args2.space}" not found.`, {
+        content: `Available spaces:
+${availableSpaces}`
+      });
       exit(1);
       return;
     }
-    const commands = await packmindCliHexa.listCommands(
-      matchedSpace ? { spaceId: matchedSpace.id } : {}
+    const commands = await packmindCliHexa.output.withLoader(
+      "Fetching commands",
+      () => packmindCliHexa.listCommands(
+        matchedSpace ? { spaceId: matchedSpace.id } : {}
+      )
     );
     if (commands.length === 0) {
-      logConsole(
+      packmindCliHexa.output.notifyInfo(
         matchedSpace ? `No commands found in space "@${matchedSpace.slug}".` : "No commands found."
       );
       exit(0);
       return;
     }
-    logConsole(formatHeader(`\u{1F4CB} Commands (${commands.length})
-`));
+    const groupedCommands = groupArtefactBySpaces(commands, spaces);
     const buildUrl = resolveUrlBuilder((id) => `commands/${id}`);
-    displayGroupedCommands(commands, spaces, buildUrl);
+    packmindCliHexa.output.listScopedArtefacts(
+      `\u{1F4CB} Commands (${commands.length})`,
+      groupedCommands.map(({ space, artefacts }) => ({
+        title: `Space: ${space.name}`,
+        artefacts: artefacts.map((cmd) => ({
+          title: cmd.name,
+          slug: cmd.slug,
+          url: buildUrl(space.slug, cmd.id)
+        }))
+      }))
+    );
     exit(0);
   } catch (err) {
-    logErrorConsole("Failed to list commands:");
-    if (err instanceof Error) {
-      logErrorConsole(err.message);
-    } else {
-      logErrorConsole(String(err));
-    }
+    packmindCliHexa.output.notifyError("Failed to list commands:", {
+      content: err instanceof Error ? err.message : String(err)
+    });
     exit(1);
   }
 }
 
 // apps/cli/src/infra/commands/ListCommandsCommand.ts
-var listCommandsCommand = (0, import_cmd_ts17.command)({
+var listCommandsCommand = (0, import_cmd_ts16.command)({
   name: "list",
   description: "List available commands",
   args: {
-    space: (0, import_cmd_ts17.option)({
-      type: (0, import_cmd_ts17.optional)(SpaceSlug),
+    space: (0, import_cmd_ts16.option)({
+      type: (0, import_cmd_ts16.optional)(SpaceSlug),
       long: "space",
       description: "Filter commands by space slug"
     })
@@ -15576,7 +15219,7 @@ var listCommandsCommand = (0, import_cmd_ts17.command)({
 });
 
 // apps/cli/src/infra/commands/CommandsCommand.ts
-var commandsCommand = (0, import_cmd_ts18.subcommands)({
+var commandsCommand = (0, import_cmd_ts17.subcommands)({
   name: "commands",
   description: "Manage commands",
   cmds: {
@@ -15586,11 +15229,11 @@ var commandsCommand = (0, import_cmd_ts18.subcommands)({
 });
 
 // apps/cli/src/infra/commands/DiffCommand.ts
-var import_cmd_ts19 = __toESM(require_cjs());
+var import_cmd_ts18 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/diffArtefactsHandler.ts
 var nodePath = __toESM(require("path"));
-var fs22 = __toESM(require("fs/promises"));
+var fs19 = __toESM(require("fs/promises"));
 
 // apps/cli/src/infra/utils/diffFormatter.ts
 var import_diff4 = require("diff");
@@ -15889,7 +15532,7 @@ async function diffArtefactsHandler(deps) {
   const searchPath = nodePath.resolve(cwd, deps.path ?? ".");
   if (deps.path !== void 0) {
     try {
-      await fs22.stat(searchPath);
+      await fs19.stat(searchPath);
     } catch {
       logErrorConsole(`Path does not exist: ${searchPath}`);
       exit(1);
@@ -16019,37 +15662,37 @@ async function diffArtefactsHandler(deps) {
 }
 
 // apps/cli/src/infra/commands/DiffCommand.ts
-var diffCommand = (0, import_cmd_ts19.command)({
+var diffCommand = (0, import_cmd_ts18.command)({
   name: "diff",
   description: "[Deprecated] Use `playbook diff` commands instead. Run for migration guidance",
   args: {
-    submit: (0, import_cmd_ts19.flag)({
+    submit: (0, import_cmd_ts18.flag)({
       long: "submit",
       description: "Submit detected changes as change proposals"
     }),
-    includeSubmitted: (0, import_cmd_ts19.flag)({
+    includeSubmitted: (0, import_cmd_ts18.flag)({
       long: "include-submitted",
       description: "Include already submitted changes in the output"
     }),
-    message: (0, import_cmd_ts19.option)({
+    message: (0, import_cmd_ts18.option)({
       long: "message",
       short: "m",
       description: "Message describing the intent behind the changes (max 1024 chars)",
-      type: (0, import_cmd_ts19.optional)(import_cmd_ts19.string)
+      type: (0, import_cmd_ts18.optional)(import_cmd_ts18.string)
     }),
-    path: (0, import_cmd_ts19.option)({
+    path: (0, import_cmd_ts18.option)({
       long: "path",
       short: "p",
       description: "Path to analyze (relative to current directory)",
-      type: (0, import_cmd_ts19.optional)(import_cmd_ts19.string)
+      type: (0, import_cmd_ts18.optional)(import_cmd_ts18.string)
     }),
-    positionals: (0, import_cmd_ts19.restPositionals)({
-      type: import_cmd_ts19.string,
+    positionals: (0, import_cmd_ts18.restPositionals)({
+      type: import_cmd_ts18.string,
       displayName: "args",
       description: "Subcommand and arguments (e.g., add <path>, remove <path>)"
     })
   },
-  handler: async ({ submit, includeSubmitted, message, path: path37, positionals }) => {
+  handler: async ({ submit, includeSubmitted, message, path: path35, positionals }) => {
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
     if (submit) {
@@ -16065,7 +15708,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       process.exit(1);
     }
     if (positionals[0] === "add") {
-      const addFilePath = path37 && positionals[1] ? `${path37}/${positionals[1]}`.replace(/\/+/g, "/") : positionals[1];
+      const addFilePath = path35 && positionals[1] ? `${path35}/${positionals[1]}`.replace(/\/+/g, "/") : positionals[1];
       const addCommand = `packmind-cli playbook add ${addFilePath}`;
       logErrorConsole("Deprecated: `packmind-cli diff add` has been removed");
       logInfoConsole("Use the following command instead:");
@@ -16073,7 +15716,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       process.exit(1);
     }
     if (positionals[0] === "remove" || positionals[0] === "rm") {
-      const removeFilePath = path37 && positionals[1] ? `${path37}/${positionals[1]}`.replace(/\/+/g, "/") : positionals[1];
+      const removeFilePath = path35 && positionals[1] ? `${path35}/${positionals[1]}`.replace(/\/+/g, "/") : positionals[1];
       const removeCommand = `packmind-cli playbook remove ${removeFilePath}`;
       logErrorConsole(
         "Deprecated: `packmind-cli diff remove` has been removed"
@@ -16082,7 +15725,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       logInfoConsole(` ${formatCommand(removeCommand)}`);
       process.exit(1);
     }
-    const diffCommand3 = `packmind-cli playbook diff${includeSubmitted ? " --include-submitted" : ""}${path37 ? ` --path ${path37}` : ""}`;
+    const diffCommand3 = `packmind-cli playbook diff${includeSubmitted ? " --include-submitted" : ""}${path35 ? ` --path ${path35}` : ""}`;
     logErrorConsole("Deprecated: `packmind-cli diff` will be removed");
     logInfoConsole("Use the following command instead:");
     logInfoConsole(` ${formatCommand(diffCommand3)}`);
@@ -16092,16 +15735,16 @@ var diffCommand = (0, import_cmd_ts19.command)({
       getCwd: () => process.cwd(),
       log: console.log,
       includeSubmitted,
-      path: path37
+      path: path35
     });
   }
 });
 
 // apps/cli/src/infra/commands/PackagesCommand.ts
-var import_cmd_ts24 = __toESM(require_cjs());
+var import_cmd_ts23 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/CreatePackageCommand.ts
-var import_cmd_ts20 = __toESM(require_cjs());
+var import_cmd_ts19 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/packages/createPackageHandler.ts
 function toExpectedSlug(name) {
@@ -16158,15 +15801,15 @@ var CreatePackageUseCase = class {
     this.gateway = gateway;
     this.spaceService = spaceService;
   }
-  async execute(command33) {
-    const space = await this.getSpace(command33);
+  async execute(command32) {
+    const space = await this.getSpace(command32);
     const result = await this.gateway.packages.create({
       spaceId: space.id,
-      name: command33.name,
-      description: command33.description ?? "",
+      name: command32.name,
+      description: command32.description ?? "",
       recipeIds: [],
       standardIds: [],
-      originSkill: command33.originSkill
+      originSkill: command32.originSkill
     });
     return {
       packageId: result.package.id,
@@ -16175,12 +15818,12 @@ var CreatePackageUseCase = class {
       spaceSlug: space.slug
     };
   }
-  async getSpace(command33) {
+  async getSpace(command32) {
     const spaces = await this.spaceService.getSpaces();
-    if (command33.spaceSlug) {
-      const found = spaces.find((s) => s.slug === command33.spaceSlug);
+    if (command32.spaceSlug) {
+      const found = spaces.find((s) => s.slug === command32.spaceSlug);
       if (!found) {
-        throw new Error(`Space '${command33.spaceSlug}' not found.`);
+        throw new Error(`Space '${command32.spaceSlug}' not found.`);
       }
       return found;
     }
@@ -16198,25 +15841,25 @@ ${spaceList}`
 };
 
 // apps/cli/src/infra/commands/CreatePackageCommand.ts
-var createPackageCommand = (0, import_cmd_ts20.command)({
+var createPackageCommand = (0, import_cmd_ts19.command)({
   name: "create",
   description: "Create a new package",
   args: {
-    name: (0, import_cmd_ts20.positional)({
+    name: (0, import_cmd_ts19.positional)({
       displayName: "name",
       description: "Name of the package to create",
-      type: import_cmd_ts20.string
+      type: import_cmd_ts19.string
     }),
-    description: (0, import_cmd_ts20.option)({
+    description: (0, import_cmd_ts19.option)({
       long: "description",
       short: "d",
       description: "Description of the package (optional)",
-      type: (0, import_cmd_ts20.optional)(import_cmd_ts20.string)
+      type: (0, import_cmd_ts19.optional)(import_cmd_ts19.string)
     }),
-    space: (0, import_cmd_ts20.option)({
+    space: (0, import_cmd_ts19.option)({
       long: "space",
       description: "Slug of the space in which to create the package",
-      type: (0, import_cmd_ts20.optional)(SpaceSlug)
+      type: (0, import_cmd_ts19.optional)(SpaceSlug)
     }),
     originSkill: originSkillOption
   },
@@ -16270,7 +15913,7 @@ var createPackageCommand = (0, import_cmd_ts20.command)({
 });
 
 // apps/cli/src/infra/commands/AddToPackageCommand.ts
-var import_cmd_ts21 = __toESM(require_cjs());
+var import_cmd_ts20 = __toESM(require_cjs());
 
 // apps/cli/src/domain/errors/ItemNotFoundError.ts
 var ItemNotFoundError = class extends Error {
@@ -16290,8 +15933,8 @@ var AddToPackageUseCase = class {
     this.gateway = gateway;
     this.spaceService = spaceService;
   }
-  async execute(command33) {
-    const { packageSlug, spaceSlug, itemType, itemSlugs } = command33;
+  async execute(command32) {
+    const { packageSlug, spaceSlug, itemType, itemSlugs } = command32;
     const space = spaceSlug ? await this.resolveSpaceBySlug(spaceSlug) : await this.spaceService.getDefaultSpace();
     const packages = await this.gateway.packages.list({
       spaceId: space.id
@@ -16312,7 +15955,7 @@ var AddToPackageUseCase = class {
       standardIds: [],
       recipeIds: [],
       skillIds: [],
-      originSkill: command33.originSkill
+      originSkill: command32.originSkill
     };
     if (itemType === "standard") {
       addCommand.standardIds = ids.map(createStandardId);
@@ -16364,7 +16007,7 @@ var AddToPackageUseCase = class {
   }
   async findCommandBySlug(slug3, spaceId) {
     const commands = await this.gateway.commands.list({ spaceId });
-    return commands.recipes.find((command33) => command33.slug === slug3) ?? null;
+    return commands.recipes.find((command32) => command32.slug === slug3) ?? null;
   }
   async findSkillBySlug(slug3, spaceId) {
     const skills = await this.gateway.skills.list({ spaceId });
@@ -16450,11 +16093,11 @@ async function executeAddToPackage(pkgSlug, spaceSlug, itemType, itemSlugs, useC
     logErrorConsole(message);
     if (error instanceof ItemNotFoundError) {
       const spaceFlag = error.spaceSlug ? ` --space ${error.spaceSlug}` : "";
-      const command33 = formatCommand(
+      const command32 = formatCommand(
         `packmind-cli ${error.itemType}s list${spaceFlag}`
       );
       logInfoConsole(
-        `Run \`${command33}\` to display available ${error.itemType}s`
+        `Run \`${command32}\` to display available ${error.itemType}s`
       );
     }
     return { success: false, error: message };
@@ -16480,29 +16123,29 @@ async function addToPackageHandler(args2, deps) {
 }
 
 // apps/cli/src/infra/commands/AddToPackageCommand.ts
-var addToPackageCommand = (0, import_cmd_ts21.command)({
+var addToPackageCommand = (0, import_cmd_ts20.command)({
   name: "add",
   description: "Add standards, commands, or skills to a package",
   args: {
-    to: (0, import_cmd_ts21.option)({
+    to: (0, import_cmd_ts20.option)({
       long: "to",
       description: "Target package slug (use @space/package format when multiple spaces exist)",
-      type: import_cmd_ts21.string
+      type: import_cmd_ts20.string
     }),
-    standards: (0, import_cmd_ts21.multioption)({
+    standards: (0, import_cmd_ts20.multioption)({
       long: "standard",
       description: "Standard slug(s) to add",
-      type: (0, import_cmd_ts21.array)(import_cmd_ts21.string)
+      type: (0, import_cmd_ts20.array)(import_cmd_ts20.string)
     }),
-    commands: (0, import_cmd_ts21.multioption)({
+    commands: (0, import_cmd_ts20.multioption)({
       long: "command",
       description: "Command slug(s) to add",
-      type: (0, import_cmd_ts21.array)(import_cmd_ts21.string)
+      type: (0, import_cmd_ts20.array)(import_cmd_ts20.string)
     }),
-    skills: (0, import_cmd_ts21.multioption)({
+    skills: (0, import_cmd_ts20.multioption)({
       long: "skill",
       description: "Skill slug(s) to add",
-      type: (0, import_cmd_ts21.array)(import_cmd_ts21.string)
+      type: (0, import_cmd_ts20.array)(import_cmd_ts20.string)
     }),
     originSkill: originSkillOption
   },
@@ -16538,111 +16181,79 @@ var addToPackageCommand = (0, import_cmd_ts21.command)({
 });
 
 // apps/cli/src/infra/commands/listPackagesCommand.ts
-var import_cmd_ts22 = __toESM(require_cjs());
+var import_cmd_ts21 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/packages/listPackagesHandler.ts
-function logPackageEntry(pkg, fullSlug, spaceSlug, buildUrl) {
-  logConsole(`- ${formatSlug(fullSlug)}`);
-  logConsole(`    ${formatLabel("Name:")} ${pkg.name}`);
-  const url = buildUrl(spaceSlug, pkg.id);
-  if (url) {
-    logConsole(`    ${formatLabel("Link:")} ${url}`);
-  }
-  if (pkg.description) {
-    const lines = pkg.description.trim().split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
-    const [first, ...rest] = lines;
-    logConsole(`    ${formatLabel("Description:")} ${first}`);
-    rest.forEach((l) => logConsole(`                 ${l}`));
-  }
-}
-function groupPackagesBySpace(packages, spaces) {
-  const spaceMap = new Map(
-    spaces.map((s) => [s.id, s])
-  );
-  const groupsMap = /* @__PURE__ */ new Map();
-  for (const pkg of packages) {
-    const space = spaceMap.get(pkg.spaceId);
-    if (!space) {
-      continue;
-    }
-    let group = groupsMap.get(space.id);
-    if (!group) {
-      group = { space, pkgs: [] };
-      groupsMap.set(space.id, group);
-    }
-    group.pkgs.push(pkg);
-  }
-  return [...groupsMap.values()].sort(
-    (a, b) => a.space.name.localeCompare(b.space.name)
-  );
-}
-function displayGroupedPackages(packages, spaces, buildUrl) {
-  const groups = groupPackagesBySpace(packages, spaces);
-  let firstSlug = null;
-  for (const { space, pkgs } of groups) {
-    logConsole(`Space "${space.name}":
-`);
-    for (const pkg of [...pkgs].sort((a, b) => a.slug.localeCompare(b.slug))) {
-      const fullSlug = `@${space.slug}/${pkg.slug}`;
-      firstSlug ??= fullSlug;
-      logPackageEntry(pkg, fullSlug, space.slug, buildUrl);
-      logConsole("");
-    }
-  }
-  return firstSlug ?? formatSlug(packages[0].slug);
-}
 async function listPackagesHandler(args2, deps) {
   const { packmindCliHexa, exit } = deps;
   try {
-    logInfoConsole("Fetching available packages...");
-    const allSpaces = await packmindCliHexa.getSpaces();
+    const allSpaces = await packmindCliHexa.output.withLoader(
+      "Fetching spaces",
+      () => packmindCliHexa.getSpaces()
+    );
     if (!allSpaces || allSpaces.length === 0) {
       throw new Error("Unable to list organization spaces.");
     }
     const matchedSpace = resolveSpaceFromArgs(args2.space, allSpaces);
     if (args2.space && !matchedSpace) {
-      logErrorConsole(`Space "@${args2.space}" not found.`);
-      logInfoConsole(
-        `Available spaces: ${allSpaces.map((s) => `@${s.slug}`).join(", ")}`
-      );
+      const availableSpaces = allSpaces.map((s) => ` - @${s.slug}`).join("\n");
+      packmindCliHexa.output.notifyError(`Space "@${args2.space}" not found.`, {
+        content: `Available spaces:
+${availableSpaces}`
+      });
       exit(1);
       return;
     }
-    const packages = await packmindCliHexa.listPackages(
-      matchedSpace ? { spaceId: matchedSpace.id } : {}
+    const packages = await packmindCliHexa.output.withLoader(
+      "Fetching packages",
+      () => packmindCliHexa.listPackages(
+        matchedSpace ? { spaceId: matchedSpace.id } : {}
+      )
     );
     const spaces = matchedSpace ? [matchedSpace] : allSpaces;
     if (packages.length === 0) {
-      logConsole(
+      packmindCliHexa.output.notifyInfo(
         matchedSpace ? `No packages found in space "@${matchedSpace.slug}".` : "No packages found."
       );
       exit(0);
       return;
     }
     const buildUrl = resolveUrlBuilder((id) => `packages/${id}`);
-    logConsole("\nAvailable packages:\n");
-    const exampleSlug = displayGroupedPackages(packages, spaces, buildUrl);
-    logConsole("How to install a package:\n");
-    logConsole(`  ${formatCommand(`packmind-cli install ${exampleSlug}`)}`);
+    const groups = groupArtefactBySpaces(packages, spaces);
+    const scopedArtefacts = groups.map(({ space, artefacts }) => ({
+      title: `Space: ${space.name}`,
+      artefacts: artefacts.map((pkg) => ({
+        title: pkg.name,
+        slug: `@${space.slug}/${pkg.slug}`,
+        description: pkg.description,
+        url: buildUrl(space.slug, pkg.id)
+      }))
+    }));
+    const firstSlug = scopedArtefacts[0]?.artefacts[0]?.slug ?? `@${packages[0].slug}`;
+    packmindCliHexa.output.listScopedArtefacts(
+      `\u{1F4E6} Packages (${packages.length})`,
+      scopedArtefacts,
+      {
+        content: "How to install a package:",
+        exampleCommand: `packmind-cli install ${firstSlug}`
+      }
+    );
     exit(0);
   } catch (err) {
-    logErrorConsole("Failed to list packages:");
-    if (err instanceof Error) {
-      logErrorConsole(err.message);
-    } else {
-      logErrorConsole(String(err));
-    }
+    packmindCliHexa.output.notifyError("Failed to list packages:", {
+      content: err instanceof Error ? err.message : String(err)
+    });
     exit(1);
   }
 }
 
 // apps/cli/src/infra/commands/listPackagesCommand.ts
-var listPackagesCommand = (0, import_cmd_ts22.command)({
+var listPackagesCommand = (0, import_cmd_ts21.command)({
   name: "list",
   description: "List available packages",
   args: {
-    space: (0, import_cmd_ts22.option)({
-      type: (0, import_cmd_ts22.optional)(SpaceSlug),
+    space: (0, import_cmd_ts21.option)({
+      type: (0, import_cmd_ts21.optional)(SpaceSlug),
       long: "space",
       description: "Filter packages by space slug"
     })
@@ -16659,7 +16270,7 @@ var listPackagesCommand = (0, import_cmd_ts22.command)({
 });
 
 // apps/cli/src/infra/commands/packages/showPackageCommand.ts
-var import_cmd_ts23 = __toESM(require_cjs());
+var import_cmd_ts22 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/packages/showPackageHandler.ts
 function isNotFoundError(err) {
@@ -16778,12 +16389,12 @@ ${pkg.name} (${fullSlug}):
 }
 
 // apps/cli/src/infra/commands/packages/showPackageCommand.ts
-var showPackageCommand = (0, import_cmd_ts23.command)({
+var showPackageCommand = (0, import_cmd_ts22.command)({
   name: "show",
   description: "Show details of a specific package",
   args: {
-    slug: (0, import_cmd_ts23.positional)({
-      type: import_cmd_ts23.string,
+    slug: (0, import_cmd_ts22.positional)({
+      type: import_cmd_ts22.string,
       displayName: "package",
       description: "Package slug (e.g. backend or @my-space/backend)"
     })
@@ -16796,7 +16407,7 @@ var showPackageCommand = (0, import_cmd_ts23.command)({
 });
 
 // apps/cli/src/infra/commands/PackagesCommand.ts
-var packagesCommand = (0, import_cmd_ts24.subcommands)({
+var packagesCommand = (0, import_cmd_ts23.subcommands)({
   name: "packages",
   description: "Manage packages",
   cmds: {
@@ -16808,24 +16419,24 @@ var packagesCommand = (0, import_cmd_ts24.subcommands)({
 });
 
 // apps/cli/src/infra/commands/PlaybookCommand.ts
-var import_cmd_ts31 = __toESM(require_cjs());
+var import_cmd_ts30 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/AddCommand.ts
 var import_fs21 = require("fs");
-var import_cmd_ts25 = __toESM(require_cjs());
+var import_cmd_ts24 = __toESM(require_cjs());
 
 // apps/cli/src/infra/repositories/PlaybookLocalRepository.ts
 var crypto = __toESM(require("crypto"));
-var fs23 = __toESM(require("fs"));
-var os5 = __toESM(require("os"));
-var path23 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
+var os3 = __toESM(require("os"));
+var path21 = __toESM(require("path"));
 var yaml = __toESM(require("yaml"));
 var PlaybookLocalRepository = class {
   constructor(repoRoot) {
     const normalized = this.normalizeRepoRoot(repoRoot);
     const hash = crypto.createHash("md5").update(normalized).digest("hex");
-    this.storagePath = path23.join(
-      os5.homedir(),
+    this.storagePath = path21.join(
+      os3.homedir(),
       ".packmind",
       hash,
       "playbook.yaml"
@@ -16872,11 +16483,11 @@ var PlaybookLocalRepository = class {
     return normalized;
   }
   readYaml() {
-    if (!fs23.existsSync(this.storagePath)) {
+    if (!fs20.existsSync(this.storagePath)) {
       return { version: 1, changes: [] };
     }
     try {
-      const content = fs23.readFileSync(this.storagePath, "utf-8");
+      const content = fs20.readFileSync(this.storagePath, "utf-8");
       const parsed = yaml.parse(content);
       if (!parsed || !Array.isArray(parsed.changes)) {
         return { version: 1, changes: [] };
@@ -16890,20 +16501,20 @@ var PlaybookLocalRepository = class {
     }
   }
   writeYaml(data) {
-    const dir = path23.dirname(this.storagePath);
-    fs23.mkdirSync(dir, { recursive: true });
-    fs23.writeFileSync(this.storagePath, yaml.stringify(data), "utf-8");
+    const dir = path21.dirname(this.storagePath);
+    fs20.mkdirSync(dir, { recursive: true });
+    fs20.writeFileSync(this.storagePath, yaml.stringify(data), "utf-8");
   }
 };
 
 // apps/cli/src/infra/commands/playbook/addHandler.ts
-var fs24 = __toESM(require("fs"));
-var path27 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
+var path25 = __toESM(require("path"));
 var yaml2 = __toESM(require("yaml"));
 var import_slug = __toESM(require("slug"));
 
 // apps/cli/src/application/utils/parseCommandFile.ts
-var path24 = __toESM(require("path"));
+var path22 = __toESM(require("path"));
 var FRONTMATTER_DELIMITER3 = "---";
 function parseCommandFile(content, filePath) {
   content = normalizeLineEndings(content);
@@ -16959,7 +16570,7 @@ function stripYamlQuotes2(value) {
   return value;
 }
 function extractFilenameSlug(filePath) {
-  let basename4 = path24.basename(filePath);
+  let basename4 = path22.basename(filePath);
   if (basename4.endsWith(".prompt.md")) {
     basename4 = basename4.slice(0, -".prompt.md".length);
   } else if (basename4.endsWith(".md")) {
@@ -17126,7 +16737,7 @@ function parseSkillDirectory(files) {
 }
 
 // apps/cli/src/application/utils/findNearestConfigDir.ts
-var path25 = __toESM(require("path"));
+var path23 = __toESM(require("path"));
 async function findNearestConfigDir(startDir, packmindCliHexa) {
   let current = startDir;
   while (true) {
@@ -17134,7 +16745,7 @@ async function findNearestConfigDir(startDir, packmindCliHexa) {
     if (exists) {
       return current;
     }
-    const parent = path25.dirname(current);
+    const parent = path23.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -17143,7 +16754,7 @@ async function findNearestConfigDir(startDir, packmindCliHexa) {
 }
 
 // apps/cli/src/application/utils/resolveDeployedContext.ts
-var path26 = __toESM(require("path"));
+var path24 = __toESM(require("path"));
 async function resolveDeployedContext(packmindCliHexa, targetDir) {
   try {
     const space = await packmindCliHexa.getDefaultSpace();
@@ -17155,7 +16766,7 @@ async function resolveDeployedContext(packmindCliHexa, targetDir) {
     }
     const gitRemoteUrl = packmindCliHexa.getGitRemoteUrlFromPath(gitRoot);
     const gitBranch = packmindCliHexa.getCurrentBranch(gitRoot);
-    const rel = path26.relative(gitRoot, targetDir);
+    const rel = path24.relative(gitRoot, targetDir);
     const relativePath = rel.startsWith("..") ? "/" : rel ? `/${rel}/` : "/";
     const deployedContent = await packmindCliHexa.getPackmindGateway().deployment.getDeployed({
       packagesSlugs: configPackages,
@@ -17220,19 +16831,19 @@ async function fetchDeployedFiles(gateway, lockFile) {
 
 // apps/cli/src/infra/commands/playbook/addHandler.ts
 async function tryStageRemovedFromLockFile(resolvedPath, deps) {
-  const fileDir = path27.dirname(resolvedPath);
+  const fileDir = path25.dirname(resolvedPath);
   const targetDir = await findNearestConfigDir(fileDir, deps.packmindCliHexa);
   if (!targetDir) return false;
   const lockFile = await deps.lockFileRepository.read(targetDir);
   if (!lockFile) return false;
-  const normalizedPath = normalizePath2(path27.relative(targetDir, resolvedPath));
+  const normalizedPath = normalizePath2(path25.relative(targetDir, resolvedPath));
   const lockEntry = findLockFileEntryForPath(
     normalizedPath,
     lockFile.artifacts
   );
   if (!lockEntry) return false;
   const gitRoot = await deps.packmindCliHexa.tryGetGitRepositoryRoot(targetDir);
-  const configDir = gitRoot ? normalizePath2(path27.relative(gitRoot, targetDir)) : "";
+  const configDir = gitRoot ? normalizePath2(path25.relative(gitRoot, targetDir)) : "";
   const deployedContext = await resolveDeployedContext(
     deps.packmindCliHexa,
     targetDir
@@ -17264,22 +16875,22 @@ async function tryStageRemovedFromLockFile(resolvedPath, deps) {
 }
 function resolveSkillDirectoryRoot(absolutePath) {
   if (absolutePath.endsWith("SKILL.md")) {
-    return path27.dirname(absolutePath);
+    return path25.dirname(absolutePath);
   }
   try {
-    if (fs24.statSync(absolutePath).isDirectory()) {
+    if (fs21.statSync(absolutePath).isDirectory()) {
       return absolutePath;
     }
   } catch {
     return absolutePath;
   }
-  let current = path27.dirname(absolutePath);
-  const root = path27.parse(current).root;
+  let current = path25.dirname(absolutePath);
+  const root = path25.parse(current).root;
   while (current !== root) {
-    if (fs24.existsSync(path27.join(current, "SKILL.md"))) {
+    if (fs21.existsSync(path25.join(current, "SKILL.md"))) {
       return current;
     }
-    current = path27.dirname(current);
+    current = path25.dirname(current);
   }
   return absolutePath;
 }
@@ -17302,17 +16913,17 @@ async function playbookAddHandler(deps) {
     exit(1);
     return;
   }
-  const absolutePath = path27.resolve(cwd, filePath);
+  const absolutePath = path25.resolve(cwd, filePath);
   let artifactType;
   let codingAgent;
   const earlyTargetDir = await findNearestConfigDir(
-    path27.dirname(absolutePath),
+    path25.dirname(absolutePath),
     packmindCliHexa
   );
   const earlyLockFile = earlyTargetDir ? await lockFileRepository.read(earlyTargetDir) : null;
   if (earlyLockFile && earlyTargetDir) {
     const normalizedForLookup = normalizePath2(
-      path27.relative(earlyTargetDir, absolutePath)
+      path25.relative(earlyTargetDir, absolutePath)
     );
     const lockResult = findLockFileEntryAndFileForPath(
       normalizedForLookup,
@@ -17446,7 +17057,7 @@ Content goes here...`
     return;
   }
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(targetDir);
-  const configDir = gitRoot ? normalizePath2(path27.relative(gitRoot, targetDir)) : "";
+  const configDir = gitRoot ? normalizePath2(path25.relative(gitRoot, targetDir)) : "";
   const deployedContext = await resolveDeployedContext(
     packmindCliHexa,
     targetDir
@@ -17454,7 +17065,7 @@ Content goes here...`
   const targetId = deployedContext?.targetId ?? earlyLockFile?.targetId;
   const normalizedFilePath = (() => {
     const refPath = artifactType === "skill" && skillDirPath ? skillDirPath : absolutePath;
-    return normalizePath2(path27.relative(targetDir, refPath));
+    return normalizePath2(path25.relative(targetDir, refPath));
   })();
   let spaceId;
   let spaceName;
@@ -17569,7 +17180,7 @@ Run ${formatLabel("packmind-cli install")} to update before making changes.`
       );
       const allMatch = skillDeployedFiles.length > 0 && skillDeployedFiles.length === skillFiles.length && skillDeployedFiles.every((deployed) => {
         const localFile = skillFiles.find(
-          (f) => normalizePath2(path27.join(normalizedFilePath, f.relativePath)) === normalizePath2(deployed.path)
+          (f) => normalizePath2(path25.join(normalizedFilePath, f.relativePath)) === normalizePath2(deployed.path)
         );
         return localFile && deployed.content?.trim() === localFile.content.trim() && (!deployed.skillFilePermissions || deployed.skillFilePermissions === localFile.permissions);
       });
@@ -17639,17 +17250,17 @@ function formatSpaceList(spaces) {
 }
 
 // apps/cli/src/infra/commands/playbook/AddCommand.ts
-var addPlaybookCommand = (0, import_cmd_ts25.command)({
+var addPlaybookCommand = (0, import_cmd_ts24.command)({
   name: "add",
   description: "Stage a local artifact change",
   args: {
-    filePath: (0, import_cmd_ts25.positional)({
-      type: import_cmd_ts25.string,
+    filePath: (0, import_cmd_ts24.positional)({
+      type: import_cmd_ts24.string,
       displayName: "path",
       description: "Path to the artifact file or directory to stage"
     }),
-    space: (0, import_cmd_ts25.option)({
-      type: (0, import_cmd_ts25.optional)(SpaceSlug),
+    space: (0, import_cmd_ts24.option)({
+      type: (0, import_cmd_ts24.optional)(SpaceSlug),
       long: "space",
       description: "Target space slug"
     })
@@ -17678,11 +17289,11 @@ var addPlaybookCommand = (0, import_cmd_ts25.command)({
 });
 
 // apps/cli/src/infra/commands/playbook/RmCommand.ts
-var import_cmd_ts26 = __toESM(require_cjs());
+var import_cmd_ts25 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/rmHandler.ts
-var fs25 = __toESM(require("fs"));
-var path28 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
+var path26 = __toESM(require("path"));
 function isSkillSupportFile(absolutePath) {
   const normalized = absolutePath.replace(/\\/g, "/");
   const skillDirMatch = normalized.match(/\/skills\/[^/]+\//);
@@ -17709,14 +17320,14 @@ async function playbookRmHandler(deps) {
     exit(1);
     return;
   }
-  const absolutePath = path28.resolve(getCwd(), filePath);
-  if (!fs25.existsSync(absolutePath)) {
+  const absolutePath = path26.resolve(getCwd(), filePath);
+  if (!fs22.existsSync(absolutePath)) {
     logErrorConsole(`File not found: "${filePath}"`);
     exit(1);
     return;
   }
   const targetDir = await findNearestConfigDir(
-    path28.dirname(absolutePath),
+    path26.dirname(absolutePath),
     packmindCliHexa
   );
   if (!targetDir) {
@@ -17733,7 +17344,7 @@ async function playbookRmHandler(deps) {
     return;
   }
   const normalizedForLookup = normalizePath2(
-    path28.relative(targetDir, absolutePath)
+    path26.relative(targetDir, absolutePath)
   );
   const lockResult = findLockFileEntryAndFileForPath(
     normalizedForLookup,
@@ -17755,7 +17366,7 @@ async function playbookRmHandler(deps) {
   }
   const resolvedAbsolutePath = artifactType === "skill" ? resolveSkillDirPath(absolutePath) : absolutePath;
   const normalizedFilePath = normalizePath2(
-    path28.relative(targetDir, resolvedAbsolutePath)
+    path26.relative(targetDir, resolvedAbsolutePath)
   );
   const lockEntry = findLockFileEntryAndFileForPath(normalizedFilePath, lockFile.artifacts)?.entry ?? lockResult.entry;
   if (!lockEntry) {
@@ -17783,7 +17394,7 @@ async function playbookRmHandler(deps) {
   }
   const spaceName = matchingSpace.name;
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(targetDir);
-  const configDir = gitRoot ? normalizePath2(path28.relative(gitRoot, targetDir)) : "";
+  const configDir = gitRoot ? normalizePath2(path26.relative(gitRoot, targetDir)) : "";
   const deployedContext = await resolveDeployedContext(
     packmindCliHexa,
     targetDir
@@ -17809,13 +17420,13 @@ async function playbookRmHandler(deps) {
 }
 
 // apps/cli/src/infra/commands/playbook/RmCommand.ts
-var rmPlaybookCommand = (0, import_cmd_ts26.command)({
+var rmPlaybookCommand = (0, import_cmd_ts25.command)({
   name: "rm",
   description: "Stage an artifact for removal",
   aliases: ["remove"],
   args: {
-    filePath: (0, import_cmd_ts26.positional)({
-      type: import_cmd_ts26.string,
+    filePath: (0, import_cmd_ts25.positional)({
+      type: import_cmd_ts25.string,
       displayName: "path",
       description: "Path to the artifact file or directory to remove"
     })
@@ -17841,10 +17452,10 @@ var rmPlaybookCommand = (0, import_cmd_ts26.command)({
 });
 
 // apps/cli/src/infra/commands/playbook/UnstageCommand.ts
-var import_cmd_ts27 = __toESM(require_cjs());
+var import_cmd_ts26 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/unstageHandler.ts
-var path29 = __toESM(require("path"));
+var path27 = __toESM(require("path"));
 async function playbookUnstageHandler(deps) {
   const {
     packmindCliHexa,
@@ -17862,10 +17473,10 @@ async function playbookUnstageHandler(deps) {
     return;
   }
   const cwd = getCwd();
-  const absolutePath = path29.resolve(cwd, filePath);
+  const absolutePath = path27.resolve(cwd, filePath);
   const resolvedPath = resolveSkillDirPath(absolutePath);
   const configDir = await findNearestConfigDir(
-    path29.dirname(resolvedPath),
+    path27.dirname(resolvedPath),
     packmindCliHexa
   );
   if (!configDir) {
@@ -17878,10 +17489,10 @@ async function playbookUnstageHandler(deps) {
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
   const baseDir = gitRoot ?? configDir;
   const normalizedFilePath = normalizePath2(
-    path29.relative(baseDir, resolvedPath)
+    path27.relative(baseDir, resolvedPath)
   );
   const matchingEntries = playbookLocalRepository.getChanges().filter((c) => {
-    const fullEntryPath = c.configDir ? normalizePath2(path29.join(c.configDir, c.filePath)) : c.filePath;
+    const fullEntryPath = c.configDir ? normalizePath2(path27.join(c.configDir, c.filePath)) : c.filePath;
     return fullEntryPath === normalizedFilePath;
   });
   if (matchingEntries.length === 0) {
@@ -17925,17 +17536,17 @@ ${spaceList}`
 }
 
 // apps/cli/src/infra/commands/playbook/UnstageCommand.ts
-var unstagePlaybookCommand = (0, import_cmd_ts27.command)({
+var unstagePlaybookCommand = (0, import_cmd_ts26.command)({
   name: "unstage",
   description: "Remove a staged change",
   args: {
-    filePath: (0, import_cmd_ts27.positional)({
-      type: import_cmd_ts27.string,
+    filePath: (0, import_cmd_ts26.positional)({
+      type: import_cmd_ts26.string,
       displayName: "path",
       description: "Path to the artifact file or directory to unstage"
     }),
-    space: (0, import_cmd_ts27.option)({
-      type: (0, import_cmd_ts27.optional)(SpaceSlug),
+    space: (0, import_cmd_ts26.option)({
+      type: (0, import_cmd_ts26.optional)(SpaceSlug),
       long: "space",
       description: "Target space slug (required when artifact is staged for multiple spaces)"
     })
@@ -17961,19 +17572,19 @@ var unstagePlaybookCommand = (0, import_cmd_ts27.command)({
 
 // apps/cli/src/infra/commands/playbook/StatusCommand.ts
 var import_fs23 = require("fs");
-var import_cmd_ts28 = __toESM(require_cjs());
+var import_cmd_ts27 = __toESM(require_cjs());
 
 // apps/cli/src/infra/utils/listDirectoryFiles.ts
 var import_fs22 = require("fs");
-var path30 = __toESM(require("path"));
+var path28 = __toESM(require("path"));
 function listDirectoryFiles(dirPath) {
   const results = [];
   const entries = (0, import_fs22.readdirSync)(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path30.join(dirPath, entry.name);
+    const fullPath = path28.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       for (const nested of listDirectoryFiles(fullPath)) {
-        results.push(path30.join(entry.name, nested));
+        results.push(path28.join(entry.name, nested));
       }
     } else if (entry.isFile()) {
       results.push(entry.name);
@@ -17983,7 +17594,7 @@ function listDirectoryFiles(dirPath) {
 }
 
 // apps/cli/src/infra/commands/playbook/statusHandler.ts
-var path31 = __toESM(require("path"));
+var path29 = __toESM(require("path"));
 
 // apps/cli/src/infra/utils/stringUtils.ts
 function capitalize(s) {
@@ -18018,7 +17629,7 @@ function groupStagedChanges(changes, cwd, gitRoot) {
     const changeType = change.changeType ?? "updated";
     const key = `${change.artifactType}:${change.artifactName}:${changeType}`;
     const rootRelativePath = change.configDir ? `${change.configDir}/${change.filePath}` : change.filePath;
-    const displayPath = gitRoot ? normalizePath2(path31.relative(cwd, path31.join(gitRoot, rootRelativePath))) : rootRelativePath;
+    const displayPath = gitRoot ? normalizePath2(path29.relative(cwd, path29.join(gitRoot, rootRelativePath))) : rootRelativePath;
     const existing = groups.get(key);
     if (existing) {
       existing.filePaths.push(displayPath);
@@ -18076,12 +17687,12 @@ async function playbookStatusHandler(deps) {
   const fallbackConfigDir = await findNearestConfigDir(cwd, packmindCliHexa);
   const configDirs = /* @__PURE__ */ new Set([...stagedByConfigDir.keys()]);
   if (fallbackConfigDir && !configDirs.has("__cwd__")) {
-    const rel = gitRoot ? normalizePath2(path31.relative(gitRoot, fallbackConfigDir)) : "";
+    const rel = gitRoot ? normalizePath2(path29.relative(gitRoot, fallbackConfigDir)) : "";
     if (!configDirs.has(rel)) configDirs.add(rel);
   }
   const descendantDirs = await packmindCliHexa.findDescendantConfigs(cwd);
   for (const descendantDir of descendantDirs) {
-    const rel = gitRoot ? normalizePath2(path31.relative(gitRoot, descendantDir)) : normalizePath2(path31.relative(cwd, descendantDir));
+    const rel = gitRoot ? normalizePath2(path29.relative(gitRoot, descendantDir)) : normalizePath2(path29.relative(cwd, descendantDir));
     if (!configDirs.has(rel)) configDirs.add(rel);
   }
   for (const configDirKey of configDirs) {
@@ -18089,7 +17700,7 @@ async function playbookStatusHandler(deps) {
     if (configDirKey === "__cwd__") {
       projectDir = fallbackConfigDir;
     } else if (gitRoot) {
-      projectDir = path31.join(gitRoot, configDirKey);
+      projectDir = path29.join(gitRoot, configDirKey);
     } else {
       continue;
     }
@@ -18114,11 +17725,11 @@ async function playbookStatusHandler(deps) {
         continue;
       }
       const displayPath = normalizePath2(
-        path31.relative(cwd, path31.join(projectDir, deployedFile.path))
+        path29.relative(cwd, path29.join(projectDir, deployedFile.path))
       );
       let localContent;
       try {
-        localContent = readFile11(path31.join(projectDir, deployedFile.path));
+        localContent = readFile11(path29.join(projectDir, deployedFile.path));
       } catch {
         const artifact = findArtifactForFile(
           deployedFile.path,
@@ -18147,7 +17758,7 @@ async function playbookStatusHandler(deps) {
           });
         }
       } else if (deployedFile.skillFilePermissions && getFileMode) {
-        const localMode = getFileMode(path31.join(projectDir, deployedFile.path));
+        const localMode = getFileMode(path29.join(projectDir, deployedFile.path));
         if (localMode !== null) {
           const localPermissions = modeToPermissionStringOrDefault(localMode);
           if (localPermissions !== deployedFile.skillFilePermissions) {
@@ -18176,13 +17787,13 @@ async function playbookStatusHandler(deps) {
         (f) => normalizePath2(f.path).endsWith("/SKILL.md")
       );
       if (!skillMdFile) continue;
-      const skillDir = normalizePath2(path31.dirname(skillMdFile.path));
+      const skillDir = normalizePath2(path29.dirname(skillMdFile.path));
       if (targetStagedPaths.has(skillDir) || targetSkillDirPaths.some(
         (staged) => skillDir === staged || skillDir.startsWith(staged + "/")
       )) {
         continue;
       }
-      const absoluteSkillDir = path31.join(projectDir, skillDir);
+      const absoluteSkillDir = path29.join(projectDir, skillDir);
       let localFiles;
       try {
         localFiles = listDirectoryFiles2(absoluteSkillDir);
@@ -18191,11 +17802,11 @@ async function playbookStatusHandler(deps) {
       }
       for (const localRelPath of localFiles) {
         const normalizedLocalPath = normalizePath2(
-          path31.join(skillDir, localRelPath)
+          path29.join(skillDir, localRelPath)
         );
         if (!deployedPathSet.has(normalizedLocalPath)) {
           const displayPath = normalizePath2(
-            path31.relative(cwd, path31.join(projectDir, normalizedLocalPath))
+            path29.relative(cwd, path29.join(projectDir, normalizedLocalPath))
           );
           untrackedChanges.push({
             artifactName: entry.name,
@@ -18243,7 +17854,7 @@ async function playbookStatusHandler(deps) {
 }
 
 // apps/cli/src/infra/commands/playbook/StatusCommand.ts
-var statusPlaybookCommand = (0, import_cmd_ts28.command)({
+var statusPlaybookCommand = (0, import_cmd_ts27.command)({
   name: "status",
   description: "Show staged and untracked changes",
   args: {},
@@ -18277,13 +17888,13 @@ var statusPlaybookCommand = (0, import_cmd_ts28.command)({
 
 // apps/cli/src/infra/commands/playbook/SubmitCommand.ts
 var import_fs24 = require("fs");
-var import_child_process5 = require("child_process");
+var import_child_process3 = require("child_process");
 var import_os2 = require("os");
 var import_path5 = require("path");
-var import_cmd_ts29 = __toESM(require_cjs());
+var import_cmd_ts28 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/submitHandler.ts
-var path33 = __toESM(require("path"));
+var path31 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/playbook/submit/duplicateNameChecker.ts
 var import_slug2 = __toESM(require("slug"));
@@ -18345,7 +17956,7 @@ async function checkForDuplicateNames(createdEntries, packmindGateway) {
 }
 
 // apps/cli/src/infra/commands/playbook/submit/targetContextResolver.ts
-var path32 = __toESM(require("path"));
+var path30 = __toESM(require("path"));
 async function createTargetContextResolver(deps) {
   const { lockFileRepository, cwd, packmindCliHexa } = deps;
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
@@ -18356,7 +17967,7 @@ async function createTargetContextResolver(deps) {
       if (cache.has(key)) return cache.get(key);
       let projectDir;
       if (entry.configDir !== void 0 && gitRoot) {
-        projectDir = path32.join(gitRoot, entry.configDir);
+        projectDir = path30.join(gitRoot, entry.configDir);
       } else {
         projectDir = await findNearestConfigDir(cwd, packmindCliHexa);
       }
@@ -19304,7 +18915,7 @@ Only one agent version can be submitted at a time. Use "playbook unstage" to rem
           const entryCtx = resolver.getCachedContext(entry.configDir);
           if (!entryCtx?.projectDir) continue;
           try {
-            const fullPath = path33.join(entryCtx.projectDir, entry.filePath);
+            const fullPath = path31.join(entryCtx.projectDir, entry.filePath);
             if (entry.artifactType === "skill") {
               deps.rmSync(fullPath, { recursive: true });
             } else {
@@ -19332,7 +18943,7 @@ Only one agent version can be submitted at a time. Use "playbook unstage" to rem
         const entryCtx = resolver.getCachedContext(entry.configDir);
         if (!entryCtx?.projectDir) continue;
         try {
-          const fullPath = path33.join(entryCtx.projectDir, entry.filePath);
+          const fullPath = path31.join(entryCtx.projectDir, entry.filePath);
           if (entry.artifactType === "skill") {
             deps.rmSync(fullPath, { recursive: true });
           } else {
@@ -19385,7 +18996,7 @@ function openEditorForMessage(prefill) {
   const tmpFile = (0, import_path5.join)((0, import_os2.tmpdir)(), `packmind-submit-${Date.now()}.md`);
   try {
     (0, import_fs24.writeFileSync)(tmpFile, prefill, "utf-8");
-    (0, import_child_process5.execSync)(`${editor} "${tmpFile}"`, { stdio: "inherit" });
+    (0, import_child_process3.execSync)(`${editor} "${tmpFile}"`, { stdio: "inherit" });
     const content = (0, import_fs24.readFileSync)(tmpFile, "utf-8");
     const stripped = content.split("\n").filter((line) => !line.startsWith("#")).join("\n").trim();
     return stripped || null;
@@ -19398,17 +19009,17 @@ function openEditorForMessage(prefill) {
     }
   }
 }
-var submitPlaybookCommand = (0, import_cmd_ts29.command)({
+var submitPlaybookCommand = (0, import_cmd_ts28.command)({
   name: "submit",
   description: "Submit staged changes as proposals",
   args: {
-    message: (0, import_cmd_ts29.option)({
-      type: (0, import_cmd_ts29.optional)(import_cmd_ts29.string),
+    message: (0, import_cmd_ts28.option)({
+      type: (0, import_cmd_ts28.optional)(import_cmd_ts28.string),
       long: "message",
       short: "m",
       description: "Message describing the intent behind the proposed changes"
     }),
-    noReview: (0, import_cmd_ts29.flag)({
+    noReview: (0, import_cmd_ts28.flag)({
       long: "no-review",
       description: "Apply changes directly without creating proposals for review"
     })
@@ -19438,23 +19049,23 @@ var submitPlaybookCommand = (0, import_cmd_ts29.command)({
 });
 
 // apps/cli/src/infra/commands/playbook/DiffCommand.ts
-var import_cmd_ts30 = __toESM(require_cjs());
-var diffCommand2 = (0, import_cmd_ts30.command)({
+var import_cmd_ts29 = __toESM(require_cjs());
+var diffCommand2 = (0, import_cmd_ts29.command)({
   name: "diff",
   description: "Show differences between local command files and server content",
   args: {
-    includeSubmitted: (0, import_cmd_ts30.flag)({
+    includeSubmitted: (0, import_cmd_ts29.flag)({
       long: "include-submitted",
       description: "Include already submitted changes in the output"
     }),
-    path: (0, import_cmd_ts30.option)({
+    path: (0, import_cmd_ts29.option)({
       long: "path",
       short: "p",
       description: "Path to analyze (relative to current directory)",
-      type: (0, import_cmd_ts30.optional)(import_cmd_ts30.string)
+      type: (0, import_cmd_ts29.optional)(import_cmd_ts29.string)
     })
   },
-  handler: async ({ includeSubmitted, path: path37 }) => {
+  handler: async ({ includeSubmitted, path: path35 }) => {
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
     await diffArtefactsHandler({
@@ -19463,13 +19074,13 @@ var diffCommand2 = (0, import_cmd_ts30.command)({
       getCwd: () => process.cwd(),
       log: console.log,
       includeSubmitted,
-      path: path37
+      path: path35
     });
   }
 });
 
 // apps/cli/src/infra/commands/PlaybookCommand.ts
-var playbookCommand = (0, import_cmd_ts31.subcommands)({
+var playbookCommand = (0, import_cmd_ts30.subcommands)({
   name: "playbook",
   description: "Manage local playbook files and propose changes to your team",
   cmds: {
@@ -19483,10 +19094,10 @@ var playbookCommand = (0, import_cmd_ts31.subcommands)({
 });
 
 // apps/cli/src/infra/commands/SpacesCommand.ts
-var import_cmd_ts33 = __toESM(require_cjs());
+var import_cmd_ts32 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/ListSpacesCommand.ts
-var import_cmd_ts32 = __toESM(require_cjs());
+var import_cmd_ts31 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/spaces/listSpacesHandler.ts
 function displaySpace(space) {
@@ -19522,7 +19133,7 @@ async function listSpacesHandler(deps) {
 }
 
 // apps/cli/src/infra/commands/ListSpacesCommand.ts
-var listSpacesCommand = (0, import_cmd_ts32.command)({
+var listSpacesCommand = (0, import_cmd_ts31.command)({
   name: "list",
   description: "List available spaces in the organization",
   args: {},
@@ -19537,7 +19148,7 @@ var listSpacesCommand = (0, import_cmd_ts32.command)({
 });
 
 // apps/cli/src/infra/commands/SpacesCommand.ts
-var spacesCommand = (0, import_cmd_ts33.subcommands)({
+var spacesCommand = (0, import_cmd_ts32.subcommands)({
   name: "spaces",
   description: "Manage spaces in your Packmind organization",
   cmds: {
@@ -19546,14 +19157,14 @@ var spacesCommand = (0, import_cmd_ts33.subcommands)({
 });
 
 // apps/cli/src/infra/commands/config/ConfigCommand.ts
-var import_cmd_ts39 = __toESM(require_cjs());
+var import_cmd_ts38 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/config/ConfigAgentsCommand.ts
-var import_cmd_ts38 = __toESM(require_cjs());
+var import_cmd_ts37 = __toESM(require_cjs());
 
 // apps/cli/src/application/services/AgentArtifactDetectionService.ts
-var fs26 = __toESM(require("fs/promises"));
-var path34 = __toESM(require("path"));
+var fs23 = __toESM(require("fs/promises"));
+var path32 = __toESM(require("path"));
 var AGENT_ARTIFACT_CHECKS = [
   { agent: "claude", paths: [".claude"] },
   { agent: "cursor", paths: [".cursor"] },
@@ -19582,7 +19193,7 @@ var AgentArtifactDetectionService = class {
         }
       } else {
         for (const relativePath of check.paths) {
-          const fullPath = path34.join(baseDirectory, relativePath);
+          const fullPath = path32.join(baseDirectory, relativePath);
           const exists = await this.pathExists(fullPath);
           if (exists) {
             detected.push({
@@ -19598,7 +19209,7 @@ var AgentArtifactDetectionService = class {
   }
   async pathExists(filePath) {
     try {
-      await fs26.access(filePath);
+      await fs23.access(filePath);
       return true;
     } catch {
       return false;
@@ -19609,16 +19220,16 @@ var AgentArtifactDetectionService = class {
     while (queue.length > 0) {
       const currentDir = queue.shift();
       for (const targetPath of targetPaths) {
-        const fullPath = path34.join(currentDir, targetPath);
+        const fullPath = path32.join(currentDir, targetPath);
         if (await this.pathExists(fullPath)) {
           return fullPath;
         }
       }
       try {
-        const entries = await fs26.readdir(currentDir, { withFileTypes: true });
+        const entries = await fs23.readdir(currentDir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-            queue.push(path34.join(currentDir, entry.name));
+            queue.push(path32.join(currentDir, entry.name));
           }
         }
       } catch {
@@ -19629,22 +19240,22 @@ var AgentArtifactDetectionService = class {
 };
 
 // apps/cli/src/infra/commands/config/configAgentsHandler.ts
-var readline4 = __toESM(require("readline"));
-var inquirer2 = __toESM(require("inquirer"));
+var readline3 = __toESM(require("readline"));
+var inquirer = __toESM(require("inquirer"));
 
 // apps/cli/src/infra/commands/config/agents/agentsHandlerUtils.ts
-var path35 = __toESM(require("path"));
-var fs27 = __toESM(require("fs/promises"));
+var path33 = __toESM(require("path"));
+var fs24 = __toESM(require("fs/promises"));
 function getRelativePath(dir, startDirectory) {
   if (dir === startDirectory) return "./packmind.json";
-  return "./" + path35.relative(startDirectory, dir) + "/packmind.json";
+  return "./" + path33.relative(startDirectory, dir) + "/packmind.json";
 }
 async function resolveStartDirectory(args2, getCwd, exit) {
   let startDirectory = getCwd();
   if (args2.path) {
-    const resolvedPath = path35.resolve(getCwd(), args2.path);
+    const resolvedPath = path33.resolve(getCwd(), args2.path);
     try {
-      const stat9 = await fs27.stat(resolvedPath);
+      const stat9 = await fs24.stat(resolvedPath);
       if (!stat9.isDirectory()) {
         logErrorConsole(`Path is not a directory: ${resolvedPath}`);
         exit(1);
@@ -19706,9 +19317,9 @@ async function configAgentsHandler(deps) {
   }));
   let selectedAgents;
   if (useSimplePrompt) {
-    selectedAgents = await promptAgentsWithReadline2(choices);
+    selectedAgents = await promptAgentsWithReadline(choices);
   } else {
-    const result = await inquirer2.default.prompt([
+    const result = await inquirer.default.prompt([
       {
         type: "checkbox",
         name: "selectedAgents",
@@ -19739,10 +19350,10 @@ async function configAgentsHandler(deps) {
     );
   }
 }
-async function promptAgentsWithReadline2(choices) {
+async function promptAgentsWithReadline(choices) {
   const input = process.stdin;
   const output = process.stdout;
-  const rl = readline4.createInterface({
+  const rl = readline3.createInterface({
     input,
     output
   });
@@ -19811,12 +19422,30 @@ async function propagateAgentsToDescendants(configRepository, baseDirectory, sel
 }
 
 // apps/cli/src/infra/commands/config/ConfigAgentsAddCommand.ts
-var readline5 = __toESM(require("readline"));
-var import_cmd_ts35 = __toESM(require_cjs());
+var readline4 = __toESM(require("readline"));
+var import_cmd_ts34 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/customParameters/AgentNamesPositional.ts
-var import_cmd_ts34 = __toESM(require_cjs());
-var agentNamesPositional = (0, import_cmd_ts34.restPositionals)({
+var import_cmd_ts33 = __toESM(require_cjs());
+
+// apps/cli/src/infra/commands/customParameters/AgentArgType.ts
+var VALID_AGENTS = Object.keys(CodingAgents).filter(
+  (a) => a !== "packmind"
+);
+var AgentArgType = {
+  from: async (input) => {
+    const normalized = input.toLowerCase();
+    if (VALID_AGENTS.includes(normalized)) {
+      return normalized;
+    }
+    throw new Error(
+      `Invalid agent '${input}'. Valid options are: ${VALID_AGENTS.join(", ")}`
+    );
+  }
+};
+
+// apps/cli/src/infra/commands/customParameters/AgentNamesPositional.ts
+var agentNamesPositional = (0, import_cmd_ts33.restPositionals)({
   type: AgentArgType,
   displayName: "agents",
   description: "Agent identifiers (e.g. claude cursor)"
@@ -19912,7 +19541,7 @@ To restore organization settings later, remove all local agents with: packmind-c
 // apps/cli/src/infra/commands/config/ConfigAgentsAddCommand.ts
 function createPromptConfirm() {
   return (message) => new Promise((resolve15) => {
-    const rl = readline5.createInterface({
+    const rl = readline4.createInterface({
       input: process.stdin,
       output: process.stdout
     });
@@ -19922,12 +19551,12 @@ function createPromptConfirm() {
     });
   });
 }
-var addAgentsCommand = (0, import_cmd_ts35.command)({
+var addAgentsCommand = (0, import_cmd_ts34.command)({
   name: "add",
   description: "Add coding agents to packmind.json files",
   args: {
-    path: (0, import_cmd_ts35.option)({
-      type: import_cmd_ts35.string,
+    path: (0, import_cmd_ts34.option)({
+      type: import_cmd_ts34.string,
       short: "p",
       long: "path",
       defaultValue: () => "",
@@ -19953,7 +19582,7 @@ var addAgentsCommand = (0, import_cmd_ts35.command)({
 });
 
 // apps/cli/src/infra/commands/config/ConfigAgentsListCommand.ts
-var import_cmd_ts36 = __toESM(require_cjs());
+var import_cmd_ts35 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/config/agents/listAgentsHandler.ts
 var SOURCE_LABELS = {
@@ -20033,12 +19662,12 @@ async function listAgentsHandler(args2, deps) {
 }
 
 // apps/cli/src/infra/commands/config/ConfigAgentsListCommand.ts
-var listAgentsCommand = (0, import_cmd_ts36.command)({
+var listAgentsCommand = (0, import_cmd_ts35.command)({
   name: "list",
   description: "List coding agents configured across packmind.json files",
   args: {
-    path: (0, import_cmd_ts36.option)({
-      type: import_cmd_ts36.string,
+    path: (0, import_cmd_ts35.option)({
+      type: import_cmd_ts35.string,
       short: "p",
       long: "path",
       defaultValue: () => "",
@@ -20062,7 +19691,7 @@ var listAgentsCommand = (0, import_cmd_ts36.command)({
 });
 
 // apps/cli/src/infra/commands/config/ConfigAgentsRemoveCommand.ts
-var import_cmd_ts37 = __toESM(require_cjs());
+var import_cmd_ts36 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/config/agents/removeAgentsHandler.ts
 async function removeAgentsHandler(args2, deps) {
@@ -20145,13 +19774,13 @@ function logConfiguredAgentsHint(configuredAgents) {
 }
 
 // apps/cli/src/infra/commands/config/ConfigAgentsRemoveCommand.ts
-var removeAgentsCommand = (0, import_cmd_ts37.command)({
+var removeAgentsCommand = (0, import_cmd_ts36.command)({
   name: "rm",
   aliases: ["remove"],
   description: "Remove coding agents from packmind.json files",
   args: {
-    path: (0, import_cmd_ts37.option)({
-      type: import_cmd_ts37.string,
+    path: (0, import_cmd_ts36.option)({
+      type: import_cmd_ts36.string,
       short: "p",
       long: "path",
       defaultValue: () => "",
@@ -20173,7 +19802,7 @@ var removeAgentsCommand = (0, import_cmd_ts37.command)({
 });
 
 // apps/cli/src/infra/commands/config/ConfigAgentsCommand.ts
-var configAgentsSetupCommand = (0, import_cmd_ts38.command)({
+var configAgentsSetupCommand = (0, import_cmd_ts37.command)({
   name: "setup",
   description: "Configure which coding agents to generate artifacts for",
   args: {},
@@ -20191,7 +19820,7 @@ var configAgentsSetupCommand = (0, import_cmd_ts38.command)({
     });
   }
 });
-var configAgentsCommand = (0, import_cmd_ts38.subcommands)({
+var configAgentsCommand = (0, import_cmd_ts37.subcommands)({
   name: "agents",
   description: "Manage coding agents configuration",
   cmds: {
@@ -20203,7 +19832,7 @@ var configAgentsCommand = (0, import_cmd_ts38.subcommands)({
 });
 
 // apps/cli/src/infra/commands/config/ConfigCommand.ts
-var configCommand = (0, import_cmd_ts39.subcommands)({
+var configCommand = (0, import_cmd_ts38.subcommands)({
   name: "config",
   description: "Manage Packmind configuration",
   cmds: {
@@ -20212,7 +19841,7 @@ var configCommand = (0, import_cmd_ts39.subcommands)({
 });
 
 // apps/cli/src/infra/commands/InitCommand.ts
-var import_cmd_ts40 = __toESM(require_cjs());
+var import_cmd_ts39 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/initHandler.ts
 async function initHandler(deps) {
@@ -20273,8 +19902,8 @@ async function initHandler(deps) {
 }
 
 // apps/cli/src/infra/commands/InitCommand.ts
-var { version: CLI_VERSION3 } = require_package();
-var initCommand = (0, import_cmd_ts40.command)({
+var { version: CLI_VERSION4 } = require_package();
+var initCommand = (0, import_cmd_ts39.command)({
   name: "init",
   description: "Initialize Packmind in the current project",
   args: {},
@@ -20290,7 +19919,7 @@ var initCommand = (0, import_cmd_ts40.command)({
       packmindGateway: packmindCliHexa.getPackmindGateway(),
       baseDirectory,
       installDefaultSkills: packmindCliHexa.installDefaultSkills.bind(packmindCliHexa),
-      cliVersion: CLI_VERSION3
+      cliVersion: CLI_VERSION4
     });
     if (!result.success) {
       for (const error of result.errors) {
@@ -20302,20 +19931,20 @@ var initCommand = (0, import_cmd_ts40.command)({
 });
 
 // apps/cli/src/infra/commands/UpdateCommand.ts
-var import_cmd_ts41 = __toESM(require_cjs());
-var { version: CLI_VERSION4 } = require_package();
-var updateCommand = (0, import_cmd_ts41.command)({
+var import_cmd_ts40 = __toESM(require_cjs());
+var { version: CLI_VERSION5 } = require_package();
+var updateCommand = (0, import_cmd_ts40.command)({
   name: "update",
   description: "Update packmind-cli to the latest version",
   args: {
-    check: (0, import_cmd_ts41.flag)({
+    check: (0, import_cmd_ts40.flag)({
       long: "check",
       description: "Only check if a newer version is available without performing the update"
     })
   },
   handler: async ({ check }) => {
     await updateHandler({
-      currentVersion: CLI_VERSION4,
+      currentVersion: CLI_VERSION5,
       isExecutableMode: hasEmbeddedWasmFiles(),
       executablePath: process.execPath,
       scriptPath: require.main?.filename,
@@ -20328,25 +19957,25 @@ var updateCommand = (0, import_cmd_ts41.command)({
 });
 
 // apps/cli/src/main.ts
-var { version: CLI_VERSION5 } = require_package();
+var { version: CLI_VERSION6 } = require_package();
 function findEnvFile() {
   const currentDir = process.cwd();
   const gitService = new GitService();
   const gitRoot = gitService.getGitRepositoryRootSync(currentDir);
-  const filesystemRoot = path36.parse(currentDir).root;
+  const filesystemRoot = path34.parse(currentDir).root;
   const stopDir = gitRoot ?? filesystemRoot;
   let searchDir = currentDir;
-  let parentDir = path36.dirname(searchDir);
+  let parentDir = path34.dirname(searchDir);
   while (searchDir !== parentDir) {
-    const envPath2 = path36.join(searchDir, ".env");
-    if (fs28.existsSync(envPath2)) {
+    const envPath2 = path34.join(searchDir, ".env");
+    if (fs25.existsSync(envPath2)) {
       return envPath2;
     }
     if (searchDir === stopDir) {
       return null;
     }
     searchDir = parentDir;
-    parentDir = path36.dirname(searchDir);
+    parentDir = path34.dirname(searchDir);
   }
   return null;
 }
@@ -20363,10 +19992,10 @@ if (hasEmbeddedWasmFiles()) {
 }
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
-  logConsole(`packmind-cli version ${CLI_VERSION5}`);
+  logConsole(`packmind-cli version ${CLI_VERSION6}`);
   process.exit(0);
 }
-var app = (0, import_cmd_ts42.subcommands)({
+var app = (0, import_cmd_ts41.subcommands)({
   name: "packmind-cli",
   description: "Packmind CLI tool",
   cmds: {
@@ -20380,7 +20009,6 @@ var app = (0, import_cmd_ts42.subcommands)({
     logout: logoutCommand,
     packages: packagesCommand,
     playbook: playbookCommand,
-    "setup-mcp": setupMcpCommand,
     skills: skillsCommand,
     spaces: spacesCommand,
     standards: standardsCommand,
@@ -20389,7 +20017,7 @@ var app = (0, import_cmd_ts42.subcommands)({
     whoami: whoamiCommand
   }
 });
-(0, import_cmd_ts42.run)(app, args).catch((error) => {
+(0, import_cmd_ts41.run)(app, args).catch((error) => {
   logErrorConsole(error.message);
   process.exit(1);
 });