@packmind/cli 0.29.0 → 0.29.1

package/main.cjs

@@ -2590,7 +2590,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os5 = require("os");
+    var os6 = require("os");
     var tty2 = require("tty");
     var hasFlag2 = require_has_flag();
     var { env: env2 } = process;
@@ -2638,7 +2638,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os5.release().split(".");
+        const osRelease = os6.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -3855,7 +3855,7 @@ var require_package = __commonJS({
   "apps/cli/package.json"(exports2, module2) {
     module2.exports = {
       name: "@packmind/cli",
-      version: "0.29.0",
+      version: "0.29.1",
       description: "A command-line interface for Packmind linting and code quality checks",
       private: false,
       bin: {
@@ -4347,6 +4347,7 @@ function camelToKebab(str) {
 }
 var CLAUDE_CODE_ADDITIONAL_FIELDS = {
   "argument-hint": "argumentHint",
+  arguments: "arguments",
   when_to_use: "whenToUse",
   "disable-model-invocation": "disableModelInvocation",
   "user-invocable": "userInvocable",
@@ -5419,30 +5420,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;
     }
@@ -6744,10 +6745,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,
@@ -10145,8 +10146,8 @@ ${endMarker}`;
 };
 
 // apps/cli/src/application/useCases/InstallUseCase.ts
-var fs6 = __toESM(require("fs/promises"));
-var path7 = __toESM(require("path"));
+var fs7 = __toESM(require("fs/promises"));
+var path8 = __toESM(require("path"));
 
 // apps/cli/src/application/utils/normalizePackageSlugs.ts
 async function normalizePackageSlugs(slugs, spaceService) {
@@ -10164,6 +10165,48 @@ async function normalizePackageSlugs(slugs, spaceService) {
   );
 }
 
+// apps/cli/src/infra/utils/agentHomeDirectory.ts
+var fs6 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+var path7 = __toESM(require("path"));
+var AGENT_HOME_DIR_NAMES = {
+  claude: ".claude"
+};
+function safeRealpath(target) {
+  try {
+    return fs6.realpathSync(target);
+  } catch {
+    return path7.resolve(target);
+  }
+}
+function isAgentHomeDirectory(cwd) {
+  const home = os2.homedir();
+  if (!home) {
+    return null;
+  }
+  const resolvedCwd = safeRealpath(cwd);
+  const resolvedHome = safeRealpath(home);
+  for (const [agent, dirName] of Object.entries(AGENT_HOME_DIR_NAMES)) {
+    if (!dirName) continue;
+    if (resolvedCwd === path7.join(resolvedHome, dirName)) {
+      return agent;
+    }
+  }
+  return null;
+}
+function getAgentHomeDirPrefix(agent) {
+  const dirName = AGENT_HOME_DIR_NAMES[agent];
+  return dirName ? `${dirName}/` : null;
+}
+
+// apps/cli/src/infra/utils/stripFullStandardLinkFooter.ts
+function stripFullStandardLinkFooter(content) {
+  return content.replace(
+    /\n+Full standard is available here for further request: \[.+?]\(.+?\.packmind\/standards\/.+?\)\s*$/,
+    ""
+  );
+}
+
 // apps/cli/src/application/useCases/InstallUseCase.ts
 var InstallUseCase = class {
   constructor(packmindGateway, lockFileRepository, configFileRepository, spaceService) {
@@ -10184,6 +10227,9 @@ var InstallUseCase = class {
       standardsCount: 0,
       commandsCount: 0,
       skillsCount: 0,
+      skillsChanged: 0,
+      standardsChanged: 0,
+      commandsChanged: 0,
       recipesRemoved: 0,
       standardsRemoved: 0,
       commandsRemoved: 0,
@@ -10253,11 +10299,31 @@ var InstallUseCase = class {
       }
       return result;
     }
+    const installAgents = this.resolveInstallAgents(command32, config);
+    const stripPathPrefix = command32.homeAgent ? getAgentHomeDirPrefix(command32.homeAgent) ?? void 0 : void 0;
     const response = await this.packmindGateway.deployment.install({
       packagesSlugs,
       packmindLockFile: effectiveLockFile,
-      agents: config?.agents
+      agents: installAgents
     });
+    if (stripPathPrefix) {
+      const isPackmindMirrorPath = (p) => p.startsWith(".packmind/");
+      response.fileUpdates.createOrUpdate = response.fileUpdates.createOrUpdate.filter((file) => !isPackmindMirrorPath(file.path)).map((file) => {
+        const remapped = {
+          ...file,
+          path: this.stripPrefix(file.path, stripPathPrefix)
+        };
+        if (remapped.content !== void 0) {
+          remapped.content = stripFullStandardLinkFooter(remapped.content);
+        }
+        return remapped;
+      });
+      response.fileUpdates.delete = response.fileUpdates.delete.filter((file) => !isPackmindMirrorPath(file.path)).map((file) => ({
+        ...file,
+        path: this.stripPrefix(file.path, stripPathPrefix)
+      }));
+      response.skillFolders = response.skillFolders.filter((folder) => !isPackmindMirrorPath(folder)).map((folder) => this.stripPrefix(folder, stripPathPrefix));
+    }
     result.missingAccess = response.missingAccess;
     result.resolvedAgents = response.resolvedAgents;
     result.sourceArtifacts = response.sourceArtifacts;
@@ -10277,6 +10343,25 @@ var InstallUseCase = class {
       uniqueFilesMap.set(file.path, file);
     }
     const uniqueFiles = Array.from(uniqueFilesMap.values());
+    const changedArtifactIds = {
+      skill: /* @__PURE__ */ new Set(),
+      standard: /* @__PURE__ */ new Set(),
+      command: /* @__PURE__ */ new Set()
+    };
+    const filesByArtifactId = /* @__PURE__ */ new Map();
+    for (const file of uniqueFiles) {
+      if (file.artifactType && file.artifactId) {
+        const list = filesByArtifactId.get(file.artifactId) ?? [];
+        list.push(file);
+        filesByArtifactId.set(file.artifactId, list);
+      }
+    }
+    const unchangedArtifactIds = /* @__PURE__ */ new Set();
+    for (const [artifactId, files] of filesByArtifactId) {
+      if (await this.allFilesAlreadyMatch(baseDirectory, files)) {
+        unchangedArtifactIds.add(artifactId);
+      }
+    }
     for (const file of uniqueFiles) {
       if (file.path.includes(".packmind/recipes/") && file.path.endsWith(".md")) {
         result.recipesCount++;
@@ -10302,9 +10387,13 @@ var InstallUseCase = class {
             result,
             file.skillFilePermissions
           );
-          if (result.filesCreated + result.filesUpdated > changesBefore && this.isContentFile(file.path)) {
+          const fileActuallyChanged = result.filesCreated + result.filesUpdated > changesBefore;
+          if (fileActuallyChanged && this.isContentFile(file.path)) {
             result.contentFilesChanged++;
           }
+          if (fileActuallyChanged && file.artifactType && file.artifactId && !unchangedArtifactIds.has(file.artifactId)) {
+            changedArtifactIds[file.artifactType].add(file.artifactId);
+          }
         } catch (error) {
           const errorMsg = error instanceof Error ? error.message : String(error);
           result.errors.push(
@@ -10340,6 +10429,9 @@ var InstallUseCase = class {
       const errorMsg = error instanceof Error ? error.message : String(error);
       result.errors.push(`Failed to install packages: ${errorMsg}`);
     }
+    result.skillsChanged = changedArtifactIds.skill.size;
+    result.standardsChanged = changedArtifactIds.standard.size;
+    result.commandsChanged = changedArtifactIds.command.size;
     try {
       let lockFileToPersist = effectiveLockFile;
       if (serverLockFile?.content) {
@@ -10352,6 +10444,12 @@ var InstallUseCase = class {
         delete lockFileToPersist.installedAt;
       }
       lockFileToPersist.cliVersion = command32.cliVersion;
+      if (stripPathPrefix) {
+        lockFileToPersist = this.stripLockFileArtifactPaths(
+          lockFileToPersist,
+          stripPathPrefix
+        );
+      }
       await this.lockFileRepository.write(baseDirectory, lockFileToPersist);
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
@@ -10374,6 +10472,32 @@ var InstallUseCase = class {
   async normalizePackageSlugs(slugs) {
     return normalizePackageSlugs(slugs, this.spaceService);
   }
+  resolveInstallAgents(command32, config) {
+    if (command32.homeAgent) {
+      return [command32.homeAgent];
+    }
+    return config?.agents;
+  }
+  stripPrefix(filePath, prefix) {
+    return filePath.startsWith(prefix) ? filePath.slice(prefix.length) : filePath;
+  }
+  // In home-install mode the on-disk files live without the agent prefix
+  // (e.g. `commands/foo.md` instead of `.claude/commands/foo.md`) and the
+  // `.packmind/` mirror folder is not rendered. The lockfile content returned
+  // by the server still references the original paths, so we realign it here
+  // before persisting — otherwise `playbook status`/`add` can't match local
+  // files against the lockfile entries.
+  stripLockFileArtifactPaths(lockFile, prefix) {
+    const remappedArtifacts = {};
+    for (const [key, entry] of Object.entries(lockFile.artifacts)) {
+      const remappedFiles = entry.files.filter((file) => !file.path.startsWith(".packmind/")).map((file) => ({
+        ...file,
+        path: this.stripPrefix(file.path, prefix)
+      }));
+      remappedArtifacts[key] = { ...entry, files: remappedFiles };
+    }
+    return { ...lockFile, artifacts: remappedArtifacts };
+  }
   async normalizeAndSaveConfigPackages(baseDirectory, config) {
     const originalSlugs = Object.keys(config.packages);
     if (originalSlugs.length === 0) return [];
@@ -10434,9 +10558,9 @@ var InstallUseCase = class {
     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 fs6.mkdir(directory, { recursive: true });
+    const fullPath = path8.join(baseDirectory, file.path);
+    const directory = path8.dirname(fullPath);
+    await fs7.mkdir(directory, { recursive: true });
     const fileExists = await this.fileExists(fullPath);
     if (file.content !== void 0) {
       await this.handleFullContentUpdate(
@@ -10456,13 +10580,13 @@ var InstallUseCase = class {
       );
     }
     if (skillFilePermissions && supportsUnixPermissions()) {
-      await fs6.chmod(fullPath, parsePermissionString(skillFilePermissions));
+      await fs7.chmod(fullPath, parsePermissionString(skillFilePermissions));
     }
   }
   async handleFullContentUpdate(fullPath, content, fileExists, result, isBase64) {
     if (isBase64) {
       const buffer = Buffer.from(content, "base64");
-      await fs6.writeFile(fullPath, buffer);
+      await fs7.writeFile(fullPath, buffer);
       if (fileExists) {
         result.filesUpdated++;
       } else {
@@ -10471,7 +10595,7 @@ var InstallUseCase = class {
       return;
     }
     if (fileExists) {
-      const existingContent = await fs6.readFile(fullPath, "utf-8");
+      const existingContent = await fs7.readFile(fullPath, "utf-8");
       const commentMarker = this.extractCommentMarker(content);
       let finalContent;
       if (!commentMarker) {
@@ -10484,18 +10608,18 @@ var InstallUseCase = class {
         );
       }
       if (existingContent !== finalContent) {
-        await fs6.writeFile(fullPath, finalContent, "utf-8");
+        await fs7.writeFile(fullPath, finalContent, "utf-8");
         result.filesUpdated++;
       }
     } else {
-      await fs6.writeFile(fullPath, content, "utf-8");
+      await fs7.writeFile(fullPath, content, "utf-8");
       result.filesCreated++;
     }
   }
   async handleSectionsUpdate(fullPath, sections, fileExists, result, baseDirectory) {
     let currentContent = "";
     if (fileExists) {
-      currentContent = await fs6.readFile(fullPath, "utf-8");
+      currentContent = await fs7.readFile(fullPath, "utf-8");
     }
     const mergedContent = mergeSectionsIntoFileContent(
       currentContent,
@@ -10503,11 +10627,11 @@ var InstallUseCase = class {
     );
     if (currentContent !== mergedContent) {
       if (this.isEffectivelyEmpty(mergedContent) && fileExists) {
-        await fs6.unlink(fullPath);
+        await fs7.unlink(fullPath);
         result.filesDeleted++;
         await this.removeEmptyParentDirectories(fullPath, baseDirectory);
       } else {
-        await fs6.writeFile(fullPath, mergedContent, "utf-8");
+        await fs7.writeFile(fullPath, mergedContent, "utf-8");
         if (fileExists) {
           result.filesUpdated++;
         } else {
@@ -10517,14 +10641,14 @@ var InstallUseCase = class {
     }
   }
   async deleteFile(baseDirectory, filePath, result) {
-    const fullPath = path7.join(baseDirectory, filePath);
-    const stat9 = await fs6.stat(fullPath).catch(() => null);
+    const fullPath = path8.join(baseDirectory, filePath);
+    const stat9 = await fs7.stat(fullPath).catch(() => null);
     if (stat9?.isDirectory()) {
-      await fs6.rm(fullPath, { recursive: true, force: true });
+      await fs7.rm(fullPath, { recursive: true, force: true });
       result.filesDeleted++;
       await this.removeEmptyParentDirectories(fullPath, baseDirectory);
     } else if (stat9?.isFile()) {
-      await fs6.unlink(fullPath);
+      await fs7.unlink(fullPath);
       result.filesDeleted++;
       await this.removeEmptyParentDirectories(fullPath, baseDirectory);
     }
@@ -10534,12 +10658,36 @@ var InstallUseCase = class {
   }
   async fileExists(filePath) {
     try {
-      await fs6.access(filePath);
+      await fs7.access(filePath);
       return true;
     } catch {
       return false;
     }
   }
+  // Returns true iff every file in `files` already exists on disk with the
+  // exact content the server is about to write. Used to decide whether an
+  // artifact (skill/standard/command) is genuinely changing this install.
+  // Files with `sections` (index files like CLAUDE.md) carry no artifactType
+  // and never reach this helper.
+  async allFilesAlreadyMatch(baseDirectory, files) {
+    for (const file of files) {
+      if (file.content === void 0) return false;
+      const fullPath = path8.join(baseDirectory, file.path);
+      try {
+        if (file.isBase64) {
+          const expected = Buffer.from(file.content, "base64");
+          const actual = await fs7.readFile(fullPath);
+          if (!expected.equals(actual)) return false;
+        } else {
+          const actual = await fs7.readFile(fullPath, "utf-8");
+          if (actual !== file.content) return false;
+        }
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  }
   extractCommentMarker(content) {
     const startMarkerPattern = /<!--\s*start:\s*([^-]+?)\s*-->/;
     const match = content.match(startMarkerPattern);
@@ -10584,11 +10732,11 @@ ${endMarker}`;
   async deleteSkillFolders(baseDirectory, folders) {
     let deletedFilesCount = 0;
     for (const folder of folders) {
-      const fullPath = path7.join(baseDirectory, folder);
+      const fullPath = path8.join(baseDirectory, folder);
       try {
-        await fs6.access(fullPath);
+        await fs7.access(fullPath);
         const fileCount = await this.countFilesInDirectory(fullPath);
-        await fs6.rm(fullPath, { recursive: true, force: true });
+        await fs7.rm(fullPath, { recursive: true, force: true });
         deletedFilesCount += fileCount;
         await this.removeEmptyParentDirectories(fullPath, baseDirectory);
       } catch {
@@ -10598,9 +10746,9 @@ ${endMarker}`;
   }
   async countFilesInDirectory(dirPath) {
     let count = 0;
-    const entries = await fs6.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs7.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path7.join(dirPath, entry.name);
+      const entryPath = path8.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         count += await this.countFilesInDirectory(entryPath);
       } else {
@@ -10611,24 +10759,24 @@ ${endMarker}`;
   }
   async isDirectoryEmpty(dirPath) {
     try {
-      const entries = await fs6.readdir(dirPath);
+      const entries = await fs7.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 normalizedBase = path8.resolve(baseDirectory);
+    let currentDir = path8.dirname(path8.resolve(fullPath));
+    while (currentDir.startsWith(normalizedBase + path8.sep) && currentDir !== normalizedBase) {
       const isEmpty = await this.isDirectoryEmpty(currentDir);
       if (!isEmpty) break;
       try {
-        await fs6.rmdir(currentDir);
+        await fs7.rmdir(currentDir);
       } catch {
         break;
       }
-      currentDir = path7.dirname(currentDir);
+      currentDir = path8.dirname(currentDir);
     }
   }
 };
@@ -10692,8 +10840,8 @@ ${pkgList}`
 };
 
 // apps/cli/src/application/useCases/InstallDefaultSkillsUseCase.ts
-var fs7 = __toESM(require("fs/promises"));
-var path8 = __toESM(require("path"));
+var fs8 = __toESM(require("fs/promises"));
+var path9 = __toESM(require("path"));
 var import_semver = __toESM(require("semver"));
 
 // apps/cli/src/application/utils/normalizeSemver.ts
@@ -10745,9 +10893,9 @@ var InstallDefaultSkillsUseCase = class {
     const incompatibleSkillDirs = /* @__PURE__ */ new Map();
     if (command32.cliVersion) {
       for (const file of response.fileUpdates.createOrUpdate) {
-        if (path8.basename(file.path) === "SKILL.md" && file.content && this.isVersionConstraintViolated(file.content, command32.cliVersion)) {
-          const dir = path8.dirname(file.path);
-          const skillName = this.getSkillName(file.content) ?? path8.basename(dir);
+        if (path9.basename(file.path) === "SKILL.md" && file.content && this.isVersionConstraintViolated(file.content, command32.cliVersion)) {
+          const dir = path9.dirname(file.path);
+          const skillName = this.getSkillName(file.content) ?? path9.basename(dir);
           incompatibleSkillDirs.set(dir, skillName);
         }
       }
@@ -10764,8 +10912,8 @@ var InstallDefaultSkillsUseCase = class {
             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 skillName = this.getSkillName(file.content) ?? this.getSkillNameForPath(file.path, incompatibleSkillDirs) ?? path9.basename(file.path);
+            const fullPath = path9.join(baseDirectory, file.path);
             const fileAlreadyInstalled = await this.fileExists(fullPath);
             if (fileAlreadyInstalled) {
               const paths = incompatibleInstalledMap.get(skillName) ?? [];
@@ -10882,24 +11030,24 @@ var InstallDefaultSkillsUseCase = class {
     );
   }
   async createOrUpdateFile(baseDirectory, file, result) {
-    const fullPath = path8.join(baseDirectory, file.path);
-    const directory = path8.dirname(fullPath);
-    await fs7.mkdir(directory, { recursive: true });
+    const fullPath = path9.join(baseDirectory, file.path);
+    const directory = path9.dirname(fullPath);
+    await fs8.mkdir(directory, { recursive: true });
     const fileExists = await this.fileExists(fullPath);
     if (fileExists) {
-      const existingContent = await fs7.readFile(fullPath, "utf-8");
+      const existingContent = await fs8.readFile(fullPath, "utf-8");
       if (existingContent !== file.content) {
-        await fs7.writeFile(fullPath, file.content, "utf-8");
+        await fs8.writeFile(fullPath, file.content, "utf-8");
         result.filesUpdated++;
       }
     } else {
-      await fs7.writeFile(fullPath, file.content, "utf-8");
+      await fs8.writeFile(fullPath, file.content, "utf-8");
       result.filesCreated++;
     }
   }
   async fileExists(filePath) {
     try {
-      await fs7.access(filePath);
+      await fs8.access(filePath);
       return true;
     } catch {
       return false;
@@ -10918,7 +11066,7 @@ var InstallDefaultSkillsUseCase = class {
    */
   getSkillNameForPath(filePath, incompatibleSkillDirs) {
     for (const [dir, skillName] of incompatibleSkillDirs.entries()) {
-      if (filePath === dir || filePath.startsWith(dir + "/") || filePath.startsWith(dir + path8.sep)) {
+      if (filePath === dir || filePath.startsWith(dir + "/") || filePath.startsWith(dir + path9.sep)) {
         return skillName;
       }
     }
@@ -11091,13 +11239,13 @@ var EnvCredentialsProvider = class {
 };
 
 // apps/cli/src/infra/utils/credentials/FileCredentialsProvider.ts
-var fs8 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
-var os2 = __toESM(require("os"));
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+var os3 = __toESM(require("os"));
 var CREDENTIALS_DIR = ".packmind";
 var CREDENTIALS_FILE = "credentials.json";
 function getCredentialsPath() {
-  return path9.join(os2.homedir(), CREDENTIALS_DIR, CREDENTIALS_FILE);
+  return path10.join(os3.homedir(), CREDENTIALS_DIR, CREDENTIALS_FILE);
 }
 var FileCredentialsProvider = class {
   getSourceName() {
@@ -11105,11 +11253,11 @@ var FileCredentialsProvider = class {
   }
   hasCredentials() {
     const credentialsPath = getCredentialsPath();
-    if (!fs8.existsSync(credentialsPath)) {
+    if (!fs9.existsSync(credentialsPath)) {
       return false;
     }
     try {
-      const content = fs8.readFileSync(credentialsPath, "utf-8");
+      const content = fs9.readFileSync(credentialsPath, "utf-8");
       const credentials = JSON.parse(content);
       return !!credentials.apiKey;
     } catch {
@@ -11118,11 +11266,11 @@ var FileCredentialsProvider = class {
   }
   loadCredentials() {
     const credentialsPath = getCredentialsPath();
-    if (!fs8.existsSync(credentialsPath)) {
+    if (!fs9.existsSync(credentialsPath)) {
       return null;
     }
     try {
-      const content = fs8.readFileSync(credentialsPath, "utf-8");
+      const content = fs9.readFileSync(credentialsPath, "utf-8");
       const credentials = JSON.parse(content);
       if (!credentials.apiKey) {
         return null;
@@ -11145,13 +11293,13 @@ var FileCredentialsProvider = class {
   }
 };
 function saveCredentials(apiKey) {
-  const credentialsDir = path9.join(os2.homedir(), CREDENTIALS_DIR);
-  if (!fs8.existsSync(credentialsDir)) {
-    fs8.mkdirSync(credentialsDir, { recursive: true, mode: 448 });
+  const credentialsDir = path10.join(os3.homedir(), CREDENTIALS_DIR);
+  if (!fs9.existsSync(credentialsDir)) {
+    fs9.mkdirSync(credentialsDir, { recursive: true, mode: 448 });
   }
   const credentialsPath = getCredentialsPath();
   const credentials = { apiKey };
-  fs8.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
+  fs9.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
     mode: 384
   });
 }
@@ -11222,10 +11370,10 @@ async function defaultPromptForCode() {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     rl.question("Enter the login code from the browser: ", (answer) => {
       rl.close();
-      resolve15(answer.trim());
+      resolve16(answer.trim());
     });
   });
 }
@@ -11259,7 +11407,7 @@ async function defaultExchangeCodeForApiKey(code, host) {
   return await response.json();
 }
 function defaultStartCallbackServer() {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     let timeoutId = null;
     const server = http.createServer((req, res) => {
       res.setHeader("Access-Control-Allow-Origin", "*");
@@ -11272,7 +11420,7 @@ function defaultStartCallbackServer() {
         if (timeoutId) {
           clearTimeout(timeoutId);
         }
-        resolve15(code);
+        resolve16(code);
         setImmediate(() => {
           server.close();
         });
@@ -11343,13 +11491,13 @@ var LoginUseCase = class {
 };
 
 // apps/cli/src/application/useCases/LogoutUseCase.ts
-var fs9 = __toESM(require("fs"));
+var fs10 = __toESM(require("fs"));
 var LogoutUseCase = class {
   constructor(deps) {
     this.deps = {
       getCredentialsPath: deps?.getCredentialsPath ?? getCredentialsPath,
-      fileExists: deps?.fileExists ?? ((path36) => fs9.existsSync(path36)),
-      deleteFile: deps?.deleteFile ?? ((path36) => fs9.unlinkSync(path36)),
+      fileExists: deps?.fileExists ?? ((path37) => fs10.existsSync(path37)),
+      deleteFile: deps?.deleteFile ?? ((path37) => fs10.unlinkSync(path37)),
       hasEnvVar: deps?.hasEnvVar ?? (() => ENV_VAR_NAMES.some((name) => {
         const value = process.env[name];
         return !!value && value.trim().length > 0;
@@ -11622,23 +11770,23 @@ async function updateHandler(deps) {
 }
 
 // apps/cli/src/infra/utils/versionCache/FileVersionCacheProvider.ts
-var fs10 = __toESM(require("fs"));
-var os3 = __toESM(require("os"));
-var path11 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var os4 = __toESM(require("os"));
+var path12 = __toESM(require("path"));
 var import_semver4 = __toESM(require("semver"));
 var CACHE_DIR = ".packmind";
 var CACHE_FILE = "version-check.json";
 function getCachePath() {
-  return path11.join(os3.homedir(), CACHE_DIR, CACHE_FILE);
+  return path12.join(os4.homedir(), CACHE_DIR, CACHE_FILE);
 }
 var FileVersionCacheProvider = class {
   read() {
     const cachePath = getCachePath();
-    if (!fs10.existsSync(cachePath)) {
+    if (!fs11.existsSync(cachePath)) {
       return null;
     }
     try {
-      const content = fs10.readFileSync(cachePath, "utf-8");
+      const content = fs11.readFileSync(cachePath, "utf-8");
       const stored = JSON.parse(content);
       if (!stored.latestVersion || !stored.checkedAt) {
         return null;
@@ -11659,10 +11807,10 @@ var FileVersionCacheProvider = class {
     }
   }
   write(entry) {
-    const cacheDir = path11.join(os3.homedir(), CACHE_DIR);
+    const cacheDir = path12.join(os4.homedir(), CACHE_DIR);
     try {
-      if (!fs10.existsSync(cacheDir)) {
-        fs10.mkdirSync(cacheDir, { recursive: true, mode: 448 });
+      if (!fs11.existsSync(cacheDir)) {
+        fs11.mkdirSync(cacheDir, { recursive: true, mode: 448 });
       }
       const stored = {
         latestVersion: entry.latestVersion,
@@ -11670,10 +11818,10 @@ var FileVersionCacheProvider = class {
       };
       const cachePath = getCachePath();
       const tmpPath = `${cachePath}.${process.pid}.tmp`;
-      fs10.writeFileSync(tmpPath, JSON.stringify(stored, null, 2), {
+      fs11.writeFileSync(tmpPath, JSON.stringify(stored, null, 2), {
         mode: 384
       });
-      fs10.renameSync(tmpPath, cachePath);
+      fs11.renameSync(tmpPath, cachePath);
     } catch {
     }
   }
@@ -11743,8 +11891,8 @@ var CheckCliVersionUseCase = class {
 };
 
 // apps/cli/src/infra/repositories/ConfigFileRepository.ts
-var fs11 = __toESM(require("fs/promises"));
-var path12 = __toESM(require("path"));
+var fs12 = __toESM(require("fs/promises"));
+var path13 = __toESM(require("path"));
 var ConfigFileRepository = class {
   constructor() {
     this.CONFIG_FILENAME = "packmind.json";
@@ -11765,7 +11913,7 @@ var ConfigFileRepository = class {
   async configExists(baseDirectory) {
     const configPath = this.getConfigPath(baseDirectory);
     try {
-      await fs11.access(configPath);
+      await fs12.access(configPath);
       return true;
     } catch {
       return false;
@@ -11774,7 +11922,7 @@ var ConfigFileRepository = class {
   async readConfig(baseDirectory) {
     const configPath = this.getConfigPath(baseDirectory);
     try {
-      const configContent = await fs11.readFile(configPath, "utf-8");
+      const configContent = await fs12.readFile(configPath, "utf-8");
       const rawConfig = JSON.parse(configContent);
       if (!rawConfig.packages || typeof rawConfig.packages !== "object") {
         throw new Error(
@@ -11808,18 +11956,18 @@ var ConfigFileRepository = class {
     }
   }
   getConfigPath(directory) {
-    return path12.join(directory, this.CONFIG_FILENAME);
+    return path13.join(directory, this.CONFIG_FILENAME);
   }
   async writeConfigToPath(configPath, config) {
     const configContent = JSON.stringify(config, null, 2) + "\n";
-    await fs11.writeFile(configPath, configContent, "utf-8");
+    await fs12.writeFile(configPath, configContent, "utf-8");
   }
   /**
    * Recursively finds all directories containing packmind.json in descendant folders.
    * Excludes common build/dependency directories (node_modules, .git, dist, etc.)
    */
   async findDescendantConfigs(directory) {
-    const normalizedDir = normalizePath2(path12.resolve(directory));
+    const normalizedDir = normalizePath2(path13.resolve(directory));
     return this.searchDescendantsRecursively(normalizedDir);
   }
   async searchDescendantsRecursively(currentDir) {
@@ -11832,7 +11980,7 @@ var ConfigFileRepository = class {
       if (!entry.isDirectory() || this.isExcludedDirectory(entry.name)) {
         continue;
       }
-      const entryPath = normalizePath2(path12.join(currentDir, entry.name));
+      const entryPath = normalizePath2(path13.join(currentDir, entry.name));
       const config = await this.readConfig(entryPath);
       if (config) {
         results.push(entryPath);
@@ -11844,7 +11992,7 @@ var ConfigFileRepository = class {
   }
   async tryReadDirectory(directory) {
     try {
-      return await fs11.readdir(directory, { withFileTypes: true });
+      return await fs12.readdir(directory, { withFileTypes: true });
     } catch {
       return null;
     }
@@ -11863,21 +12011,21 @@ var ConfigFileRepository = class {
   async readHierarchicalConfig(startDirectory, stopDirectory) {
     const configs = [];
     const configPaths = [];
-    const normalizedStart = normalizePath2(path12.resolve(startDirectory));
-    const normalizedStop = stopDirectory ? normalizePath2(path12.resolve(stopDirectory)) : null;
+    const normalizedStart = normalizePath2(path13.resolve(startDirectory));
+    const normalizedStop = stopDirectory ? normalizePath2(path13.resolve(stopDirectory)) : null;
     let currentDir = normalizedStart;
     while (true) {
       const config = await this.readConfig(currentDir);
       if (config) {
         configs.push(config);
         configPaths.push(
-          normalizePath2(path12.join(currentDir, this.CONFIG_FILENAME))
+          normalizePath2(path13.join(currentDir, this.CONFIG_FILENAME))
         );
       }
       if (normalizedStop !== null && currentDir === normalizedStop) {
         break;
       }
-      const parentDir = normalizePath2(path12.dirname(currentDir));
+      const parentDir = normalizePath2(path13.dirname(currentDir));
       if (parentDir === currentDir) {
         break;
       }
@@ -11902,8 +12050,8 @@ var ConfigFileRepository = class {
    * and returns each config with its target path.
    */
   async findAllConfigsInTree(startDirectory, stopDirectory) {
-    const normalizedStart = normalizePath2(path12.resolve(startDirectory));
-    const normalizedStop = stopDirectory ? normalizePath2(path12.resolve(stopDirectory)) : null;
+    const normalizedStart = normalizePath2(path13.resolve(startDirectory));
+    const normalizedStop = stopDirectory ? normalizePath2(path13.resolve(stopDirectory)) : null;
     const basePath = normalizedStop ?? normalizedStart;
     const searchRoot = normalizedStop ?? normalizedStart;
     const configsMap = /* @__PURE__ */ new Map();
@@ -11929,7 +12077,7 @@ var ConfigFileRepository = class {
       if (stopDir !== null && currentDir === stopDir) {
         break;
       }
-      const parentDir = normalizePath2(path12.dirname(currentDir));
+      const parentDir = normalizePath2(path13.dirname(currentDir));
       if (parentDir === currentDir) {
         break;
       }
@@ -12060,7 +12208,7 @@ var ConfigFileRepository = class {
   }
   async tryReadFile(filePath) {
     try {
-      return await fs11.readFile(filePath, "utf-8");
+      return await fs12.readFile(filePath, "utf-8");
     } catch (error) {
       if (error.code === "ENOENT") {
         return null;
@@ -12078,8 +12226,8 @@ var ConfigFileRepository = class {
 };
 
 // apps/cli/src/infra/repositories/LockFileRepository.ts
-var fs12 = __toESM(require("fs/promises"));
-var path13 = __toESM(require("path"));
+var fs13 = __toESM(require("fs/promises"));
+var path14 = __toESM(require("path"));
 var LockFileRepository = class {
   constructor() {
     this.LOCK_FILENAME = "packmind-lock.json";
@@ -12088,7 +12236,7 @@ var LockFileRepository = class {
   async read(baseDirectory) {
     const lockFilePath = this.getLockFilePath(baseDirectory);
     try {
-      const content = await fs12.readFile(lockFilePath, "utf-8");
+      const content = await fs13.readFile(lockFilePath, "utf-8");
       const parsed = JSON.parse(content);
       if (!this.isValidLockFile(parsed)) {
         logWarningConsole(`Malformed lock file: ${lockFilePath}`);
@@ -12112,7 +12260,7 @@ var LockFileRepository = class {
   async write(baseDirectory, lockFile) {
     const lockFilePath = this.getLockFilePath(baseDirectory);
     const serialized = JSON.stringify(lockFile, null, 2) + "\n";
-    await fs12.writeFile(lockFilePath, serialized, "utf-8");
+    await fs13.writeFile(lockFilePath, serialized, "utf-8");
   }
   isValidLockFile(data) {
     if (typeof data !== "object" || data === null || Array.isArray(data)) {
@@ -12152,7 +12300,7 @@ var LockFileRepository = class {
     };
   }
   getLockFilePath(baseDirectory) {
-    return path13.join(baseDirectory, this.LOCK_FILENAME);
+    return path14.join(baseDirectory, this.LOCK_FILENAME);
   }
 };
 
@@ -12248,7 +12396,7 @@ function normalizeLineEndings(content) {
 }
 
 // apps/cli/src/infra/utils/binaryDetection.ts
-var path14 = __toESM(require("path"));
+var path15 = __toESM(require("path"));
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   // Images
   ".png",
@@ -12306,7 +12454,7 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".sqlite3"
 ]);
 function isBinaryExtension(filePath) {
-  const ext = path14.extname(filePath).toLowerCase();
+  const ext = path15.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 }
 function isBinaryBuffer(buffer) {
@@ -12452,17 +12600,17 @@ ${spaceList}`
 
 // apps/cli/src/application/useCases/diffStrategies/CommandDiffStrategy.ts
 var import_diff2 = require("diff");
-var fs14 = __toESM(require("fs/promises"));
-var path16 = __toESM(require("path"));
+var fs15 = __toESM(require("fs/promises"));
+var path17 = __toESM(require("path"));
 var CommandDiffStrategy = class {
   supports(file) {
     return file.artifactType === "command";
   }
   async diff(file, baseDirectory) {
-    const fullPath = path16.join(baseDirectory, file.path);
+    const fullPath = path17.join(baseDirectory, file.path);
     let localContent;
     try {
-      localContent = await fs14.readFile(fullPath, "utf-8");
+      localContent = await fs15.readFile(fullPath, "utf-8");
     } catch {
       return [];
     }
@@ -12492,8 +12640,8 @@ var CommandDiffStrategy = class {
 
 // apps/cli/src/application/useCases/diffStrategies/SkillDiffStrategy.ts
 var import_diff3 = require("diff");
-var fs15 = __toESM(require("fs/promises"));
-var path17 = __toESM(require("path"));
+var fs16 = __toESM(require("fs/promises"));
+var path18 = __toESM(require("path"));
 
 // apps/cli/src/application/utils/stripFrontmatter.ts
 var FRONTMATTER_DELIMITER2 = "---";
@@ -12528,7 +12676,7 @@ var SkillDiffStrategy = class {
   async diffNewFiles(skillFolders, serverFiles, baseDirectory) {
     const diffs = [];
     for (const folder of skillFolders) {
-      const folderPath = path17.join(baseDirectory, folder);
+      const folderPath = path18.join(baseDirectory, folder);
       const localFiles = await this.listFilesRecursively(folderPath);
       const serverPathsInFolder = new Set(
         serverFiles.filter((f) => f.path.startsWith(folder + "/")).map((f) => f.path)
@@ -12547,7 +12695,7 @@ var SkillDiffStrategy = class {
         if (serverPathsInFolder.has(filePath)) {
           continue;
         }
-        const fullPath = path17.join(baseDirectory, filePath);
+        const fullPath = path18.join(baseDirectory, filePath);
         const localRead = await this.tryReadFileBinaryAware(fullPath);
         if (localRead === null) {
           continue;
@@ -12574,7 +12722,7 @@ var SkillDiffStrategy = class {
     return diffs;
   }
   async diffSkillMd(file, baseDirectory) {
-    const fullPath = path17.join(baseDirectory, file.path);
+    const fullPath = path18.join(baseDirectory, file.path);
     const localContent = await this.tryReadFile(fullPath);
     if (localContent === null) {
       return [];
@@ -12631,7 +12779,7 @@ var SkillDiffStrategy = class {
       return [];
     }
     const skillFileId = createSkillFileId(file.skillFileId);
-    const fullPath = path17.join(baseDirectory, file.path);
+    const fullPath = path18.join(baseDirectory, file.path);
     const localRead = await this.tryReadFileBinaryAware(fullPath);
     const fileRelativePath = this.computeRelativePath(file.path, skillFolders);
     if (localRead === null) {
@@ -12841,14 +12989,14 @@ var SkillDiffStrategy = class {
   }
   async tryReadFile(filePath) {
     try {
-      return await fs15.readFile(filePath, "utf-8");
+      return await fs16.readFile(filePath, "utf-8");
     } catch {
       return null;
     }
   }
   async tryReadFileBinaryAware(filePath) {
     try {
-      const buffer = await fs15.readFile(filePath);
+      const buffer = await fs16.readFile(filePath);
       if (isBinaryFile(filePath, buffer)) {
         return { content: buffer.toString("base64"), isBase64: true };
       }
@@ -12860,13 +13008,13 @@ var SkillDiffStrategy = class {
   async listFilesRecursively(dirPath, prefix = "") {
     let entries;
     try {
-      entries = await fs15.readdir(dirPath);
+      entries = await fs16.readdir(dirPath);
     } catch {
       return [];
     }
     const files = [];
     for (const entry of entries) {
-      const fullPath = path17.join(dirPath, entry);
+      const fullPath = path18.join(dirPath, entry);
       const stat9 = await this.tryStatFile(fullPath);
       if (!stat9) {
         continue;
@@ -12886,7 +13034,7 @@ var SkillDiffStrategy = class {
   }
   async tryStatFile(filePath) {
     try {
-      const stat9 = await fs15.stat(filePath);
+      const stat9 = await fs16.stat(filePath);
       return { isDirectory: stat9.isDirectory() };
     } catch {
       return null;
@@ -12894,7 +13042,7 @@ var SkillDiffStrategy = class {
   }
   async tryGetPermissions(filePath) {
     try {
-      const stat9 = await fs15.stat(filePath);
+      const stat9 = await fs16.stat(filePath);
       return modeToPermissionStringOrDefault(stat9.mode);
     } catch {
       return null;
@@ -12910,8 +13058,8 @@ var SkillDiffStrategy = class {
 };
 
 // apps/cli/src/application/useCases/diffStrategies/StandardDiffStrategy.ts
-var fs16 = __toESM(require("fs/promises"));
-var path18 = __toESM(require("path"));
+var fs17 = __toESM(require("fs/promises"));
+var path19 = __toESM(require("path"));
 
 // apps/cli/src/application/utils/parseStandardMd.ts
 var DEPLOYER_PARSERS = [
@@ -12922,7 +13070,13 @@ var DEPLOYER_PARSERS = [
     pattern: ".continue/rules/packmind/standard-",
     parse: parseContinueStandard
   },
-  { pattern: ".github/instructions/packmind-", parse: parseCopilotStandard }
+  { pattern: ".github/instructions/packmind-", parse: parseCopilotStandard },
+  // Home-install variant (e.g. `~/.claude`): the agent directory prefix is
+  // stripped from on-disk and lockfile paths. Only Claude supports home-install
+  // today, so an unprefixed `rules/packmind/standard-…` path is Claude-rendered.
+  // Keep this entry last so the prefixed patterns above still win for in-repo
+  // installs whose paths happen to contain this suffix.
+  { pattern: "rules/packmind/standard-", parse: parseClaudeStandard }
 ];
 function parseStandardMd(content, filePath) {
   const deployer = DEPLOYER_PARSERS.find((d) => filePath.includes(d.pattern));
@@ -13219,10 +13373,10 @@ var StandardDiffStrategy = class {
     return file.artifactType === "standard";
   }
   async diff(file, baseDirectory) {
-    const fullPath = path18.join(baseDirectory, file.path);
+    const fullPath = path19.join(baseDirectory, file.path);
     let localContent;
     try {
-      localContent = await fs16.readFile(fullPath, "utf-8");
+      localContent = await fs17.readFile(fullPath, "utf-8");
     } catch {
       return [];
     }
@@ -14139,31 +14293,31 @@ var HumanReadableLogger = class {
 var pathModule2 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/lintHandler.ts
-var fs18 = __toESM(require("fs/promises"));
+var fs19 = __toESM(require("fs/promises"));
 var pathModule = __toESM(require("path"));
 
 // apps/cli/src/application/services/PackmindIgnoreReader.ts
-var fs17 = __toESM(require("fs/promises"));
-var path19 = __toESM(require("path"));
+var fs18 = __toESM(require("fs/promises"));
+var path20 = __toESM(require("path"));
 var IGNORE_FILENAME = ".packmindignore";
 var PackmindIgnoreReader = class {
   async readIgnorePatterns(startDirectory, stopDirectory) {
     const patterns = [];
-    const normalizedStart = path19.resolve(startDirectory);
-    const normalizedStop = stopDirectory ? path19.resolve(stopDirectory) : null;
+    const normalizedStart = path20.resolve(startDirectory);
+    const normalizedStop = stopDirectory ? path20.resolve(stopDirectory) : null;
     if (normalizedStop === null) {
-      const ignoreFile = path19.join(normalizedStart, IGNORE_FILENAME);
+      const ignoreFile = path20.join(normalizedStart, IGNORE_FILENAME);
       return this.parseIgnoreFile(ignoreFile);
     }
     let currentDir = normalizedStart;
     while (true) {
-      const ignoreFile = path19.join(currentDir, IGNORE_FILENAME);
+      const ignoreFile = path20.join(currentDir, IGNORE_FILENAME);
       const filePatterns = await this.parseIgnoreFile(ignoreFile);
       patterns.push(...filePatterns);
       if (currentDir === normalizedStop) {
         break;
       }
-      const parentDir = path19.dirname(currentDir);
+      const parentDir = path20.dirname(currentDir);
       if (parentDir === currentDir) {
         break;
       }
@@ -14174,7 +14328,7 @@ var PackmindIgnoreReader = class {
   async parseIgnoreFile(filePath) {
     let content;
     try {
-      content = await fs17.readFile(filePath, "utf-8");
+      content = await fs18.readFile(filePath, "utf-8");
     } catch (err) {
       if (err.code === "ENOENT") {
         return [];
@@ -14195,7 +14349,7 @@ function isNotLoggedInError(error) {
 }
 async function lintHandler(args2, deps) {
   const {
-    path: path36,
+    path: path37,
     draft,
     rule,
     language,
@@ -14217,11 +14371,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 fs18.stat(absolutePath);
+    stats = await fs19.stat(absolutePath);
   } catch (err) {
     const isNotFound = err.code === "ENOENT";
     const message = isNotFound ? `File or directory "${absolutePath}" does not exist` : `Cannot access "${absolutePath}": ${err.message}`;
@@ -14539,13 +14693,13 @@ 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 path23 = __toESM(require("path"));
-var fs22 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
 
 // apps/cli/src/infra/commands/installPackagesHandler.ts
 function formatOverviewRow(configPath, packages, pathColumnWidth) {
@@ -14628,28 +14782,23 @@ function pluralize(noun, count) {
 function nounFor(type, count) {
   return `${count} ${pluralize(type, count)}`;
 }
-function contentParts(result) {
+function changedParts(result) {
   const parts = [];
-  if (result.standardsCount > 0)
-    parts.push(nounFor("standard", result.standardsCount));
-  if (result.commandsCount > 0)
-    parts.push(nounFor("command", result.commandsCount));
-  if (result.skillsCount > 0) parts.push(nounFor("skill", result.skillsCount));
-  if (result.recipesCount > 0)
-    parts.push(nounFor("recipe", result.recipesCount));
+  if (result.standardsChanged > 0)
+    parts.push(nounFor("standard", result.standardsChanged));
+  if (result.commandsChanged > 0)
+    parts.push(nounFor("command", result.commandsChanged));
+  if (result.skillsChanged > 0)
+    parts.push(nounFor("skill", result.skillsChanged));
   return parts;
 }
 function buildInstallSummary(result) {
-  const contentChanged = result.contentFilesChanged > 0;
-  const parts = contentParts(result);
+  const contentChanged = result.skillsChanged > 0 || result.standardsChanged > 0 || result.commandsChanged > 0;
   const filesDeleted = result.filesDeleted > 0;
   const configCreated = result.configCreated;
   const packagesAdded = result.packagesAdded.length > 0;
   const nothingHappened = !configCreated && !packagesAdded && !contentChanged && !filesDeleted;
   if (nothingHappened) {
-    if (parts.length > 0) {
-      return `\u2705 Already up to date \u2014 ${parts.join(", ")}`;
-    }
     return "\u2705 Already up to date";
   }
   const lines = [];
@@ -14668,7 +14817,10 @@ function buildInstallSummary(result) {
     lines.push(...result.packagesAdded.map((s) => `   - ${s}`));
   }
   if (contentChanged) {
-    lines.push(`\u2705 Synced ${parts.join(", ")}`);
+    const changed = changedParts(result);
+    if (changed.length > 0) {
+      lines.push(`\u2705 Synced ${changed.join(", ")}`);
+    }
   }
   if (filesDeleted && !contentChanged) {
     lines.push(
@@ -14714,8 +14866,8 @@ function buildIncapableArtifactsWarning(result) {
 }
 
 // apps/cli/src/application/services/AgentArtifactDetectionService.ts
-var fs19 = __toESM(require("fs/promises"));
-var path20 = __toESM(require("path"));
+var fs20 = __toESM(require("fs/promises"));
+var path21 = __toESM(require("path"));
 var AGENT_ARTIFACT_CHECKS = [
   { agent: "claude", paths: [".claude"] },
   { agent: "cursor", paths: [".cursor"] },
@@ -14749,7 +14901,7 @@ var AgentArtifactDetectionService = class {
         }
       } else {
         for (const relativePath of check.paths) {
-          const fullPath = path20.join(baseDirectory, relativePath);
+          const fullPath = path21.join(baseDirectory, relativePath);
           const exists = await this.pathExists(fullPath);
           if (exists) {
             detected.push({
@@ -14765,7 +14917,7 @@ var AgentArtifactDetectionService = class {
   }
   async pathExists(filePath) {
     try {
-      await fs19.access(filePath);
+      await fs20.access(filePath);
       return true;
     } catch {
       return false;
@@ -14776,16 +14928,16 @@ var AgentArtifactDetectionService = class {
     while (queue.length > 0) {
       const currentDir = queue.shift();
       for (const targetPath of targetPaths) {
-        const fullPath = path20.join(currentDir, targetPath);
+        const fullPath = path21.join(currentDir, targetPath);
         if (await this.pathExists(fullPath)) {
           return fullPath;
         }
       }
       try {
-        const entries = await fs19.readdir(currentDir, { withFileTypes: true });
+        const entries = await fs20.readdir(currentDir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-            queue.push(path20.join(currentDir, entry.name));
+            queue.push(path21.join(currentDir, entry.name));
           }
         }
       } catch {
@@ -14804,18 +14956,18 @@ var readline2 = __toESM(require("readline"));
 var inquirer = __toESM(require("inquirer"));
 
 // apps/cli/src/infra/commands/config/agents/agentsHandlerUtils.ts
-var path21 = __toESM(require("path"));
-var fs20 = __toESM(require("fs/promises"));
+var path22 = __toESM(require("path"));
+var fs21 = __toESM(require("fs/promises"));
 function getRelativePath(dir, startDirectory) {
   if (dir === startDirectory) return "./packmind.json";
-  return "./" + path21.relative(startDirectory, dir) + "/packmind.json";
+  return "./" + path22.relative(startDirectory, dir) + "/packmind.json";
 }
 async function resolveStartDirectory(args2, getCwd, exit) {
   let startDirectory = getCwd();
   if (args2.path) {
-    const resolvedPath = path21.resolve(getCwd(), args2.path);
+    const resolvedPath = path22.resolve(getCwd(), args2.path);
     try {
-      const stat9 = await fs20.stat(resolvedPath);
+      const stat9 = await fs21.stat(resolvedPath);
       if (!stat9.isDirectory()) {
         logErrorConsole(`Path is not a directory: ${resolvedPath}`);
         exit(1);
@@ -14932,7 +15084,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((resolve15) => {
+  return new Promise((resolve16) => {
     rl.question(
       `Enter numbers separated by commas (default: ${defaultValue}): `,
       (answer) => {
@@ -14941,7 +15093,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);
-        resolve15(selectedAgents);
+        resolve16(selectedAgents);
       }
     );
   });
@@ -14988,8 +15140,8 @@ async function propagateAgentsToDescendants(configRepository, baseDirectory, sel
 }
 
 // apps/cli/src/infra/commands/skills/incompatibleSkillsHandler.ts
-var fs21 = __toESM(require("fs/promises"));
-var path22 = __toESM(require("path"));
+var fs22 = __toESM(require("fs/promises"));
+var path23 = __toESM(require("path"));
 var alwaysConfirm = () => Promise.resolve(true);
 async function handleIncompatibleInstalledSkillsSilently(skills, baseDirectory) {
   for (const skill of skills) {
@@ -15009,10 +15161,10 @@ async function handleIncompatibleInstalledSkills(skills, baseDirectory, confirm)
     return;
   }
   for (const skill of skills) {
-    const skillRootDirs = skill.filePaths.filter((p) => path22.basename(p) === "SKILL.md").map((p) => path22.dirname(p));
+    const skillRootDirs = skill.filePaths.filter((p) => path23.basename(p) === "SKILL.md").map((p) => path23.dirname(p));
     for (const dir of skillRootDirs) {
       try {
-        await fs21.rm(path22.join(baseDirectory, dir), {
+        await fs22.rm(path23.join(baseDirectory, dir), {
           recursive: true,
           force: true
         });
@@ -15025,7 +15177,7 @@ async function handleIncompatibleInstalledSkills(skills, baseDirectory, confirm)
     for (const relativePath of skill.filePaths) {
       if (!skillRootDirs.some((dir) => relativePath.startsWith(dir + "/"))) {
         try {
-          await fs21.unlink(path22.join(baseDirectory, relativePath));
+          await fs22.unlink(path23.join(baseDirectory, relativePath));
         } catch (error) {
           logErrorConsole(
             `Failed to delete "${relativePath}": ${error instanceof Error ? error.message : String(error)}`
@@ -15165,7 +15317,8 @@ async function bootstrapInstallContext(deps) {
     isTTY = false,
     installDefaultSkills,
     cliVersion,
-    runInit = initHandler
+    runInit = initHandler,
+    homeAgent
   } = deps;
   const hierarchicalResult = await configRepository.readHierarchicalConfig(
     baseDirectory,
@@ -15179,6 +15332,22 @@ async function bootstrapInstallContext(deps) {
       packagesAdded: []
     };
   }
+  if (homeAgent) {
+    const packagesMap = packages.length > 0 ? Object.fromEntries(packages.map((s) => [s, "*"])) : {};
+    await configRepository.writeConfig(baseDirectory, {
+      packages: packagesMap,
+      agents: [homeAgent]
+    });
+    logSuccessConsole(
+      `Created packmind.json at ${baseDirectory} for ${homeAgent} (home install).`
+    );
+    return {
+      configReady: true,
+      warned: false,
+      configCreated: true,
+      packagesAdded: [...packages]
+    };
+  }
   const detected = await agentDetectionService.detectAgentArtifacts(baseDirectory);
   if (detected.length > 0) {
     const agents = [...new Set(detected.map((d) => d.agent))];
@@ -15321,11 +15490,11 @@ async function confirmWithReadline(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     rl.question(question, (answer) => {
       rl.close();
       const trimmed = answer.trim().toLowerCase();
-      resolve15(trimmed === "" || trimmed === "y" || trimmed === "yes");
+      resolve16(trimmed === "" || trimmed === "y" || trimmed === "yes");
     });
   });
 }
@@ -15336,14 +15505,14 @@ function findSubDirectoriesWithPackmindJson(dirPath, recursive) {
   const result = [];
   let entries;
   try {
-    entries = fs22.readdirSync(dirPath, { withFileTypes: true });
+    entries = fs23.readdirSync(dirPath, { withFileTypes: true });
   } catch {
     return result;
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const subDir = path23.join(dirPath, entry.name);
-    if (fs22.existsSync(path23.join(subDir, "packmind.json"))) {
+    const subDir = path24.join(dirPath, entry.name);
+    if (fs23.existsSync(path24.join(subDir, "packmind.json"))) {
       result.push(subDir);
     }
     if (recursive) {
@@ -15363,6 +15532,9 @@ function mergeInstallResults(results) {
     standardsCount: 0,
     commandsCount: 0,
     skillsCount: 0,
+    skillsChanged: 0,
+    standardsChanged: 0,
+    commandsChanged: 0,
     recipesRemoved: 0,
     standardsRemoved: 0,
     commandsRemoved: 0,
@@ -15392,6 +15564,9 @@ function mergeInstallResults(results) {
     merged.standardsCount += r.standardsCount;
     merged.commandsCount += r.commandsCount;
     merged.skillsCount += r.skillsCount;
+    merged.skillsChanged += r.skillsChanged;
+    merged.standardsChanged += r.standardsChanged;
+    merged.commandsChanged += r.commandsChanged;
     merged.recipesRemoved += r.recipesRemoved;
     merged.standardsRemoved += r.standardsRemoved;
     merged.commandsRemoved += r.commandsRemoved;
@@ -15421,8 +15596,8 @@ async function notifyArtefactsDistributionIfInGitRepo(params) {
   try {
     const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(dir);
     if (!gitRoot) return;
-    const lockFilePath = path23.join(dir, "packmind-lock.json");
-    const content = fs22.readFileSync(lockFilePath, "utf-8");
+    const lockFilePath = path24.join(dir, "packmind-lock.json");
+    const content = fs23.readFileSync(lockFilePath, "utf-8");
     const packmindLockFile = JSON.parse(content);
     const gitRemoteUrl = packmindCliHexa.getGitRemoteUrlFromPath(gitRoot);
     const gitBranch = packmindCliHexa.getCurrentBranch(gitRoot);
@@ -15511,14 +15686,14 @@ async function installHandler({
     logConsole(`Use ${formatCommand(showCommand)} instead.`);
     process.exit(1);
   }
-  const cwd = installPath ? path23.resolve(process.cwd(), installPath) : process.cwd();
+  const cwd = installPath ? path24.resolve(process.cwd(), installPath) : process.cwd();
   if (installPath) {
-    if (!fs22.existsSync(cwd)) {
+    if (!fs23.existsSync(cwd)) {
       logErrorConsole(`Path does not exist: ${cwd}`);
       process.exit(1);
       return;
     }
-    if (!fs22.statSync(cwd).isDirectory()) {
+    if (!fs23.statSync(cwd).isDirectory()) {
       logErrorConsole(`Path is not a directory: ${cwd}`);
       process.exit(1);
       return;
@@ -15534,6 +15709,7 @@ async function installHandler({
   } catch {
   }
   const configRepository = new ConfigFileRepository();
+  const cwdHomeAgent = isAgentHomeDirectory(cwd) ?? void 0;
   const bootstrap = await bootstrapInstallContext({
     configRepository,
     agentDetectionService: new AgentArtifactDetectionService(),
@@ -15542,12 +15718,13 @@ async function installHandler({
     packages,
     isTTY: process.stdin.isTTY ?? false,
     installDefaultSkills: packmindCliHexa.installDefaultSkills.bind(packmindCliHexa),
-    cliVersion: CLI_VERSION
+    cliVersion: CLI_VERSION,
+    homeAgent: cwdHomeAgent
   });
   let targetDirs;
   if (installPath) {
     targetDirs = [];
-    if (fs22.existsSync(path23.join(cwd, "packmind.json")) || packages.length > 0) {
+    if (fs23.existsSync(path24.join(cwd, "packmind.json")) || packages.length > 0) {
       targetDirs.push(cwd);
     }
     targetDirs.push(...findSubDirectoriesWithPackmindJson(cwd, false));
@@ -15555,7 +15732,7 @@ async function installHandler({
     targetDirs = [cwd];
   } else {
     targetDirs = [];
-    if (fs22.existsSync(path23.join(cwd, "packmind.json"))) {
+    if (fs23.existsSync(path24.join(cwd, "packmind.json"))) {
       targetDirs.push(cwd);
     }
     targetDirs.push(...findSubDirectoriesWithPackmindJson(cwd, true));
@@ -15574,17 +15751,21 @@ async function installHandler({
   const multiDir = targetDirs.length > 1;
   for (const dir of targetDirs) {
     try {
+      const dirHomeAgent = isAgentHomeDirectory(dir) ?? void 0;
       const result = await packmindCliHexa.install({
         baseDirectory: dir,
         packages: packages.length > 0 ? packages : void 0,
         skipInstalledAt,
-        cliVersion: CLI_VERSION
+        cliVersion: CLI_VERSION,
+        homeAgent: dirHomeAgent
       });
       results.push(result);
-      await notifyArtefactsDistributionIfInGitRepo({
-        packmindCliHexa,
-        dir
-      });
+      if (!dirHomeAgent) {
+        await notifyArtefactsDistributionIfInGitRepo({
+          packmindCliHexa,
+          dir
+        });
+      }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       thrownErrors.push(
@@ -15617,11 +15798,13 @@ async function installHandler({
       logWarningConsole(capabilityWarning);
     }
     logConsole(buildInstallSummary(combined));
-    await installDefaultSkillsIfAtGitRoot({
-      packmindCliHexa,
-      cwd,
-      configRepository
-    });
+    if (!cwdHomeAgent) {
+      await installDefaultSkillsIfAtGitRoot({
+        packmindCliHexa,
+        cwd,
+        configRepository
+      });
+    }
   }
   const allErrors = [...combined.errors, ...thrownErrors];
   if (allErrors.length > 0) {
@@ -15704,6 +15887,15 @@ var uninstallCommand = (0, import_cmd_ts3.command)({
     }
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
+    try {
+      const ensureOutcome = await packmindCliHexa.ensureCliVersion({
+        baseDirectory: process.cwd(),
+        currentCliVersion: CLI_VERSION2,
+        includeBeta: false
+      });
+      reportEnsureCliVersionOutcome(ensureOutcome, CLI_VERSION2);
+    } catch {
+    }
     try {
       const result = await packmindCliHexa.uninstall({
         baseDirectory: process.cwd(),
@@ -16436,7 +16628,7 @@ var import_cmd_ts18 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/diffArtefactsHandler.ts
 var nodePath = __toESM(require("path"));
-var fs23 = __toESM(require("fs/promises"));
+var fs24 = __toESM(require("fs/promises"));
 
 // apps/cli/src/infra/utils/diffFormatter.ts
 var import_diff4 = require("diff");
@@ -16735,7 +16927,7 @@ async function diffArtefactsHandler(deps) {
   const searchPath = nodePath.resolve(cwd, deps.path ?? ".");
   if (deps.path !== void 0) {
     try {
-      await fs23.stat(searchPath);
+      await fs24.stat(searchPath);
     } catch {
       logErrorConsole(`Path does not exist: ${searchPath}`);
       exit(1);
@@ -16895,7 +17087,7 @@ var diffCommand = (0, import_cmd_ts18.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) {
@@ -16911,7 +17103,7 @@ var diffCommand = (0, import_cmd_ts18.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:");
@@ -16919,7 +17111,7 @@ var diffCommand = (0, import_cmd_ts18.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"
@@ -16928,7 +17120,7 @@ var diffCommand = (0, import_cmd_ts18.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)}`);
@@ -16938,7 +17130,7 @@ var diffCommand = (0, import_cmd_ts18.command)({
       getCwd: () => process.cwd(),
       log: console.log,
       includeSubmitted,
-      path: path36
+      path: path37
     });
   }
 });
@@ -17630,16 +17822,16 @@ var import_cmd_ts24 = __toESM(require_cjs());
 
 // apps/cli/src/infra/repositories/PlaybookLocalRepository.ts
 var crypto = __toESM(require("crypto"));
-var fs24 = __toESM(require("fs"));
-var os4 = __toESM(require("os"));
-var path24 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var os5 = __toESM(require("os"));
+var path25 = __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 = path24.join(
-      os4.homedir(),
+    this.storagePath = path25.join(
+      os5.homedir(),
       ".packmind",
       hash,
       "playbook.yaml"
@@ -17686,11 +17878,11 @@ var PlaybookLocalRepository = class {
     return normalized;
   }
   readYaml() {
-    if (!fs24.existsSync(this.storagePath)) {
+    if (!fs25.existsSync(this.storagePath)) {
       return { version: 1, changes: [] };
     }
     try {
-      const content = fs24.readFileSync(this.storagePath, "utf-8");
+      const content = fs25.readFileSync(this.storagePath, "utf-8");
       const parsed = yaml.parse(content);
       if (!parsed || !Array.isArray(parsed.changes)) {
         return { version: 1, changes: [] };
@@ -17704,20 +17896,20 @@ var PlaybookLocalRepository = class {
     }
   }
   writeYaml(data) {
-    const dir = path24.dirname(this.storagePath);
-    fs24.mkdirSync(dir, { recursive: true });
-    fs24.writeFileSync(this.storagePath, yaml.stringify(data), "utf-8");
+    const dir = path25.dirname(this.storagePath);
+    fs25.mkdirSync(dir, { recursive: true });
+    fs25.writeFileSync(this.storagePath, yaml.stringify(data), "utf-8");
   }
 };
 
 // apps/cli/src/infra/commands/playbook/addHandler.ts
-var fs25 = __toESM(require("fs"));
-var path28 = __toESM(require("path"));
+var fs26 = __toESM(require("fs"));
+var path29 = __toESM(require("path"));
 var yaml2 = __toESM(require("yaml"));
 var import_slug4 = __toESM(require("slug"));
 
 // apps/cli/src/application/utils/parseCommandFile.ts
-var path25 = __toESM(require("path"));
+var path26 = __toESM(require("path"));
 var FRONTMATTER_DELIMITER3 = "---";
 function parseCommandFile(content, filePath) {
   content = normalizeLineEndings(content);
@@ -17773,7 +17965,7 @@ function stripYamlQuotes2(value) {
   return value;
 }
 function extractFilenameSlug(filePath) {
-  let basename4 = path25.basename(filePath);
+  let basename4 = path26.basename(filePath);
   if (basename4.endsWith(".prompt.md")) {
     basename4 = basename4.slice(0, -".prompt.md".length);
   } else if (basename4.endsWith(".md")) {
@@ -18187,7 +18379,7 @@ function parseSkillDirectory(files) {
 }
 
 // apps/cli/src/application/utils/findNearestConfigDir.ts
-var path26 = __toESM(require("path"));
+var path27 = __toESM(require("path"));
 async function findNearestConfigDir(startDir, packmindCliHexa) {
   let current = startDir;
   while (true) {
@@ -18195,7 +18387,7 @@ async function findNearestConfigDir(startDir, packmindCliHexa) {
     if (exists) {
       return current;
     }
-    const parent = path26.dirname(current);
+    const parent = path27.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -18204,7 +18396,7 @@ async function findNearestConfigDir(startDir, packmindCliHexa) {
 }
 
 // apps/cli/src/application/utils/resolveDeployedContext.ts
-var path27 = __toESM(require("path"));
+var path28 = __toESM(require("path"));
 async function resolveDeployedContext(packmindCliHexa, targetDir) {
   try {
     const space = await packmindCliHexa.getDefaultSpace();
@@ -18216,7 +18408,7 @@ async function resolveDeployedContext(packmindCliHexa, targetDir) {
     }
     const gitRemoteUrl = packmindCliHexa.getGitRemoteUrlFromPath(gitRoot);
     const gitBranch = packmindCliHexa.getCurrentBranch(gitRoot);
-    const rel = path27.relative(gitRoot, targetDir);
+    const rel = path28.relative(gitRoot, targetDir);
     const relativePath = rel.startsWith("..") ? "/" : rel ? `/${rel}/` : "/";
     const deployedContent = await packmindCliHexa.getPackmindGateway().deployment.getDeployed({
       packagesSlugs: configPackages,
@@ -18266,34 +18458,51 @@ function lockFileToArtifactVersionEntries(lockFile) {
     spaceId: entry.spaceId
   }));
 }
-async function fetchDeployedFiles(gateway, lockFile) {
+async function fetchDeployedFiles(gateway, lockFile, options = {}) {
   try {
     const artifacts = lockFileToArtifactVersionEntries(lockFile);
     const response = await gateway.deployment.getContentByVersions({
       artifacts,
       agents: lockFile.agents
     });
-    return response.fileUpdates.createOrUpdate;
+    return remapDeployedFilesForHomeInstall(
+      response.fileUpdates.createOrUpdate,
+      options.projectDir
+    );
   } catch {
     return [];
   }
 }
+function remapDeployedFilesForHomeInstall(files, projectDir) {
+  if (!projectDir) return files;
+  const homeAgent = isAgentHomeDirectory(projectDir);
+  if (!homeAgent) return files;
+  const prefix = getAgentHomeDirPrefix(homeAgent);
+  if (!prefix) return files;
+  return files.filter((file) => !file.path.startsWith(".packmind/")).map((file) => {
+    const remapped = file.path.startsWith(prefix) ? { ...file, path: file.path.slice(prefix.length) } : { ...file };
+    if (remapped.content !== void 0) {
+      remapped.content = stripFullStandardLinkFooter(remapped.content);
+    }
+    return remapped;
+  });
+}
 
 // apps/cli/src/infra/commands/playbook/addHandler.ts
 async function tryStageRemovedFromLockFile(resolvedPath, deps) {
-  const fileDir = path28.dirname(resolvedPath);
+  const fileDir = path29.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(path28.relative(targetDir, resolvedPath));
+  const normalizedPath = normalizePath2(path29.relative(targetDir, resolvedPath));
   const lockEntry = findLockFileEntryForPath(
     normalizedPath,
     lockFile.artifacts
   );
   if (!lockEntry) return false;
   const gitRoot = await deps.packmindCliHexa.tryGetGitRepositoryRoot(targetDir);
-  const configDir = gitRoot ? normalizePath2(path28.relative(gitRoot, targetDir)) : "";
+  const configDir = gitRoot ? normalizePath2(path29.relative(gitRoot, targetDir)) : void 0;
   const deployedContext = await resolveDeployedContext(
     deps.packmindCliHexa,
     targetDir
@@ -18325,22 +18534,22 @@ async function tryStageRemovedFromLockFile(resolvedPath, deps) {
 }
 function resolveSkillDirectoryRoot(absolutePath) {
   if (absolutePath.endsWith("SKILL.md")) {
-    return path28.dirname(absolutePath);
+    return path29.dirname(absolutePath);
   }
   try {
-    if (fs25.statSync(absolutePath).isDirectory()) {
+    if (fs26.statSync(absolutePath).isDirectory()) {
       return absolutePath;
     }
   } catch {
     return absolutePath;
   }
-  let current = path28.dirname(absolutePath);
-  const root = path28.parse(current).root;
+  let current = path29.dirname(absolutePath);
+  const root = path29.parse(current).root;
   while (current !== root) {
-    if (fs25.existsSync(path28.join(current, "SKILL.md"))) {
+    if (fs26.existsSync(path29.join(current, "SKILL.md"))) {
       return current;
     }
-    current = path28.dirname(current);
+    current = path29.dirname(current);
   }
   return absolutePath;
 }
@@ -18363,17 +18572,17 @@ async function playbookAddHandler(deps) {
     exit(1);
     return;
   }
-  const absolutePath = path28.resolve(cwd, filePath);
+  const absolutePath = path29.resolve(cwd, filePath);
   let artifactType;
   let codingAgent;
   const earlyTargetDir = await findNearestConfigDir(
-    path28.dirname(absolutePath),
+    path29.dirname(absolutePath),
     packmindCliHexa
   );
   const earlyLockFile = earlyTargetDir ? await lockFileRepository.read(earlyTargetDir) : null;
   if (earlyLockFile && earlyTargetDir) {
     const normalizedForLookup = normalizePath2(
-      path28.relative(earlyTargetDir, absolutePath)
+      path29.relative(earlyTargetDir, absolutePath)
     );
     const lockResult = findLockFileEntryAndFileForPath(
       normalizedForLookup,
@@ -18507,7 +18716,7 @@ Content goes here...`
     return;
   }
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(targetDir);
-  const configDir = gitRoot ? normalizePath2(path28.relative(gitRoot, targetDir)) : "";
+  const configDir = gitRoot ? normalizePath2(path29.relative(gitRoot, targetDir)) : void 0;
   const deployedContext = await resolveDeployedContext(
     packmindCliHexa,
     targetDir
@@ -18515,7 +18724,7 @@ Content goes here...`
   const targetId = deployedContext?.targetId ?? earlyLockFile?.targetId;
   const normalizedFilePath = (() => {
     const refPath = artifactType === "skill" && skillDirPath ? skillDirPath : absolutePath;
-    return normalizePath2(path28.relative(targetDir, refPath));
+    return normalizePath2(path29.relative(targetDir, refPath));
   })();
   let spaceId;
   let spaceName;
@@ -18622,7 +18831,8 @@ Run ${formatLabel("packmind-cli install")} to update before making changes.`
   if (changeType === "updated" && earlyLockFile) {
     const deployedFiles = await fetchDeployedFiles(
       packmindCliHexa.getPackmindGateway(),
-      earlyLockFile
+      earlyLockFile,
+      { projectDir: targetDir }
     );
     if (artifactType === "skill") {
       const skillDeployedFiles = deployedFiles.filter(
@@ -18630,7 +18840,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(path28.join(normalizedFilePath, f.relativePath)) === normalizePath2(deployed.path)
+          (f) => normalizePath2(path29.join(normalizedFilePath, f.relativePath)) === normalizePath2(deployed.path)
         );
         return localFile && deployed.content?.trim() === localFile.content.trim() && (!deployed.skillFilePermissions || deployed.skillFilePermissions === localFile.permissions);
       });
@@ -18742,8 +18952,8 @@ var addPlaybookCommand = (0, import_cmd_ts24.command)({
 var import_cmd_ts25 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/rmHandler.ts
-var fs26 = __toESM(require("fs"));
-var path29 = __toESM(require("path"));
+var fs27 = __toESM(require("fs"));
+var path30 = __toESM(require("path"));
 function isSkillSupportFile(absolutePath) {
   const normalized = absolutePath.replace(/\\/g, "/");
   const skillDirMatch = normalized.match(/\/skills\/[^/]+\//);
@@ -18770,14 +18980,14 @@ async function playbookRmHandler(deps) {
     exit(1);
     return;
   }
-  const absolutePath = path29.resolve(getCwd(), filePath);
-  if (!fs26.existsSync(absolutePath)) {
+  const absolutePath = path30.resolve(getCwd(), filePath);
+  if (!fs27.existsSync(absolutePath)) {
     logErrorConsole(`File not found: "${filePath}"`);
     exit(1);
     return;
   }
   const targetDir = await findNearestConfigDir(
-    path29.dirname(absolutePath),
+    path30.dirname(absolutePath),
     packmindCliHexa
   );
   if (!targetDir) {
@@ -18794,7 +19004,7 @@ async function playbookRmHandler(deps) {
     return;
   }
   const normalizedForLookup = normalizePath2(
-    path29.relative(targetDir, absolutePath)
+    path30.relative(targetDir, absolutePath)
   );
   const lockResult = findLockFileEntryAndFileForPath(
     normalizedForLookup,
@@ -18816,7 +19026,7 @@ async function playbookRmHandler(deps) {
   }
   const resolvedAbsolutePath = artifactType === "skill" ? resolveSkillDirPath(absolutePath) : absolutePath;
   const normalizedFilePath = normalizePath2(
-    path29.relative(targetDir, resolvedAbsolutePath)
+    path30.relative(targetDir, resolvedAbsolutePath)
   );
   const lockEntry = findLockFileEntryAndFileForPath(normalizedFilePath, lockFile.artifacts)?.entry ?? lockResult.entry;
   if (!lockEntry) {
@@ -18844,7 +19054,7 @@ async function playbookRmHandler(deps) {
   }
   const spaceName = matchingSpace.name;
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(targetDir);
-  const configDir = gitRoot ? normalizePath2(path29.relative(gitRoot, targetDir)) : "";
+  const configDir = gitRoot ? normalizePath2(path30.relative(gitRoot, targetDir)) : "";
   const deployedContext = await resolveDeployedContext(
     packmindCliHexa,
     targetDir
@@ -18905,7 +19115,7 @@ var rmPlaybookCommand = (0, import_cmd_ts25.command)({
 var import_cmd_ts26 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/unstageHandler.ts
-var path30 = __toESM(require("path"));
+var path31 = __toESM(require("path"));
 async function playbookUnstageHandler(deps) {
   const {
     packmindCliHexa,
@@ -18923,10 +19133,10 @@ async function playbookUnstageHandler(deps) {
     return;
   }
   const cwd = getCwd();
-  const absolutePath = path30.resolve(cwd, filePath);
+  const absolutePath = path31.resolve(cwd, filePath);
   const resolvedPath = resolveSkillDirPath(absolutePath);
   const configDir = await findNearestConfigDir(
-    path30.dirname(resolvedPath),
+    path31.dirname(resolvedPath),
     packmindCliHexa
   );
   if (!configDir) {
@@ -18939,10 +19149,10 @@ async function playbookUnstageHandler(deps) {
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
   const baseDir = gitRoot ?? configDir;
   const normalizedFilePath = normalizePath2(
-    path30.relative(baseDir, resolvedPath)
+    path31.relative(baseDir, resolvedPath)
   );
   const matchingEntries = playbookLocalRepository.getChanges().filter((c) => {
-    const fullEntryPath = c.configDir ? normalizePath2(path30.join(c.configDir, c.filePath)) : c.filePath;
+    const fullEntryPath = c.configDir ? normalizePath2(path31.join(c.configDir, c.filePath)) : c.filePath;
     return fullEntryPath === normalizedFilePath;
   });
   if (matchingEntries.length === 0) {
@@ -19026,15 +19236,15 @@ var import_cmd_ts27 = __toESM(require_cjs());
 
 // apps/cli/src/infra/utils/listDirectoryFiles.ts
 var import_fs22 = require("fs");
-var path31 = __toESM(require("path"));
+var path32 = __toESM(require("path"));
 function listDirectoryFiles(dirPath) {
   const results = [];
   const entries = (0, import_fs22.readdirSync)(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path31.join(dirPath, entry.name);
+    const fullPath = path32.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       for (const nested of listDirectoryFiles(fullPath)) {
-        results.push(path31.join(entry.name, nested));
+        results.push(path32.join(entry.name, nested));
       }
     } else if (entry.isFile()) {
       results.push(entry.name);
@@ -19044,7 +19254,7 @@ function listDirectoryFiles(dirPath) {
 }
 
 // apps/cli/src/infra/commands/playbook/statusHandler.ts
-var path32 = __toESM(require("path"));
+var path33 = __toESM(require("path"));
 
 // apps/cli/src/infra/utils/stringUtils.ts
 function capitalize(s) {
@@ -19079,7 +19289,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(path32.relative(cwd, path32.join(gitRoot, rootRelativePath))) : rootRelativePath;
+    const displayPath = gitRoot ? normalizePath2(path33.relative(cwd, path33.join(gitRoot, rootRelativePath))) : rootRelativePath;
     const existing = groups.get(key);
     if (existing) {
       existing.filePaths.push(displayPath);
@@ -19137,12 +19347,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(path32.relative(gitRoot, fallbackConfigDir)) : "";
-    if (!configDirs.has(rel)) configDirs.add(rel);
+    const key = gitRoot ? normalizePath2(path33.relative(gitRoot, fallbackConfigDir)) : "__cwd__";
+    if (!configDirs.has(key)) configDirs.add(key);
   }
   const descendantDirs = await packmindCliHexa.findDescendantConfigs(cwd);
   for (const descendantDir of descendantDirs) {
-    const rel = gitRoot ? normalizePath2(path32.relative(gitRoot, descendantDir)) : normalizePath2(path32.relative(cwd, descendantDir));
+    const rel = gitRoot ? normalizePath2(path33.relative(gitRoot, descendantDir)) : normalizePath2(path33.relative(cwd, descendantDir));
     if (!configDirs.has(rel)) configDirs.add(rel);
   }
   for (const configDirKey of configDirs) {
@@ -19150,7 +19360,7 @@ async function playbookStatusHandler(deps) {
     if (configDirKey === "__cwd__") {
       projectDir = fallbackConfigDir;
     } else if (gitRoot) {
-      projectDir = path32.join(gitRoot, configDirKey);
+      projectDir = path33.join(gitRoot, configDirKey);
     } else {
       continue;
     }
@@ -19159,7 +19369,8 @@ async function playbookStatusHandler(deps) {
     if (!lockFile || Object.keys(lockFile.artifacts).length === 0) continue;
     const deployedFiles = await fetchDeployedFiles(
       packmindCliHexa.getPackmindGateway(),
-      lockFile
+      lockFile,
+      { projectDir }
     );
     const targetStagedPaths = new Set(
       (stagedByConfigDir.get(configDirKey) ?? []).map(
@@ -19175,11 +19386,11 @@ async function playbookStatusHandler(deps) {
         continue;
       }
       const displayPath = normalizePath2(
-        path32.relative(cwd, path32.join(projectDir, deployedFile.path))
+        path33.relative(cwd, path33.join(projectDir, deployedFile.path))
       );
       let localContent;
       try {
-        localContent = readFile11(path32.join(projectDir, deployedFile.path));
+        localContent = readFile11(path33.join(projectDir, deployedFile.path));
       } catch {
         const artifact = findArtifactForFile(
           deployedFile.path,
@@ -19208,7 +19419,7 @@ async function playbookStatusHandler(deps) {
           });
         }
       } else if (deployedFile.skillFilePermissions && getFileMode) {
-        const localMode = getFileMode(path32.join(projectDir, deployedFile.path));
+        const localMode = getFileMode(path33.join(projectDir, deployedFile.path));
         if (localMode !== null) {
           const localPermissions = modeToPermissionStringOrDefault(localMode);
           if (localPermissions !== deployedFile.skillFilePermissions) {
@@ -19237,13 +19448,13 @@ async function playbookStatusHandler(deps) {
         (f) => normalizePath2(f.path).endsWith("/SKILL.md")
       );
       if (!skillMdFile) continue;
-      const skillDir = normalizePath2(path32.dirname(skillMdFile.path));
+      const skillDir = normalizePath2(path33.dirname(skillMdFile.path));
       if (targetStagedPaths.has(skillDir) || targetSkillDirPaths.some(
         (staged) => skillDir === staged || skillDir.startsWith(staged + "/")
       )) {
         continue;
       }
-      const absoluteSkillDir = path32.join(projectDir, skillDir);
+      const absoluteSkillDir = path33.join(projectDir, skillDir);
       let localFiles;
       try {
         localFiles = listDirectoryFiles2(absoluteSkillDir);
@@ -19252,11 +19463,11 @@ async function playbookStatusHandler(deps) {
       }
       for (const localRelPath of localFiles) {
         const normalizedLocalPath = normalizePath2(
-          path32.join(skillDir, localRelPath)
+          path33.join(skillDir, localRelPath)
         );
         if (!deployedPathSet.has(normalizedLocalPath)) {
           const displayPath = normalizePath2(
-            path32.relative(cwd, path32.join(projectDir, normalizedLocalPath))
+            path33.relative(cwd, path33.join(projectDir, normalizedLocalPath))
           );
           untrackedChanges.push({
             artifactName: entry.name,
@@ -19341,7 +19552,7 @@ var import_fs25 = require("fs");
 var import_cmd_ts28 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/playbook/submitHandler.ts
-var path34 = __toESM(require("path"));
+var path35 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/playbook/submit/duplicateNameChecker.ts
 var import_slug5 = __toESM(require("slug"));
@@ -19403,7 +19614,7 @@ async function checkForDuplicateNames(createdEntries, packmindGateway) {
 }
 
 // apps/cli/src/infra/commands/playbook/submit/targetContextResolver.ts
-var path33 = __toESM(require("path"));
+var path34 = __toESM(require("path"));
 async function createTargetContextResolver(deps) {
   const { lockFileRepository, cwd, packmindCliHexa } = deps;
   const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
@@ -19414,14 +19625,15 @@ async function createTargetContextResolver(deps) {
       if (cache.has(key)) return cache.get(key);
       let projectDir;
       if (entry.configDir !== void 0 && gitRoot) {
-        projectDir = path33.join(gitRoot, entry.configDir);
+        projectDir = path34.join(gitRoot, entry.configDir);
       } else {
         projectDir = await findNearestConfigDir(cwd, packmindCliHexa);
       }
       const lockFile = projectDir ? await lockFileRepository.read(projectDir) : null;
       const deployedFiles = lockFile && Object.keys(lockFile.artifacts).length > 0 ? await fetchDeployedFiles(
         packmindCliHexa.getPackmindGateway(),
-        lockFile
+        lockFile,
+        { projectDir: projectDir ?? void 0 }
       ) : [];
       const ctx = { lockFile, deployedFiles, projectDir };
       cache.set(key, ctx);
@@ -20396,7 +20608,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 = path34.join(entryCtx.projectDir, entry.filePath);
+            const fullPath = path35.join(entryCtx.projectDir, entry.filePath);
             if (entry.artifactType === "skill") {
               deps.rmSync(fullPath, { recursive: true });
             } else {
@@ -20424,7 +20636,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 = path34.join(entryCtx.projectDir, entry.filePath);
+          const fullPath = path35.join(entryCtx.projectDir, entry.filePath);
           if (entry.artifactType === "skill") {
             deps.rmSync(fullPath, { recursive: true });
           } else {
@@ -20602,7 +20814,7 @@ var diffCommand2 = (0, import_cmd_ts29.command)({
       type: (0, import_cmd_ts29.optional)(import_cmd_ts29.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({
@@ -20611,7 +20823,7 @@ var diffCommand2 = (0, import_cmd_ts29.command)({
       getCwd: () => process.cwd(),
       log: console.log,
       includeSubmitted,
-      path: path36
+      path: path37
     });
   }
 });
@@ -20818,14 +21030,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((resolve15) => {
+  return (message) => new Promise((resolve16) => {
     const rl = readline4.createInterface({
       input: process.stdin,
       output: process.stdout
     });
     rl.question(`${message} (y/N) `, (answer) => {
       rl.close();
-      resolve15(answer.toLowerCase() === "y");
+      resolve16(answer.toLowerCase() === "y");
     });
   });
 }
@@ -21181,20 +21393,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;
 }