@3lineas/grooveskills 1.1.0 → 1.3.1

package/dist/{chunk-5Q6O3BRA.js → chunk-M7ZPBGQE.js}

@@ -29,20 +29,38 @@ function detectAgents(targetPath) {
 import { readFileSync, existsSync } from "fs";
 import { join } from "path";
 function detectDependencies(targetPath) {
+  const detected = /* @__PURE__ */ new Set();
+  let hasManifest = false;
   const packageJsonPath = join(targetPath, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    return { dependencies: [], exists: false };
+  if (existsSync(packageJsonPath)) {
+    hasManifest = true;
+    try {
+      const raw = readFileSync(packageJsonPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      for (const dep of Object.keys(parsed.dependencies ?? {})) {
+        detected.add(dep);
+      }
+      for (const dep of Object.keys(parsed.devDependencies ?? {})) {
+        detected.add(dep);
+      }
+    } catch {
+    }
   }
-  try {
-    const raw = readFileSync(packageJsonPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    const direct = Object.keys(parsed.dependencies ?? {});
-    const dev = Object.keys(parsed.devDependencies ?? {});
-    const all = Array.from(/* @__PURE__ */ new Set([...direct, ...dev]));
-    return { dependencies: all, exists: true };
-  } catch {
-    return { dependencies: [], exists: true };
+  const cargoPath = join(targetPath, "Cargo.toml");
+  if (existsSync(cargoPath)) {
+    hasManifest = true;
+    detected.add("rust");
+  }
+  const pyprojectPath = join(targetPath, "pyproject.toml");
+  const requirementsPath = join(targetPath, "requirements.txt");
+  if (existsSync(pyprojectPath) || existsSync(requirementsPath)) {
+    hasManifest = true;
+    detected.add("python");
   }
+  return {
+    dependencies: Array.from(detected),
+    exists: hasManifest
+  };
 }
 
 // src/domains/registry/skill-catalog.ts
@@ -50,10 +68,17 @@ var SKILL_CATALOG = [
   {
     id: "groove-harness",
     name: "GrooveSkills Harness",
-    description: "Lightweight project harness, context memory, and 3-lane task execution (Answer, Task, Spec) for AI coding agents",
+    description: "Lightweight project harness, context memory, and ODD 3-lane task execution (Answer, Task, Spec) for AI coding agents",
     dependencies: [],
     directoryName: "groove-harness"
   },
+  {
+    id: "odd-ai",
+    name: "Organic & Outcome-Driven Development (ODD)",
+    description: "7-step ODD protocol for AI agents: authorize, explore, classify, outcome hypotheses, and verifiable evidence receipts",
+    dependencies: [],
+    directoryName: "odd-ai"
+  },
   {
     id: "best-practices",
     name: "Universal Best Practices",
@@ -61,6 +86,62 @@ var SKILL_CATALOG = [
     dependencies: [],
     directoryName: "best-practices"
   },
+  {
+    id: "ux-writing",
+    name: "UX Writing & Microcopy Standards",
+    description: "Persuasive, empathetic, professional bilingual microcopy (ES/EN) for error messages, forms, CTAs, toasts, and empty states",
+    dependencies: [],
+    directoryName: "ux-writing"
+  },
+  {
+    id: "typescript-clean",
+    name: "TypeScript Clean Code (TS 5.5+)",
+    description: "Advanced strict TypeScript, discriminated unions, satisfies, const generics, unknown over any, and zero unsafe casts",
+    dependencies: ["typescript"],
+    directoryName: "typescript-clean"
+  },
+  {
+    id: "rust-clean",
+    name: "Rust Clean Code (Rust 2024)",
+    description: "Idiomatic Rust clean code: let-else guard clauses, no unwrap in production, thiserror typed errors, Newtypes, zero barrel files, <200 lines",
+    dependencies: ["rust"],
+    directoryName: "rust-clean"
+  },
+  {
+    id: "python-clean",
+    name: "Python Clean Code (Python 3.12+)",
+    description: "Modern Python standards: guard clauses (no nested ifs), strict typing (zero Any), uv, Ruff, Pyright, Pydantic v2 boundaries, <200 lines",
+    dependencies: ["python"],
+    directoryName: "python-clean"
+  },
+  {
+    id: "error-handling-logging",
+    name: "Error Handling & Structured Logging",
+    description: "Deterministic error management with AppError, Result/ActionResponse contracts, and structured context logging",
+    dependencies: [],
+    directoryName: "error-handling-logging"
+  },
+  {
+    id: "valibot-validation",
+    name: "Valibot Schema Validation",
+    description: "Boundary schema validation with Valibot (* as v from 'valibot'), strict type inference, and friendly error messages",
+    dependencies: ["valibot"],
+    directoryName: "valibot-validation"
+  },
+  {
+    id: "clean-architecture-ddd",
+    name: "Clean Architecture & DDD",
+    description: "Domain-driven design, isolated single-purpose Actions, pure functions, immutability, zero barrel files, <200 lines per file",
+    dependencies: [],
+    directoryName: "clean-architecture-ddd"
+  },
+  {
+    id: "testing-vitest",
+    name: "Vitest Testing Standards",
+    description: "Clean unit and integration testing with Vitest: AAA pattern, behavioral testing over mocks, and boundary edge cases",
+    dependencies: ["vitest"],
+    directoryName: "testing-vitest"
+  },
   {
     id: "hono",
     name: "Hono Architecture (Valibot)",
@@ -95,7 +176,13 @@ var SKILL_CATALOG = [
 function detectProjectContext(targetPath) {
   const detectedAgents = detectAgents(targetPath);
   const { dependencies, exists } = detectDependencies(targetPath);
-  const suggestedSkillIds = ["best-practices"];
+  const suggestedSkillIds = [
+    "odd-ai",
+    "best-practices",
+    "ux-writing",
+    "error-handling-logging",
+    "clean-architecture-ddd"
+  ];
   for (const skill of SKILL_CATALOG) {
     if (skill.dependencies.length === 0) {
       continue;
@@ -117,7 +204,7 @@ function detectProjectContext(targetPath) {
 }
 
 // src/domains/ui/ui-orchestrator.ts
-import * as p5 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 import pc2 from "picocolors";
 
 // src/domains/ui/banners.ts
@@ -180,10 +267,28 @@ async function promptHarness(harnessExists) {
   return confirm3;
 }
 
-// src/domains/ui/prompt-confirm-overwrite.ts
+// src/domains/ui/prompt-language.ts
 import * as p4 from "@clack/prompts";
+async function promptLanguage(defaultLanguage = "es") {
+  const options = [
+    { value: "es", label: "Espa\xF1ol (Spanish)", hint: "Recomendado para proyectos en espa\xF1ol" },
+    { value: "en", label: "English", hint: "Standard international English" },
+    { value: "pt", label: "Portugu\xEAs (Portuguese)", hint: "Portugu\xEAs para o Brasil e Portugal" },
+    { value: "it", label: "Italiano (Italian)", hint: "Comunicazione in lingua italiana" },
+    { value: "fr", label: "Fran\xE7ais (French)", hint: "Communication en langue fran\xE7aise" }
+  ];
+  const selected = await p4.select({
+    message: "Which language should AI agents use for user-facing copy and communication?",
+    options,
+    initialValue: defaultLanguage
+  });
+  return selected;
+}
+
+// src/domains/ui/prompt-confirm-overwrite.ts
+import * as p5 from "@clack/prompts";
 async function promptConfirmOverwrite() {
-  return await p4.confirm({
+  return await p5.confirm({
     message: "Some skills already exist in this project. Would you like to overwrite them with the latest version?",
     initialValue: true
   });
@@ -418,9 +523,44 @@ alwaysApply: false
 import { existsSync as existsSync10, mkdirSync as mkdirSync6, writeFileSync as writeFileSync3 } from "fs";
 import { join as join12 } from "path";
 
+// src/domains/harness/harness-languages.ts
+var SUPPORTED_LANGUAGES = {
+  es: {
+    code: "es",
+    name: "Spanish",
+    nativeName: "Espa\xF1ol",
+    instruction: "Todos los mensajes, validaciones, errores, CTAs y comunicaciones con el usuario deben redactarse estrictamente en Espa\xF1ol. El tono debe ser emp\xE1tico, amable, persuasivo y profesional."
+  },
+  en: {
+    code: "en",
+    name: "English",
+    nativeName: "English",
+    instruction: "All user-facing messages, form validations, errors, CTAs, and notifications must be written strictly in English. Tone must be empathetic, friendly, persuasive, and professional."
+  },
+  pt: {
+    code: "pt",
+    name: "Portuguese",
+    nativeName: "Portugu\xEAs",
+    instruction: "Todas as mensagens, valida\xE7\xF5es, erros, CTAs e comunica\xE7\xF5es voltadas para o usu\xE1rio devem ser redigidas estritamente em Portugu\xEAs. O tom deve ser emp\xE1tico, amig\xE1vel, persuasivo e profissional."
+  },
+  it: {
+    code: "it",
+    name: "Italian",
+    nativeName: "Italiano",
+    instruction: "Tutti i messaggi, le convalide, gli errori, i pulsanti/CTA e le comunicazioni rivolte all'utente devono essere scritti rigorosamente in Italiano. Il tono deve essere empatico, cordiale, persuasivo e professionale."
+  },
+  fr: {
+    code: "fr",
+    name: "French",
+    nativeName: "Fran\xE7ais",
+    instruction: "Tous les messages, validations, erreurs, boutons d'appel \xE0 l'action (CTA) et notifications destin\xE9s \xE0 l'utilisateur doivent \xEAtre r\xE9dig\xE9s strictement en Fran\xE7ais. Le ton doit \xEAtre empathique, courtois, persuasif et professionnel."
+  }
+};
+
 // src/domains/harness/harness-templates.ts
-function buildContextTemplate(detectedDependencies) {
+function buildContextTemplate(detectedDependencies, language = "es") {
   const depsFormatted = detectedDependencies.length > 0 ? detectedDependencies.map((d) => `- \`${d}\``).join("\n") : "- (No external dependencies detected)";
+  const langConfig = SUPPORTED_LANGUAGES[language];
   return `# Project Context & Architecture
 
 This file provides AI agents with instant architectural orientation for this project.
@@ -433,21 +573,26 @@ ${depsFormatted}
 - Maintain direct imports with path aliases; avoid barrel files.
 - Keep domain boundaries explicit and clean.
 
-## 3. Essential Commands
+## 3. Communication & User Copy Language
+- **Configured Language**: ${langConfig.nativeName} (\`${language}\`).
+- **Policy**: ${langConfig.instruction}
+
+## 4. Essential Commands
 - Build: Refer to \`package.json\` scripts.
 - Typecheck: Refer to TypeScript configuration.
 - Tests: Refer to test runner configuration.
 `;
 }
-function buildDecisionsTemplate() {
+function buildDecisionsTemplate(language = "es") {
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const langConfig = SUPPORTED_LANGUAGES[language];
   return `# Architecture Decision Records (ADR)
 
 An append-only log of significant technical and architectural choices.
 
 | Date | Title | Decision | Reason & Consequences |
 | :--- | :--- | :--- | :--- |
-| ${now} | Adopt GrooveSkills Harness | Initialized \`.grooveskills/\` control plane | Clean, encapsulated agent memory and 3-lane execution flow |
+| ${now} | Adopt GrooveSkills Harness | Initialized \`.grooveskills/\` control plane with ODD | Clean, encapsulated agent memory, 3-lane ODD flow, and ${langConfig.nativeName} copy standard |
 `;
 }
 function buildTaskTemplate() {
@@ -458,8 +603,9 @@ createdAt: \${CURRENT_DATE}
 
 # Feature / Task Title
 
-## Intent
-Describe what changes are being made and why they are necessary.
+## Outcome Hypothesis
+Describe the expected behavioral outcome:
+By [Output / Technical Change], [Outcome / Verifiable Behavior] will occur, proven by [Evidence / Test / Build Command].
 
 ## Scope
 - In scope:
@@ -476,18 +622,24 @@ Describe what changes are being made and why they are necessary.
 - Next concrete step if interrupted.
 `;
 }
-function buildAgentHarnessBlock() {
+function buildAgentHarnessBlock(language = "es") {
+  const langConfig = SUPPORTED_LANGUAGES[language];
   return `<!-- grooveskills:harness:start -->
 # GrooveSkills Harness \u2014 Agent Rules & Memory
 
 This project uses the **GrooveSkills Harness** located in \`.grooveskills/\`.
 
-## 1. Three-Lane Rule
-- **Answer**: Explanations, audits, or questions. Read-only; write zero code.
-- **Task**: Direct implementation. Record intent, scope, and checklist in \`.grooveskills/memory/tasks/<slug>.md\`. Only check off tasks with observed evidence under \`Evidence\`.
-- **Spec**: Ambiguous or high-impact architecture. Clarify and validate the spec in \`.grooveskills/memory/tasks/<slug>.md\` before writing code.
+## 1. Three-Lane ODD Protocol
+- **Authorize & Explore**: Follow the 7-step ODD protocol (Authorize, Explore, Resolve, Classify, Track & Hypothesize, Execute, Verify).
+- **Lane 1 (Answer)**: Explanations, audits, or questions. Read-only; write zero code.
+- **Lane 2 (Task)**: Direct implementation. Declare Outcome Hypothesis and checklist in \`.grooveskills/memory/tasks/<slug>.md\`. Only check off tasks with observed evidence under \`Evidence\`.
+- **Lane 3 (Spec)**: Ambiguous or high-impact architecture. Clarify and validate the spec in \`.grooveskills/memory/tasks/<slug>.md\` before writing code.
+
+## 2. User Communication Language (${langConfig.nativeName})
+- **Language**: \`${language}\` (${langConfig.nativeName}).
+- **Requirement**: ${langConfig.instruction}
 
-## 2. Memory Locations
+## 3. Memory Locations
 - Architecture context: \`.grooveskills/memory/context.md\`
 - Technical decisions (ADR): \`.grooveskills/memory/decisions.md\`
 - Active tasks & evidence: \`.grooveskills/memory/tasks/\`
@@ -499,8 +651,8 @@ import { existsSync as existsSync9, readFileSync as readFileSync3, writeFileSync
 import { join as join11 } from "path";
 var START_MARKER = "<!-- grooveskills:harness:start -->";
 var END_MARKER = "<!-- grooveskills:harness:end -->";
-function applyHarnessBlock(filePath) {
-  const block = buildAgentHarnessBlock();
+function applyHarnessBlock(filePath, language = "es") {
+  const block = buildAgentHarnessBlock(language);
   if (!existsSync9(filePath)) {
     writeFileSync2(filePath, `${block}
 `, "utf-8");
@@ -517,14 +669,14 @@ function applyHarnessBlock(filePath) {
   writeFileSync2(filePath, `${existingContent}${separator}${block}
 `, "utf-8");
 }
-function upsertAgentInstructions(targetPath, selectedAgents) {
+function upsertAgentInstructions(targetPath, selectedAgents, language = "es") {
   const updatedFiles = [];
   const agentsMdPath = join11(targetPath, "AGENTS.md");
-  applyHarnessBlock(agentsMdPath);
+  applyHarnessBlock(agentsMdPath, language);
   updatedFiles.push(agentsMdPath);
   if (selectedAgents.includes("claude")) {
     const claudeMdPath = join11(targetPath, "CLAUDE.md");
-    applyHarnessBlock(claudeMdPath);
+    applyHarnessBlock(claudeMdPath, language);
     updatedFiles.push(claudeMdPath);
   }
   return updatedFiles;
@@ -534,18 +686,19 @@ function upsertAgentInstructions(targetPath, selectedAgents) {
 function installHarness(options) {
   const memoryDir = getProjectMemoryDir(options.targetPath);
   const tasksDir = getProjectTasksDir(options.targetPath);
+  const language = options.language ?? "es";
   if (!existsSync10(tasksDir)) {
     mkdirSync6(tasksDir, { recursive: true });
   }
   const createdFiles = [];
   const contextPath = join12(memoryDir, "context.md");
   if (!existsSync10(contextPath)) {
-    writeFileSync3(contextPath, buildContextTemplate(options.detectedDependencies), "utf-8");
+    writeFileSync3(contextPath, buildContextTemplate(options.detectedDependencies, language), "utf-8");
     createdFiles.push(contextPath);
   }
   const decisionsPath = join12(memoryDir, "decisions.md");
   if (!existsSync10(decisionsPath)) {
-    writeFileSync3(decisionsPath, buildDecisionsTemplate(), "utf-8");
+    writeFileSync3(decisionsPath, buildDecisionsTemplate(language), "utf-8");
     createdFiles.push(decisionsPath);
   }
   const templateTaskPath = join12(tasksDir, "_template.md");
@@ -553,38 +706,46 @@ function installHarness(options) {
     writeFileSync3(templateTaskPath, buildTaskTemplate(), "utf-8");
     createdFiles.push(templateTaskPath);
   }
-  const instructions = upsertAgentInstructions(options.targetPath, options.selectedAgents);
+  const instructions = upsertAgentInstructions(options.targetPath, options.selectedAgents, language);
   createdFiles.push(...instructions);
   return createdFiles;
 }
 
 // src/domains/harness/write-project-config.ts
 import { existsSync as existsSync11, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-function writeProjectConfig(targetPath, newSkills, newAgents, harnessEnabled) {
-  const configPath = getProjectConfigPath(targetPath);
-  let existingSkills = [];
-  let existingAgents = [];
-  let existingHarness = false;
-  if (existsSync11(configPath)) {
-    try {
-      const parsed = JSON.parse(readFileSync4(configPath, "utf-8"));
-      if (Array.isArray(parsed.skills)) {
-        existingSkills = parsed.skills;
-      }
-      if (Array.isArray(parsed.agents)) {
-        existingAgents = parsed.agents;
-      }
-      if (typeof parsed.harness === "boolean") {
-        existingHarness = parsed.harness;
-      }
-    } catch {
-    }
+function readExistingConfig(configPath) {
+  const fallback = {
+    skills: [],
+    agents: [],
+    harness: false
+  };
+  if (!existsSync11(configPath)) {
+    return fallback;
   }
-  const mergedSkills = Array.from(/* @__PURE__ */ new Set([...existingSkills, ...newSkills]));
-  const mergedAgents = Array.from(/* @__PURE__ */ new Set([...existingAgents, ...newAgents]));
+  try {
+    const raw = readFileSync4(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      skills: Array.isArray(parsed.skills) ? parsed.skills : [],
+      agents: Array.isArray(parsed.agents) ? parsed.agents : [],
+      harness: typeof parsed.harness === "boolean" ? parsed.harness : false,
+      language: typeof parsed.language === "string" ? parsed.language : void 0
+    };
+  } catch {
+    return fallback;
+  }
+}
+function writeProjectConfig(targetPath, newSkills, newAgents, harnessEnabled, language) {
+  const configPath = getProjectConfigPath(targetPath);
+  const existing = readExistingConfig(configPath);
+  const mergedSkills = Array.from(/* @__PURE__ */ new Set([...existing.skills, ...newSkills]));
+  const mergedAgents = Array.from(/* @__PURE__ */ new Set([...existing.agents, ...newAgents]));
+  const resolvedLanguage = language ?? existing.language ?? "es";
+  const isHarnessActive = existing.harness || harnessEnabled;
   const config = {
     version: 1,
-    harness: existingHarness || harnessEnabled,
+    harness: isHarnessActive,
+    ...isHarnessActive ? { language: resolvedLanguage } : {},
     agents: mergedAgents,
     skills: mergedSkills,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -606,6 +767,9 @@ async function installSkills(options) {
   if (options.enableHarness && !skillsToInstall.includes("groove-harness")) {
     skillsToInstall.push("groove-harness");
   }
+  if (options.enableHarness && !skillsToInstall.includes("odd-ai")) {
+    skillsToInstall.push("odd-ai");
+  }
   syncProjectStore(options.targetPath, skillsToInstall, options.selectedAgents);
   const projectSkillsDir = getProjectSkillsDir(options.targetPath);
   const createdFiles = [];
@@ -630,7 +794,8 @@ async function installSkills(options) {
       targetPath: options.targetPath,
       selectedAgents: options.selectedAgents,
       selectedSkillIds: skillsToInstall,
-      detectedDependencies: options.detectedDependencies || []
+      detectedDependencies: options.detectedDependencies || [],
+      language: options.language
     });
     createdFiles.push(...harnessFiles);
     harnessInitialized = true;
@@ -639,75 +804,98 @@ async function installSkills(options) {
     options.targetPath,
     skillsToInstall,
     options.selectedAgents,
-    Boolean(options.enableHarness)
+    Boolean(options.enableHarness),
+    options.language
   );
   createdFiles.push(configPath);
   return {
     installedSkills: skillsToInstall,
     configuredAgents: options.selectedAgents,
     createdFiles,
-    harnessInitialized
+    harnessInitialized,
+    language: options.language
   };
 }
 
 // src/domains/ui/ui-orchestrator.ts
+async function resolveLanguageSelection(harnessEnabled) {
+  if (!harnessEnabled) {
+    return "es";
+  }
+  const langChoice = await promptLanguage("es");
+  if (p6.isCancel(langChoice)) {
+    p6.cancel("Installation cancelled. Have a wonderful day!");
+    process.exit(0);
+  }
+  return langChoice;
+}
+async function resolveOverwriteConfirmation(targetPath, selectedSkills, selectedAgents) {
+  const anyExists = selectedSkills.some((skillId) => {
+    const meta = SKILL_CATALOG.find((s) => s.id === skillId);
+    return meta ? verifySkillExists(targetPath, meta.directoryName, selectedAgents) : false;
+  });
+  if (!anyExists) {
+    return true;
+  }
+  const confirm3 = await promptConfirmOverwrite();
+  if (p6.isCancel(confirm3) || !confirm3) {
+    p6.cancel("Installation stopped to protect existing skills.");
+    process.exit(0);
+  }
+  return Boolean(confirm3);
+}
 async function runInteractiveUi(context) {
   console.log(renderBanner());
-  p5.intro(pc2.magenta("Welcome to GrooveSkills! Let's tailor your AI agents with clean architectural standards."));
+  p6.intro(pc2.magenta("Welcome to GrooveSkills! Let's tailor your AI agents with clean architectural standards."));
   if (context.detectedDependencies.length > 0) {
-    p5.note(
+    p6.note(
       `Detected dependencies: ${context.detectedDependencies.map((d) => pc2.bold(d)).join(", ")}
 Active AI folders: ${context.detectedAgents.map((a) => pc2.green(a)).join(", ") || "None (will be created)"}`,
       "Project Environment"
     );
   }
   const selectedSkills = await promptSkills(context.suggestedSkillIds);
-  if (p5.isCancel(selectedSkills)) {
-    p5.cancel("Installation cancelled. Have a wonderful day!");
+  if (p6.isCancel(selectedSkills)) {
+    p6.cancel("Installation cancelled. Have a wonderful day!");
     process.exit(0);
   }
   const selectedAgents = await promptAgents(context.detectedAgents);
-  if (p5.isCancel(selectedAgents)) {
-    p5.cancel("Installation cancelled. Have a wonderful day!");
+  if (p6.isCancel(selectedAgents)) {
+    p6.cancel("Installation cancelled. Have a wonderful day!");
     process.exit(0);
   }
   const harnessChoice = await promptHarness(context.harnessExists);
-  if (p5.isCancel(harnessChoice)) {
-    p5.cancel("Installation cancelled. Have a wonderful day!");
+  if (p6.isCancel(harnessChoice)) {
+    p6.cancel("Installation cancelled. Have a wonderful day!");
     process.exit(0);
   }
-  let forceOverwrite = true;
-  const anyExists = selectedSkills.some((skillId) => {
-    const meta = SKILL_CATALOG.find((s2) => s2.id === skillId);
-    return meta ? verifySkillExists(context.targetPath, meta.directoryName, selectedAgents) : false;
-  });
-  if (anyExists) {
-    const confirm3 = await promptConfirmOverwrite();
-    if (p5.isCancel(confirm3) || !confirm3) {
-      p5.cancel("Installation stopped to protect existing skills.");
-      process.exit(0);
-    }
-    forceOverwrite = Boolean(confirm3);
-  }
-  const s = p5.spinner();
+  const harnessEnabled = Boolean(harnessChoice);
+  const selectedLanguage = await resolveLanguageSelection(harnessEnabled);
+  const forceOverwrite = await resolveOverwriteConfirmation(
+    context.targetPath,
+    selectedSkills,
+    selectedAgents
+  );
+  const s = p6.spinner();
   s.start("Installing and adapting skills across your configured AI agents...");
   const result = await installSkills({
     targetPath: context.targetPath,
     selectedSkillIds: selectedSkills,
     selectedAgents,
     forceOverwrite,
-    enableHarness: Boolean(harnessChoice),
-    detectedDependencies: context.detectedDependencies
+    enableHarness: harnessEnabled,
+    detectedDependencies: context.detectedDependencies,
+    language: selectedLanguage
   });
   s.stop(pc2.green("All skills and harness have been successfully configured!"));
-  const harnessStatus = result.harnessInitialized ? pc2.green("Initialized in .grooveskills/") : pc2.dim("Skipped");
-  p5.note(
+  const harnessStatus = result.harnessInitialized ? pc2.green(`Initialized in .grooveskills/ (Language: ${selectedLanguage})`) : pc2.dim("Skipped");
+  p6.note(
     `Configured skills: ${result.installedSkills.map((s2) => pc2.bold(s2)).join(", ")}
 Target agents: ${result.configuredAgents.map((a) => pc2.cyan(a)).join(", ")}
 GrooveSkills Harness: ${harnessStatus}`,
     "Installation Summary"
   );
-  p5.outro(pc2.green("Your AI programming pair is now empowered with your team's architectural habits! \u{1F680}"));
+  p6.outro(pc2.green("Your AI programming pair is now empowered with your team's architectural habits! \u{1F680}"));
 }
 
 // src/main.ts
@@ -724,7 +912,8 @@ async function runGrooveSkills(options = {}) {
       selectedAgents: options.agents || [],
       forceOverwrite: Boolean(options.yes),
       enableHarness: options.harness,
-      detectedDependencies: context.detectedDependencies
+      detectedDependencies: context.detectedDependencies,
+      language: options.language
     });
     return;
   }
@@ -734,4 +923,4 @@ async function runGrooveSkills(options = {}) {
 export {
   runGrooveSkills
 };
-//# sourceMappingURL=chunk-5Q6O3BRA.js.map
+//# sourceMappingURL=chunk-M7ZPBGQE.js.map