@3lineas/grooveskills 1.6.0 → 1.7.0

package/dist/{chunk-HUG3MG3P.js → chunk-E63GTCOE.js}

@@ -94,6 +94,13 @@ var SKILL_CATALOG = [
     dependencies: [],
     directoryName: "ux-writing"
   },
+  {
+    id: "docs-standards",
+    name: "Documentation & ADR Standards",
+    description: "English documentation standard, relative POSIX links, resilient Mermaid diagrams, ADR lifecycle, and intent-focused docstrings",
+    dependencies: [],
+    directoryName: "docs-standards"
+  },
   {
     id: "typescript-clean",
     name: "TypeScript Clean Code (TS 5.5+)",
@@ -243,6 +250,7 @@ function detectProjectContext(targetPath) {
     "odd-ai",
     "best-practices",
     "ux-writing",
+    "docs-standards",
     "error-handling-logging",
     "clean-architecture-ddd",
     "external-service-adapters",
@@ -382,7 +390,7 @@ function verifySkillExists(targetPath, skillDirectoryName, agents) {
 import { join as join11 } from "path";
 
 // src/domains/adapters/skill-reference-builder.ts
-import { existsSync as existsSync3, lstatSync as lstatSync2, mkdirSync, readFileSync as readFileSync3, rmSync, unlinkSync, writeFileSync } from "fs";
+import { existsSync as existsSync4, lstatSync as lstatSync2, mkdirSync, readFileSync as readFileSync3, rmSync, unlinkSync } from "fs";
 import { join as join5 } from "path";
 
 // src/domains/project-store/project-paths.ts
@@ -403,9 +411,46 @@ function getProjectConfigPath(targetPath) {
   return join4(getProjectStoreDir(targetPath), "config.json");
 }
 
+// src/domains/fs/safe-file-writer.ts
+import { chmodSync, existsSync as existsSync3, writeFileSync } from "fs";
+
+// src/errors/file-permission-error.ts
+var FilePermissionError = class extends Error {
+  code = "EACCES";
+  filePath;
+  suggestedFixCommand;
+  constructor(filePath) {
+    super(`No tienes permisos de escritura para modificar '${filePath}'.`);
+    this.name = "FilePermissionError";
+    this.filePath = filePath;
+    this.suggestedFixCommand = `chmod u+w "${filePath}"`;
+  }
+};
+
+// src/domains/fs/safe-file-writer.ts
+function safeWriteFileSync(filePath, content) {
+  try {
+    writeFileSync(filePath, content, "utf-8");
+  } catch (error) {
+    const err = error;
+    if (err.code === "EACCES" || err.code === "EPERM") {
+      if (existsSync3(filePath)) {
+        try {
+          chmodSync(filePath, 420);
+          writeFileSync(filePath, content, "utf-8");
+          return;
+        } catch {
+        }
+      }
+      throw new FilePermissionError(filePath);
+    }
+    throw error;
+  }
+}
+
 // src/domains/adapters/skill-reference-builder.ts
 function removeExistingPathSafely(path) {
-  const fileExists = existsSync3(path);
+  const fileExists = existsSync4(path);
   if (!fileExists) {
     try {
       const lstat = lstatSync2(path);
@@ -431,7 +476,7 @@ function removeExistingPathSafely(path) {
   }
 }
 function extractSkillDescription(canonicalSkillMdPath, fallback) {
-  if (!existsSync3(canonicalSkillMdPath)) {
+  if (!existsSync4(canonicalSkillMdPath)) {
     return fallback;
   }
   try {
@@ -445,8 +490,14 @@ function extractSkillDescription(canonicalSkillMdPath, fallback) {
   }
   return fallback;
 }
-function writeAgentSkillReference(targetPath, agentRelativeSkillsDir, skill) {
+function writeAgentSkillReference(targetPath, agentRelativeSkillsDir, skill, transaction) {
   const agentSkillFolder = join5(targetPath, agentRelativeSkillsDir, skill.directoryName);
+  const targetFile = join5(agentSkillFolder, "SKILL.md");
+  if (transaction) {
+    transaction.recordCreatedDir(join5(targetPath, agentRelativeSkillsDir));
+    transaction.recordCreatedDir(agentSkillFolder);
+    transaction.recordBeforeWrite(targetFile);
+  }
   removeExistingPathSafely(agentSkillFolder);
   mkdirSync(agentSkillFolder, { recursive: true });
   const canonicalSkillMd = join5(getProjectSkillsDir(targetPath), skill.directoryName, "SKILL.md");
@@ -465,16 +516,19 @@ Canonical skill specification stored in \`.grooveskills/\`.
 
 > **Instruction**: Read \`.grooveskills/skills/${skill.directoryName}/SKILL.md\` before executing tasks matching this skill.
 `;
-  const targetFile = join5(agentSkillFolder, "SKILL.md");
-  writeFileSync(targetFile, referenceContent, "utf-8");
+  safeWriteFileSync(targetFile, referenceContent);
   return targetFile;
 }
-function writeCursorRuleReference(targetPath, cursorRelativeRulesDir, skill) {
+function writeCursorRuleReference(targetPath, cursorRelativeRulesDir, skill, transaction) {
   const rulesDir = join5(targetPath, cursorRelativeRulesDir);
-  if (!existsSync3(rulesDir)) {
+  const targetFile = join5(rulesDir, `${skill.id}.mdc`);
+  if (transaction) {
+    transaction.recordCreatedDir(rulesDir);
+    transaction.recordBeforeWrite(targetFile);
+  }
+  if (!existsSync4(rulesDir)) {
     mkdirSync(rulesDir, { recursive: true });
   }
-  const targetFile = join5(rulesDir, `${skill.id}.mdc`);
   removeExistingPathSafely(targetFile);
   const canonicalSkillMd = join5(getProjectSkillsDir(targetPath), skill.directoryName, "SKILL.md");
   const description = extractSkillDescription(canonicalSkillMd, skill.description);
@@ -493,7 +547,7 @@ Canonical rule specification stored in \`.grooveskills/\`.
 
 > **Instruction**: Read \`.grooveskills/skills/${skill.directoryName}/SKILL.md\` before executing tasks matching this rule.
 `;
-  writeFileSync(targetFile, referenceContent, "utf-8");
+  safeWriteFileSync(targetFile, referenceContent);
   return targetFile;
 }
 
@@ -502,8 +556,8 @@ var AntigravityAdapter = class {
   id = "antigravity";
   name = "Antigravity";
   targetRelativeDir = ".agents/skills";
-  async installSkill(targetPath, skill, _skillSourceDir) {
-    const file = writeAgentSkillReference(targetPath, this.targetRelativeDir, skill);
+  async installSkill(targetPath, skill, _skillSourceDir, transaction) {
+    const file = writeAgentSkillReference(targetPath, this.targetRelativeDir, skill, transaction);
     return [file];
   }
 };
@@ -513,8 +567,8 @@ var ClaudeAdapter = class {
   id = "claude";
   name = "Claude Code";
   targetRelativeDir = ".claude/skills";
-  async installSkill(targetPath, skill, _skillSourceDir) {
-    const file = writeAgentSkillReference(targetPath, this.targetRelativeDir, skill);
+  async installSkill(targetPath, skill, _skillSourceDir, transaction) {
+    const file = writeAgentSkillReference(targetPath, this.targetRelativeDir, skill, transaction);
     return [file];
   }
 };
@@ -524,8 +578,8 @@ var CursorAdapter = class {
   id = "cursor";
   name = "Cursor";
   targetRelativeDir = ".cursor/rules";
-  async installSkill(targetPath, skill, _skillSourceDir) {
-    const file = writeCursorRuleReference(targetPath, this.targetRelativeDir, skill);
+  async installSkill(targetPath, skill, _skillSourceDir, transaction) {
+    const file = writeCursorRuleReference(targetPath, this.targetRelativeDir, skill, transaction);
     return [file];
   }
 };
@@ -535,35 +589,35 @@ var GeminiAdapter = class {
   id = "gemini";
   name = "Gemini Code Assist";
   targetRelativeDir = ".gemini/skills";
-  async installSkill(targetPath, skill, _skillSourceDir) {
-    const file = writeAgentSkillReference(targetPath, this.targetRelativeDir, skill);
+  async installSkill(targetPath, skill, _skillSourceDir, transaction) {
+    const file = writeAgentSkillReference(targetPath, this.targetRelativeDir, skill, transaction);
     return [file];
   }
 };
 
 // src/domains/project-store/sync-project-store.ts
-import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync2, rmSync as rmSync2 } from "fs";
+import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync2, rmSync as rmSync2 } from "fs";
 import { join as join7 } from "path";
 
 // src/domains/installer/resolve-skills-source.ts
 import { fileURLToPath } from "url";
 import { dirname, resolve, join as join6 } from "path";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 function resolveSkillsSourceRoot() {
   const currentFilePath = fileURLToPath(import.meta.url);
   const currentDir = dirname(currentFilePath);
   const candidateFromDist = resolve(currentDir, "../skills");
-  if (existsSync4(candidateFromDist)) {
+  if (existsSync5(candidateFromDist)) {
     return candidateFromDist;
   }
   const candidateFromSrc = resolve(currentDir, "../../../skills");
-  if (existsSync4(candidateFromSrc)) {
+  if (existsSync5(candidateFromSrc)) {
     return candidateFromSrc;
   }
   let searchDir = currentDir;
   for (let i = 0; i < 5; i++) {
     const candidate = join6(searchDir, "skills");
-    if (existsSync4(candidate)) {
+    if (existsSync5(candidate)) {
       return candidate;
     }
     const parent = dirname(searchDir);
@@ -578,14 +632,17 @@ function resolveSkillsSourceRoot() {
 }
 
 // src/domains/project-store/sync-project-store.ts
-function syncProjectStore(targetPath, selectedSkillIds, _selectedAgents) {
+function syncProjectStore(targetPath, selectedSkillIds, _selectedAgents, transaction) {
   const bundledSkillsDir = resolveSkillsSourceRoot();
   const projectSkillsDir = getProjectSkillsDir(targetPath);
-  if (!existsSync5(projectSkillsDir)) {
+  if (transaction) {
+    transaction.recordCreatedDir(projectSkillsDir);
+  }
+  if (!existsSync6(projectSkillsDir)) {
     mkdirSync2(projectSkillsDir, { recursive: true });
   }
   const legacyCursorRules = join7(targetPath, ".grooveskills", "cursor-rules");
-  if (existsSync5(legacyCursorRules)) {
+  if (existsSync6(legacyCursorRules)) {
     try {
       rmSync2(legacyCursorRules, { recursive: true, force: true });
     } catch {
@@ -598,14 +655,17 @@ function syncProjectStore(targetPath, selectedSkillIds, _selectedAgents) {
     }
     const sourceSkillDir = join7(bundledSkillsDir, skill.directoryName);
     const destSkillDir = join7(projectSkillsDir, skill.directoryName);
-    if (existsSync5(sourceSkillDir)) {
+    if (transaction) {
+      transaction.recordCreatedDir(destSkillDir);
+    }
+    if (existsSync6(sourceSkillDir)) {
       cpSync(sourceSkillDir, destSkillDir, { recursive: true });
     }
   }
 }
 
 // src/domains/harness/install-harness.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3 } from "fs";
 import { join as join10 } from "path";
 
 // src/domains/harness/harness-languages.ts
@@ -805,11 +865,11 @@ This project uses the **GrooveSkills Harness** located in \`.grooveskills/\`.
 }
 
 // src/domains/harness/scan-project-onboarding.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
 import { basename, join as join8 } from "path";
 function detectProjectName(targetPath) {
   const packageJsonPath = join8(targetPath, "package.json");
-  if (existsSync6(packageJsonPath)) {
+  if (existsSync7(packageJsonPath)) {
     try {
       const raw = readFileSync4(packageJsonPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -820,7 +880,7 @@ function detectProjectName(targetPath) {
     }
   }
   const cargoPath = join8(targetPath, "Cargo.toml");
-  if (existsSync6(cargoPath)) {
+  if (existsSync7(cargoPath)) {
     try {
       const cargoRaw = readFileSync4(cargoPath, "utf-8");
       const nameMatch = cargoRaw.match(/name\s*=\s*"([^"]+)"/);
@@ -831,7 +891,7 @@ function detectProjectName(targetPath) {
     }
   }
   const pyprojectPath = join8(targetPath, "pyproject.toml");
-  if (existsSync6(pyprojectPath)) {
+  if (existsSync7(pyprojectPath)) {
     try {
       const pyRaw = readFileSync4(pyprojectPath, "utf-8");
       const pyMatch = pyRaw.match(/name\s*=\s*"([^"]+)"/);
@@ -844,32 +904,32 @@ function detectProjectName(targetPath) {
   return basename(targetPath) || "project";
 }
 function detectPackageManager(targetPath) {
-  if (existsSync6(join8(targetPath, "pnpm-lock.yaml"))) {
+  if (existsSync7(join8(targetPath, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync6(join8(targetPath, "bun.lockb")) || existsSync6(join8(targetPath, "bun.lock"))) {
+  if (existsSync7(join8(targetPath, "bun.lockb")) || existsSync7(join8(targetPath, "bun.lock"))) {
     return "bun";
   }
-  if (existsSync6(join8(targetPath, "yarn.lock"))) {
+  if (existsSync7(join8(targetPath, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync6(join8(targetPath, "package-lock.json"))) {
+  if (existsSync7(join8(targetPath, "package-lock.json"))) {
     return "npm";
   }
-  if (existsSync6(join8(targetPath, "Cargo.lock")) || existsSync6(join8(targetPath, "Cargo.toml"))) {
+  if (existsSync7(join8(targetPath, "Cargo.lock")) || existsSync7(join8(targetPath, "Cargo.toml"))) {
     return "cargo";
   }
-  if (existsSync6(join8(targetPath, "uv.lock"))) {
+  if (existsSync7(join8(targetPath, "uv.lock"))) {
     return "uv";
   }
-  if (existsSync6(join8(targetPath, "poetry.lock"))) {
+  if (existsSync7(join8(targetPath, "poetry.lock"))) {
     return "poetry";
   }
   return "npm";
 }
 function detectCommands(targetPath, pkgManager) {
   const packageJsonPath = join8(targetPath, "package.json");
-  if (!existsSync6(packageJsonPath)) {
+  if (!existsSync7(packageJsonPath)) {
     return {};
   }
   try {
@@ -904,7 +964,7 @@ function detectCommands(targetPath, pkgManager) {
 }
 function detectPathAliases(targetPath) {
   const tsconfigPath = join8(targetPath, "tsconfig.json");
-  if (!existsSync6(tsconfigPath)) {
+  if (!existsSync7(tsconfigPath)) {
     return {};
   }
   try {
@@ -924,7 +984,7 @@ function detectPathAliases(targetPath) {
 }
 function detectSourceDirectories(targetPath) {
   const srcPath = join8(targetPath, "src");
-  const scanTarget = existsSync6(srcPath) ? srcPath : targetPath;
+  const scanTarget = existsSync7(srcPath) ? srcPath : targetPath;
   try {
     const entries = readdirSync2(scanTarget, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".") && name !== "node_modules" && name !== "dist");
@@ -948,36 +1008,39 @@ function scanProjectOnboarding(targetPath) {
 }
 
 // src/domains/harness/upsert-agent-instructions.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
 import { join as join9 } from "path";
 var START_MARKER = "<!-- grooveskills:harness:start -->";
 var END_MARKER = "<!-- grooveskills:harness:end -->";
-function applyHarnessBlock(filePath, language = "es") {
+function applyHarnessBlock(filePath, language = "es", transaction) {
+  if (transaction) {
+    transaction.recordBeforeWrite(filePath);
+  }
   const block = buildAgentHarnessBlock(language);
-  if (!existsSync7(filePath)) {
-    writeFileSync2(filePath, `${block}
-`, "utf-8");
+  if (!existsSync8(filePath)) {
+    safeWriteFileSync(filePath, `${block}
+`);
     return;
   }
   const existingContent = readFileSync5(filePath, "utf-8");
   if (existingContent.includes(START_MARKER) && existingContent.includes(END_MARKER)) {
     const regex = new RegExp(`${START_MARKER}[\\s\\S]*?${END_MARKER}`, "g");
     const updated = existingContent.replace(regex, block);
-    writeFileSync2(filePath, updated, "utf-8");
+    safeWriteFileSync(filePath, updated);
     return;
   }
   const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
-  writeFileSync2(filePath, `${existingContent}${separator}${block}
-`, "utf-8");
+  safeWriteFileSync(filePath, `${existingContent}${separator}${block}
+`);
 }
-function upsertAgentInstructions(targetPath, selectedAgents, language = "es") {
+function upsertAgentInstructions(targetPath, selectedAgents, language = "es", transaction) {
   const updatedFiles = [];
   const agentsMdPath = join9(targetPath, "AGENTS.md");
-  applyHarnessBlock(agentsMdPath, language);
+  applyHarnessBlock(agentsMdPath, language, transaction);
   updatedFiles.push(agentsMdPath);
   if (selectedAgents.includes("claude")) {
     const claudeMdPath = join9(targetPath, "CLAUDE.md");
-    applyHarnessBlock(claudeMdPath, language);
+    applyHarnessBlock(claudeMdPath, language, transaction);
     updatedFiles.push(claudeMdPath);
   }
   return updatedFiles;
@@ -989,43 +1052,60 @@ function installHarness(options) {
   const tasksDir = getProjectTasksDir(options.targetPath);
   const language = options.language ?? "es";
   const forceOnboarding = Boolean(options.forceOnboarding);
-  if (!existsSync8(tasksDir)) {
+  const tx = options.transaction;
+  if (tx) {
+    tx.recordCreatedDir(memoryDir);
+    tx.recordCreatedDir(tasksDir);
+  }
+  if (!existsSync9(tasksDir)) {
     mkdirSync3(tasksDir, { recursive: true });
   }
   const createdFiles = [];
   const contextPath = join10(memoryDir, "context.md");
-  const shouldWriteContext = !existsSync8(contextPath) || forceOnboarding;
+  const shouldWriteContext = !existsSync9(contextPath) || forceOnboarding;
   if (shouldWriteContext) {
+    if (tx) {
+      tx.recordBeforeWrite(contextPath);
+    }
     const profile = scanProjectOnboarding(options.targetPath);
     const contextContent = buildContextTemplate(
       options.detectedDependencies,
       language,
       profile
     );
-    writeFileSync3(contextPath, contextContent, "utf-8");
+    safeWriteFileSync(contextPath, contextContent);
     createdFiles.push(contextPath);
     const onboardingTaskPath = join10(tasksDir, "00-onboarding.md");
-    writeFileSync3(
+    if (tx) {
+      tx.recordBeforeWrite(onboardingTaskPath);
+    }
+    safeWriteFileSync(
       onboardingTaskPath,
-      buildOnboardingTaskTemplate(profile.projectName),
-      "utf-8"
+      buildOnboardingTaskTemplate(profile.projectName)
     );
     createdFiles.push(onboardingTaskPath);
   }
   const decisionsPath = join10(memoryDir, "decisions.md");
-  if (!existsSync8(decisionsPath)) {
-    writeFileSync3(decisionsPath, buildDecisionsTemplate(language), "utf-8");
+  if (!existsSync9(decisionsPath)) {
+    if (tx) {
+      tx.recordBeforeWrite(decisionsPath);
+    }
+    safeWriteFileSync(decisionsPath, buildDecisionsTemplate(language));
     createdFiles.push(decisionsPath);
   }
   const templateTaskPath = join10(tasksDir, "_template.md");
-  if (!existsSync8(templateTaskPath)) {
-    writeFileSync3(templateTaskPath, buildTaskTemplate(), "utf-8");
+  if (!existsSync9(templateTaskPath)) {
+    if (tx) {
+      tx.recordBeforeWrite(templateTaskPath);
+    }
+    safeWriteFileSync(templateTaskPath, buildTaskTemplate());
     createdFiles.push(templateTaskPath);
   }
   const instructions = upsertAgentInstructions(
     options.targetPath,
     options.selectedAgents,
-    language
+    language,
+    tx
   );
   createdFiles.push(...instructions);
   return {
@@ -1035,14 +1115,14 @@ function installHarness(options) {
 }
 
 // src/domains/harness/write-project-config.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
 function readExistingConfig(configPath) {
   const fallback = {
     skills: [],
     agents: [],
     harness: false
   };
-  if (!existsSync9(configPath)) {
+  if (!existsSync10(configPath)) {
     return fallback;
   }
   try {
@@ -1058,8 +1138,11 @@ function readExistingConfig(configPath) {
     return fallback;
   }
 }
-function writeProjectConfig(targetPath, newSkills, newAgents, harnessEnabled, language) {
+function writeProjectConfig(targetPath, newSkills, newAgents, harnessEnabled, language, transaction) {
   const configPath = getProjectConfigPath(targetPath);
+  if (transaction) {
+    transaction.recordBeforeWrite(configPath);
+  }
   const existing = readExistingConfig(configPath);
   const mergedSkills = Array.from(/* @__PURE__ */ new Set([...existing.skills, ...newSkills]));
   const mergedAgents = Array.from(/* @__PURE__ */ new Set([...existing.agents, ...newAgents]));
@@ -1073,11 +1156,84 @@ function writeProjectConfig(targetPath, newSkills, newAgents, harnessEnabled, la
     skills: mergedSkills,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync4(configPath, `${JSON.stringify(config, null, 2)}
-`, "utf-8");
+  safeWriteFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`);
   return configPath;
 }
 
+// src/domains/fs/install-transaction.ts
+import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync7, rmSync as rmSync3 } from "fs";
+var InstallTransaction = class {
+  originalFiles = /* @__PURE__ */ new Map();
+  createdDirs = [];
+  recordBeforeWrite(filePath) {
+    if (this.originalFiles.has(filePath)) {
+      return;
+    }
+    if (existsSync11(filePath)) {
+      try {
+        this.originalFiles.set(filePath, readFileSync7(filePath, "utf-8"));
+      } catch {
+        this.originalFiles.set(filePath, null);
+      }
+    } else {
+      this.originalFiles.set(filePath, null);
+    }
+  }
+  recordCreatedDir(dirPath) {
+    if (!existsSync11(dirPath) && !this.createdDirs.includes(dirPath)) {
+      this.createdDirs.push(dirPath);
+    }
+  }
+  rollback() {
+    const restoredFiles = [];
+    const removedFiles = [];
+    const removedDirs = [];
+    for (const [filePath, content] of this.originalFiles.entries()) {
+      try {
+        if (content === null) {
+          if (existsSync11(filePath)) {
+            rmSync3(filePath, { force: true });
+            removedFiles.push(filePath);
+          }
+        } else {
+          safeWriteFileSync(filePath, content);
+          restoredFiles.push(filePath);
+        }
+      } catch {
+      }
+    }
+    const sortedDirs = [...this.createdDirs].sort((a, b) => b.length - a.length);
+    for (const dir of sortedDirs) {
+      try {
+        if (existsSync11(dir) && readdirSync3(dir).length === 0) {
+          rmSync3(dir, { recursive: true, force: true });
+          removedDirs.push(dir);
+        }
+      } catch {
+      }
+    }
+    return { restoredFiles, removedFiles, removedDirs };
+  }
+};
+
+// src/errors/install-transaction-error.ts
+var InstallTransactionError = class extends Error {
+  stage;
+  causeError;
+  rollbackReport;
+  suggestedFix;
+  constructor(options) {
+    const rawMessage = options.cause instanceof Error ? options.cause.message : String(options.cause);
+    super(`Error durante la etapa '${options.stage}': ${rawMessage}`);
+    this.name = "InstallTransactionError";
+    this.stage = options.stage;
+    this.causeError = options.cause;
+    this.rollbackReport = options.rollbackReport;
+    this.suggestedFix = options.suggestedFix;
+  }
+};
+
 // src/domains/installer/install-orchestrator.ts
 var ADAPTER_REGISTRY = {
   antigravity: new AntigravityAdapter(),
@@ -1085,7 +1241,20 @@ var ADAPTER_REGISTRY = {
   cursor: new CursorAdapter(),
   gemini: new GeminiAdapter()
 };
+function formatSuggestedFix(cause) {
+  if (cause instanceof FilePermissionError) {
+    return cause.suggestedFixCommand;
+  }
+  const err = cause;
+  if (err?.code === "EACCES" || err?.code === "EPERM") {
+    if (err.path) {
+      return `chmod u+w "${err.path}"`;
+    }
+  }
+  return void 0;
+}
 async function installSkills(options) {
+  const transaction = new InstallTransaction();
   const skillsToInstall = [...options.selectedSkillIds];
   if (!skillsToInstall.includes("groove-harness")) {
     skillsToInstall.push("groove-harness");
@@ -1093,48 +1262,70 @@ async function installSkills(options) {
   if (!skillsToInstall.includes("odd-ai")) {
     skillsToInstall.push("odd-ai");
   }
-  syncProjectStore(options.targetPath, skillsToInstall, options.selectedAgents);
-  const projectSkillsDir = getProjectSkillsDir(options.targetPath);
-  const createdFiles = [];
-  for (const skillId of skillsToInstall) {
-    const skill = SKILL_CATALOG.find((item) => item.id === skillId);
-    if (!skill) {
-      continue;
-    }
-    const skillSourceDir = join11(projectSkillsDir, skill.directoryName);
-    for (const agentId of options.selectedAgents) {
-      const adapter = ADAPTER_REGISTRY[agentId];
-      if (!adapter) {
+  let currentStage = "Sincronizaci\xF3n del almac\xE9n de skills (.grooveskills/skills)";
+  try {
+    syncProjectStore(options.targetPath, skillsToInstall, options.selectedAgents, transaction);
+    const projectSkillsDir = getProjectSkillsDir(options.targetPath);
+    const createdFiles = [];
+    currentStage = "Configuraci\xF3n de referencias de agentes (.agents, .claude, etc.)";
+    for (const skillId of skillsToInstall) {
+      const skill = SKILL_CATALOG.find((item) => item.id === skillId);
+      if (!skill) {
         continue;
       }
-      const files = await adapter.installSkill(options.targetPath, skill, skillSourceDir);
-      createdFiles.push(...files);
+      const skillSourceDir = join11(projectSkillsDir, skill.directoryName);
+      for (const agentId of options.selectedAgents) {
+        const adapter = ADAPTER_REGISTRY[agentId];
+        if (!adapter) {
+          continue;
+        }
+        const files = await adapter.installSkill(
+          options.targetPath,
+          skill,
+          skillSourceDir,
+          transaction
+        );
+        createdFiles.push(...files);
+      }
     }
+    currentStage = "Instalaci\xF3n del Groove Harness (contexto, decisiones, tareas e instrucciones)";
+    const harnessResult = installHarness({
+      targetPath: options.targetPath,
+      selectedAgents: options.selectedAgents,
+      selectedSkillIds: skillsToInstall,
+      detectedDependencies: options.detectedDependencies || [],
+      language: options.language,
+      forceOnboarding: options.forceOnboarding,
+      transaction
+    });
+    createdFiles.push(...harnessResult.createdFiles);
+    currentStage = "Persistencia de la configuraci\xF3n del proyecto (.grooveskills/config.json)";
+    const configPath = writeProjectConfig(
+      options.targetPath,
+      skillsToInstall,
+      options.selectedAgents,
+      true,
+      options.language,
+      transaction
+    );
+    createdFiles.push(configPath);
+    return {
+      installedSkills: skillsToInstall,
+      configuredAgents: options.selectedAgents,
+      createdFiles,
+      harnessInitialized: harnessResult.onboardingInitialized,
+      language: options.language
+    };
+  } catch (cause) {
+    const rollbackReport = transaction.rollback();
+    const suggestedFix = formatSuggestedFix(cause);
+    throw new InstallTransactionError({
+      stage: currentStage,
+      cause,
+      rollbackReport,
+      suggestedFix
+    });
   }
-  const harnessResult = installHarness({
-    targetPath: options.targetPath,
-    selectedAgents: options.selectedAgents,
-    selectedSkillIds: skillsToInstall,
-    detectedDependencies: options.detectedDependencies || [],
-    language: options.language,
-    forceOnboarding: options.forceOnboarding
-  });
-  createdFiles.push(...harnessResult.createdFiles);
-  const configPath = writeProjectConfig(
-    options.targetPath,
-    skillsToInstall,
-    options.selectedAgents,
-    true,
-    options.language
-  );
-  createdFiles.push(configPath);
-  return {
-    installedSkills: skillsToInstall,
-    configuredAgents: options.selectedAgents,
-    createdFiles,
-    harnessInitialized: harnessResult.onboardingInitialized,
-    language: options.language
-  };
 }
 
 // src/domains/ui/render-onboarding-prompt.ts
@@ -1165,7 +1356,7 @@ async function resolveLanguageSelection(harnessExists, configuredLanguage, force
   }
   const langChoice = await promptLanguage(configuredLanguage ?? "es");
   if (p5.isCancel(langChoice)) {
-    p5.cancel("Installation cancelled. Have a wonderful day!");
+    p5.cancel("Instalaci\xF3n cancelada. \xA1Que tengas un excelente d\xEDa!");
     process.exit(0);
   }
   return langChoice;
@@ -1180,31 +1371,53 @@ async function resolveOverwriteConfirmation(targetPath, selectedSkills, selected
   }
   const confirm2 = await promptConfirmOverwrite();
   if (p5.isCancel(confirm2) || !confirm2) {
-    p5.cancel("Installation stopped to protect existing skills.");
+    p5.cancel("Instalaci\xF3n detenida para proteger las skills existentes.");
     process.exit(0);
   }
   return Boolean(confirm2);
 }
+function renderInstallFailure(error) {
+  const { stage, causeError, rollbackReport, suggestedFix } = error;
+  const rawMsg = causeError instanceof Error ? causeError.message : String(causeError);
+  const lines = [
+    `${pc3.bold("Fase afectada:")} ${pc3.yellow(stage)}`,
+    `${pc3.bold("Causa:")} ${pc3.red(rawMsg)}`,
+    "",
+    pc3.bold("Reporte de Rollback autom\xE1tico:"),
+    ` \u2022 Archivos restaurados a su estado previo: ${pc3.cyan(String(rollbackReport.restoredFiles.length))}`,
+    ` \u2022 Archivos temporales eliminados: ${pc3.cyan(String(rollbackReport.removedFiles.length))}`,
+    ` \u2022 Directorios vac\xEDos eliminados: ${pc3.cyan(String(rollbackReport.removedDirs.length))}`
+  ];
+  if (suggestedFix) {
+    lines.push(
+      "",
+      pc3.bold("Soluci\xF3n recomendada:"),
+      ` Ejecuta en tu terminal: ${pc3.green(suggestedFix)}`
+    );
+  }
+  p5.note(lines.join("\n"), "Detalles de la interrupci\xF3n y reversi\xF3n");
+  p5.outro(pc3.yellow("Tu proyecto no sufri\xF3 alteraciones y se preserv\xF3 intacto. Corrige la causa y vuelve a intentarlo cuando gustes."));
+}
 async function runInteractiveUi(context, forceOnboarding = false) {
   console.log(renderBanner());
-  p5.intro(pc3.magenta("Welcome to GrooveSkills! Let's tailor your AI agents with clean architectural standards."));
+  p5.intro(pc3.magenta("\xA1Bienvenido a GrooveSkills! Configuremos tus agentes de IA con est\xE1ndares limpios de arquitectura."));
   if (context.detectedDependencies.length > 0) {
-    const harnessInfo = context.harnessExists && !forceOnboarding ? pc3.green(`Active (.grooveskills/memory, lang: ${context.configuredLanguage ?? "es"})`) : pc3.cyan("Will be initialized");
+    const harnessInfo = context.harnessExists && !forceOnboarding ? pc3.green(`Activo (.grooveskills/memory, idioma: ${context.configuredLanguage ?? "es"})`) : pc3.cyan("Ser\xE1 inicializado");
     p5.note(
-      `Detected dependencies: ${context.detectedDependencies.map((d) => pc3.bold(d)).join(", ")}
-Active AI folders: ${context.detectedAgents.map((a) => pc3.green(a)).join(", ") || "None (will be created)"}
+      `Dependencias detectadas: ${context.detectedDependencies.map((d) => pc3.bold(d)).join(", ")}
+Carpetas de IA activas: ${context.detectedAgents.map((a) => pc3.green(a)).join(", ") || "Ninguna (se crear\xE1n)"}
 GrooveSkills Harness: ${harnessInfo}`,
-      "Project Environment"
+      "Entorno del Proyecto"
     );
   }
   const selectedSkills = await promptSkills(context.suggestedSkillIds);
   if (p5.isCancel(selectedSkills)) {
-    p5.cancel("Installation cancelled. Have a wonderful day!");
+    p5.cancel("Instalaci\xF3n cancelada. \xA1Que tengas un excelente d\xEDa!");
     process.exit(0);
   }
   const selectedAgents = await promptAgents(context.detectedAgents);
   if (p5.isCancel(selectedAgents)) {
-    p5.cancel("Installation cancelled. Have a wonderful day!");
+    p5.cancel("Instalaci\xF3n cancelada. \xA1Que tengas un excelente d\xEDa!");
     process.exit(0);
   }
   const selectedLanguage = await resolveLanguageSelection(
@@ -1218,33 +1431,42 @@ GrooveSkills Harness: ${harnessInfo}`,
     selectedAgents
   );
   const s = p5.spinner();
-  s.start("Installing and adapting skills across your configured AI agents...");
-  const result = await installSkills({
-    targetPath: context.targetPath,
-    selectedSkillIds: selectedSkills,
-    selectedAgents,
-    forceOverwrite,
-    enableHarness: true,
-    detectedDependencies: context.detectedDependencies,
-    language: selectedLanguage,
-    forceOnboarding
-  });
-  s.stop(pc3.green("All skills and harness have been successfully configured!"));
-  const harnessStatus = result.harnessInitialized ? pc3.green(`Initialized in .grooveskills/ (Language: ${selectedLanguage})`) : pc3.cyan(`Preserved in .grooveskills/ (Language: ${selectedLanguage})`);
-  p5.note(
-    `Configured skills: ${result.installedSkills.map((s2) => pc3.bold(s2)).join(", ")}
-Target agents: ${result.configuredAgents.map((a) => pc3.cyan(a)).join(", ")}
-GrooveSkills Harness: ${harnessStatus}`,
-    "Installation Summary"
-  );
-  if (result.harnessInitialized) {
-    const promptRender = formatOnboardingPrompt(selectedLanguage);
+  s.start("Instalando y adaptando skills para tus agentes de IA configurados...");
+  try {
+    const result = await installSkills({
+      targetPath: context.targetPath,
+      selectedSkillIds: selectedSkills,
+      selectedAgents,
+      forceOverwrite,
+      enableHarness: true,
+      detectedDependencies: context.detectedDependencies,
+      language: selectedLanguage,
+      forceOnboarding
+    });
+    s.stop(pc3.green("\xA1Todas las skills y el harness fueron configurados exitosamente!"));
+    const harnessStatus = result.harnessInitialized ? pc3.green(`Inicializado en .grooveskills/ (Idioma: ${selectedLanguage})`) : pc3.cyan(`Preservado en .grooveskills/ (Idioma: ${selectedLanguage})`);
     p5.note(
-      pc3.green(promptRender.prompt),
-      promptRender.title
+      `Skills configuradas: ${result.installedSkills.map((sk) => pc3.bold(sk)).join(", ")}
+Agentes objetivo: ${result.configuredAgents.map((a) => pc3.cyan(a)).join(", ")}
+GrooveSkills Harness: ${harnessStatus}`,
+      "Resumen de Instalaci\xF3n"
     );
+    if (result.harnessInitialized) {
+      const promptRender = formatOnboardingPrompt(selectedLanguage);
+      p5.note(
+        pc3.green(promptRender.prompt),
+        promptRender.title
+      );
+    }
+    p5.outro(pc3.green("\xA1Tus agentes de IA ahora est\xE1n potenciados con los h\xE1bitos arquitect\xF3nicos de tu equipo! \u{1F680}"));
+  } catch (error) {
+    s.stop(pc3.yellow("La instalaci\xF3n no pudo completarse."));
+    if (error instanceof InstallTransactionError) {
+      renderInstallFailure(error);
+      return;
+    }
+    throw error;
   }
-  p5.outro(pc3.green("Your AI programming pair is now empowered with your team's architectural habits! \u{1F680}"));
 }
 
 // src/main.ts
@@ -1279,6 +1501,7 @@ ${promptRender.formattedOutput}
 }
 
 export {
+  InstallTransactionError,
   runGrooveSkills
 };
-//# sourceMappingURL=chunk-HUG3MG3P.js.map
+//# sourceMappingURL=chunk-E63GTCOE.js.map