@packmind/cli 0.25.0 → 0.26.1

package/main.cjs

@@ -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;
@@ -3852,7 +3855,7 @@ var require_package = __commonJS({
   "apps/cli/package.json"(exports2, module2) {
     module2.exports = {
       name: "@packmind/cli",
-      version: "0.25.0",
+      version: "0.26.1",
       description: "A command-line interface for Packmind linting and code quality checks",
       private: false,
       bin: {
@@ -4427,6 +4430,48 @@ var SpaceCreatedEvent = class extends UserEvent {
   }
 };
 
+// packages/types/src/spaces/events/SpaceMembersAddedEvent.ts
+var SpaceMembersAddedEvent = class extends UserEvent {
+  static {
+    this.eventName = "spaces.space.members-added";
+  }
+};
+
+// packages/types/src/spaces/events/SpaceMembersRemovedEvent.ts
+var SpaceMembersRemovedEvent = class extends UserEvent {
+  static {
+    this.eventName = "spaces.space.members-removed";
+  }
+};
+
+// packages/types/src/spaces/events/SpaceMembersRoleUpdatedEvent.ts
+var SpaceMembersRoleUpdatedEvent = class extends UserEvent {
+  static {
+    this.eventName = "spaces.space.members-role-updated";
+  }
+};
+
+// 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 {
+    this.eventName = "spaces.space.visibility-updated";
+  }
+};
+
 // packages/types/src/spaces-management/events/PlaybookArtefactMovedEvent.ts
 var PlaybookArtefactMovedEvent = class extends UserEvent {
   static {
@@ -5335,30 +5380,30 @@ var GitService = class {
     this.gitRunner = gitRunner;
     this.logger = logger2;
   }
-  getGitRepositoryRoot(path36) {
+  getGitRepositoryRoot(path37) {
     try {
       const { stdout } = this.gitRunner("rev-parse --show-toplevel", {
-        cwd: path36
+        cwd: path37
       });
       const gitRoot = stdout.trim();
       this.logger.debug("Resolved git repository root", {
-        inputPath: path36,
+        inputPath: path37,
         gitRoot
       });
       return gitRoot;
     } catch (error) {
       if (error instanceof Error) {
         throw new Error(
-          `Failed to get Git repository root. The path '${path36}' does not appear to be inside a Git repository.
+          `Failed to get Git repository root. The path '${path37}' does not appear to be inside a Git repository.
 ${error.message}`
         );
       }
       throw new Error("Failed to get Git repository root: Unknown error");
     }
   }
-  tryGetGitRepositoryRoot(path36) {
+  tryGetGitRepositoryRoot(path37) {
     try {
-      return this.getGitRepositoryRoot(path36);
+      return this.getGitRepositoryRoot(path37);
     } catch {
       return null;
     }
@@ -6623,10 +6668,10 @@ var PackmindHttpClient = class {
       return null;
     }
   }
-  async request(path36, options = {}) {
+  async request(path37, options = {}) {
     const { host } = this.getAuthContext();
     const { method = "GET", body } = options;
-    const url = `${host}${path36}`;
+    const url = `${host}${path37}`;
     try {
       const response = await fetch(url, {
         method,
@@ -6838,6 +6883,21 @@ var SpacesGateway = class {
       );
     };
   }
+  async getSpaceBySlug(slug3) {
+    const { organizationId } = this.httpClient.getAuthContext();
+    try {
+      return await this.httpClient.request(
+        `/api/v0/organizations/${organizationId}/spaces/${slug3}`
+      );
+    } catch (error) {
+      if (error.statusCode === 404) return null;
+      throw error;
+    }
+  }
+  getApiContext() {
+    const { host, organizationId } = this.httpClient.getAuthContext();
+    return { host, organizationId };
+  }
 };
 
 // apps/cli/src/infra/repositories/SkillsGateway.ts
@@ -7026,6 +7086,21 @@ var DeploymentGateway = class {
         `/api/v0/organizations/${organizationId}/pull?${queryParams.toString()}`
       );
     };
+    this.install = async (command33) => {
+      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 }
+          }
+        }
+      );
+    };
     this.getDeployed = async (command33) => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
@@ -7065,6 +7140,21 @@ var DeploymentGateway = class {
         }
       );
     };
+    this.notifyArtefactsDistribution = async (command33) => {
+      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
+          }
+        }
+      );
+    };
     this.getRenderModeConfiguration = async () => {
       const { organizationId } = this.httpClient.getAuthContext();
       return this.httpClient.request(
@@ -7086,6 +7176,24 @@ var DeploymentGateway = class {
   }
 };
 
+// apps/cli/src/infra/repositories/OrganizationGateway.ts
+var OrganizationGateway = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async getOrganization() {
+    const { organizationId } = this.httpClient.getAuthContext();
+    const organizations = await this.httpClient.request(
+      "/api/v0/organizations"
+    );
+    const org = organizations.find((o) => o.id === organizationId);
+    if (!org) {
+      throw new Error(`Organization ${organizationId} not found`);
+    }
+    return org;
+  }
+};
+
 // apps/cli/src/infra/repositories/PackmindGateway.ts
 var PackmindGateway = class {
   constructor(apiKey) {
@@ -7100,6 +7208,7 @@ var PackmindGateway = class {
     this.standards = new StandardsGateway(this.httpClient);
     this.packages = new PackagesGateway(apiKey, this.httpClient);
     this.deployment = new DeploymentGateway(this.httpClient);
+    this.organization = new OrganizationGateway(this.httpClient);
   }
 };
 
@@ -9927,69 +10036,150 @@ ${endMarker}`;
   }
 };
 
-// apps/cli/src/application/useCases/InstallDefaultSkillsUseCase.ts
+// apps/cli/src/application/useCases/InstallUseCase.ts
 var fs5 = __toESM(require("fs/promises"));
 var path7 = __toESM(require("path"));
-var import_semver = __toESM(require("semver"));
-var InstallDefaultSkillsUseCase = class {
-  constructor(repositories) {
-    this.repositories = repositories;
+
+// apps/cli/src/application/utils/normalizePackageSlugs.ts
+async function normalizePackageSlugs(slugs, spaceService) {
+  const hasUnprefixed = slugs.some((s) => !s.startsWith("@"));
+  if (!hasUnprefixed) return slugs;
+  const spaces = await spaceService.getSpaces();
+  if (spaces.length > 1) {
+    throw new Error(
+      `Your organization has multiple spaces. Please specify the space for each package using the @space/package format (e.g. @${spaces[0].slug}/my-package).`
+    );
+  }
+  const defaultSpace = await spaceService.getDefaultSpace();
+  return slugs.map(
+    (slug3) => slug3.startsWith("@") ? slug3 : `@${defaultSpace.slug}/${slug3}`
+  );
+}
+
+// apps/cli/src/application/useCases/InstallUseCase.ts
+var InstallUseCase = class {
+  constructor(packmindGateway, lockFileRepository, configFileRepository, spaceService) {
+    this.packmindGateway = packmindGateway;
+    this.lockFileRepository = lockFileRepository;
+    this.configFileRepository = configFileRepository;
+    this.spaceService = spaceService;
   }
   async execute(command33) {
     const baseDirectory = command33.baseDirectory || process.cwd();
     const result = {
       filesCreated: 0,
       filesUpdated: 0,
+      filesDeleted: 0,
+      contentFilesChanged: 0,
       errors: [],
-      skippedSkillsCount: 0,
-      skippedIncompatibleSkillNames: [],
-      incompatibleInstalledSkills: []
+      recipesCount: 0,
+      standardsCount: 0,
+      commandsCount: 0,
+      skillsCount: 0,
+      recipesRemoved: 0,
+      standardsRemoved: 0,
+      commandsRemoved: 0,
+      skillsRemoved: 0,
+      skillDirectoriesDeleted: 0,
+      missingAccess: []
     };
-    const config = await this.repositories.configFileRepository.readConfig(baseDirectory);
-    const agents = config?.agents;
-    const response = await this.repositories.packmindGateway.skills.getDefaults(
-      {
-        cliVersion: command33.cliVersion,
-        includeBeta: command33.includeBeta,
-        agents
+    const hasExplicitPackages = command33.packages && command33.packages.length > 0;
+    const lockFile = await this.lockFileRepository.read(baseDirectory);
+    const config = await this.configFileRepository.readConfig(baseDirectory);
+    if (!config && !hasExplicitPackages) {
+      const configFileExists = await this.configFileRepository.configExists(baseDirectory);
+      if (configFileExists) {
+        throw new Error(
+          "packmind.json exists but could not be parsed. Please fix the JSON syntax errors and try again."
+        );
       }
-    );
-    result.skippedSkillsCount = response.skippedSkillsCount;
-    const incompatibleInstalledMap = /* @__PURE__ */ new Map();
-    const incompatibleSkillDirs = /* @__PURE__ */ new Map();
-    if (command33.cliVersion) {
-      for (const file of response.fileUpdates.createOrUpdate) {
-        if (path7.basename(file.path) === "SKILL.md" && file.content && this.isVersionConstraintViolated(file.content, command33.cliVersion)) {
-          const dir = path7.dirname(file.path);
-          const skillName = this.getSkillName(file.content) ?? path7.basename(dir);
-          incompatibleSkillDirs.set(dir, skillName);
+      throw new Error(
+        "No packmind.json found in this directory. Run `packmind-cli install <@space/package>` first to install your packages."
+      );
+    }
+    const effectiveLockFile = lockFile ?? {
+      lockfileVersion: 1,
+      packageSlugs: [],
+      agents: [],
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      artifacts: {}
+    };
+    let packagesSlugs;
+    let normalizedPackages = [];
+    if (hasExplicitPackages) {
+      normalizedPackages = await this.normalizePackageSlugs(command33.packages);
+      await this.validatePackageAccess(normalizedPackages);
+      const normalizedConfigPackages = config ? await this.normalizeAndSaveConfigPackages(baseDirectory, config) : [];
+      packagesSlugs = [
+        .../* @__PURE__ */ new Set([...normalizedConfigPackages, ...normalizedPackages])
+      ];
+    } else {
+      packagesSlugs = await this.normalizeAndSaveConfigPackages(
+        baseDirectory,
+        config
+      );
+    }
+    if (packagesSlugs.length === 0) {
+      try {
+        for (const entry of Object.values(effectiveLockFile.artifacts)) {
+          for (const file of entry.files) {
+            await this.deleteFile(baseDirectory, file.path, result);
+          }
         }
+        await this.deleteFile(baseDirectory, "packmind-lock.json", result);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        result.errors.push(`Failed to clean up artifacts: ${errorMsg}`);
+      }
+      return result;
+    }
+    const response = await this.packmindGateway.deployment.install({
+      packagesSlugs,
+      packmindLockFile: effectiveLockFile,
+      agents: config?.agents
+    });
+    result.missingAccess = response.missingAccess;
+    if (result.missingAccess.length > 0) {
+      result.joinSpaceUrl = await this.computeJoinSpaceUrl(
+        result.missingAccess
+      );
+    }
+    const filteredCreateOrUpdate = response.fileUpdates.createOrUpdate.filter(
+      (file) => file.path !== "packmind.json"
+    );
+    const uniqueFilesMap = /* @__PURE__ */ new Map();
+    for (const file of filteredCreateOrUpdate) {
+      uniqueFilesMap.set(file.path, file);
+    }
+    const uniqueFiles = Array.from(uniqueFilesMap.values());
+    for (const file of uniqueFiles) {
+      if (file.path.includes(".packmind/recipes/") && file.path.endsWith(".md")) {
+        result.recipesCount++;
+      } else if (file.path.includes(".packmind/standards/") && file.path.endsWith(".md")) {
+        result.standardsCount++;
+      } else if (file.path.includes(".packmind/commands/") && file.path.endsWith(".md")) {
+        result.commandsCount++;
+      } else if (file.path.includes(".packmind/skills/") && file.path.endsWith(".md")) {
+        result.skillsCount++;
       }
     }
     try {
-      for (const file of response.fileUpdates.createOrUpdate) {
+      result.skillDirectoriesDeleted = await this.deleteSkillFolders(
+        baseDirectory,
+        response.skillFolders
+      );
+      for (const file of uniqueFiles) {
         try {
-          if (!file.content) continue;
-          const isIncompatible = command33.cliVersion && (this.isVersionConstraintViolated(
-            file.content,
-            command33.cliVersion
-          ) || incompatibleSkillDirs.has(path7.dirname(file.path)));
-          if (isIncompatible) {
-            const skillName = this.getSkillName(file.content) ?? incompatibleSkillDirs.get(path7.dirname(file.path)) ?? path7.basename(file.path);
-            const fullPath = path7.join(baseDirectory, file.path);
-            const fileAlreadyInstalled = await this.fileExists(fullPath);
-            if (fileAlreadyInstalled) {
-              const paths = incompatibleInstalledMap.get(skillName) ?? [];
-              paths.push(file.path);
-              incompatibleInstalledMap.set(skillName, paths);
-            } else {
-              if (!result.skippedIncompatibleSkillNames.includes(skillName)) {
-                result.skippedIncompatibleSkillNames.push(skillName);
-              }
-            }
-            continue;
+          const changesBefore = result.filesCreated + result.filesUpdated;
+          await this.createOrUpdateFile(
+            baseDirectory,
+            file,
+            result,
+            file.skillFilePermissions
+          );
+          if (result.filesCreated + result.filesUpdated > changesBefore && this.isContentFile(file.path)) {
+            result.contentFilesChanged++;
           }
-          await this.createOrUpdateFile(baseDirectory, file, result);
         } catch (error) {
           const errorMsg = error instanceof Error ? error.message : String(error);
           result.errors.push(
@@ -9997,44 +10187,489 @@ var InstallDefaultSkillsUseCase = class {
           );
         }
       }
+      for (const file of response.fileUpdates.delete) {
+        try {
+          const deletedBefore = result.filesDeleted;
+          await this.deleteFile(baseDirectory, file.path, result);
+          if (result.filesDeleted > deletedBefore) {
+            if (file.path.includes(".packmind/standards/") && file.path.endsWith(".md")) {
+              result.standardsRemoved++;
+              result.contentFilesChanged++;
+            } else if (file.path.includes(".packmind/commands/") && file.path.endsWith(".md")) {
+              result.commandsRemoved++;
+              result.contentFilesChanged++;
+            } else if (file.path.includes(".packmind/skills/") && file.path.endsWith(".md")) {
+              result.skillsRemoved++;
+              result.contentFilesChanged++;
+            } else if (file.path.includes(".packmind/recipes/") && file.path.endsWith(".md")) {
+              result.recipesRemoved++;
+              result.contentFilesChanged++;
+            }
+          }
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          result.errors.push(`Failed to delete ${file.path}: ${errorMsg}`);
+        }
+      }
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      result.errors.push(`Failed to install default skills: ${errorMsg}`);
+      result.errors.push(`Failed to install packages: ${errorMsg}`);
+    }
+    if (normalizedPackages.length > 0) {
+      await this.configFileRepository.addPackagesToConfig(
+        baseDirectory,
+        normalizedPackages
+      );
     }
-    result.incompatibleInstalledSkills = Array.from(
-      incompatibleInstalledMap.entries()
-    ).map(
-      ([skillName, filePaths]) => ({
-        skillName,
-        filePaths
-      })
-    );
     return result;
   }
-  async createOrUpdateFile(baseDirectory, file, result) {
+  async normalizePackageSlugs(slugs) {
+    return normalizePackageSlugs(slugs, this.spaceService);
+  }
+  async normalizeAndSaveConfigPackages(baseDirectory, config) {
+    const originalSlugs = Object.keys(config.packages);
+    if (originalSlugs.length === 0) return [];
+    const normalizedSlugs = await this.normalizePackageSlugs(originalSlugs);
+    const hasChanges = normalizedSlugs.some(
+      (slug3, i) => slug3 !== originalSlugs[i]
+    );
+    if (hasChanges) {
+      const normalizedPackagesMap = {};
+      for (let i = 0; i < normalizedSlugs.length; i++) {
+        normalizedPackagesMap[normalizedSlugs[i]] = config.packages[originalSlugs[i]];
+      }
+      await this.configFileRepository.updateConfig(
+        baseDirectory,
+        "packages",
+        normalizedPackagesMap
+      );
+    }
+    return normalizedSlugs;
+  }
+  async validatePackageAccess(packages) {
+    const userSpaces = await this.spaceService.getSpaces();
+    const userSpaceSlugs = new Set(userSpaces.map((s) => s.slug));
+    const { host } = this.spaceService.getApiContext();
+    const errors = [];
+    for (const pkg of packages) {
+      const spaceSlug = pkg.startsWith("@") ? pkg.slice(1).split("/")[0] : null;
+      if (!spaceSlug || userSpaceSlugs.has(spaceSlug)) continue;
+      const space = await this.spaceService.getSpaceBySlug(spaceSlug);
+      if (!space || space.type === "private" /* private */) {
+        errors.push(`Package ${pkg} does not exist.`);
+      } else {
+        const organization = await this.packmindGateway.organization.getOrganization();
+        const joinUrl = `${host}/org/${organization.slug}/spaces/${spaceSlug}/join`;
+        errors.push(
+          `You don't have access to space @${spaceSlug}. It is a public space \u2014 you can join at: ${joinUrl}`
+        );
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(errors.join("\n"));
+    }
+  }
+  async computeJoinSpaceUrl(missingAccessSlugs) {
+    const spaceSlugs = /* @__PURE__ */ new Set();
+    for (const slug3 of missingAccessSlugs) {
+      if (slug3.startsWith("@")) {
+        const spaceSlug2 = slug3.slice(1).split("/")[0];
+        spaceSlugs.add(spaceSlug2);
+      }
+    }
+    if (spaceSlugs.size !== 1) return void 0;
+    const [spaceSlug] = spaceSlugs;
+    const space = await this.spaceService.getSpaceBySlug(spaceSlug);
+    if (!space || space.type !== "open" /* open */) return void 0;
+    const organization = await this.packmindGateway.organization.getOrganization();
+    const { host } = this.spaceService.getApiContext();
+    return `${host}/org/${organization.slug}/spaces/${spaceSlug}/join`;
+  }
+  async createOrUpdateFile(baseDirectory, file, result, skillFilePermissions) {
     const fullPath = path7.join(baseDirectory, file.path);
     const directory = path7.dirname(fullPath);
     await fs5.mkdir(directory, { recursive: true });
     const fileExists = await this.fileExists(fullPath);
+    if (file.content !== void 0) {
+      await this.handleFullContentUpdate(
+        fullPath,
+        file.content,
+        fileExists,
+        result,
+        file.isBase64
+      );
+    } else if (file.sections !== void 0) {
+      await this.handleSectionsUpdate(
+        fullPath,
+        file.sections,
+        fileExists,
+        result,
+        baseDirectory
+      );
+    }
+    if (skillFilePermissions && supportsUnixPermissions()) {
+      await fs5.chmod(fullPath, parsePermissionString(skillFilePermissions));
+    }
+  }
+  async handleFullContentUpdate(fullPath, content, fileExists, result, isBase64) {
+    if (isBase64) {
+      const buffer = Buffer.from(content, "base64");
+      await fs5.writeFile(fullPath, buffer);
+      if (fileExists) {
+        result.filesUpdated++;
+      } else {
+        result.filesCreated++;
+      }
+      return;
+    }
     if (fileExists) {
       const existingContent = await fs5.readFile(fullPath, "utf-8");
-      if (existingContent !== file.content) {
-        await fs5.writeFile(fullPath, file.content, "utf-8");
+      const commentMarker = this.extractCommentMarker(content);
+      let finalContent;
+      if (!commentMarker) {
+        finalContent = content;
+      } else {
+        finalContent = this.mergeContentWithMarkers(
+          existingContent,
+          content,
+          commentMarker
+        );
+      }
+      if (existingContent !== finalContent) {
+        await fs5.writeFile(fullPath, finalContent, "utf-8");
         result.filesUpdated++;
       }
     } else {
-      await fs5.writeFile(fullPath, file.content, "utf-8");
+      await fs5.writeFile(fullPath, content, "utf-8");
       result.filesCreated++;
     }
   }
-  async fileExists(filePath) {
-    try {
+  async handleSectionsUpdate(fullPath, sections, fileExists, result, baseDirectory) {
+    let currentContent = "";
+    if (fileExists) {
+      currentContent = await fs5.readFile(fullPath, "utf-8");
+    }
+    const mergedContent = mergeSectionsIntoFileContent(
+      currentContent,
+      sections
+    );
+    if (currentContent !== mergedContent) {
+      if (this.isEffectivelyEmpty(mergedContent) && fileExists) {
+        await fs5.unlink(fullPath);
+        result.filesDeleted++;
+        await this.removeEmptyParentDirectories(fullPath, baseDirectory);
+      } else {
+        await fs5.writeFile(fullPath, mergedContent, "utf-8");
+        if (fileExists) {
+          result.filesUpdated++;
+        } else {
+          result.filesCreated++;
+        }
+      }
+    }
+  }
+  async deleteFile(baseDirectory, filePath, result) {
+    const fullPath = path7.join(baseDirectory, filePath);
+    const stat9 = await fs5.stat(fullPath).catch(() => null);
+    if (stat9?.isDirectory()) {
+      await fs5.rm(fullPath, { recursive: true, force: true });
+      result.filesDeleted++;
+      await this.removeEmptyParentDirectories(fullPath, baseDirectory);
+    } else if (stat9?.isFile()) {
+      await fs5.unlink(fullPath);
+      result.filesDeleted++;
+      await this.removeEmptyParentDirectories(fullPath, baseDirectory);
+    }
+  }
+  isContentFile(filePath) {
+    return (filePath.includes(".packmind/standards/") || filePath.includes(".packmind/commands/") || filePath.includes(".packmind/skills/") || filePath.includes(".packmind/recipes/")) && filePath.endsWith(".md");
+  }
+  async fileExists(filePath) {
+    try {
       await fs5.access(filePath);
       return true;
     } catch {
       return false;
     }
   }
+  extractCommentMarker(content) {
+    const startMarkerPattern = /<!--\s*start:\s*([^-]+?)\s*-->/;
+    const match = content.match(startMarkerPattern);
+    return match ? match[1].trim() : null;
+  }
+  mergeContentWithMarkers(existingContent, newContent, commentMarker) {
+    const startMarker = `<!-- start: ${commentMarker} -->`;
+    const endMarker = `<!-- end: ${commentMarker} -->`;
+    const newSectionPattern = new RegExp(
+      `${this.escapeRegex(startMarker)}([\\s\\S]*?)${this.escapeRegex(endMarker)}`
+    );
+    const newSectionMatch = newContent.match(newSectionPattern);
+    const newSectionContent = newSectionMatch ? newSectionMatch[1].trim() : newContent;
+    const existingSectionPattern = new RegExp(
+      `${this.escapeRegex(startMarker)}[\\s\\S]*?${this.escapeRegex(endMarker)}`,
+      "g"
+    );
+    if (existingSectionPattern.test(existingContent)) {
+      return existingContent.replace(
+        existingSectionPattern,
+        `${startMarker}
+${newSectionContent}
+${endMarker}`
+      );
+    } else {
+      return `${existingContent}
+${startMarker}
+${newSectionContent}
+${endMarker}`;
+    }
+  }
+  isEffectivelyEmpty(content) {
+    const withoutEmptySections = content.replace(
+      /<!--\s*start:\s*[^-]+?\s*-->\s*<!--\s*end:\s*[^-]+?\s*-->/g,
+      ""
+    );
+    return withoutEmptySections.trim() === "";
+  }
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  async deleteSkillFolders(baseDirectory, folders) {
+    let deletedFilesCount = 0;
+    for (const folder of folders) {
+      const fullPath = path7.join(baseDirectory, folder);
+      try {
+        await fs5.access(fullPath);
+        const fileCount = await this.countFilesInDirectory(fullPath);
+        await fs5.rm(fullPath, { recursive: true, force: true });
+        deletedFilesCount += fileCount;
+        await this.removeEmptyParentDirectories(fullPath, baseDirectory);
+      } catch {
+      }
+    }
+    return deletedFilesCount;
+  }
+  async countFilesInDirectory(dirPath) {
+    let count = 0;
+    const entries = await fs5.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = path7.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        count += await this.countFilesInDirectory(entryPath);
+      } else {
+        count++;
+      }
+    }
+    return count;
+  }
+  async isDirectoryEmpty(dirPath) {
+    try {
+      const entries = await fs5.readdir(dirPath);
+      return entries.length === 0;
+    } catch {
+      return false;
+    }
+  }
+  async removeEmptyParentDirectories(fullPath, baseDirectory) {
+    const normalizedBase = path7.resolve(baseDirectory);
+    let currentDir = path7.dirname(path7.resolve(fullPath));
+    while (currentDir.startsWith(normalizedBase + path7.sep) && currentDir !== normalizedBase) {
+      const isEmpty = await this.isDirectoryEmpty(currentDir);
+      if (!isEmpty) break;
+      try {
+        await fs5.rmdir(currentDir);
+      } catch {
+        break;
+      }
+      currentDir = path7.dirname(currentDir);
+    }
+  }
+};
+
+// apps/cli/src/application/useCases/UninstallUseCase.ts
+var UninstallUseCase = class {
+  constructor(configFileRepository, spaceService, installUseCase) {
+    this.configFileRepository = configFileRepository;
+    this.spaceService = spaceService;
+    this.installUseCase = installUseCase;
+  }
+  async execute(command33) {
+    const baseDirectory = command33.baseDirectory || process.cwd();
+    const config = await this.configFileRepository.readConfig(baseDirectory);
+    if (!config) {
+      const configFileExists = await this.configFileRepository.configExists(baseDirectory);
+      if (configFileExists) {
+        throw new Error(
+          "packmind.json exists but could not be parsed. Please fix the JSON syntax errors and try again."
+        );
+      }
+      throw new Error(
+        "No packmind.json found in this directory. Run `packmind-cli install <@space/package>` first to install your packages."
+      );
+    }
+    const normalized = await normalizePackageSlugs(
+      command33.packages,
+      this.spaceService
+    );
+    const notInstalled = normalized.filter((pkg) => !(pkg in config.packages));
+    if (notInstalled.length > 0) {
+      const pkgList = notInstalled.map((p) => `  - ${p}`).join("\n");
+      throw new Error(
+        `The following package${notInstalled.length > 1 ? "s are" : " is"} not installed:
+${pkgList}`
+      );
+    }
+    const updatedPackages = { ...config.packages };
+    for (const pkg of normalized) {
+      delete updatedPackages[pkg];
+    }
+    await this.configFileRepository.updateConfig(
+      baseDirectory,
+      "packages",
+      updatedPackages
+    );
+    try {
+      return await this.installUseCase.execute({ baseDirectory });
+    } catch (error) {
+      await this.configFileRepository.updateConfig(
+        baseDirectory,
+        "packages",
+        config.packages
+      );
+      throw error;
+    }
+  }
+};
+
+// apps/cli/src/application/useCases/InstallDefaultSkillsUseCase.ts
+var fs6 = __toESM(require("fs/promises"));
+var path8 = __toESM(require("path"));
+var import_semver = __toESM(require("semver"));
+var InstallDefaultSkillsUseCase = class {
+  constructor(repositories) {
+    this.repositories = repositories;
+  }
+  async execute(command33) {
+    const baseDirectory = command33.baseDirectory || process.cwd();
+    const result = {
+      filesCreated: 0,
+      filesUpdated: 0,
+      errors: [],
+      skippedSkillsCount: 0,
+      skippedIncompatibleSkillNames: [],
+      incompatibleInstalledSkills: []
+    };
+    const config = await this.repositories.configFileRepository.readConfig(baseDirectory);
+    const agents = config?.agents;
+    const response = await this.repositories.packmindGateway.skills.getDefaults(
+      {
+        cliVersion: command33.cliVersion,
+        includeBeta: command33.includeBeta,
+        agents
+      }
+    );
+    result.skippedSkillsCount = response.skippedSkillsCount;
+    const incompatibleInstalledMap = /* @__PURE__ */ new Map();
+    const incompatibleSkillDirs = /* @__PURE__ */ new Map();
+    if (command33.cliVersion) {
+      for (const file of response.fileUpdates.createOrUpdate) {
+        if (path8.basename(file.path) === "SKILL.md" && file.content && this.isVersionConstraintViolated(file.content, command33.cliVersion)) {
+          const dir = path8.dirname(file.path);
+          const skillName = this.getSkillName(file.content) ?? path8.basename(dir);
+          incompatibleSkillDirs.set(dir, skillName);
+        }
+      }
+    }
+    try {
+      for (const file of response.fileUpdates.createOrUpdate) {
+        try {
+          if (!file.content) continue;
+          const isIncompatible = command33.cliVersion && (this.isVersionConstraintViolated(
+            file.content,
+            command33.cliVersion
+          ) || this.isUnderIncompatibleSkillDir(
+            file.path,
+            incompatibleSkillDirs
+          ));
+          if (isIncompatible) {
+            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) {
+              const paths = incompatibleInstalledMap.get(skillName) ?? [];
+              paths.push(file.path);
+              incompatibleInstalledMap.set(skillName, paths);
+            } else {
+              if (!result.skippedIncompatibleSkillNames.includes(skillName)) {
+                result.skippedIncompatibleSkillNames.push(skillName);
+              }
+            }
+            continue;
+          }
+          await this.createOrUpdateFile(baseDirectory, file, result);
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          result.errors.push(
+            `Failed to create/update ${file.path}: ${errorMsg}`
+          );
+        }
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      result.errors.push(`Failed to install default skills: ${errorMsg}`);
+    }
+    result.incompatibleInstalledSkills = Array.from(
+      incompatibleInstalledMap.entries()
+    ).map(
+      ([skillName, filePaths]) => ({
+        skillName,
+        filePaths
+      })
+    );
+    return result;
+  }
+  async createOrUpdateFile(baseDirectory, file, result) {
+    const fullPath = path8.join(baseDirectory, file.path);
+    const directory = path8.dirname(fullPath);
+    await fs6.mkdir(directory, { recursive: true });
+    const fileExists = await this.fileExists(fullPath);
+    if (fileExists) {
+      const existingContent = await fs6.readFile(fullPath, "utf-8");
+      if (existingContent !== file.content) {
+        await fs6.writeFile(fullPath, file.content, "utf-8");
+        result.filesUpdated++;
+      }
+    } else {
+      await fs6.writeFile(fullPath, file.content, "utf-8");
+      result.filesCreated++;
+    }
+  }
+  async fileExists(filePath) {
+    try {
+      await fs6.access(filePath);
+      return true;
+    } catch {
+      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
@@ -10148,13 +10783,13 @@ var EnvCredentialsProvider = class {
 };
 
 // apps/cli/src/infra/utils/credentials/FileCredentialsProvider.ts
-var fs6 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 var CREDENTIALS_DIR = ".packmind";
 var CREDENTIALS_FILE = "credentials.json";
 function getCredentialsPath() {
-  return path8.join(os2.homedir(), CREDENTIALS_DIR, CREDENTIALS_FILE);
+  return path9.join(os2.homedir(), CREDENTIALS_DIR, CREDENTIALS_FILE);
 }
 var FileCredentialsProvider = class {
   getSourceName() {
@@ -10162,11 +10797,11 @@ var FileCredentialsProvider = class {
   }
   hasCredentials() {
     const credentialsPath = getCredentialsPath();
-    if (!fs6.existsSync(credentialsPath)) {
+    if (!fs7.existsSync(credentialsPath)) {
       return false;
     }
     try {
-      const content = fs6.readFileSync(credentialsPath, "utf-8");
+      const content = fs7.readFileSync(credentialsPath, "utf-8");
       const credentials = JSON.parse(content);
       return !!credentials.apiKey;
     } catch {
@@ -10175,11 +10810,11 @@ var FileCredentialsProvider = class {
   }
   loadCredentials() {
     const credentialsPath = getCredentialsPath();
-    if (!fs6.existsSync(credentialsPath)) {
+    if (!fs7.existsSync(credentialsPath)) {
       return null;
     }
     try {
-      const content = fs6.readFileSync(credentialsPath, "utf-8");
+      const content = fs7.readFileSync(credentialsPath, "utf-8");
       const credentials = JSON.parse(content);
       if (!credentials.apiKey) {
         return null;
@@ -10202,13 +10837,13 @@ var FileCredentialsProvider = class {
   }
 };
 function saveCredentials(apiKey) {
-  const credentialsDir = path8.join(os2.homedir(), CREDENTIALS_DIR);
-  if (!fs6.existsSync(credentialsDir)) {
-    fs6.mkdirSync(credentialsDir, { recursive: true, mode: 448 });
+  const credentialsDir = path9.join(os2.homedir(), CREDENTIALS_DIR);
+  if (!fs7.existsSync(credentialsDir)) {
+    fs7.mkdirSync(credentialsDir, { recursive: true, mode: 448 });
   }
   const credentialsPath = getCredentialsPath();
   const credentials = { apiKey };
-  fs6.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
+  fs7.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
     mode: 384
   });
 }
@@ -10279,10 +10914,10 @@ async function defaultPromptForCode() {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     rl.question("Enter the login code from the browser: ", (answer) => {
       rl.close();
-      resolve14(answer.trim());
+      resolve15(answer.trim());
     });
   });
 }
@@ -10316,7 +10951,7 @@ async function defaultExchangeCodeForApiKey(code, host) {
   return await response.json();
 }
 function defaultStartCallbackServer() {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     let timeoutId = null;
     const server = http.createServer((req, res) => {
       res.setHeader("Access-Control-Allow-Origin", "*");
@@ -10329,7 +10964,7 @@ function defaultStartCallbackServer() {
         if (timeoutId) {
           clearTimeout(timeoutId);
         }
-        resolve14(code);
+        resolve15(code);
         setImmediate(() => {
           server.close();
         });
@@ -10400,14 +11035,14 @@ var LoginUseCase = class {
 };
 
 // apps/cli/src/application/useCases/LogoutUseCase.ts
-var fs7 = __toESM(require("fs"));
+var fs8 = __toESM(require("fs"));
 var ENV_VAR_NAME2 = "PACKMIND_API_KEY_V3";
 var LogoutUseCase = class {
   constructor(deps) {
     this.deps = {
       getCredentialsPath: deps?.getCredentialsPath ?? getCredentialsPath,
-      fileExists: deps?.fileExists ?? ((path36) => fs7.existsSync(path36)),
-      deleteFile: deps?.deleteFile ?? ((path36) => fs7.unlinkSync(path36)),
+      fileExists: deps?.fileExists ?? ((path37) => fs8.existsSync(path37)),
+      deleteFile: deps?.deleteFile ?? ((path37) => fs8.unlinkSync(path37)),
       hasEnvVar: deps?.hasEnvVar ?? (() => !!process.env[ENV_VAR_NAME2])
     };
   }
@@ -10756,8 +11391,8 @@ var SetupMcpUseCase = class {
 };
 
 // apps/cli/src/application/services/McpConfigService.ts
-var fs8 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+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 {
@@ -10804,11 +11439,11 @@ var McpConfigService = class {
   }
   installCursorMcp(config) {
     try {
-      const cursorConfigPath = path10.join(os3.homedir(), ".cursor", "mcp.json");
+      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);
-      fs8.writeFileSync(cursorConfigPath, JSON.stringify(mergedConfig, null, 2));
+      fs9.writeFileSync(cursorConfigPath, JSON.stringify(mergedConfig, null, 2));
       return { success: true };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -10817,15 +11452,15 @@ var McpConfigService = class {
   }
   installVSCodeMcp(config) {
     try {
-      const vscodeDir = path10.join(this.projectDir, ".vscode");
-      if (!fs8.existsSync(vscodeDir)) {
-        fs8.mkdirSync(vscodeDir, { recursive: true });
+      const vscodeDir = path11.join(this.projectDir, ".vscode");
+      if (!fs9.existsSync(vscodeDir)) {
+        fs9.mkdirSync(vscodeDir, { recursive: true });
       }
-      const vscodeConfigPath = path10.join(vscodeDir, "mcp.json");
+      const vscodeConfigPath = path11.join(vscodeDir, "mcp.json");
       const vscodeConfig = this.buildVSCodeConfig(config);
       const existingConfig = this.readExistingJsonConfig(vscodeConfigPath);
       const mergedConfig = this.mergeVSCodeConfig(existingConfig, vscodeConfig);
-      fs8.writeFileSync(vscodeConfigPath, JSON.stringify(mergedConfig, null, 2));
+      fs9.writeFileSync(vscodeConfigPath, JSON.stringify(mergedConfig, null, 2));
       return { success: true };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -10834,14 +11469,14 @@ var McpConfigService = class {
   }
   installContinueMcp(config) {
     try {
-      const continueDir = path10.join(this.projectDir, ".continue");
-      const mcpServersDir = path10.join(continueDir, "mcpServers");
-      if (!fs8.existsSync(mcpServersDir)) {
-        fs8.mkdirSync(mcpServersDir, { recursive: true });
+      const continueDir = path11.join(this.projectDir, ".continue");
+      const mcpServersDir = path11.join(continueDir, "mcpServers");
+      if (!fs9.existsSync(mcpServersDir)) {
+        fs9.mkdirSync(mcpServersDir, { recursive: true });
       }
-      const continueConfigPath = path10.join(mcpServersDir, "packmind.yaml");
+      const continueConfigPath = path11.join(mcpServersDir, "packmind.yaml");
       const continueConfig = this.buildContinueYamlConfig(config);
-      fs8.writeFileSync(continueConfigPath, continueConfig);
+      fs9.writeFileSync(continueConfigPath, continueConfig);
       return { success: true };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -10889,8 +11524,8 @@ mcpServers:
   }
   readExistingJsonConfig(filePath) {
     try {
-      if (fs8.existsSync(filePath)) {
-        const content = fs8.readFileSync(filePath, "utf-8");
+      if (fs9.existsSync(filePath)) {
+        const content = fs9.readFileSync(filePath, "utf-8");
         return JSON.parse(content);
       }
     } catch {
@@ -10923,8 +11558,8 @@ mcpServers:
 };
 
 // apps/cli/src/infra/repositories/ConfigFileRepository.ts
-var fs9 = __toESM(require("fs/promises"));
-var path11 = __toESM(require("path"));
+var fs10 = __toESM(require("fs/promises"));
+var path12 = __toESM(require("path"));
 var ConfigFileRepository = class {
   constructor() {
     this.CONFIG_FILENAME = "packmind.json";
@@ -10945,7 +11580,7 @@ var ConfigFileRepository = class {
   async configExists(baseDirectory) {
     const configPath = this.getConfigPath(baseDirectory);
     try {
-      await fs9.access(configPath);
+      await fs10.access(configPath);
       return true;
     } catch {
       return false;
@@ -10954,7 +11589,7 @@ var ConfigFileRepository = class {
   async readConfig(baseDirectory) {
     const configPath = this.getConfigPath(baseDirectory);
     try {
-      const configContent = await fs9.readFile(configPath, "utf-8");
+      const configContent = await fs10.readFile(configPath, "utf-8");
       const rawConfig = JSON.parse(configContent);
       if (!rawConfig.packages || typeof rawConfig.packages !== "object") {
         throw new Error(
@@ -10988,18 +11623,18 @@ var ConfigFileRepository = class {
     }
   }
   getConfigPath(directory) {
-    return path11.join(directory, this.CONFIG_FILENAME);
+    return path12.join(directory, this.CONFIG_FILENAME);
   }
   async writeConfigToPath(configPath, config) {
     const configContent = JSON.stringify(config, null, 2) + "\n";
-    await fs9.writeFile(configPath, configContent, "utf-8");
+    await fs10.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(path11.resolve(directory));
+    const normalizedDir = normalizePath2(path12.resolve(directory));
     return this.searchDescendantsRecursively(normalizedDir);
   }
   async searchDescendantsRecursively(currentDir) {
@@ -11012,7 +11647,7 @@ var ConfigFileRepository = class {
       if (!entry.isDirectory() || this.isExcludedDirectory(entry.name)) {
         continue;
       }
-      const entryPath = normalizePath2(path11.join(currentDir, entry.name));
+      const entryPath = normalizePath2(path12.join(currentDir, entry.name));
       const config = await this.readConfig(entryPath);
       if (config) {
         results.push(entryPath);
@@ -11024,7 +11659,7 @@ var ConfigFileRepository = class {
   }
   async tryReadDirectory(directory) {
     try {
-      return await fs9.readdir(directory, { withFileTypes: true });
+      return await fs10.readdir(directory, { withFileTypes: true });
     } catch {
       return null;
     }
@@ -11043,21 +11678,21 @@ var ConfigFileRepository = class {
   async readHierarchicalConfig(startDirectory, stopDirectory) {
     const configs = [];
     const configPaths = [];
-    const normalizedStart = normalizePath2(path11.resolve(startDirectory));
-    const normalizedStop = stopDirectory ? normalizePath2(path11.resolve(stopDirectory)) : null;
+    const normalizedStart = normalizePath2(path12.resolve(startDirectory));
+    const normalizedStop = stopDirectory ? normalizePath2(path12.resolve(stopDirectory)) : null;
     let currentDir = normalizedStart;
     while (true) {
       const config = await this.readConfig(currentDir);
       if (config) {
         configs.push(config);
         configPaths.push(
-          normalizePath2(path11.join(currentDir, this.CONFIG_FILENAME))
+          normalizePath2(path12.join(currentDir, this.CONFIG_FILENAME))
         );
       }
       if (normalizedStop !== null && currentDir === normalizedStop) {
         break;
       }
-      const parentDir = normalizePath2(path11.dirname(currentDir));
+      const parentDir = normalizePath2(path12.dirname(currentDir));
       if (parentDir === currentDir) {
         break;
       }
@@ -11082,8 +11717,8 @@ var ConfigFileRepository = class {
    * and returns each config with its target path.
    */
   async findAllConfigsInTree(startDirectory, stopDirectory) {
-    const normalizedStart = normalizePath2(path11.resolve(startDirectory));
-    const normalizedStop = stopDirectory ? normalizePath2(path11.resolve(stopDirectory)) : null;
+    const normalizedStart = normalizePath2(path12.resolve(startDirectory));
+    const normalizedStop = stopDirectory ? normalizePath2(path12.resolve(stopDirectory)) : null;
     const basePath = normalizedStop ?? normalizedStart;
     const searchRoot = normalizedStop ?? normalizedStart;
     const configsMap = /* @__PURE__ */ new Map();
@@ -11109,7 +11744,7 @@ var ConfigFileRepository = class {
       if (stopDir !== null && currentDir === stopDir) {
         break;
       }
-      const parentDir = normalizePath2(path11.dirname(currentDir));
+      const parentDir = normalizePath2(path12.dirname(currentDir));
       if (parentDir === currentDir) {
         break;
       }
@@ -11240,7 +11875,7 @@ var ConfigFileRepository = class {
   }
   async tryReadFile(filePath) {
     try {
-      return await fs9.readFile(filePath, "utf-8");
+      return await fs10.readFile(filePath, "utf-8");
     } catch (error) {
       if (error.code === "ENOENT") {
         return null;
@@ -11258,8 +11893,8 @@ var ConfigFileRepository = class {
 };
 
 // apps/cli/src/infra/repositories/LockFileRepository.ts
-var fs10 = __toESM(require("fs/promises"));
-var path12 = __toESM(require("path"));
+var fs11 = __toESM(require("fs/promises"));
+var path13 = __toESM(require("path"));
 var LockFileRepository = class {
   constructor() {
     this.LOCK_FILENAME = "packmind-lock.json";
@@ -11267,7 +11902,7 @@ var LockFileRepository = class {
   async read(baseDirectory) {
     const lockFilePath = this.getLockFilePath(baseDirectory);
     try {
-      const content = await fs10.readFile(lockFilePath, "utf-8");
+      const content = await fs11.readFile(lockFilePath, "utf-8");
       const parsed = JSON.parse(content);
       if (!this.isValidLockFile(parsed)) {
         logWarningConsole(`Malformed lock file: ${lockFilePath}`);
@@ -11293,7 +11928,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 path12.join(baseDirectory, this.LOCK_FILENAME);
+    return path13.join(baseDirectory, this.LOCK_FILENAME);
   }
 };
 
@@ -11308,17 +11943,12 @@ var ListStandardsUseCase = class {
       const response = await this.packmindGateway.standards.list({
         spaceId: command33.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();
@@ -11363,7 +11993,7 @@ var ListSkillsUseCase = class {
         slug: s.slug,
         name: s.name,
         description: s.description,
-        spaceId: command33.spaceId
+        spaceId: s.spaceId
       }));
     }
     const spaces = await this.spaceService.getSpaces();
@@ -11394,7 +12024,7 @@ function normalizeLineEndings(content) {
 }
 
 // apps/cli/src/infra/utils/binaryDetection.ts
-var path13 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   // Images
   ".png",
@@ -11452,7 +12082,7 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".sqlite3"
 ]);
 function isBinaryExtension(filePath) {
-  const ext = path13.extname(filePath).toLowerCase();
+  const ext = path14.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 }
 function isBinaryBuffer(buffer) {
@@ -11472,7 +12102,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(
@@ -11594,17 +12228,17 @@ ${spaceList}`
 
 // apps/cli/src/application/useCases/diffStrategies/CommandDiffStrategy.ts
 var import_diff2 = require("diff");
-var fs12 = __toESM(require("fs/promises"));
-var path15 = __toESM(require("path"));
+var fs13 = __toESM(require("fs/promises"));
+var path16 = __toESM(require("path"));
 var CommandDiffStrategy = class {
   supports(file) {
     return file.artifactType === "command";
   }
   async diff(file, baseDirectory) {
-    const fullPath = path15.join(baseDirectory, file.path);
+    const fullPath = path16.join(baseDirectory, file.path);
     let localContent;
     try {
-      localContent = await fs12.readFile(fullPath, "utf-8");
+      localContent = await fs13.readFile(fullPath, "utf-8");
     } catch {
       return [];
     }
@@ -11634,8 +12268,8 @@ var CommandDiffStrategy = class {
 
 // apps/cli/src/application/useCases/diffStrategies/SkillDiffStrategy.ts
 var import_diff3 = require("diff");
-var fs13 = __toESM(require("fs/promises"));
-var path16 = __toESM(require("path"));
+var fs14 = __toESM(require("fs/promises"));
+var path17 = __toESM(require("path"));
 
 // apps/cli/src/application/utils/stripFrontmatter.ts
 var FRONTMATTER_DELIMITER2 = "---";
@@ -11670,7 +12304,7 @@ var SkillDiffStrategy = class {
   async diffNewFiles(skillFolders, serverFiles, baseDirectory) {
     const diffs = [];
     for (const folder of skillFolders) {
-      const folderPath = path16.join(baseDirectory, folder);
+      const folderPath = path17.join(baseDirectory, folder);
       const localFiles = await this.listFilesRecursively(folderPath);
       const serverPathsInFolder = new Set(
         serverFiles.filter((f) => f.path.startsWith(folder + "/")).map((f) => f.path)
@@ -11689,7 +12323,7 @@ var SkillDiffStrategy = class {
         if (serverPathsInFolder.has(filePath)) {
           continue;
         }
-        const fullPath = path16.join(baseDirectory, filePath);
+        const fullPath = path17.join(baseDirectory, filePath);
         const localRead = await this.tryReadFileBinaryAware(fullPath);
         if (localRead === null) {
           continue;
@@ -11716,7 +12350,7 @@ var SkillDiffStrategy = class {
     return diffs;
   }
   async diffSkillMd(file, baseDirectory) {
-    const fullPath = path16.join(baseDirectory, file.path);
+    const fullPath = path17.join(baseDirectory, file.path);
     const localContent = await this.tryReadFile(fullPath);
     if (localContent === null) {
       return [];
@@ -11773,7 +12407,7 @@ var SkillDiffStrategy = class {
       return [];
     }
     const skillFileId = createSkillFileId(file.skillFileId);
-    const fullPath = path16.join(baseDirectory, file.path);
+    const fullPath = path17.join(baseDirectory, file.path);
     const localRead = await this.tryReadFileBinaryAware(fullPath);
     const fileRelativePath = this.computeRelativePath(file.path, skillFolders);
     if (localRead === null) {
@@ -11983,14 +12617,14 @@ var SkillDiffStrategy = class {
   }
   async tryReadFile(filePath) {
     try {
-      return await fs13.readFile(filePath, "utf-8");
+      return await fs14.readFile(filePath, "utf-8");
     } catch {
       return null;
     }
   }
   async tryReadFileBinaryAware(filePath) {
     try {
-      const buffer = await fs13.readFile(filePath);
+      const buffer = await fs14.readFile(filePath);
       if (isBinaryFile(filePath, buffer)) {
         return { content: buffer.toString("base64"), isBase64: true };
       }
@@ -12002,13 +12636,13 @@ var SkillDiffStrategy = class {
   async listFilesRecursively(dirPath, prefix = "") {
     let entries;
     try {
-      entries = await fs13.readdir(dirPath);
+      entries = await fs14.readdir(dirPath);
     } catch {
       return [];
     }
     const files = [];
     for (const entry of entries) {
-      const fullPath = path16.join(dirPath, entry);
+      const fullPath = path17.join(dirPath, entry);
       const stat9 = await this.tryStatFile(fullPath);
       if (!stat9) {
         continue;
@@ -12028,7 +12662,7 @@ var SkillDiffStrategy = class {
   }
   async tryStatFile(filePath) {
     try {
-      const stat9 = await fs13.stat(filePath);
+      const stat9 = await fs14.stat(filePath);
       return { isDirectory: stat9.isDirectory() };
     } catch {
       return null;
@@ -12036,7 +12670,7 @@ var SkillDiffStrategy = class {
   }
   async tryGetPermissions(filePath) {
     try {
-      const stat9 = await fs13.stat(filePath);
+      const stat9 = await fs14.stat(filePath);
       return modeToPermissionStringOrDefault(stat9.mode);
     } catch {
       return null;
@@ -12052,8 +12686,8 @@ var SkillDiffStrategy = class {
 };
 
 // apps/cli/src/application/useCases/diffStrategies/StandardDiffStrategy.ts
-var fs14 = __toESM(require("fs/promises"));
-var path17 = __toESM(require("path"));
+var fs15 = __toESM(require("fs/promises"));
+var path18 = __toESM(require("path"));
 
 // apps/cli/src/application/utils/parseStandardMd.ts
 var DEPLOYER_PARSERS = [
@@ -12361,10 +12995,10 @@ var StandardDiffStrategy = class {
     return file.artifactType === "standard";
   }
   async diff(file, baseDirectory) {
-    const fullPath = path17.join(baseDirectory, file.path);
+    const fullPath = path18.join(baseDirectory, file.path);
     let localContent;
     try {
-      localContent = await fs14.readFile(fullPath, "utf-8");
+      localContent = await fs15.readFile(fullPath, "utf-8");
     } catch {
       return [];
     }
@@ -12728,6 +13362,149 @@ var SpaceService = class {
     }
     return defaultSpace;
   }
+  async getSpaceBySlug(slug3) {
+    return this.spaceGateway.getSpaceBySlug(slug3);
+  }
+  getApiContext() {
+    return this.spaceGateway.getApiContext();
+  }
+};
+
+// 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(command33) {
+    return source_default.yellow(command33);
+  }
+  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
@@ -12736,7 +13513,8 @@ var PackmindCliHexaFactory = class {
     this.repositories = {
       packmindGateway: new PackmindGateway(loadApiKey()),
       configFileRepository: new ConfigFileRepository(),
-      lockFileRepository: new LockFileRepository()
+      lockFileRepository: new LockFileRepository(),
+      output: new CliOutput()
     };
     this.services = {
       listFiles: new ListFiles(),
@@ -12745,6 +13523,12 @@ var PackmindCliHexaFactory = class {
       diffViolationFilterService: new DiffViolationFilterService(),
       spaceService: new SpaceService(this.repositories.packmindGateway.spaces)
     };
+    const installUseCase = new InstallUseCase(
+      this.repositories.packmindGateway,
+      this.repositories.lockFileRepository,
+      this.repositories.configFileRepository,
+      this.services.spaceService
+    );
     this.useCases = {
       executeSingleFileAst: new ExecuteSingleFileAstUseCase(
         this.services.linterExecutionUseCase
@@ -12762,6 +13546,12 @@ var PackmindCliHexaFactory = class {
       installPackages: new InstallPackagesUseCase(
         this.repositories.packmindGateway
       ),
+      install: installUseCase,
+      uninstall: new UninstallUseCase(
+        this.repositories.configFileRepository,
+        this.services.spaceService,
+        installUseCase
+      ),
       installDefaultSkills: new InstallDefaultSkillsUseCase(this.repositories),
       listPackages: new ListPackagesUseCase(
         this.repositories.packmindGateway,
@@ -12813,6 +13603,11 @@ var PackmindCliHexa = class {
         command33
       );
     };
+    this.notifyArtefactsDistribution = async (command33) => {
+      return this.hexa.repositories.packmindGateway.deployment.notifyArtefactsDistribution(
+        command33
+      );
+    };
     this.logger = logger2;
     try {
       this.hexa = new PackmindCliHexaFactory();
@@ -12830,6 +13625,9 @@ var PackmindCliHexa = class {
     this.logger.info("Destroying PackmindCliHexa");
     this.logger.info("PackmindCliHexa destroyed");
   }
+  get output() {
+    return this.hexa.repositories.output;
+  }
   async getGitRemoteUrl(command33) {
     return this.hexa.useCases.getGitRemoteUrl.execute(command33);
   }
@@ -12845,6 +13643,12 @@ var PackmindCliHexa = class {
   async installPackages(command33) {
     return this.hexa.useCases.installPackages.execute(command33);
   }
+  async install(command33) {
+    return this.hexa.useCases.install.execute(command33);
+  }
+  async uninstall(command33) {
+    return this.hexa.useCases.uninstall.execute(command33);
+  }
   async diffArtefacts(command33) {
     return this.hexa.useCases.diffArtefacts.execute(command33);
   }
@@ -13103,31 +13907,31 @@ var HumanReadableLogger = class {
 var pathModule2 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/lintHandler.ts
-var fs16 = __toESM(require("fs/promises"));
+var fs17 = __toESM(require("fs/promises"));
 var pathModule = __toESM(require("path"));
 
 // apps/cli/src/application/services/PackmindIgnoreReader.ts
-var fs15 = __toESM(require("fs/promises"));
-var path18 = __toESM(require("path"));
+var fs16 = __toESM(require("fs/promises"));
+var path19 = __toESM(require("path"));
 var IGNORE_FILENAME = ".packmindignore";
 var PackmindIgnoreReader = class {
   async readIgnorePatterns(startDirectory, stopDirectory) {
     const patterns = [];
-    const normalizedStart = path18.resolve(startDirectory);
-    const normalizedStop = stopDirectory ? path18.resolve(stopDirectory) : null;
+    const normalizedStart = path19.resolve(startDirectory);
+    const normalizedStop = stopDirectory ? path19.resolve(stopDirectory) : null;
     if (normalizedStop === null) {
-      const ignoreFile = path18.join(normalizedStart, IGNORE_FILENAME);
+      const ignoreFile = path19.join(normalizedStart, IGNORE_FILENAME);
       return this.parseIgnoreFile(ignoreFile);
     }
     let currentDir = normalizedStart;
     while (true) {
-      const ignoreFile = path18.join(currentDir, IGNORE_FILENAME);
+      const ignoreFile = path19.join(currentDir, IGNORE_FILENAME);
       const filePatterns = await this.parseIgnoreFile(ignoreFile);
       patterns.push(...filePatterns);
       if (currentDir === normalizedStop) {
         break;
       }
-      const parentDir = path18.dirname(currentDir);
+      const parentDir = path19.dirname(currentDir);
       if (parentDir === currentDir) {
         break;
       }
@@ -13138,7 +13942,7 @@ var PackmindIgnoreReader = class {
   async parseIgnoreFile(filePath) {
     let content;
     try {
-      content = await fs15.readFile(filePath, "utf-8");
+      content = await fs16.readFile(filePath, "utf-8");
     } catch (err) {
       if (err.code === "ENOENT") {
         return [];
@@ -13159,7 +13963,7 @@ function isNotLoggedInError(error) {
 }
 async function lintHandler(args2, deps) {
   const {
-    path: path36,
+    path: path37,
     draft,
     rule,
     language,
@@ -13181,11 +13985,11 @@ async function lintHandler(args2, deps) {
     throw new Error("option --rule is required to use --draft mode");
   }
   const startedAt = Date.now();
-  const targetPath = path36 ?? ".";
+  const targetPath = path37 ?? ".";
   const absolutePath = resolvePath(targetPath);
   let stats;
   try {
-    stats = await fs16.stat(absolutePath);
+    stats = await fs17.stat(absolutePath);
   } catch (err) {
     const isNotFound = err.code === "ENOENT";
     const message = isNotFound ? `File or directory "${absolutePath}" does not exist` : `Cannot access "${absolutePath}": ${err.message}`;
@@ -13503,72 +14307,15 @@ function extractWasmFiles() {
 
 // apps/cli/src/main.ts
 var import_dotenv = require("dotenv");
-var fs27 = __toESM(require("fs"));
-var path35 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path36 = __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"));
 
 // apps/cli/src/infra/commands/installPackagesHandler.ts
-var fs17 = __toESM(require("fs/promises"));
-var path19 = __toESM(require("path"));
-var { version: CLI_VERSION } = require_package();
-async function notifyDistributionIfInGitRepo(params) {
-  const { packmindCliHexa, cwd, packages, log, agents } = params;
-  const resolvedGitRoot = params.gitRoot ?? await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
-  if (!resolvedGitRoot) {
-    return false;
-  }
-  try {
-    const gitRemoteUrl = packmindCliHexa.getGitRemoteUrlFromPath(resolvedGitRoot);
-    const gitBranch = packmindCliHexa.getCurrentBranch(resolvedGitRoot);
-    let relativePath = cwd.startsWith(resolvedGitRoot) ? cwd.slice(resolvedGitRoot.length) : "/";
-    if (!relativePath.startsWith("/")) {
-      relativePath = "/" + relativePath;
-    }
-    if (!relativePath.endsWith("/")) {
-      relativePath = relativePath + "/";
-    }
-    await packmindCliHexa.notifyDistribution({
-      distributedPackages: packages,
-      gitRemoteUrl,
-      gitBranch,
-      relativePath,
-      agents
-    });
-    log("Successfully notified Packmind of the new distribution");
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function installDefaultSkillsIfAtGitRoot(params) {
-  const { packmindCliHexa, cwd, log } = params;
-  const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
-  if (!gitRoot || cwd !== gitRoot) {
-    return;
-  }
-  try {
-    log("\nInstalling default skills...");
-    const skillsResult = await packmindCliHexa.installDefaultSkills({
-      cliVersion: CLI_VERSION
-    });
-    if (skillsResult.errors.length > 0) {
-      skillsResult.errors.forEach((err) => {
-        log(`   Warning: ${err}`);
-      });
-    }
-    const totalSkillFiles = skillsResult.filesCreated + skillsResult.filesUpdated;
-    if (totalSkillFiles > 0) {
-      log(
-        `Default skills: added ${skillsResult.filesCreated} files, changed ${skillsResult.filesUpdated} files`
-      );
-    } else if (skillsResult.errors.length === 0) {
-      log("Default skills are already up to date");
-    }
-  } catch {
-  }
-}
 function formatOverviewRow(configPath, packages, pathColumnWidth) {
   const paddedPath = configPath.padEnd(pathColumnWidth);
   if (packages.length === 0) {
@@ -13641,1150 +14388,340 @@ ${uniqueCount} unique ${packageWord} currently installed.`);
     };
   }
 }
-async function executeInstallForDirectory(directory, deps) {
-  const { packmindCliHexa, log } = deps;
-  let configPackages;
-  let configAgents;
+
+// apps/cli/src/infra/commands/InstallCommand.ts
+var { version: CLI_VERSION } = require_package();
+function findSubDirectoriesWithPackmindJson(dirPath, recursive) {
+  const result = [];
+  let entries;
   try {
-    const fullConfig = await packmindCliHexa.readFullConfig(directory);
-    if (fullConfig) {
-      configPackages = Object.keys(fullConfig.packages);
-      configAgents = fullConfig.agents;
-    } else {
-      configPackages = [];
-    }
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    return {
-      success: false,
-      filesCreated: 0,
-      filesUpdated: 0,
-      filesDeleted: 0,
-      notificationSent: false,
-      errorMessage: `Failed to parse packmind.json: ${errorMessage}`
-    };
-  }
-  if (configPackages.length === 0) {
-    return {
-      success: true,
-      filesCreated: 0,
-      filesUpdated: 0,
-      filesDeleted: 0,
-      notificationSent: false
-    };
+    entries = fs18.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return result;
   }
-  const normalizedConfigPackages = await packmindCliHexa.normalizePackageSlugs(configPackages);
-  let gitRemoteUrl;
-  let gitBranch;
-  let relativePath;
-  const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(directory);
-  if (gitRoot) {
-    try {
-      gitRemoteUrl = packmindCliHexa.getGitRemoteUrlFromPath(gitRoot);
-      gitBranch = packmindCliHexa.getCurrentBranch(gitRoot);
-      relativePath = directory.startsWith(gitRoot) ? directory.slice(gitRoot.length) : "/";
-      if (!relativePath.startsWith("/")) {
-        relativePath = "/" + relativePath;
-      }
-      if (!relativePath.endsWith("/")) {
-        relativePath = relativePath + "/";
-      }
-    } catch {
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const subDir = path20.join(dirPath, entry.name);
+    if (fs18.existsSync(path20.join(subDir, "packmind.json"))) {
+      result.push(subDir);
+    }
+    if (recursive) {
+      result.push(...findSubDirectoriesWithPackmindJson(subDir, true));
     }
   }
+  return result;
+}
+function mergeInstallResults(results) {
+  const merged = {
+    filesCreated: 0,
+    filesUpdated: 0,
+    filesDeleted: 0,
+    contentFilesChanged: 0,
+    errors: [],
+    recipesCount: 0,
+    standardsCount: 0,
+    commandsCount: 0,
+    skillsCount: 0,
+    recipesRemoved: 0,
+    standardsRemoved: 0,
+    commandsRemoved: 0,
+    skillsRemoved: 0,
+    skillDirectoriesDeleted: 0,
+    missingAccess: [],
+    joinSpaceUrl: void 0
+  };
+  for (const r of results) {
+    merged.filesCreated += r.filesCreated;
+    merged.filesUpdated += r.filesUpdated;
+    merged.filesDeleted += r.filesDeleted;
+    merged.contentFilesChanged += r.contentFilesChanged;
+    merged.errors.push(...r.errors);
+    merged.recipesCount += r.recipesCount;
+    merged.standardsCount += r.standardsCount;
+    merged.commandsCount += r.commandsCount;
+    merged.skillsCount += r.skillsCount;
+    merged.recipesRemoved += r.recipesRemoved;
+    merged.standardsRemoved += r.standardsRemoved;
+    merged.commandsRemoved += r.commandsRemoved;
+    merged.skillsRemoved += r.skillsRemoved;
+    merged.skillDirectoriesDeleted += r.skillDirectoriesDeleted;
+    merged.missingAccess.push(...r.missingAccess);
+  }
+  merged.missingAccess = [...new Set(merged.missingAccess)];
+  const urlsFromResultsWithMissingAccess = results.filter((r) => r.missingAccess.length > 0).map((r) => r.joinSpaceUrl);
+  const uniqueUrls = new Set(urlsFromResultsWithMissingAccess.filter(Boolean));
+  if (uniqueUrls.size === 1 && !urlsFromResultsWithMissingAccess.some((u) => u === void 0)) {
+    merged.joinSpaceUrl = [...uniqueUrls][0];
+  }
+  return merged;
+}
+function buildInstallSummary(result) {
+  const contentParts = [
+    result.standardsCount > 0 ? `${result.standardsCount} ${result.standardsCount === 1 ? "standard" : "standards"}` : null,
+    result.commandsCount > 0 ? `${result.commandsCount} ${result.commandsCount === 1 ? "command" : "commands"}` : null,
+    result.skillsCount > 0 ? `${result.skillsCount} ${result.skillsCount === 1 ? "skill" : "skills"}` : null,
+    result.recipesCount > 0 ? `${result.recipesCount} ${result.recipesCount === 1 ? "recipe" : "recipes"}` : null
+  ].filter(Boolean);
+  const contentChanged = result.contentFilesChanged > 0;
+  if (!contentChanged && contentParts.length === 0) {
+    return "\u2705 Nothing to install";
+  }
+  if (!contentChanged) {
+    return `\u2705 Already up to date \u2014 ${contentParts.join(", ")}`;
+  }
+  if (contentParts.length === 0) {
+    return "\u2705 Packages removed";
+  }
+  return `\u2705 Synced ${contentParts.join(", ")}`;
+}
+async function notifyArtefactsDistributionIfInGitRepo(params) {
+  const { packmindCliHexa, dir } = params;
   try {
-    const packageCount = normalizedConfigPackages.length;
-    const packageWord = packageCount === 1 ? "package" : "packages";
-    log(
-      `  Fetching ${packageCount} ${packageWord}: ${normalizedConfigPackages.join(", ")}...`
-    );
-    const result = await packmindCliHexa.installPackages({
-      baseDirectory: directory,
-      packagesSlugs: normalizedConfigPackages,
-      previousPackagesSlugs: normalizedConfigPackages,
-      // Pass for consistency
+    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 packmindLockFile = JSON.parse(content);
+    const gitRemoteUrl = packmindCliHexa.getGitRemoteUrlFromPath(gitRoot);
+    const gitBranch = packmindCliHexa.getCurrentBranch(gitRoot);
+    let relativePath = dir.startsWith(gitRoot) ? dir.slice(gitRoot.length) : "/";
+    if (!relativePath.startsWith("/")) {
+      relativePath = "/" + relativePath;
+    }
+    if (!relativePath.endsWith("/")) {
+      relativePath = relativePath + "/";
+    }
+    await packmindCliHexa.notifyArtefactsDistribution({
       gitRemoteUrl,
       gitBranch,
       relativePath,
-      agents: configAgents
-      // Pass agents from config if present
+      packmindLockFile
     });
-    const parts = [];
-    if (result.recipesCount > 0) parts.push(`${result.recipesCount} commands`);
-    if (result.standardsCount > 0)
-      parts.push(`${result.standardsCount} standards`);
-    if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
-    log(`  Installing ${parts.join(", ") || "artifacts"}...`);
-    log(
-      `  added ${result.filesCreated} files, changed ${result.filesUpdated} files, removed ${result.filesDeleted} files`
-    );
-    if (result.errors.length > 0) {
-      return {
-        success: false,
-        filesCreated: result.filesCreated,
-        filesUpdated: result.filesUpdated,
-        filesDeleted: result.filesDeleted,
-        notificationSent: false,
-        errorMessage: result.errors.join(", ")
-      };
-    }
-    const configSlugsWereNormalized = configPackages.some(
-      (slug3, i) => slug3 !== normalizedConfigPackages[i]
-    );
-    if (configSlugsWereNormalized) {
-      await packmindCliHexa.writeConfig(directory, normalizedConfigPackages);
-    }
-    const skillDirsDeleted = result.skillDirectoriesDeleted || 0;
-    let notificationSent = false;
-    if (result.filesCreated > 0 || result.filesUpdated > 0 || result.filesDeleted > 0 || skillDirsDeleted > 0) {
-      notificationSent = await notifyDistributionIfInGitRepo({
-        packmindCliHexa,
-        cwd: directory,
-        packages: normalizedConfigPackages,
-        agents: configAgents,
-        log: () => {
-        },
-        gitRoot: gitRoot ?? void 0
-      });
-    }
-    return {
-      success: true,
-      filesCreated: result.filesCreated,
-      filesUpdated: result.filesUpdated,
-      filesDeleted: result.filesDeleted + skillDirsDeleted,
-      notificationSent
-    };
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    return {
-      success: false,
-      filesCreated: 0,
-      filesUpdated: 0,
-      filesDeleted: 0,
-      notificationSent: false,
-      errorMessage
-    };
+  } catch {
   }
 }
-async function installPackagesHandler(args2, deps) {
-  const { packmindCliHexa, exit, getCwd, log, error } = deps;
-  const { packagesSlugs } = args2;
-  const rawCwd = getCwd();
-  let cwd = rawCwd;
-  if (args2.path) {
-    const resolvedPath = path19.resolve(rawCwd, args2.path);
-    try {
-      const stat9 = await fs17.stat(resolvedPath);
-      if (!stat9.isDirectory()) {
-        logErrorConsole(`Path is not a directory: ${resolvedPath}`);
-        exit(1);
-        return {
-          filesCreated: 0,
-          filesUpdated: 0,
-          filesDeleted: 0,
-          notificationSent: false
-        };
-      }
-      cwd = resolvedPath;
-    } catch {
-      logErrorConsole(`Path does not exist: ${resolvedPath}`);
-      exit(1);
-      return {
-        filesCreated: 0,
-        filesUpdated: 0,
-        filesDeleted: 0,
-        notificationSent: false
-      };
-    }
-    const relativeToCwd = path19.relative(rawCwd, resolvedPath);
-    const displayPath = relativeToCwd ? `./${relativeToCwd}/packmind.json` : `./packmind.json`;
-    log(`Installing in ${displayPath}...`);
+async function installDefaultSkillsIfAtGitRoot(params) {
+  const { packmindCliHexa, cwd } = params;
+  const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
+  if (!gitRoot || cwd !== gitRoot) {
+    return;
   }
-  let configPackages;
-  let configAgents;
-  let configFileExists = false;
   try {
-    configFileExists = await packmindCliHexa.configExists(cwd);
-    const fullConfig = await packmindCliHexa.readFullConfig(cwd);
-    if (fullConfig) {
-      const hasNonWildcardVersions = Object.values(fullConfig.packages).some(
-        (version2) => version2 !== "*"
-      );
-      if (hasNonWildcardVersions) {
-        logWarningConsole(
-          "Package versions are not supported yet, getting the latest version"
-        );
-      }
-      configPackages = Object.keys(fullConfig.packages);
-      configAgents = fullConfig.agents;
-    } else {
-      configPackages = [];
+    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}`);
+      });
     }
-  } catch (err) {
-    error("ERROR Failed to parse packmind.json");
-    if (err instanceof Error) {
-      error(`ERROR ${err.message}`);
-    } else {
-      error(`ERROR ${String(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");
     }
-    error("\n\u{1F4A1} Please fix the packmind.json file or delete it to continue.");
-    exit(1);
-    return {
-      filesCreated: 0,
-      filesUpdated: 0,
-      filesDeleted: 0,
-      notificationSent: false
-    };
+  } catch {
   }
-  let normalizedNewSlugs;
-  let normalizedConfigSlugs;
-  try {
-    normalizedNewSlugs = await packmindCliHexa.normalizePackageSlugs(packagesSlugs);
-    normalizedConfigSlugs = await packmindCliHexa.normalizePackageSlugs(configPackages);
-  } catch (err) {
-    error(`ERROR ${err instanceof Error ? err.message : String(err)}`);
-    exit(1);
-    return {
-      filesCreated: 0,
-      filesUpdated: 0,
-      filesDeleted: 0,
-      notificationSent: false
+}
+async function installHandler({
+  installPath,
+  packages,
+  list,
+  show,
+  status
+}) {
+  const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
+  const packmindCliHexa = new PackmindCliHexa(packmindLogger);
+  if (status) {
+    const deps = {
+      packmindCliHexa,
+      exit: process.exit,
+      getCwd: () => process.cwd(),
+      log: console.log,
+      error: console.error
     };
+    await statusHandler({}, deps);
+    return;
   }
-  const allPackages = [
-    .../* @__PURE__ */ new Set([...normalizedConfigSlugs, ...normalizedNewSlugs])
-  ];
-  if (allPackages.length === 0) {
-    if (configFileExists) {
-      logWarningConsole(
-        "config packmind.json is empty, no packages to install"
-      );
-    } else {
-      logWarningConsole("config packmind.json not found");
-    }
-    log("Usage: packmind-cli install <package-slug> [package-slug...]");
-    log("       packmind-cli install --list");
-    log("");
-    log("Examples:");
-    log("  packmind-cli install backend");
-    log("  packmind-cli install backend frontend");
-    log("  packmind-cli install --list  # Show available packages");
-    log("");
-    log("Install commands and standards from the specified packages.");
-    exit(0);
-    return {
-      filesCreated: 0,
-      filesUpdated: 0,
-      filesDeleted: 0,
-      notificationSent: false
-    };
-  }
-  if (!configFileExists && packagesSlugs.length > 0) {
-    log("INFO initializing packmind.json");
-  }
-  try {
-    const packageCount = allPackages.length;
-    const packageWord = packageCount === 1 ? "package" : "packages";
-    log(
-      `Fetching ${packageCount} ${packageWord}: ${allPackages.join(", ")}...`
-    );
-    let gitRemoteUrl;
-    let gitBranch;
-    let relativePath;
-    const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
-    if (gitRoot) {
-      try {
-        gitRemoteUrl = packmindCliHexa.getGitRemoteUrlFromPath(gitRoot);
-        gitBranch = packmindCliHexa.getCurrentBranch(gitRoot);
-        relativePath = cwd.startsWith(gitRoot) ? cwd.slice(gitRoot.length) : "/";
-        if (!relativePath.startsWith("/")) {
-          relativePath = "/" + relativePath;
-        }
-        if (!relativePath.endsWith("/")) {
-          relativePath = relativePath + "/";
-        }
-      } catch {
-      }
-    }
-    const result = await packmindCliHexa.installPackages({
-      baseDirectory: cwd,
-      packagesSlugs: allPackages,
-      previousPackagesSlugs: normalizedConfigSlugs,
-      // Pass previous config for change detection
-      gitRemoteUrl,
-      gitBranch,
-      relativePath,
-      agents: configAgents
-      // Pass agents from config if present (overrides org-level)
-    });
-    const parts = [];
-    if (result.recipesCount > 0) parts.push(`${result.recipesCount} commands`);
-    if (result.standardsCount > 0)
-      parts.push(`${result.standardsCount} standards`);
-    if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
-    log(`Installing ${parts.join(", ") || "artifacts"}...`);
-    const skillDirsDeleted = result.skillDirectoriesDeleted || 0;
-    const totalDeleted = result.filesDeleted + skillDirsDeleted;
-    log(
-      `
-added ${result.filesCreated} files, changed ${result.filesUpdated} files, removed ${totalDeleted} files`
-    );
-    if (result.errors.length > 0) {
-      log("\n\u26A0\uFE0F  Errors encountered:");
-      result.errors.forEach((err) => {
-        log(`   - ${err}`);
-      });
-      exit(1);
-      return {
-        filesCreated: result.filesCreated,
-        filesUpdated: result.filesUpdated,
-        filesDeleted: totalDeleted,
-        notificationSent: false
-      };
-    }
-    const configSlugsWereNormalized = configPackages.some(
-      (slug3, i) => slug3 !== normalizedConfigSlugs[i]
-    );
-    const newPackages = normalizedNewSlugs.filter(
-      (slug3) => !normalizedConfigSlugs.includes(slug3)
-    );
-    if (configSlugsWereNormalized) {
-      await packmindCliHexa.writeConfig(cwd, allPackages);
-    } else if (newPackages.length > 0) {
-      await packmindCliHexa.addPackagesToConfig(cwd, newPackages);
-    }
-    let notificationSent = false;
-    if (result.filesCreated > 0 || result.filesUpdated > 0 || result.filesDeleted > 0 || skillDirsDeleted > 0) {
-      notificationSent = await notifyDistributionIfInGitRepo({
-        packmindCliHexa,
-        cwd,
-        packages: allPackages,
-        agents: configAgents,
-        log
-      });
-    }
-    await installDefaultSkillsIfAtGitRoot({
-      packmindCliHexa,
-      cwd,
-      log
-    });
-    if (deps.playbookLocalRepository) {
-      deps.playbookLocalRepository.clearAll();
-    }
-    return {
-      filesCreated: result.filesCreated,
-      filesUpdated: result.filesUpdated,
-      filesDeleted: totalDeleted,
-      notificationSent
-    };
-  } catch (err) {
-    error("\n\u274C Failed to install content:");
-    if (err instanceof Error) {
-      const errorObj = err;
-      if (errorObj.statusCode === 400) {
-        error(`   ${errorObj.message}`);
-        error("\n\u{1F4A1} This is a validation error. Please check:");
-        error("   - The command syntax is correct");
-        error("   - You have provided at least one package slug");
-        error("   - Your packmind.json file contains valid package slugs");
-      } else if (errorObj.statusCode === 404) {
-        error(`   ${errorObj.message}`);
-        if (configFileExists && configPackages.length > 0) {
-          const missingPackages = allPackages.filter(
-            (pkg) => configPackages.includes(pkg)
-          );
-          if (missingPackages.length > 0) {
-            error(
-              "\n\u{1F4A1} Either remove the following package(s) from packmind.json:"
-            );
-            missingPackages.forEach((pkg) => {
-              error(`     "${pkg}"`);
-            });
-            error("   Or ensure that:");
-            error("     - The package slug exists and is correctly spelled");
-            error("     - The package exists in your organization");
-            error("     - You have the correct API key configured");
-          } else {
-            error("\n\u{1F4A1} Troubleshooting tips:");
-            error(
-              "   - Check if the package slug exists and is correctly spelled"
-            );
-            error("   - Check that the package exists in your organization");
-            error("   - Ensure you have the correct API key configured");
-          }
-        } else {
-          error("\n\u{1F4A1} Troubleshooting tips:");
-          error(
-            "   - Check if the package slug exists and is correctly spelled"
-          );
-          error("   - Check that the package exists in your organization");
-          error("   - Ensure you have the correct API key configured");
-        }
-      } else {
-        error(`   ${errorObj.message}`);
-        const apiErrorObj = err;
-        if (apiErrorObj.response?.data?.message) {
-          error(`
-   Details: ${apiErrorObj.response.data.message}`);
-        }
-        error("\n\u{1F4A1} Troubleshooting tips:");
-        error("   - Verify that the package slugs are correct");
-        error("   - Check that the packages exist in your organization");
-        error("   - Ensure you have the correct API key configured");
-      }
-    } else {
-      error(`   ${String(err)}`);
-    }
-    exit(1);
-    return {
-      filesCreated: 0,
-      filesUpdated: 0,
-      filesDeleted: 0,
-      notificationSent: false
-    };
-  }
-}
-async function uninstallPackagesHandler(args2, deps) {
-  const { packmindCliHexa, exit, getCwd, log, error } = deps;
-  const { packagesSlugs } = args2;
-  const cwd = getCwd();
-  if (!packagesSlugs || packagesSlugs.length === 0) {
-    error("\u274C No packages specified.");
-    log("");
-    log("Usage: packmind-cli uninstall <package-slug> [package-slug...]");
-    log("       packmind-cli remove <package-slug> [package-slug...]");
-    log("");
-    log("Examples:");
-    log("  packmind-cli uninstall backend");
-    log("  packmind-cli remove backend frontend");
-    exit(1);
-    return {
-      filesDeleted: 0,
-      packagesUninstalled: []
-    };
-  }
-  let configPackages;
-  let configAgents;
-  let configFileExists = false;
-  try {
-    configFileExists = await packmindCliHexa.configExists(cwd);
-    const fullConfig = await packmindCliHexa.readFullConfig(cwd);
-    if (fullConfig) {
-      configPackages = fullConfig.packages;
-      configAgents = fullConfig.agents;
-    } else {
-      configPackages = {};
-    }
-  } catch (err) {
-    error("\u274C Failed to read packmind.json");
-    if (err instanceof Error) {
-      error(`   ${err.message}`);
-    } else {
-      error(`   ${String(err)}`);
-    }
-    error("\n\u{1F4A1} Please fix the packmind.json file or delete it to continue.");
-    exit(1);
-    return {
-      filesDeleted: 0,
-      packagesUninstalled: []
-    };
-  }
-  if (Object.keys(configPackages).length === 0) {
-    if (configFileExists) {
-      error("\u274C packmind.json is empty.");
-    } else {
-      error("\u274C No packmind.json found in current directory.");
-    }
-    log("");
-    log("\u{1F4A1} There are no packages to uninstall.");
-    log("   To install packages, run: packmind-cli install <package-slug>");
-    exit(1);
-    return {
-      filesDeleted: 0,
-      packagesUninstalled: []
-    };
-  }
-  let normalizedRequestedSlugs;
-  let normalizedConfigSlugs;
-  try {
-    normalizedRequestedSlugs = await packmindCliHexa.normalizePackageSlugs(packagesSlugs);
-    normalizedConfigSlugs = await packmindCliHexa.normalizePackageSlugs(
-      Object.keys(configPackages)
-    );
-  } catch (err) {
-    error(`\u274C ${err instanceof Error ? err.message : String(err)}`);
-    exit(1);
-    return {
-      filesDeleted: 0,
-      packagesUninstalled: []
-    };
-  }
-  const normalizedToOriginalConfigKey = /* @__PURE__ */ new Map();
-  Object.keys(configPackages).forEach((originalKey, index) => {
-    normalizedToOriginalConfigKey.set(
-      normalizedConfigSlugs[index],
-      originalKey
-    );
-  });
-  const packagesToUninstall = normalizedRequestedSlugs.filter((slug3) => normalizedToOriginalConfigKey.has(slug3)).map((slug3) => normalizedToOriginalConfigKey.get(slug3));
-  const notInstalledPackages = packagesSlugs.filter(
-    (_, i) => !normalizedToOriginalConfigKey.has(normalizedRequestedSlugs[i])
-  );
-  if (notInstalledPackages.length > 0) {
-    const packageWord = notInstalledPackages.length === 1 ? "package" : "packages";
-    log(
-      `\u26A0\uFE0F  Warning: The following ${packageWord} ${notInstalledPackages.length === 1 ? "is" : "are"} not installed:`
-    );
-    notInstalledPackages.forEach((pkg) => {
-      log(`   - ${pkg}`);
-    });
-    log("");
-  }
-  if (packagesToUninstall.length === 0) {
-    error("\u274C No packages to uninstall.");
-    exit(1);
-    return {
-      filesDeleted: 0,
-      packagesUninstalled: []
-    };
-  }
-  try {
-    const packageCount = packagesToUninstall.length;
-    const packageWord = packageCount === 1 ? "package" : "packages";
-    log(
-      `Uninstalling ${packageCount} ${packageWord}: ${packagesToUninstall.join(", ")}...`
-    );
-    const remainingPackages = Object.keys(configPackages).filter(
-      (pkg) => !packagesToUninstall.includes(pkg)
-    );
-    let filesDeleted = 0;
-    if (remainingPackages.length === 0) {
-      log("Removing all packages and cleaning up...");
-      const result = await packmindCliHexa.installPackages({
-        baseDirectory: cwd,
-        packagesSlugs: [],
-        previousPackagesSlugs: Object.keys(configPackages),
-        agents: configAgents
-      });
-      log(`
-removed ${result.filesDeleted} files`);
-      if (result.errors.length > 0) {
-        log("\n\u26A0\uFE0F  Errors encountered:");
-        result.errors.forEach((err) => {
-          log(`   - ${err}`);
-        });
-        exit(1);
-        return {
-          filesDeleted: result.filesDeleted,
-          packagesUninstalled: packagesToUninstall
-        };
-      }
-      filesDeleted = result.filesDeleted;
-    } else {
-      const result = await packmindCliHexa.installPackages({
-        baseDirectory: cwd,
-        packagesSlugs: remainingPackages,
-        previousPackagesSlugs: Object.keys(configPackages),
-        agents: configAgents
-      });
-      if (result.recipesCount > 0 || result.standardsCount > 0) {
-        log(
-          `Removing ${result.recipesCount} commands and ${result.standardsCount} standards...`
-        );
-      }
-      log(`
-removed ${result.filesDeleted} files`);
-      if (result.errors.length > 0) {
-        log("\n\u26A0\uFE0F  Errors encountered:");
-        result.errors.forEach((err) => {
-          log(`   - ${err}`);
-        });
-        exit(1);
-        return {
-          filesDeleted: result.filesDeleted,
-          packagesUninstalled: packagesToUninstall
-        };
-      }
-      filesDeleted = result.filesDeleted;
-    }
-    await packmindCliHexa.writeConfig(cwd, remainingPackages);
-    await notifyDistributionIfInGitRepo({
-      packmindCliHexa,
-      cwd,
-      packages: remainingPackages,
-      log
-    });
-    log("");
-    if (packagesToUninstall.length === 1) {
-      log(`\u2713 Package '${packagesToUninstall[0]}' has been uninstalled.`);
-    } else {
-      log(`\u2713 ${packagesToUninstall.length} packages have been uninstalled.`);
-    }
-    if (remainingPackages.length === 0) {
-      log("");
-      log("\u{1F4A1} All packages have been uninstalled.");
-      log("   Your packmind.json still exists but contains no packages.");
-    }
-    return {
-      filesDeleted,
-      packagesUninstalled: packagesToUninstall
-    };
-  } catch (err) {
-    error("\n\u274C Failed to uninstall packages:");
-    if (err instanceof Error) {
-      error(`   ${err.message}`);
-    } else {
-      error(`   ${String(err)}`);
-    }
-    exit(1);
-    return {
-      filesDeleted: 0,
-      packagesUninstalled: []
-    };
-  }
-}
-async function recursiveInstallHandler(args2, deps) {
-  const { packmindCliHexa, exit, getCwd, log, error } = deps;
-  const cwd = getCwd();
-  const result = {
-    directoriesProcessed: 0,
-    totalFilesCreated: 0,
-    totalFilesUpdated: 0,
-    totalFilesDeleted: 0,
-    totalNotifications: 0,
-    errors: []
-  };
-  let startDirectory = cwd;
-  if (args2.path) {
-    const resolvedPath = path19.resolve(cwd, args2.path);
-    try {
-      const stat9 = await fs17.stat(resolvedPath);
-      if (!stat9.isDirectory()) {
-        logErrorConsole(`Path is not a directory: ${resolvedPath}`);
-        exit(1);
-        return result;
-      }
-      startDirectory = resolvedPath;
-    } catch {
-      logErrorConsole(`Path does not exist: ${resolvedPath}`);
-      exit(1);
-      return result;
-    }
-  }
-  try {
-    const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
-    const basePath = args2.path ? startDirectory : gitRoot ?? cwd;
-    const allConfigs = await packmindCliHexa.findAllConfigsInTree(
-      startDirectory,
-      basePath
-    );
-    if (!allConfigs.hasConfigs) {
-      log("No packmind.json files found in this repository.");
-      log("");
-      log("Usage: packmind-cli install");
-      log("");
-      log(
-        "This command requires at least one packmind.json file in the repository."
-      );
-      log("Create a packmind.json file first:");
-      log("");
-      log("  packmind-cli install <package-slug>");
-      exit(0);
-      return result;
-    }
-    const sortedConfigs = [...allConfigs.configs].sort(
-      (a, b) => a.targetPath.localeCompare(b.targetPath)
-    );
-    log(`Found ${sortedConfigs.length} packmind.json file(s) to process
-`);
-    for (const config of sortedConfigs) {
-      const displayPath = args2.path ? computeDisplayPath(
-        config.absoluteTargetPath === cwd ? "/" : config.absoluteTargetPath.startsWith(cwd + "/") ? config.absoluteTargetPath.slice(cwd.length) : config.targetPath
-      ) : computeDisplayPath(config.targetPath);
-      log(`Installing in ${displayPath}...`);
-      const installResult = await executeInstallForDirectory(
-        config.absoluteTargetPath,
-        { packmindCliHexa, getCwd, log, error }
-      );
-      result.directoriesProcessed++;
-      result.totalFilesCreated += installResult.filesCreated;
-      result.totalFilesUpdated += installResult.filesUpdated;
-      result.totalFilesDeleted += installResult.filesDeleted;
-      if (installResult.notificationSent) {
-        result.totalNotifications++;
-      }
-      if (!installResult.success && installResult.errorMessage) {
-        result.errors.push({
-          directory: displayPath,
-          message: installResult.errorMessage
-        });
-        error(`  Error: ${installResult.errorMessage}`);
-      }
-      log("");
-    }
-    const dirWord = result.directoriesProcessed === 1 ? "directory" : "directories";
-    log(
-      `Summary: ${result.directoriesProcessed} ${dirWord} processed, ${result.totalFilesCreated} files added, ${result.totalFilesUpdated} changed, ${result.totalFilesDeleted} removed`
-    );
-    if (result.totalNotifications > 0) {
-      const distWord = result.totalNotifications === 1 ? "distribution" : "distributions";
-      log(`Notified Packmind of ${result.totalNotifications} ${distWord}`);
-    }
-    if (result.errors.length > 0) {
-      log("");
-      log(`\u26A0\uFE0F  ${result.errors.length} error(s) encountered:`);
-      result.errors.forEach((err) => {
-        log(`   - ${err.directory}: ${err.message}`);
-      });
-      exit(1);
-      return result;
-    }
-    if (deps.playbookLocalRepository) {
-      deps.playbookLocalRepository.clearAll();
-    }
-    exit(0);
-    return result;
-  } catch (err) {
-    error("\n\u274C Failed to run recursive install:");
-    if (err instanceof Error) {
-      error(`   ${err.message}`);
-    } else {
-      error(`   ${String(err)}`);
-    }
-    exit(1);
-    return result;
-  }
-}
-
-// apps/cli/src/infra/utils/spaceFilterUtils.ts
-function resolveSpaceFromArgs(spaceArg, spaces) {
-  if (!spaceArg) return null;
-  const slug3 = spaceArg.startsWith("@") ? spaceArg.slice(1) : spaceArg;
-  return spaces.find((s) => s.slug === slug3) ?? null;
-}
-
-// apps/cli/src/infra/utils/urlBuilderUtils.ts
-function resolveUrlBuilder(buildArtifactPath) {
-  const apiKey = loadApiKey();
-  if (!apiKey) return () => null;
-  const decoded = decodeApiKey(apiKey);
-  const orgSlug = decoded?.jwt?.organization?.slug;
-  if (!decoded?.host || !orgSlug) return () => null;
-  return (spaceSlug, artifactId) => `${decoded.host}/org/${orgSlug}/space/${spaceSlug}/${buildArtifactPath(artifactId)}`;
-}
-
-// 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);
+  if (list) {
+    logErrorConsole('Command "packmind-cli install --list" has been removed.');
+    logConsole(`Use ${formatCommand("packmind-cli packages list")} instead.`);
+    process.exit(1);
   }
-  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("");
-    }
+  if (show) {
+    const showCommand = `packmind-cli packages show ${show}`;
+    logErrorConsole('Command "packmind-cli install --show" has been removed.');
+    logConsole(`Use ${formatCommand(showCommand)} instead.`);
+    process.exit(1);
   }
-  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();
-    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(", ")}`
-      );
-      exit(1);
+  const cwd = installPath ? path20.resolve(process.cwd(), installPath) : process.cwd();
+  if (installPath) {
+    if (!fs18.existsSync(cwd)) {
+      logErrorConsole(`Path does not exist: ${cwd}`);
+      process.exit(1);
       return;
     }
-    const packages = await packmindCliHexa.listPackages(
-      matchedSpace ? { spaceId: matchedSpace.id } : {}
-    );
-    const spaces = matchedSpace ? [matchedSpace] : allSpaces;
-    if (packages.length === 0) {
-      logConsole(
-        matchedSpace ? `No packages found in space "@${matchedSpace.slug}".` : "No packages found."
-      );
-      exit(0);
+    if (!fs18.statSync(cwd).isDirectory()) {
+      logErrorConsole(`Path is not a directory: ${cwd}`);
+      process.exit(1);
       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}`)}`);
-    exit(0);
-  } catch (err) {
-    logErrorConsole("Failed to list packages:");
-    if (err instanceof Error) {
-      logErrorConsole(err.message);
-    } else {
-      logErrorConsole(String(err));
-    }
-    exit(1);
-  }
-}
-
-// apps/cli/src/infra/utils/packageSlugUtils.ts
-function parsePackageSlug(slug3) {
-  if (!slug3.startsWith("@")) return null;
-  const slash = slug3.indexOf("/", 1);
-  if (slash === -1) return null;
-  return { spaceSlug: slug3.slice(1, slash), pkgSlug: slug3.slice(slash + 1) };
-}
-
-// apps/cli/src/infra/commands/packages/showPackageHandler.ts
-function isNotFoundError(err) {
-  return err instanceof Error && err.message.includes("does not exist");
-}
-async function resolvePackage(slug3, packmindCliHexa) {
-  const allSpaces = await packmindCliHexa.getSpaces();
-  const parsed = parsePackageSlug(slug3);
-  if (parsed) {
-    const { spaceSlug, pkgSlug } = parsed;
-    const matchedSpace = allSpaces.find((s) => s.slug === spaceSlug);
-    if (!matchedSpace) {
-      throw new Error(`Space '@${spaceSlug}' not found.`);
-    }
-    let pkg;
-    try {
-      pkg = await packmindCliHexa.getPackageBySlug({
-        slug: pkgSlug,
-        spaceId: matchedSpace.id
-      });
-    } catch (err) {
-      if (isNotFoundError(err)) {
-        throw new Error(
-          `Package '${pkgSlug}' not found in space '@${spaceSlug}'.`
-        );
-      }
-      throw err;
-    }
-    return { pkg, fullSlug: `@${spaceSlug}/${pkgSlug}` };
   }
-  const results = await Promise.allSettled(
-    allSpaces.map(async (space) => ({
-      pkg: await packmindCliHexa.getPackageBySlug({
-        slug: slug3,
-        spaceId: space.id
-      }),
-      spaceSlug: space.slug
-    }))
-  );
-  const matches = results.filter(
-    (r) => r.status === "fulfilled"
-  ).map((r) => r.value);
-  if (matches.length === 0) {
-    const realError = results.filter((r) => r.status === "rejected").find((r) => !isNotFoundError(r.reason));
-    if (realError) {
-      throw realError.reason;
+  let targetDirs;
+  if (installPath) {
+    targetDirs = findSubDirectoriesWithPackmindJson(cwd, false);
+  } else if (packages.length > 0) {
+    targetDirs = [cwd];
+  } else {
+    targetDirs = [];
+    if (fs18.existsSync(path20.join(cwd, "packmind.json"))) {
+      targetDirs.push(cwd);
     }
-    throw new Error(`Package '${slug3}' not found in any space.`);
+    targetDirs.push(...findSubDirectoriesWithPackmindJson(cwd, true));
   }
-  if (matches.length > 1) {
-    const example = `@${matches[0].spaceSlug}/${slug3}`;
-    throw new Error(
-      `Package '${slug3}' exists in multiple spaces (${matches.map((m) => `@${m.spaceSlug}`).join(", ")}). Please specify the space using the @space/package format (e.g. ${example}).`
-    );
+  if (targetDirs.length === 0) {
+    targetDirs = [cwd];
   }
-  return {
-    pkg: matches[0].pkg,
-    fullSlug: `@${matches[0].spaceSlug}/${slug3}`
-  };
-}
-async function showPackageHandler(args2, deps) {
-  const { packmindCliHexa, exit } = deps;
-  try {
-    logInfoConsole(`Fetching package details for '${args2.slug}'...`);
-    const { pkg, fullSlug } = await resolvePackage(args2.slug, packmindCliHexa);
-    logConsole(`
-${pkg.name} (${fullSlug}):
-`);
-    if (pkg.description) {
-      logConsole(`${pkg.description}
-`);
-    }
-    if (pkg.standards && pkg.standards.length > 0) {
-      logConsole("Standards:");
-      pkg.standards.forEach((standard) => {
-        if (standard.summary) {
-          logConsole(`  - ${standard.name}: ${standard.summary}`);
-        } else {
-          logConsole(`  - ${standard.name}`);
-        }
-      });
-      logConsole("");
-    }
-    if (pkg.recipes && pkg.recipes.length > 0) {
-      logConsole("Commands:");
-      pkg.recipes.forEach((recipe) => {
-        if (recipe.summary) {
-          logConsole(`  - ${recipe.name}: ${recipe.summary}`);
-        } else {
-          logConsole(`  - ${recipe.name}`);
-        }
+  const results = [];
+  const thrownErrors = [];
+  const multiDir = targetDirs.length > 1;
+  for (const dir of targetDirs) {
+    try {
+      const result = await packmindCliHexa.install({
+        baseDirectory: dir,
+        packages: packages.length > 0 ? packages : void 0
       });
-      logConsole("");
-    }
-    if (pkg.skills && pkg.skills.length > 0) {
-      logConsole("Skills:");
-      pkg.skills.forEach((skill) => {
-        if (skill.summary) {
-          logConsole(`  - ${skill.name}: ${skill.summary}`);
-        } else {
-          logConsole(`  - ${skill.name}`);
-        }
+      results.push(result);
+      await notifyArtefactsDistributionIfInGitRepo({
+        packmindCliHexa,
+        dir
       });
-      logConsole("");
-    }
-    exit(0);
-  } catch (err) {
-    logErrorConsole("Failed to fetch package details:");
-    if (err instanceof Error) {
-      logErrorConsole(err.message);
-    } else {
-      logErrorConsole(String(err));
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      thrownErrors.push(
+        multiDir ? `[${dir}] install failed: ${errorMessage}` : `install failed: ${errorMessage}`
+      );
     }
-    exit(1);
   }
-}
+  const combined = mergeInstallResults(results);
+  if (combined.missingAccess.length > 0) {
+    let warning = `\u26A0\uFE0F  You don't have access to the following packages (their artifacts were preserved from the lock file):
+` + combined.missingAccess.map((s) => `  - ${s}`).join("\n");
+    if (combined.joinSpaceUrl) {
+      warning += `
 
-// apps/cli/src/infra/repositories/PlaybookLocalRepository.ts
-var crypto = __toESM(require("crypto"));
-var fs18 = __toESM(require("fs"));
-var os4 = __toESM(require("os"));
-var path20 = __toESM(require("path"));
-var yaml = __toESM(require("yaml"));
-var PlaybookLocalRepository = class {
-  constructor(repoRoot) {
-    const normalized = this.normalizeRepoRoot(repoRoot);
-    const hash = crypto.createHash("md5").update(normalized).digest("hex");
-    this.storagePath = path20.join(
-      os4.homedir(),
-      ".packmind",
-      hash,
-      "playbook.yaml"
-    );
-  }
-  addChange(entry) {
-    const data = this.readYaml();
-    const existingIndex = data.changes.findIndex(
-      (c) => c.filePath === entry.filePath && c.spaceId === entry.spaceId
-    );
-    if (existingIndex >= 0) {
-      data.changes[existingIndex] = entry;
-    } else {
-      data.changes.push(entry);
+  \u{1F449} Join the space to get access: ${combined.joinSpaceUrl}`;
     }
-    this.writeYaml(data);
+    logWarningConsole(warning);
   }
-  removeChange(filePath, spaceId) {
-    const data = this.readYaml();
-    const initialLength = data.changes.length;
-    data.changes = data.changes.filter(
-      (c) => !(c.filePath === filePath && c.spaceId === spaceId)
-    );
-    if (data.changes.length === initialLength) {
-      return false;
-    }
-    this.writeYaml(data);
-    return true;
-  }
-  getChanges() {
-    return this.readYaml().changes;
+  logConsole(buildInstallSummary(combined));
+  await installDefaultSkillsIfAtGitRoot({ packmindCliHexa, cwd });
+  const allErrors = [...combined.errors, ...thrownErrors];
+  if (allErrors.length > 0) {
+    logWarningConsole(`Encountered ${allErrors.length} error(s):`);
+    allErrors.forEach((err) => logErrorConsole(`  - ${err}`));
   }
-  getChange(filePath, spaceId) {
-    return this.readYaml().changes.find(
-      (c) => c.filePath === filePath && c.spaceId === spaceId
-    ) ?? null;
-  }
-  clearAll() {
-    this.writeYaml({ version: 1, changes: [] });
-  }
-  normalizeRepoRoot(repoRoot) {
-    let normalized = repoRoot.replace(/\\/g, "/");
-    normalized = normalized.replace(/\/$/, "");
-    return normalized;
-  }
-  readYaml() {
-    if (!fs18.existsSync(this.storagePath)) {
-      return { version: 1, changes: [] };
-    }
-    try {
-      const content = fs18.readFileSync(this.storagePath, "utf-8");
-      const parsed = yaml.parse(content);
-      if (!parsed || !Array.isArray(parsed.changes)) {
-        return { version: 1, changes: [] };
-      }
-      return { version: 1, changes: parsed.changes };
-    } catch {
-      logWarningConsole(
-        `Corrupted playbook file: ${this.storagePath}. Treating as empty.`
-      );
-      return { version: 1, changes: [] };
-    }
-  }
-  writeYaml(data) {
-    const dir = path20.dirname(this.storagePath);
-    fs18.mkdirSync(dir, { recursive: true });
-    fs18.writeFileSync(this.storagePath, yaml.stringify(data), "utf-8");
+  if (thrownErrors.length > 0) {
+    process.exit(1);
   }
-};
-
-// apps/cli/src/infra/commands/InstallCommand.ts
+}
 var installCommand = (0, import_cmd_ts2.command)({
   name: "install",
-  description: "Install packages and save their artifacts locally",
   aliases: ["pull"],
+  description: "Install packages and save their artifacts locally",
   args: {
-    list: (0, import_cmd_ts2.flag)({
-      long: "list",
-      description: "List available packages"
+    installPath: (0, import_cmd_ts2.option)({
+      type: import_cmd_ts2.string,
+      short: "p",
+      long: "path",
+      defaultValue: () => "",
+      description: "Run install in the specified directory instead of the current directory"
+    }),
+    packages: (0, import_cmd_ts2.restPositionals)({
+      type: import_cmd_ts2.string,
+      displayName: "packages",
+      description: "Package slugs to install (e.g. @my-space/my-package)"
     }),
     status: (0, import_cmd_ts2.flag)({
       long: "status",
       description: "Show status of all packmind.json files and their packages in the workspace"
     }),
-    recursive: (0, import_cmd_ts2.flag)({
-      short: "r",
-      long: "recursive",
-      description: "[Deprecated] Install is now recursive by default. This flag will be removed in a future version."
-    }),
-    path: (0, import_cmd_ts2.option)({
-      type: import_cmd_ts2.string,
-      short: "p",
-      long: "path",
-      defaultValue: () => "",
-      description: "Run install in the specified directory (recursive within that path)"
+    list: (0, import_cmd_ts2.flag)({
+      long: "list",
+      description: "[Deprecated] List available packages"
     }),
     show: (0, import_cmd_ts2.option)({
       type: import_cmd_ts2.string,
       long: "show",
-      description: "Show details of a specific package",
+      description: "[Deprecated] Show details of a specific package",
       defaultValue: () => ""
-    }),
-    packagesSlugs: (0, import_cmd_ts2.restPositionals)({
-      type: import_cmd_ts2.string,
-      displayName: "packages",
-      description: "Package slugs to install (e.g., backend frontend)"
     })
   },
-  handler: async ({ list, status, recursive, path: path36, show, packagesSlugs }) => {
-    const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
-    const packmindCliHexa = new PackmindCliHexa(packmindLogger);
-    const repoRoot = await packmindCliHexa.tryGetGitRepositoryRoot(
-      process.cwd()
-    );
-    const playbookLocalRepository = repoRoot ? new PlaybookLocalRepository(repoRoot) : void 0;
-    const deps = {
-      packmindCliHexa,
-      exit: process.exit,
-      getCwd: () => process.cwd(),
-      log: console.log,
-      error: console.error,
-      playbookLocalRepository
-    };
-    if (list) {
-      await listPackagesHandler({}, deps);
-      return;
-    }
-    if (status) {
-      await statusHandler({}, deps);
-      return;
-    }
-    if (show) {
-      await showPackageHandler(
-        { slug: show },
-        { packmindCliHexa, exit: process.exit }
-      );
-      return;
-    }
-    if (recursive) {
-      logWarningConsole(
-        "\u26A0\uFE0F  The --recursive flag is deprecated. Install is now recursive by default."
-      );
-      await recursiveInstallHandler({ path: path36 || void 0 }, deps);
-      return;
-    }
-    if (packagesSlugs.length > 0) {
-      await installPackagesHandler(
-        { packagesSlugs, path: path36 || void 0 },
-        deps
-      );
-      return;
-    }
-    await recursiveInstallHandler({ path: path36 || void 0 }, deps);
-  }
+  handler: installHandler
 });
 
 // apps/cli/src/infra/commands/UninstallCommand.ts
 var import_cmd_ts3 = __toESM(require_cjs());
+function buildUninstallSummary(result) {
+  const removedParts = [
+    result.standardsRemoved > 0 ? `${result.standardsRemoved} ${result.standardsRemoved === 1 ? "standard" : "standards"}` : null,
+    result.commandsRemoved > 0 ? `${result.commandsRemoved} ${result.commandsRemoved === 1 ? "command" : "commands"}` : null,
+    result.skillsRemoved > 0 ? `${result.skillsRemoved} ${result.skillsRemoved === 1 ? "skill" : "skills"}` : null,
+    result.recipesRemoved > 0 ? `${result.recipesRemoved} ${result.recipesRemoved === 1 ? "recipe" : "recipes"}` : null
+  ].filter(Boolean);
+  if (removedParts.length === 0) {
+    return "\u2705 Package removed";
+  }
+  return `\u2705 Removed ${removedParts.join(", ")}`;
+}
 var uninstallCommand = (0, import_cmd_ts3.command)({
   name: "uninstall",
-  description: "Uninstall packages and remove their commands and standards from the current directory",
+  description: "Uninstall packages and sync artifacts. Specify package slugs (e.g. @my-space/my-package) to uninstall.",
   aliases: ["remove"],
   args: {
-    packagesSlugs: (0, import_cmd_ts3.restPositionals)({
+    packages: (0, import_cmd_ts3.restPositionals)({
       type: import_cmd_ts3.string,
       displayName: "packages",
-      description: "Package slugs to uninstall (e.g., backend frontend)"
+      description: "Package slugs to uninstall (e.g. @my-space/my-package)"
     })
   },
-  handler: async ({ packagesSlugs }) => {
+  handler: async ({ packages }) => {
+    if (packages.length === 0) {
+      logErrorConsole("Please specify at least one package to uninstall.");
+      process.exit(1);
+    }
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
-    const deps = {
-      packmindCliHexa,
-      exit: process.exit,
-      getCwd: () => process.cwd(),
-      log: console.log,
-      error: console.error
-    };
-    await uninstallPackagesHandler({ packagesSlugs }, deps);
+    try {
+      const result = await packmindCliHexa.uninstall({
+        baseDirectory: process.cwd(),
+        packages
+      });
+      if (result.missingAccess.length > 0) {
+        let warning = `\u26A0\uFE0F  You don't have access to the following packages (their artifacts were preserved from the lock file):
+` + result.missingAccess.map((s) => `  - ${s}`).join("\n");
+        if (result.joinSpaceUrl) {
+          warning += `
+
+  \u{1F449} Join the space to get access: ${result.joinSpaceUrl}`;
+        }
+        logWarningConsole(warning);
+      }
+      logConsole(buildUninstallSummary(result));
+      if (result.errors.length > 0) {
+        logWarningConsole(`Encountered ${result.errors.length} error(s):`);
+        result.errors.forEach((err) => logErrorConsole(`  - ${err}`));
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logErrorConsole(`uninstall failed: ${errorMessage}`);
+      process.exit(1);
+    }
   }
 });
 
@@ -14980,7 +14917,7 @@ var inquirer = __toESM(require("inquirer"));
 // apps/cli/src/application/services/AgentDetectionService.ts
 var fs19 = __toESM(require("fs"));
 var path21 = __toESM(require("path"));
-var os5 = __toESM(require("os"));
+var os4 = __toESM(require("os"));
 var import_child_process4 = require("child_process");
 var AgentDetectionService = class {
   constructor(projectDir = process.cwd()) {
@@ -15006,7 +14943,7 @@ var AgentDetectionService = class {
     return this.isCommandAvailable("claude");
   }
   isCursorAvailable() {
-    const cursorConfigDir = path21.join(os5.homedir(), ".cursor");
+    const cursorConfigDir = path21.join(os4.homedir(), ".cursor");
     return fs19.existsSync(cursorConfigDir);
   }
   isVSCodeAvailable() {
@@ -15073,7 +15010,7 @@ async function promptAgentsWithReadline(choices) {
   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((resolve14) => {
+  return new Promise((resolve15) => {
     rl.question(
       `Enter numbers separated by commas (default: ${defaultValue}): `,
       (answer) => {
@@ -15084,7 +15021,7 @@ async function promptAgentsWithReadline(choices) {
         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);
-        resolve14(selectedAgents);
+        resolve15(selectedAgents);
       }
     );
   });
@@ -15258,9 +15195,14 @@ var addSkillCommand = (0, import_cmd_ts9.command)({
     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);
   }
@@ -15340,13 +15282,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,
@@ -15393,10 +15328,10 @@ async function promptConfirmation(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve14(answer.trim().toLowerCase() === "y");
+      resolve15(answer.trim().toLowerCase() === "y");
     });
   });
 }
@@ -15404,93 +15339,95 @@ async function promptConfirmation(question) {
 // apps/cli/src/infra/commands/ListSkillsCommand.ts
 var import_cmd_ts11 = __toESM(require_cjs());
 
-// apps/cli/src/infra/commands/skills/listSkillsHandler.ts
-function groupSkillsBySpace(skills, spaces) {
-  const spaceMap = new Map(
+// apps/cli/src/infra/utils/spaceFilterUtils.ts
+function resolveSpaceFromArgs(spaceArg, spaces) {
+  if (!spaceArg) return null;
+  const slug3 = spaceArg.startsWith("@") ? spaceArg.slice(1) : spaceArg;
+  return spaces.find((s) => s.slug === slug3) ?? null;
+}
+
+// apps/cli/src/infra/utils/urlBuilderUtils.ts
+function resolveUrlBuilder(buildArtifactPath) {
+  const apiKey = loadApiKey();
+  if (!apiKey) return () => null;
+  const decoded = decodeApiKey(apiKey);
+  const orgSlug = decoded?.jwt?.organization?.slug;
+  if (!decoded?.host || !orgSlug) return () => null;
+  return (spaceSlug, artifactId) => `${decoded.host}/org/${orgSlug}/space/${spaceSlug}/${buildArtifactPath(artifactId)}`;
+}
+
+// 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);
   }
 }
@@ -15552,11 +15489,14 @@ var createStandardCommand = (0, import_cmd_ts13.command)({
     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);
   }
@@ -15566,92 +15506,55 @@ var createStandardCommand = (0, import_cmd_ts13.command)({
 var import_cmd_ts14 = __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);
   }
 }
@@ -15712,9 +15615,14 @@ var createCommandCommand = (0, import_cmd_ts16.command)({
     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);
   }
@@ -15724,86 +15632,54 @@ var createCommandCommand = (0, import_cmd_ts16.command)({
 var import_cmd_ts17 = __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);
   }
 }
@@ -16011,6 +15887,21 @@ async function findTargetDirectories(searchPath, packmindCliHexa) {
       targets.push(dir);
     }
   }
+  if (targets.length === 0) {
+    let currentDir = nodePath.dirname(searchPath);
+    while (true) {
+      const ancestorExists = await packmindCliHexa.configExists(currentDir);
+      if (ancestorExists) {
+        targets.push(currentDir);
+        break;
+      }
+      const parentDir = nodePath.dirname(currentDir);
+      if (parentDir === currentDir) {
+        break;
+      }
+      currentDir = parentDir;
+    }
+  }
   return targets;
 }
 function computeRelativePath(targetAbsDir, gitRoot) {
@@ -16193,7 +16084,11 @@ async function diffArtefactsHandler(deps) {
         relativePath,
         agents: config.agents
       });
-      targetResults.push({ targetRelativePath, diffs });
+      const filterPrefix = nodePath.relative(targetDir, searchPath);
+      const filteredDiffs = filterPrefix !== "" && !filterPrefix.startsWith("..") ? diffs.filter(
+        (d) => d.filePath === filterPrefix || d.filePath.startsWith(filterPrefix + "/")
+      ) : diffs;
+      targetResults.push({ targetRelativePath, diffs: filteredDiffs });
     }
     if (targetResults.length === 0) {
       log("No packages configured in any target.");
@@ -16285,7 +16180,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       description: "Subcommand and arguments (e.g., add <path>, remove <path>)"
     })
   },
-  handler: async ({ submit, includeSubmitted, message, path: path36, positionals }) => {
+  handler: async ({ submit, includeSubmitted, message, path: path37, positionals }) => {
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
     if (submit) {
@@ -16301,7 +16196,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       process.exit(1);
     }
     if (positionals[0] === "add") {
-      const addFilePath = path36 && positionals[1] ? `${path36}/${positionals[1]}`.replace(/\/+/g, "/") : positionals[1];
+      const addFilePath = path37 && positionals[1] ? `${path37}/${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:");
@@ -16309,7 +16204,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       process.exit(1);
     }
     if (positionals[0] === "remove" || positionals[0] === "rm") {
-      const removeFilePath = path36 && positionals[1] ? `${path36}/${positionals[1]}`.replace(/\/+/g, "/") : positionals[1];
+      const removeFilePath = path37 && positionals[1] ? `${path37}/${positionals[1]}`.replace(/\/+/g, "/") : positionals[1];
       const removeCommand = `packmind-cli playbook remove ${removeFilePath}`;
       logErrorConsole(
         "Deprecated: `packmind-cli diff remove` has been removed"
@@ -16318,7 +16213,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       logInfoConsole(` ${formatCommand(removeCommand)}`);
       process.exit(1);
     }
-    const diffCommand3 = `packmind-cli playbook diff${includeSubmitted ? " --include-submitted" : ""}${path36 ? ` --path ${path36}` : ""}`;
+    const diffCommand3 = `packmind-cli playbook diff${includeSubmitted ? " --include-submitted" : ""}${path37 ? ` --path ${path37}` : ""}`;
     logErrorConsole("Deprecated: `packmind-cli diff` will be removed");
     logInfoConsole("Use the following command instead:");
     logInfoConsole(` ${formatCommand(diffCommand3)}`);
@@ -16328,7 +16223,7 @@ var diffCommand = (0, import_cmd_ts19.command)({
       getCwd: () => process.cwd(),
       log: console.log,
       includeSubmitted,
-      path: path36
+      path: path37
     });
   }
 });
@@ -16608,6 +16503,14 @@ var AddToPackageUseCase = class {
   }
 };
 
+// apps/cli/src/infra/utils/packageSlugUtils.ts
+function parsePackageSlug(slug3) {
+  if (!slug3.startsWith("@")) return null;
+  const slash = slug3.indexOf("/", 1);
+  if (slash === -1) return null;
+  return { spaceSlug: slug3.slice(1, slash), pkgSlug: slug3.slice(slash + 1) };
+}
+
 // apps/cli/src/infra/commands/packages/addToPackageHandler.ts
 function pluralize(singular, count) {
   return count === 1 ? singular : `${singular}s`;
@@ -16749,24 +16652,90 @@ var addToPackageCommand = (0, import_cmd_ts21.command)({
       );
       process.exit(1);
     }
-    if (itemTypes.length > 1) {
-      logErrorConsole(
-        "Cannot add standards, commands, and skills simultaneously.  Use dedicated commands for each artefact."
+    if (itemTypes.length > 1) {
+      logErrorConsole(
+        "Cannot add standards, commands, and skills simultaneously.  Use dedicated commands for each artefact."
+      );
+      process.exit(1);
+    }
+    const { type: itemType, slugs: itemSlugs } = itemTypes[0];
+    const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
+    const hexa = new PackmindCliHexa(packmindLogger);
+    await addToPackageHandler(
+      { to, itemType, itemSlugs, originSkill },
+      { hexa, exit: process.exit }
+    );
+  }
+});
+
+// apps/cli/src/infra/commands/listPackagesCommand.ts
+var import_cmd_ts22 = __toESM(require_cjs());
+
+// apps/cli/src/infra/commands/packages/listPackagesHandler.ts
+async function listPackagesHandler(args2, deps) {
+  const { packmindCliHexa, exit } = deps;
+  try {
+    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) {
+      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.output.withLoader(
+      "Fetching packages",
+      () => packmindCliHexa.listPackages(
+        matchedSpace ? { spaceId: matchedSpace.id } : {}
+      )
+    );
+    const spaces = matchedSpace ? [matchedSpace] : allSpaces;
+    if (packages.length === 0) {
+      packmindCliHexa.output.notifyInfo(
+        matchedSpace ? `No packages found in space "@${matchedSpace.slug}".` : "No packages found."
       );
-      process.exit(1);
+      exit(0);
+      return;
     }
-    const { type: itemType, slugs: itemSlugs } = itemTypes[0];
-    const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
-    const hexa = new PackmindCliHexa(packmindLogger);
-    await addToPackageHandler(
-      { to, itemType, itemSlugs, originSkill },
-      { hexa, exit: process.exit }
+    const buildUrl = resolveUrlBuilder((id) => `packages/${id}`);
+    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) {
+    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 import_cmd_ts22 = __toESM(require_cjs());
 var listPackagesCommand = (0, import_cmd_ts22.command)({
   name: "list",
   description: "List available packages",
@@ -16790,6 +16759,124 @@ var listPackagesCommand = (0, import_cmd_ts22.command)({
 
 // apps/cli/src/infra/commands/packages/showPackageCommand.ts
 var import_cmd_ts23 = __toESM(require_cjs());
+
+// apps/cli/src/infra/commands/packages/showPackageHandler.ts
+function isNotFoundError(err) {
+  return err instanceof Error && err.message.includes("does not exist");
+}
+async function resolvePackage(slug3, packmindCliHexa) {
+  const allSpaces = await packmindCliHexa.getSpaces();
+  const parsed = parsePackageSlug(slug3);
+  if (parsed) {
+    const { spaceSlug, pkgSlug } = parsed;
+    const matchedSpace = allSpaces.find((s) => s.slug === spaceSlug);
+    if (!matchedSpace) {
+      throw new Error(`Space '@${spaceSlug}' not found.`);
+    }
+    let pkg;
+    try {
+      pkg = await packmindCliHexa.getPackageBySlug({
+        slug: pkgSlug,
+        spaceId: matchedSpace.id
+      });
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        throw new Error(
+          `Package '${pkgSlug}' not found in space '@${spaceSlug}'.`
+        );
+      }
+      throw err;
+    }
+    return { pkg, fullSlug: `@${spaceSlug}/${pkgSlug}` };
+  }
+  const results = await Promise.allSettled(
+    allSpaces.map(async (space) => ({
+      pkg: await packmindCliHexa.getPackageBySlug({
+        slug: slug3,
+        spaceId: space.id
+      }),
+      spaceSlug: space.slug
+    }))
+  );
+  const matches = results.filter(
+    (r) => r.status === "fulfilled"
+  ).map((r) => r.value);
+  if (matches.length === 0) {
+    const realError = results.filter((r) => r.status === "rejected").find((r) => !isNotFoundError(r.reason));
+    if (realError) {
+      throw realError.reason;
+    }
+    throw new Error(`Package '${slug3}' not found in any space.`);
+  }
+  if (matches.length > 1) {
+    const example = `@${matches[0].spaceSlug}/${slug3}`;
+    throw new Error(
+      `Package '${slug3}' exists in multiple spaces (${matches.map((m) => `@${m.spaceSlug}`).join(", ")}). Please specify the space using the @space/package format (e.g. ${example}).`
+    );
+  }
+  return {
+    pkg: matches[0].pkg,
+    fullSlug: `@${matches[0].spaceSlug}/${slug3}`
+  };
+}
+async function showPackageHandler(args2, deps) {
+  const { packmindCliHexa, exit } = deps;
+  try {
+    logInfoConsole(`Fetching package details for '${args2.slug}'...`);
+    const { pkg, fullSlug } = await resolvePackage(args2.slug, packmindCliHexa);
+    logConsole(`
+${pkg.name} (${fullSlug}):
+`);
+    if (pkg.description) {
+      logConsole(`${pkg.description}
+`);
+    }
+    if (pkg.standards && pkg.standards.length > 0) {
+      logConsole("Standards:");
+      pkg.standards.forEach((standard) => {
+        if (standard.summary) {
+          logConsole(`  - ${standard.name}: ${standard.summary}`);
+        } else {
+          logConsole(`  - ${standard.name}`);
+        }
+      });
+      logConsole("");
+    }
+    if (pkg.recipes && pkg.recipes.length > 0) {
+      logConsole("Commands:");
+      pkg.recipes.forEach((recipe) => {
+        if (recipe.summary) {
+          logConsole(`  - ${recipe.name}: ${recipe.summary}`);
+        } else {
+          logConsole(`  - ${recipe.name}`);
+        }
+      });
+      logConsole("");
+    }
+    if (pkg.skills && pkg.skills.length > 0) {
+      logConsole("Skills:");
+      pkg.skills.forEach((skill) => {
+        if (skill.summary) {
+          logConsole(`  - ${skill.name}: ${skill.summary}`);
+        } else {
+          logConsole(`  - ${skill.name}`);
+        }
+      });
+      logConsole("");
+    }
+    exit(0);
+  } catch (err) {
+    logErrorConsole("Failed to fetch package details:");
+    if (err instanceof Error) {
+      logErrorConsole(err.message);
+    } else {
+      logErrorConsole(String(err));
+    }
+    exit(1);
+  }
+}
+
+// apps/cli/src/infra/commands/packages/showPackageCommand.ts
 var showPackageCommand = (0, import_cmd_ts23.command)({
   name: "show",
   description: "Show details of a specific package",
@@ -16826,14 +16913,96 @@ var import_cmd_ts31 = __toESM(require_cjs());
 var import_fs21 = require("fs");
 var import_cmd_ts25 = __toESM(require_cjs());
 
-// apps/cli/src/infra/commands/playbook/addHandler.ts
+// apps/cli/src/infra/repositories/PlaybookLocalRepository.ts
+var crypto = __toESM(require("crypto"));
 var fs23 = __toESM(require("fs"));
-var path26 = __toESM(require("path"));
+var os5 = __toESM(require("os"));
+var path23 = __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(),
+      ".packmind",
+      hash,
+      "playbook.yaml"
+    );
+  }
+  addChange(entry) {
+    const data = this.readYaml();
+    const existingIndex = data.changes.findIndex(
+      (c) => c.filePath === entry.filePath && c.spaceId === entry.spaceId
+    );
+    if (existingIndex >= 0) {
+      data.changes[existingIndex] = entry;
+    } else {
+      data.changes.push(entry);
+    }
+    this.writeYaml(data);
+  }
+  removeChange(filePath, spaceId) {
+    const data = this.readYaml();
+    const initialLength = data.changes.length;
+    data.changes = data.changes.filter(
+      (c) => !(c.filePath === filePath && c.spaceId === spaceId)
+    );
+    if (data.changes.length === initialLength) {
+      return false;
+    }
+    this.writeYaml(data);
+    return true;
+  }
+  getChanges() {
+    return this.readYaml().changes;
+  }
+  getChange(filePath, spaceId) {
+    return this.readYaml().changes.find(
+      (c) => c.filePath === filePath && c.spaceId === spaceId
+    ) ?? null;
+  }
+  clearAll() {
+    this.writeYaml({ version: 1, changes: [] });
+  }
+  normalizeRepoRoot(repoRoot) {
+    let normalized = repoRoot.replace(/\\/g, "/");
+    normalized = normalized.replace(/\/$/, "");
+    return normalized;
+  }
+  readYaml() {
+    if (!fs23.existsSync(this.storagePath)) {
+      return { version: 1, changes: [] };
+    }
+    try {
+      const content = fs23.readFileSync(this.storagePath, "utf-8");
+      const parsed = yaml.parse(content);
+      if (!parsed || !Array.isArray(parsed.changes)) {
+        return { version: 1, changes: [] };
+      }
+      return { version: 1, changes: parsed.changes };
+    } catch {
+      logWarningConsole(
+        `Corrupted playbook file: ${this.storagePath}. Treating as empty.`
+      );
+      return { version: 1, changes: [] };
+    }
+  }
+  writeYaml(data) {
+    const dir = path23.dirname(this.storagePath);
+    fs23.mkdirSync(dir, { recursive: true });
+    fs23.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 yaml2 = __toESM(require("yaml"));
 var import_slug = __toESM(require("slug"));
 
 // apps/cli/src/application/utils/parseCommandFile.ts
-var path23 = __toESM(require("path"));
+var path24 = __toESM(require("path"));
 var FRONTMATTER_DELIMITER3 = "---";
 function parseCommandFile(content, filePath) {
   content = normalizeLineEndings(content);
@@ -16889,7 +17058,7 @@ function stripYamlQuotes2(value) {
   return value;
 }
 function extractFilenameSlug(filePath) {
-  let basename4 = path23.basename(filePath);
+  let basename4 = path24.basename(filePath);
   if (basename4.endsWith(".prompt.md")) {
     basename4 = basename4.slice(0, -".prompt.md".length);
   } else if (basename4.endsWith(".md")) {
@@ -17056,7 +17225,7 @@ function parseSkillDirectory(files) {
 }
 
 // apps/cli/src/application/utils/findNearestConfigDir.ts
-var path24 = __toESM(require("path"));
+var path25 = __toESM(require("path"));
 async function findNearestConfigDir(startDir, packmindCliHexa) {
   let current = startDir;
   while (true) {
@@ -17064,7 +17233,7 @@ async function findNearestConfigDir(startDir, packmindCliHexa) {
     if (exists) {
       return current;
     }
-    const parent = path24.dirname(current);
+    const parent = path25.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -17073,7 +17242,7 @@ async function findNearestConfigDir(startDir, packmindCliHexa) {
 }
 
 // apps/cli/src/application/utils/resolveDeployedContext.ts
-var path25 = __toESM(require("path"));
+var path26 = __toESM(require("path"));
 async function resolveDeployedContext(packmindCliHexa, targetDir) {
   try {
     const space = await packmindCliHexa.getDefaultSpace();
@@ -17085,7 +17254,7 @@ async function resolveDeployedContext(packmindCliHexa, targetDir) {
     }
     const gitRemoteUrl = packmindCliHexa.getGitRemoteUrlFromPath(gitRoot);
     const gitBranch = packmindCliHexa.getCurrentBranch(gitRoot);
-    const rel = path25.relative(gitRoot, targetDir);
+    const rel = path26.relative(gitRoot, targetDir);
     const relativePath = rel.startsWith("..") ? "/" : rel ? `/${rel}/` : "/";
     const deployedContent = await packmindCliHexa.getPackmindGateway().deployment.getDeployed({
       packagesSlugs: configPackages,
@@ -17150,19 +17319,19 @@ async function fetchDeployedFiles(gateway, lockFile) {
 
 // apps/cli/src/infra/commands/playbook/addHandler.ts
 async function tryStageRemovedFromLockFile(resolvedPath, deps) {
-  const fileDir = path26.dirname(resolvedPath);
+  const fileDir = path27.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(path26.relative(targetDir, resolvedPath));
+  const normalizedPath = normalizePath2(path27.relative(targetDir, resolvedPath));
   const lockEntry = findLockFileEntryForPath(
     normalizedPath,
     lockFile.artifacts
   );
   if (!lockEntry) return false;
   const gitRoot = await deps.packmindCliHexa.tryGetGitRepositoryRoot(targetDir);
-  const configDir = gitRoot ? normalizePath2(path26.relative(gitRoot, targetDir)) : "";
+  const configDir = gitRoot ? normalizePath2(path27.relative(gitRoot, targetDir)) : "";
   const deployedContext = await resolveDeployedContext(
     deps.packmindCliHexa,
     targetDir
@@ -17194,22 +17363,22 @@ async function tryStageRemovedFromLockFile(resolvedPath, deps) {
 }
 function resolveSkillDirectoryRoot(absolutePath) {
   if (absolutePath.endsWith("SKILL.md")) {
-    return path26.dirname(absolutePath);
+    return path27.dirname(absolutePath);
   }
   try {
-    if (fs23.statSync(absolutePath).isDirectory()) {
+    if (fs24.statSync(absolutePath).isDirectory()) {
       return absolutePath;
     }
   } catch {
     return absolutePath;
   }
-  let current = path26.dirname(absolutePath);
-  const root = path26.parse(current).root;
+  let current = path27.dirname(absolutePath);
+  const root = path27.parse(current).root;
   while (current !== root) {
-    if (fs23.existsSync(path26.join(current, "SKILL.md"))) {
+    if (fs24.existsSync(path27.join(current, "SKILL.md"))) {
       return current;
     }
-    current = path26.dirname(current);
+    current = path27.dirname(current);
   }
   return absolutePath;
 }
@@ -17220,7 +17389,7 @@ async function playbookAddHandler(deps) {
     spaceSlug,
     exit,
     cwd,
-    readFile: readFile10,
+    readFile: readFile11,
     readSkillDirectory: readSkillDirectory2,
     playbookLocalRepository,
     lockFileRepository
@@ -17232,17 +17401,17 @@ async function playbookAddHandler(deps) {
     exit(1);
     return;
   }
-  const absolutePath = path26.resolve(cwd, filePath);
+  const absolutePath = path27.resolve(cwd, filePath);
   let artifactType;
   let codingAgent;
   const earlyTargetDir = await findNearestConfigDir(
-    path26.dirname(absolutePath),
+    path27.dirname(absolutePath),
     packmindCliHexa
   );
   const earlyLockFile = earlyTargetDir ? await lockFileRepository.read(earlyTargetDir) : null;
   if (earlyLockFile && earlyTargetDir) {
     const normalizedForLookup = normalizePath2(
-      path26.relative(earlyTargetDir, absolutePath)
+      path27.relative(earlyTargetDir, absolutePath)
     );
     const lockResult = findLockFileEntryAndFileForPath(
       normalizedForLookup,
@@ -17322,7 +17491,7 @@ async function playbookAddHandler(deps) {
     localContent = skillMdFile?.content ?? serializedContent;
   } else {
     try {
-      localContent = readFile10(absolutePath);
+      localContent = readFile11(absolutePath);
     } catch (err) {
       const staged = await tryStageRemovedFromLockFile(absolutePath, {
         packmindCliHexa,
@@ -17376,7 +17545,7 @@ Content goes here...`
     return;
   }
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(targetDir);
-  const configDir = gitRoot ? normalizePath2(path26.relative(gitRoot, targetDir)) : "";
+  const configDir = gitRoot ? normalizePath2(path27.relative(gitRoot, targetDir)) : "";
   const deployedContext = await resolveDeployedContext(
     packmindCliHexa,
     targetDir
@@ -17384,7 +17553,7 @@ Content goes here...`
   const targetId = deployedContext?.targetId ?? earlyLockFile?.targetId;
   const normalizedFilePath = (() => {
     const refPath = artifactType === "skill" && skillDirPath ? skillDirPath : absolutePath;
-    return normalizePath2(path26.relative(targetDir, refPath));
+    return normalizePath2(path27.relative(targetDir, refPath));
   })();
   let spaceId;
   let spaceName;
@@ -17499,7 +17668,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(path26.join(normalizedFilePath, f.relativePath)) === normalizePath2(deployed.path)
+          (f) => normalizePath2(path27.join(normalizedFilePath, f.relativePath)) === normalizePath2(deployed.path)
         );
         return localFile && deployed.content?.trim() === localFile.content.trim() && (!deployed.skillFilePermissions || deployed.skillFilePermissions === localFile.permissions);
       });
@@ -17611,8 +17780,8 @@ var addPlaybookCommand = (0, import_cmd_ts25.command)({
 var import_cmd_ts26 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/rmHandler.ts
-var fs24 = __toESM(require("fs"));
-var path27 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var path28 = __toESM(require("path"));
 function isSkillSupportFile(absolutePath) {
   const normalized = absolutePath.replace(/\\/g, "/");
   const skillDirMatch = normalized.match(/\/skills\/[^/]+\//);
@@ -17639,14 +17808,14 @@ async function playbookRmHandler(deps) {
     exit(1);
     return;
   }
-  const absolutePath = path27.resolve(getCwd(), filePath);
-  if (!fs24.existsSync(absolutePath)) {
+  const absolutePath = path28.resolve(getCwd(), filePath);
+  if (!fs25.existsSync(absolutePath)) {
     logErrorConsole(`File not found: "${filePath}"`);
     exit(1);
     return;
   }
   const targetDir = await findNearestConfigDir(
-    path27.dirname(absolutePath),
+    path28.dirname(absolutePath),
     packmindCliHexa
   );
   if (!targetDir) {
@@ -17663,7 +17832,7 @@ async function playbookRmHandler(deps) {
     return;
   }
   const normalizedForLookup = normalizePath2(
-    path27.relative(targetDir, absolutePath)
+    path28.relative(targetDir, absolutePath)
   );
   const lockResult = findLockFileEntryAndFileForPath(
     normalizedForLookup,
@@ -17685,7 +17854,7 @@ async function playbookRmHandler(deps) {
   }
   const resolvedAbsolutePath = artifactType === "skill" ? resolveSkillDirPath(absolutePath) : absolutePath;
   const normalizedFilePath = normalizePath2(
-    path27.relative(targetDir, resolvedAbsolutePath)
+    path28.relative(targetDir, resolvedAbsolutePath)
   );
   const lockEntry = findLockFileEntryAndFileForPath(normalizedFilePath, lockFile.artifacts)?.entry ?? lockResult.entry;
   if (!lockEntry) {
@@ -17713,7 +17882,7 @@ async function playbookRmHandler(deps) {
   }
   const spaceName = matchingSpace.name;
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(targetDir);
-  const configDir = gitRoot ? normalizePath2(path27.relative(gitRoot, targetDir)) : "";
+  const configDir = gitRoot ? normalizePath2(path28.relative(gitRoot, targetDir)) : "";
   const deployedContext = await resolveDeployedContext(
     packmindCliHexa,
     targetDir
@@ -17774,7 +17943,7 @@ var rmPlaybookCommand = (0, import_cmd_ts26.command)({
 var import_cmd_ts27 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/unstageHandler.ts
-var path28 = __toESM(require("path"));
+var path29 = __toESM(require("path"));
 async function playbookUnstageHandler(deps) {
   const {
     packmindCliHexa,
@@ -17792,10 +17961,10 @@ async function playbookUnstageHandler(deps) {
     return;
   }
   const cwd = getCwd();
-  const absolutePath = path28.resolve(cwd, filePath);
+  const absolutePath = path29.resolve(cwd, filePath);
   const resolvedPath = resolveSkillDirPath(absolutePath);
   const configDir = await findNearestConfigDir(
-    path28.dirname(resolvedPath),
+    path29.dirname(resolvedPath),
     packmindCliHexa
   );
   if (!configDir) {
@@ -17808,10 +17977,10 @@ async function playbookUnstageHandler(deps) {
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
   const baseDir = gitRoot ?? configDir;
   const normalizedFilePath = normalizePath2(
-    path28.relative(baseDir, resolvedPath)
+    path29.relative(baseDir, resolvedPath)
   );
   const matchingEntries = playbookLocalRepository.getChanges().filter((c) => {
-    const fullEntryPath = c.configDir ? normalizePath2(path28.join(c.configDir, c.filePath)) : c.filePath;
+    const fullEntryPath = c.configDir ? normalizePath2(path29.join(c.configDir, c.filePath)) : c.filePath;
     return fullEntryPath === normalizedFilePath;
   });
   if (matchingEntries.length === 0) {
@@ -17895,15 +18064,15 @@ var import_cmd_ts28 = __toESM(require_cjs());
 
 // apps/cli/src/infra/utils/listDirectoryFiles.ts
 var import_fs22 = require("fs");
-var path29 = __toESM(require("path"));
+var path30 = __toESM(require("path"));
 function listDirectoryFiles(dirPath) {
   const results = [];
   const entries = (0, import_fs22.readdirSync)(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path29.join(dirPath, entry.name);
+    const fullPath = path30.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       for (const nested of listDirectoryFiles(fullPath)) {
-        results.push(path29.join(entry.name, nested));
+        results.push(path30.join(entry.name, nested));
       }
     } else if (entry.isFile()) {
       results.push(entry.name);
@@ -17913,7 +18082,7 @@ function listDirectoryFiles(dirPath) {
 }
 
 // apps/cli/src/infra/commands/playbook/statusHandler.ts
-var path30 = __toESM(require("path"));
+var path31 = __toESM(require("path"));
 
 // apps/cli/src/infra/utils/stringUtils.ts
 function capitalize(s) {
@@ -17948,7 +18117,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(path30.relative(cwd, path30.join(gitRoot, rootRelativePath))) : rootRelativePath;
+    const displayPath = gitRoot ? normalizePath2(path31.relative(cwd, path31.join(gitRoot, rootRelativePath))) : rootRelativePath;
     const existing = groups.get(key);
     if (existing) {
       existing.filePaths.push(displayPath);
@@ -17989,7 +18158,7 @@ async function playbookStatusHandler(deps) {
     lockFileRepository,
     cwd,
     exit,
-    readFile: readFile10,
+    readFile: readFile11,
     listDirectoryFiles: listDirectoryFiles2,
     getFileMode
   } = deps;
@@ -18006,12 +18175,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(path30.relative(gitRoot, fallbackConfigDir)) : "";
+    const rel = gitRoot ? normalizePath2(path31.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(path30.relative(gitRoot, descendantDir)) : normalizePath2(path30.relative(cwd, descendantDir));
+    const rel = gitRoot ? normalizePath2(path31.relative(gitRoot, descendantDir)) : normalizePath2(path31.relative(cwd, descendantDir));
     if (!configDirs.has(rel)) configDirs.add(rel);
   }
   for (const configDirKey of configDirs) {
@@ -18019,7 +18188,7 @@ async function playbookStatusHandler(deps) {
     if (configDirKey === "__cwd__") {
       projectDir = fallbackConfigDir;
     } else if (gitRoot) {
-      projectDir = path30.join(gitRoot, configDirKey);
+      projectDir = path31.join(gitRoot, configDirKey);
     } else {
       continue;
     }
@@ -18044,11 +18213,11 @@ async function playbookStatusHandler(deps) {
         continue;
       }
       const displayPath = normalizePath2(
-        path30.relative(cwd, path30.join(projectDir, deployedFile.path))
+        path31.relative(cwd, path31.join(projectDir, deployedFile.path))
       );
       let localContent;
       try {
-        localContent = readFile10(path30.join(projectDir, deployedFile.path));
+        localContent = readFile11(path31.join(projectDir, deployedFile.path));
       } catch {
         const artifact = findArtifactForFile(
           deployedFile.path,
@@ -18077,7 +18246,7 @@ async function playbookStatusHandler(deps) {
           });
         }
       } else if (deployedFile.skillFilePermissions && getFileMode) {
-        const localMode = getFileMode(path30.join(projectDir, deployedFile.path));
+        const localMode = getFileMode(path31.join(projectDir, deployedFile.path));
         if (localMode !== null) {
           const localPermissions = modeToPermissionStringOrDefault(localMode);
           if (localPermissions !== deployedFile.skillFilePermissions) {
@@ -18106,13 +18275,13 @@ async function playbookStatusHandler(deps) {
         (f) => normalizePath2(f.path).endsWith("/SKILL.md")
       );
       if (!skillMdFile) continue;
-      const skillDir = normalizePath2(path30.dirname(skillMdFile.path));
+      const skillDir = normalizePath2(path31.dirname(skillMdFile.path));
       if (targetStagedPaths.has(skillDir) || targetSkillDirPaths.some(
         (staged) => skillDir === staged || skillDir.startsWith(staged + "/")
       )) {
         continue;
       }
-      const absoluteSkillDir = path30.join(projectDir, skillDir);
+      const absoluteSkillDir = path31.join(projectDir, skillDir);
       let localFiles;
       try {
         localFiles = listDirectoryFiles2(absoluteSkillDir);
@@ -18121,11 +18290,11 @@ async function playbookStatusHandler(deps) {
       }
       for (const localRelPath of localFiles) {
         const normalizedLocalPath = normalizePath2(
-          path30.join(skillDir, localRelPath)
+          path31.join(skillDir, localRelPath)
         );
         if (!deployedPathSet.has(normalizedLocalPath)) {
           const displayPath = normalizePath2(
-            path30.relative(cwd, path30.join(projectDir, normalizedLocalPath))
+            path31.relative(cwd, path31.join(projectDir, normalizedLocalPath))
           );
           untrackedChanges.push({
             artifactName: entry.name,
@@ -18213,7 +18382,7 @@ var import_path5 = require("path");
 var import_cmd_ts29 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/submitHandler.ts
-var path32 = __toESM(require("path"));
+var path33 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/playbook/submit/duplicateNameChecker.ts
 var import_slug2 = __toESM(require("slug"));
@@ -18275,7 +18444,7 @@ async function checkForDuplicateNames(createdEntries, packmindGateway) {
 }
 
 // apps/cli/src/infra/commands/playbook/submit/targetContextResolver.ts
-var path31 = __toESM(require("path"));
+var path32 = __toESM(require("path"));
 async function createTargetContextResolver(deps) {
   const { lockFileRepository, cwd, packmindCliHexa } = deps;
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
@@ -18286,7 +18455,7 @@ async function createTargetContextResolver(deps) {
       if (cache.has(key)) return cache.get(key);
       let projectDir;
       if (entry.configDir !== void 0 && gitRoot) {
-        projectDir = path31.join(gitRoot, entry.configDir);
+        projectDir = path32.join(gitRoot, entry.configDir);
       } else {
         projectDir = await findNearestConfigDir(cwd, packmindCliHexa);
       }
@@ -19234,7 +19403,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 = path32.join(entryCtx.projectDir, entry.filePath);
+            const fullPath = path33.join(entryCtx.projectDir, entry.filePath);
             if (entry.artifactType === "skill") {
               deps.rmSync(fullPath, { recursive: true });
             } else {
@@ -19262,7 +19431,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 = path32.join(entryCtx.projectDir, entry.filePath);
+          const fullPath = path33.join(entryCtx.projectDir, entry.filePath);
           if (entry.artifactType === "skill") {
             deps.rmSync(fullPath, { recursive: true });
           } else {
@@ -19384,7 +19553,7 @@ var diffCommand2 = (0, import_cmd_ts30.command)({
       type: (0, import_cmd_ts30.optional)(import_cmd_ts30.string)
     })
   },
-  handler: async ({ includeSubmitted, path: path36 }) => {
+  handler: async ({ includeSubmitted, path: path37 }) => {
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
     await diffArtefactsHandler({
@@ -19393,7 +19562,7 @@ var diffCommand2 = (0, import_cmd_ts30.command)({
       getCwd: () => process.cwd(),
       log: console.log,
       includeSubmitted,
-      path: path36
+      path: path37
     });
   }
 });
@@ -19482,8 +19651,8 @@ var import_cmd_ts39 = __toESM(require_cjs());
 var import_cmd_ts38 = __toESM(require_cjs());
 
 // apps/cli/src/application/services/AgentArtifactDetectionService.ts
-var fs25 = __toESM(require("fs/promises"));
-var path33 = __toESM(require("path"));
+var fs26 = __toESM(require("fs/promises"));
+var path34 = __toESM(require("path"));
 var AGENT_ARTIFACT_CHECKS = [
   { agent: "claude", paths: [".claude"] },
   { agent: "cursor", paths: [".cursor"] },
@@ -19512,7 +19681,7 @@ var AgentArtifactDetectionService = class {
         }
       } else {
         for (const relativePath of check.paths) {
-          const fullPath = path33.join(baseDirectory, relativePath);
+          const fullPath = path34.join(baseDirectory, relativePath);
           const exists = await this.pathExists(fullPath);
           if (exists) {
             detected.push({
@@ -19528,7 +19697,7 @@ var AgentArtifactDetectionService = class {
   }
   async pathExists(filePath) {
     try {
-      await fs25.access(filePath);
+      await fs26.access(filePath);
       return true;
     } catch {
       return false;
@@ -19539,16 +19708,16 @@ var AgentArtifactDetectionService = class {
     while (queue.length > 0) {
       const currentDir = queue.shift();
       for (const targetPath of targetPaths) {
-        const fullPath = path33.join(currentDir, targetPath);
+        const fullPath = path34.join(currentDir, targetPath);
         if (await this.pathExists(fullPath)) {
           return fullPath;
         }
       }
       try {
-        const entries = await fs25.readdir(currentDir, { withFileTypes: true });
+        const entries = await fs26.readdir(currentDir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-            queue.push(path33.join(currentDir, entry.name));
+            queue.push(path34.join(currentDir, entry.name));
           }
         }
       } catch {
@@ -19563,18 +19732,18 @@ var readline4 = __toESM(require("readline"));
 var inquirer2 = __toESM(require("inquirer"));
 
 // apps/cli/src/infra/commands/config/agents/agentsHandlerUtils.ts
-var path34 = __toESM(require("path"));
-var fs26 = __toESM(require("fs/promises"));
+var path35 = __toESM(require("path"));
+var fs27 = __toESM(require("fs/promises"));
 function getRelativePath(dir, startDirectory) {
   if (dir === startDirectory) return "./packmind.json";
-  return "./" + path34.relative(startDirectory, dir) + "/packmind.json";
+  return "./" + path35.relative(startDirectory, dir) + "/packmind.json";
 }
 async function resolveStartDirectory(args2, getCwd, exit) {
   let startDirectory = getCwd();
   if (args2.path) {
-    const resolvedPath = path34.resolve(getCwd(), args2.path);
+    const resolvedPath = path35.resolve(getCwd(), args2.path);
     try {
-      const stat9 = await fs26.stat(resolvedPath);
+      const stat9 = await fs27.stat(resolvedPath);
       if (!stat9.isDirectory()) {
         logErrorConsole(`Path is not a directory: ${resolvedPath}`);
         exit(1);
@@ -19685,7 +19854,7 @@ async function promptAgentsWithReadline2(choices) {
   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((resolve14) => {
+  return new Promise((resolve15) => {
     rl.question(
       `Enter numbers separated by commas (default: ${defaultValue}): `,
       (answer) => {
@@ -19694,7 +19863,7 @@ async function promptAgentsWithReadline2(choices) {
         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);
-        resolve14(selectedAgents);
+        resolve15(selectedAgents);
       }
     );
   });
@@ -19841,14 +20010,14 @@ 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((resolve14) => {
+  return (message) => new Promise((resolve15) => {
     const rl = readline5.createInterface({
       input: process.stdin,
       output: process.stdout
     });
     rl.question(`${message} (y/N) `, (answer) => {
       rl.close();
-      resolve14(answer.toLowerCase() === "y");
+      resolve15(answer.toLowerCase() === "y");
     });
   });
 }
@@ -20263,20 +20432,20 @@ function findEnvFile() {
   const currentDir = process.cwd();
   const gitService = new GitService();
   const gitRoot = gitService.getGitRepositoryRootSync(currentDir);
-  const filesystemRoot = path35.parse(currentDir).root;
+  const filesystemRoot = path36.parse(currentDir).root;
   const stopDir = gitRoot ?? filesystemRoot;
   let searchDir = currentDir;
-  let parentDir = path35.dirname(searchDir);
+  let parentDir = path36.dirname(searchDir);
   while (searchDir !== parentDir) {
-    const envPath2 = path35.join(searchDir, ".env");
-    if (fs27.existsSync(envPath2)) {
+    const envPath2 = path36.join(searchDir, ".env");
+    if (fs28.existsSync(envPath2)) {
       return envPath2;
     }
     if (searchDir === stopDir) {
       return null;
     }
     searchDir = parentDir;
-    parentDir = path35.dirname(searchDir);
+    parentDir = path36.dirname(searchDir);
   }
   return null;
 }