@3lineas/grooveskills 1.3.1 → 1.5.0

package/dist/{chunk-M7ZPBGQE.js → chunk-PLMYUKGW.js}

@@ -1,5 +1,5 @@
 // src/domains/detector/project-detector.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { join as join2 } from "path";
 
 // src/domains/detector/detect-agents.ts
@@ -70,7 +70,8 @@ var SKILL_CATALOG = [
     name: "GrooveSkills Harness",
     description: "Lightweight project harness, context memory, and ODD 3-lane task execution (Answer, Task, Spec) for AI coding agents",
     dependencies: [],
-    directoryName: "groove-harness"
+    directoryName: "groove-harness",
+    isCoreHarness: true
   },
   {
     id: "odd-ai",
@@ -173,6 +174,19 @@ var SKILL_CATALOG = [
 ];
 
 // src/domains/detector/project-detector.ts
+function readConfiguredLanguage(targetPath) {
+  const configPath = join2(targetPath, ".grooveskills", "config.json");
+  if (!existsSync2(configPath)) {
+    return void 0;
+  }
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.language === "string" ? parsed.language : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function detectProjectContext(targetPath) {
   const detectedAgents = detectAgents(targetPath);
   const { dependencies, exists } = detectDependencies(targetPath);
@@ -193,18 +207,20 @@ function detectProjectContext(targetPath) {
     }
   }
   const harnessExists = existsSync2(join2(targetPath, ".grooveskills", "memory", "context.md"));
+  const configuredLanguage = readConfiguredLanguage(targetPath);
   return {
     targetPath,
     detectedDependencies: dependencies,
     suggestedSkillIds,
     detectedAgents,
     packageJsonExists: exists,
-    harnessExists
+    harnessExists,
+    configuredLanguage
   };
 }
 
 // src/domains/ui/ui-orchestrator.ts
-import * as p6 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 import pc2 from "picocolors";
 
 // src/domains/ui/banners.ts
@@ -220,7 +236,8 @@ function renderBanner() {
 // src/domains/ui/prompt-skills.ts
 import * as p from "@clack/prompts";
 async function promptSkills(suggestedSkillIds) {
-  const options = SKILL_CATALOG.map((skill) => {
+  const selectableSkills = SKILL_CATALOG.filter((skill) => !skill.isCoreHarness);
+  const options = selectableSkills.map((skill) => {
     const isSuggested = suggestedSkillIds.includes(skill.id);
     return {
       value: skill.id,
@@ -256,19 +273,8 @@ async function promptAgents(detectedAgents) {
   return selected;
 }
 
-// src/domains/ui/prompt-harness.ts
-import * as p3 from "@clack/prompts";
-async function promptHarness(harnessExists) {
-  const message = harnessExists ? "GrooveSkills Harness is already initialized. Would you like to update agent rules and memory templates?" : "Would you like to initialize the GrooveSkills Harness in .grooveskills/ (project memory, ADR, and 3-lane task execution)?";
-  const confirm3 = await p3.confirm({
-    message,
-    initialValue: true
-  });
-  return confirm3;
-}
-
 // src/domains/ui/prompt-language.ts
-import * as p4 from "@clack/prompts";
+import * as p3 from "@clack/prompts";
 async function promptLanguage(defaultLanguage = "es") {
   const options = [
     { value: "es", label: "Espa\xF1ol (Spanish)", hint: "Recomendado para proyectos en espa\xF1ol" },
@@ -277,7 +283,7 @@ async function promptLanguage(defaultLanguage = "es") {
     { 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({
+  const selected = await p3.select({
     message: "Which language should AI agents use for user-facing copy and communication?",
     options,
     initialValue: defaultLanguage
@@ -286,9 +292,9 @@ async function promptLanguage(defaultLanguage = "es") {
 }
 
 // src/domains/ui/prompt-confirm-overwrite.ts
-import * as p5 from "@clack/prompts";
+import * as p4 from "@clack/prompts";
 async function promptConfirmOverwrite() {
-  return await p5.confirm({
+  return await p4.confirm({
     message: "Some skills already exist in this project. Would you like to overwrite them with the latest version?",
     initialValue: true
   });
@@ -317,10 +323,10 @@ function verifySkillExists(targetPath, skillDirectoryName, agents) {
 }
 
 // src/domains/installer/install-orchestrator.ts
-import { join as join13 } from "path";
+import { join as join11 } from "path";
 
-// src/domains/adapters/antigravity.adapter.ts
-import { mkdirSync, existsSync as existsSync3 } from "fs";
+// src/domains/adapters/skill-reference-builder.ts
+import { existsSync as existsSync3, lstatSync as lstatSync2, mkdirSync, readFileSync as readFileSync3, rmSync, unlinkSync, writeFileSync } from "fs";
 import { join as join5 } from "path";
 
 // src/domains/project-store/project-paths.ts
@@ -331,9 +337,6 @@ function getProjectStoreDir(targetPath) {
 function getProjectSkillsDir(targetPath) {
   return join4(getProjectStoreDir(targetPath), "skills");
 }
-function getProjectCursorRulesDir(targetPath) {
-  return join4(getProjectStoreDir(targetPath), "cursor-rules");
-}
 function getProjectMemoryDir(targetPath) {
   return join4(getProjectStoreDir(targetPath), "memory");
 }
@@ -344,13 +347,26 @@ function getProjectConfigPath(targetPath) {
   return join4(getProjectStoreDir(targetPath), "config.json");
 }
 
-// src/domains/adapters/link-helper.ts
-import { lstatSync as lstatSync2, unlinkSync, rmSync, symlinkSync } from "fs";
-import { dirname, relative } from "path";
-function removeExistingLinkPath(path) {
+// src/domains/adapters/skill-reference-builder.ts
+function removeExistingPathSafely(path) {
+  const fileExists = existsSync3(path);
+  if (!fileExists) {
+    try {
+      const lstat = lstatSync2(path);
+      if (lstat.isSymbolicLink()) {
+        unlinkSync(path);
+      }
+    } catch {
+    }
+    return;
+  }
   try {
     const lstat = lstatSync2(path);
-    if (lstat.isDirectory() && !lstat.isSymbolicLink()) {
+    if (lstat.isSymbolicLink()) {
+      unlinkSync(path);
+      return;
+    }
+    if (lstat.isDirectory()) {
       rmSync(path, { recursive: true, force: true });
       return;
     }
@@ -358,11 +374,71 @@ function removeExistingLinkPath(path) {
   } catch {
   }
 }
-function createOrReplaceSymlink(target, linkPath, type) {
-  removeExistingLinkPath(linkPath);
-  const linkDir = dirname(linkPath);
-  const relativeTarget = relative(linkDir, target);
-  symlinkSync(relativeTarget, linkPath, type);
+function extractSkillDescription(canonicalSkillMdPath, fallback) {
+  if (!existsSync3(canonicalSkillMdPath)) {
+    return fallback;
+  }
+  try {
+    const content = readFileSync3(canonicalSkillMdPath, "utf-8");
+    const match = content.match(/^description:\s*(.+)$/m);
+    const hasMatchedDesc = Boolean(match && match[1]);
+    if (hasMatchedDesc && match?.[1]) {
+      return match[1].trim();
+    }
+  } catch {
+  }
+  return fallback;
+}
+function writeAgentSkillReference(targetPath, agentRelativeSkillsDir, skill) {
+  const agentSkillFolder = join5(targetPath, agentRelativeSkillsDir, skill.directoryName);
+  removeExistingPathSafely(agentSkillFolder);
+  mkdirSync(agentSkillFolder, { recursive: true });
+  const canonicalSkillMd = join5(getProjectSkillsDir(targetPath), skill.directoryName, "SKILL.md");
+  const description = extractSkillDescription(canonicalSkillMd, skill.description);
+  const referenceContent = `---
+name: ${skill.id}
+description: ${description}
+---
+
+# ${skill.name} \u2014 Skill Reference
+
+Canonical skill specification stored in \`.grooveskills/\`.
+
+- **Specification**: [\`.grooveskills/skills/${skill.directoryName}/SKILL.md\`](../../../.grooveskills/skills/${skill.directoryName}/SKILL.md)
+- **References & Templates**: \`.grooveskills/skills/${skill.directoryName}/\`
+
+> **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");
+  return targetFile;
+}
+function writeCursorRuleReference(targetPath, cursorRelativeRulesDir, skill) {
+  const rulesDir = join5(targetPath, cursorRelativeRulesDir);
+  if (!existsSync3(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);
+  const referenceContent = `---
+description: ${description}
+globs: ["**/*"]
+alwaysApply: false
+---
+
+# ${skill.name} \u2014 Rule Reference
+
+Canonical rule specification stored in \`.grooveskills/\`.
+
+- **Specification**: \`.grooveskills/skills/${skill.directoryName}/SKILL.md\`
+- **References & Templates**: \`.grooveskills/skills/${skill.directoryName}/\`
+
+> **Instruction**: Read \`.grooveskills/skills/${skill.directoryName}/SKILL.md\` before executing tasks matching this rule.
+`;
+  writeFileSync(targetFile, referenceContent, "utf-8");
+  return targetFile;
 }
 
 // src/domains/adapters/antigravity.adapter.ts
@@ -371,101 +447,70 @@ var AntigravityAdapter = class {
   name = "Antigravity";
   targetRelativeDir = ".agents/skills";
   async installSkill(targetPath, skill, _skillSourceDir) {
-    const parentDir = join5(targetPath, this.targetRelativeDir);
-    if (!existsSync3(parentDir)) {
-      mkdirSync(parentDir, { recursive: true });
-    }
-    const destination = join5(parentDir, skill.directoryName);
-    const projectSkillDir = join5(getProjectSkillsDir(targetPath), skill.directoryName);
-    createOrReplaceSymlink(projectSkillDir, destination, "dir");
-    return [destination];
+    const file = writeAgentSkillReference(targetPath, this.targetRelativeDir, skill);
+    return [file];
   }
 };
 
 // src/domains/adapters/claude.adapter.ts
-import { mkdirSync as mkdirSync2, existsSync as existsSync4 } from "fs";
-import { join as join6 } from "path";
 var ClaudeAdapter = class {
   id = "claude";
   name = "Claude Code";
   targetRelativeDir = ".claude/skills";
   async installSkill(targetPath, skill, _skillSourceDir) {
-    const parentDir = join6(targetPath, this.targetRelativeDir);
-    if (!existsSync4(parentDir)) {
-      mkdirSync2(parentDir, { recursive: true });
-    }
-    const destination = join6(parentDir, skill.directoryName);
-    const projectSkillDir = join6(getProjectSkillsDir(targetPath), skill.directoryName);
-    createOrReplaceSymlink(projectSkillDir, destination, "dir");
-    return [destination];
+    const file = writeAgentSkillReference(targetPath, this.targetRelativeDir, skill);
+    return [file];
   }
 };
 
 // src/domains/adapters/cursor.adapter.ts
-import { mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
-import { join as join7 } from "path";
 var CursorAdapter = class {
   id = "cursor";
   name = "Cursor";
   targetRelativeDir = ".cursor/rules";
   async installSkill(targetPath, skill, _skillSourceDir) {
-    const rulesDir = join7(targetPath, this.targetRelativeDir);
-    if (!existsSync5(rulesDir)) {
-      mkdirSync3(rulesDir, { recursive: true });
-    }
-    const filename = `${skill.id}.mdc`;
-    const destination = join7(rulesDir, filename);
-    const projectRuleFile = join7(getProjectCursorRulesDir(targetPath), filename);
-    createOrReplaceSymlink(projectRuleFile, destination, "file");
-    return [destination];
+    const file = writeCursorRuleReference(targetPath, this.targetRelativeDir, skill);
+    return [file];
   }
 };
 
 // src/domains/adapters/gemini.adapter.ts
-import { mkdirSync as mkdirSync4, existsSync as existsSync6 } from "fs";
-import { join as join8 } from "path";
 var GeminiAdapter = class {
   id = "gemini";
   name = "Gemini Code Assist";
   targetRelativeDir = ".gemini/skills";
   async installSkill(targetPath, skill, _skillSourceDir) {
-    const parentDir = join8(targetPath, this.targetRelativeDir);
-    if (!existsSync6(parentDir)) {
-      mkdirSync4(parentDir, { recursive: true });
-    }
-    const destination = join8(parentDir, skill.directoryName);
-    const projectSkillDir = join8(getProjectSkillsDir(targetPath), skill.directoryName);
-    createOrReplaceSymlink(projectSkillDir, destination, "dir");
-    return [destination];
+    const file = writeAgentSkillReference(targetPath, this.targetRelativeDir, skill);
+    return [file];
   }
 };
 
 // src/domains/project-store/sync-project-store.ts
-import { cpSync, mkdirSync as mkdirSync5, existsSync as existsSync8, writeFileSync, readFileSync as readFileSync2 } from "fs";
-import { join as join10 } from "path";
+import { cpSync, existsSync as existsSync5, 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 as dirname2, resolve, join as join9 } from "path";
-import { existsSync as existsSync7 } from "fs";
+import { dirname, resolve, join as join6 } from "path";
+import { existsSync as existsSync4 } from "fs";
 function resolveSkillsSourceRoot() {
   const currentFilePath = fileURLToPath(import.meta.url);
-  const currentDir = dirname2(currentFilePath);
+  const currentDir = dirname(currentFilePath);
   const candidateFromDist = resolve(currentDir, "../skills");
-  if (existsSync7(candidateFromDist)) {
+  if (existsSync4(candidateFromDist)) {
     return candidateFromDist;
   }
   const candidateFromSrc = resolve(currentDir, "../../../skills");
-  if (existsSync7(candidateFromSrc)) {
+  if (existsSync4(candidateFromSrc)) {
     return candidateFromSrc;
   }
   let searchDir = currentDir;
   for (let i = 0; i < 5; i++) {
-    const candidate = join9(searchDir, "skills");
-    if (existsSync7(candidate)) {
+    const candidate = join6(searchDir, "skills");
+    if (existsSync4(candidate)) {
       return candidate;
     }
-    const parent = dirname2(searchDir);
+    const parent = dirname(searchDir);
     if (parent === searchDir) {
       break;
     }
@@ -477,51 +522,35 @@ function resolveSkillsSourceRoot() {
 }
 
 // src/domains/project-store/sync-project-store.ts
-function syncProjectStore(targetPath, selectedSkillIds, selectedAgents) {
+function syncProjectStore(targetPath, selectedSkillIds, _selectedAgents) {
   const bundledSkillsDir = resolveSkillsSourceRoot();
   const projectSkillsDir = getProjectSkillsDir(targetPath);
-  const projectCursorRulesDir = getProjectCursorRulesDir(targetPath);
-  if (!existsSync8(projectSkillsDir)) {
-    mkdirSync5(projectSkillsDir, { recursive: true });
+  if (!existsSync5(projectSkillsDir)) {
+    mkdirSync2(projectSkillsDir, { recursive: true });
   }
-  const needsCursorRules = selectedAgents.includes("cursor");
-  if (needsCursorRules && !existsSync8(projectCursorRulesDir)) {
-    mkdirSync5(projectCursorRulesDir, { recursive: true });
+  const legacyCursorRules = join7(targetPath, ".grooveskills", "cursor-rules");
+  if (existsSync5(legacyCursorRules)) {
+    try {
+      rmSync2(legacyCursorRules, { recursive: true, force: true });
+    } catch {
+    }
   }
   for (const skillId of selectedSkillIds) {
     const skill = SKILL_CATALOG.find((item) => item.id === skillId);
     if (!skill) {
       continue;
     }
-    const sourceSkillDir = join10(bundledSkillsDir, skill.directoryName);
-    const destSkillDir = join10(projectSkillsDir, skill.directoryName);
-    if (existsSync8(sourceSkillDir)) {
+    const sourceSkillDir = join7(bundledSkillsDir, skill.directoryName);
+    const destSkillDir = join7(projectSkillsDir, skill.directoryName);
+    if (existsSync5(sourceSkillDir)) {
       cpSync(sourceSkillDir, destSkillDir, { recursive: true });
     }
-    if (!needsCursorRules) {
-      continue;
-    }
-    const skillMdPath = join10(destSkillDir, "SKILL.md");
-    if (!existsSync8(skillMdPath)) {
-      continue;
-    }
-    const content = readFileSync2(skillMdPath, "utf-8");
-    const mdcHeader = `---
-description: ${skill.description}
-globs: ["**/*"]
-alwaysApply: false
----
-
-`;
-    const cleanedBody = content.replace(/^---[\s\S]*?---\s*/, "");
-    const targetMdc = join10(projectCursorRulesDir, `${skill.id}.mdc`);
-    writeFileSync(targetMdc, `${mdcHeader}${cleanedBody}`, "utf-8");
   }
 }
 
 // src/domains/harness/install-harness.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, writeFileSync as writeFileSync3 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join10 } from "path";
 
 // src/domains/harness/harness-languages.ts
 var SUPPORTED_LANGUAGES = {
@@ -558,29 +587,59 @@ var SUPPORTED_LANGUAGES = {
 };
 
 // src/domains/harness/harness-templates.ts
-function buildContextTemplate(detectedDependencies, language = "es") {
+function buildContextTemplate(detectedDependencies, language = "es", profile) {
   const depsFormatted = detectedDependencies.length > 0 ? detectedDependencies.map((d) => `- \`${d}\``).join("\n") : "- (No external dependencies detected)";
   const langConfig = SUPPORTED_LANGUAGES[language];
-  return `# Project Context & Architecture
+  const projectName = profile?.projectName ?? "Project";
+  const pkgManager = profile?.packageManager ?? "npm";
+  const commandLines = [];
+  if (profile?.commands) {
+    for (const [key, cmd] of Object.entries(profile.commands)) {
+      commandLines.push(`- **${key}**: \`${cmd}\``);
+    }
+  }
+  const commandsSection = commandLines.length > 0 ? commandLines.join("\n") : `- Build: Refer to \`package.json\` scripts.
+- Typecheck: Refer to TypeScript configuration.
+- Tests: Refer to test runner configuration.`;
+  const aliasLines = [];
+  if (profile?.pathAliases) {
+    for (const [alias, target] of Object.entries(profile.pathAliases)) {
+      aliasLines.push(`- \`${alias}\` -> \`${target}\``);
+    }
+  }
+  const aliasesSection = aliasLines.length > 0 ? `
+### Path Aliases
+${aliasLines.join("\n")}
+` : "";
+  const dirLines = [];
+  if (profile?.sourceDirectories && profile.sourceDirectories.length > 0) {
+    for (const dir of profile.sourceDirectories) {
+      dirLines.push(`- \`${dir}/\``);
+    }
+  }
+  const dirsSection = dirLines.length > 0 ? `
+### Source Modules
+${dirLines.join("\n")}
+` : "";
+  return `# Project Context & Architecture: ${projectName}
 
 This file provides AI agents with instant architectural orientation for this project.
 
 ## 1. Stack & Dependencies
+- **Package Manager**: \`${pkgManager}\`
 ${depsFormatted}
 
 ## 2. Directory Structure Conventions
 - Follow single-responsibility per file (<200 lines).
 - Maintain direct imports with path aliases; avoid barrel files.
 - Keep domain boundaries explicit and clean.
-
+${aliasesSection}${dirsSection}
 ## 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.
+${commandsSection}
 `;
 }
 function buildDecisionsTemplate(language = "es") {
@@ -595,6 +654,35 @@ An append-only log of significant technical and architectural choices.
 | ${now} | Adopt GrooveSkills Harness | Initialized \`.grooveskills/\` control plane with ODD | Clean, encapsulated agent memory, 3-lane ODD flow, and ${langConfig.nativeName} copy standard |
 `;
 }
+function buildOnboardingTaskTemplate(projectName = "Project") {
+  const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `---
+status: pending
+createdAt: ${now}
+---
+
+# 00 \u2014 Initial Project Onboarding & Architecture Exploration: ${projectName}
+
+## Outcome Hypothesis
+By scanning dependencies, entry points, configuration manifests, and module layout, the AI agent will gain a verified architectural understanding of \`${projectName}\`, proven by filling out \`.grooveskills/memory/context.md\` and validating the essential build/typecheck commands.
+
+## Scope
+- In scope: Inspect project manifests, entry points, directory conventions, and script execution.
+- Out of scope: Refactoring business logic or modifying functional code.
+
+## Checklist
+- [ ] Verify package manager and essential scripts (\`build\`, \`test\`, \`typecheck\`).
+- [ ] Map high-level module architecture and data flow in \`.grooveskills/memory/context.md\`.
+- [ ] Verify test runner or static checks pass cleanly.
+- [ ] Switch status to \`completed\` once project context is fully verified.
+
+## Evidence
+- Observed command runs and outputs during the initial onboarding pass.
+
+## Next
+- Once onboarding is marked completed, proceed with domain tasks following the 3-lane ODD protocol.
+`;
+}
 function buildTaskTemplate() {
   return `---
 status: in-progress
@@ -630,6 +718,7 @@ function buildAgentHarnessBlock(language = "es") {
 This project uses the **GrooveSkills Harness** located in \`.grooveskills/\`.
 
 ## 1. Three-Lane ODD Protocol
+- **Onboarding Check**: If \`.grooveskills/memory/tasks/00-onboarding.md\` has \`status: pending\`, complete its checklist to enrich \`context.md\` and set its status to \`completed\`.
 - **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\`.
@@ -646,19 +735,162 @@ This project uses the **GrooveSkills Harness** located in \`.grooveskills/\`.
 <!-- grooveskills:harness:end -->`;
 }
 
+// src/domains/harness/scan-project-onboarding.ts
+import { existsSync as existsSync6, 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)) {
+    try {
+      const raw = readFileSync4(packageJsonPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.name === "string" && parsed.name.trim().length > 0) {
+        return parsed.name.trim();
+      }
+    } catch {
+    }
+  }
+  const cargoPath = join8(targetPath, "Cargo.toml");
+  if (existsSync6(cargoPath)) {
+    try {
+      const cargoRaw = readFileSync4(cargoPath, "utf-8");
+      const nameMatch = cargoRaw.match(/name\s*=\s*"([^"]+)"/);
+      if (nameMatch?.[1]) {
+        return nameMatch[1];
+      }
+    } catch {
+    }
+  }
+  const pyprojectPath = join8(targetPath, "pyproject.toml");
+  if (existsSync6(pyprojectPath)) {
+    try {
+      const pyRaw = readFileSync4(pyprojectPath, "utf-8");
+      const pyMatch = pyRaw.match(/name\s*=\s*"([^"]+)"/);
+      if (pyMatch?.[1]) {
+        return pyMatch[1];
+      }
+    } catch {
+    }
+  }
+  return basename(targetPath) || "project";
+}
+function detectPackageManager(targetPath) {
+  if (existsSync6(join8(targetPath, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync6(join8(targetPath, "bun.lockb")) || existsSync6(join8(targetPath, "bun.lock"))) {
+    return "bun";
+  }
+  if (existsSync6(join8(targetPath, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync6(join8(targetPath, "package-lock.json"))) {
+    return "npm";
+  }
+  if (existsSync6(join8(targetPath, "Cargo.lock")) || existsSync6(join8(targetPath, "Cargo.toml"))) {
+    return "cargo";
+  }
+  if (existsSync6(join8(targetPath, "uv.lock"))) {
+    return "uv";
+  }
+  if (existsSync6(join8(targetPath, "poetry.lock"))) {
+    return "poetry";
+  }
+  return "npm";
+}
+function detectCommands(targetPath, pkgManager) {
+  const packageJsonPath = join8(targetPath, "package.json");
+  if (!existsSync6(packageJsonPath)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync4(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const scripts = parsed.scripts ?? {};
+    const commands = {};
+    const runner = pkgManager === "npm" ? "npm run" : pkgManager;
+    if (scripts.build) {
+      commands.build = `${runner} build`;
+    }
+    if (scripts["check-types"]) {
+      commands.typecheck = `${runner} check-types`;
+    } else if (scripts.typecheck) {
+      commands.typecheck = `${runner} typecheck`;
+    } else if (scripts.tsc) {
+      commands.typecheck = `${runner} tsc`;
+    }
+    if (scripts.test) {
+      commands.test = `${runner} test`;
+    }
+    if (scripts.lint) {
+      commands.lint = `${runner} lint`;
+    }
+    if (scripts.dev) {
+      commands.dev = `${runner} dev`;
+    }
+    return commands;
+  } catch {
+    return {};
+  }
+}
+function detectPathAliases(targetPath) {
+  const tsconfigPath = join8(targetPath, "tsconfig.json");
+  if (!existsSync6(tsconfigPath)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync4(tsconfigPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const paths = parsed.compilerOptions?.paths ?? {};
+    const aliases = {};
+    for (const [key, targets] of Object.entries(paths)) {
+      if (Array.isArray(targets) && typeof targets[0] === "string") {
+        aliases[key] = targets[0];
+      }
+    }
+    return aliases;
+  } catch {
+    return {};
+  }
+}
+function detectSourceDirectories(targetPath) {
+  const srcPath = join8(targetPath, "src");
+  const scanTarget = existsSync6(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");
+  } catch {
+    return [];
+  }
+}
+function scanProjectOnboarding(targetPath) {
+  const projectName = detectProjectName(targetPath);
+  const packageManager = detectPackageManager(targetPath);
+  const commands = detectCommands(targetPath, packageManager);
+  const pathAliases = detectPathAliases(targetPath);
+  const sourceDirectories = detectSourceDirectories(targetPath);
+  return {
+    projectName,
+    packageManager,
+    commands,
+    pathAliases,
+    sourceDirectories
+  };
+}
+
 // src/domains/harness/upsert-agent-instructions.ts
-import { existsSync as existsSync9, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } 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") {
   const block = buildAgentHarnessBlock(language);
-  if (!existsSync9(filePath)) {
+  if (!existsSync7(filePath)) {
     writeFileSync2(filePath, `${block}
 `, "utf-8");
     return;
   }
-  const existingContent = readFileSync3(filePath, "utf-8");
+  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);
@@ -671,11 +903,11 @@ function applyHarnessBlock(filePath, language = "es") {
 }
 function upsertAgentInstructions(targetPath, selectedAgents, language = "es") {
   const updatedFiles = [];
-  const agentsMdPath = join11(targetPath, "AGENTS.md");
+  const agentsMdPath = join9(targetPath, "AGENTS.md");
   applyHarnessBlock(agentsMdPath, language);
   updatedFiles.push(agentsMdPath);
   if (selectedAgents.includes("claude")) {
-    const claudeMdPath = join11(targetPath, "CLAUDE.md");
+    const claudeMdPath = join9(targetPath, "CLAUDE.md");
     applyHarnessBlock(claudeMdPath, language);
     updatedFiles.push(claudeMdPath);
   }
@@ -687,43 +919,62 @@ 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 forceOnboarding = Boolean(options.forceOnboarding);
+  if (!existsSync8(tasksDir)) {
+    mkdirSync3(tasksDir, { recursive: true });
   }
   const createdFiles = [];
-  const contextPath = join12(memoryDir, "context.md");
-  if (!existsSync10(contextPath)) {
-    writeFileSync3(contextPath, buildContextTemplate(options.detectedDependencies, language), "utf-8");
+  const contextPath = join10(memoryDir, "context.md");
+  const shouldWriteContext = !existsSync8(contextPath) || forceOnboarding;
+  if (shouldWriteContext) {
+    const profile = scanProjectOnboarding(options.targetPath);
+    const contextContent = buildContextTemplate(
+      options.detectedDependencies,
+      language,
+      profile
+    );
+    writeFileSync3(contextPath, contextContent, "utf-8");
     createdFiles.push(contextPath);
+    const onboardingTaskPath = join10(tasksDir, "00-onboarding.md");
+    writeFileSync3(
+      onboardingTaskPath,
+      buildOnboardingTaskTemplate(profile.projectName),
+      "utf-8"
+    );
+    createdFiles.push(onboardingTaskPath);
   }
-  const decisionsPath = join12(memoryDir, "decisions.md");
-  if (!existsSync10(decisionsPath)) {
+  const decisionsPath = join10(memoryDir, "decisions.md");
+  if (!existsSync8(decisionsPath)) {
     writeFileSync3(decisionsPath, buildDecisionsTemplate(language), "utf-8");
     createdFiles.push(decisionsPath);
   }
-  const templateTaskPath = join12(tasksDir, "_template.md");
-  if (!existsSync10(templateTaskPath)) {
+  const templateTaskPath = join10(tasksDir, "_template.md");
+  if (!existsSync8(templateTaskPath)) {
     writeFileSync3(templateTaskPath, buildTaskTemplate(), "utf-8");
     createdFiles.push(templateTaskPath);
   }
-  const instructions = upsertAgentInstructions(options.targetPath, options.selectedAgents, language);
+  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";
+import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 function readExistingConfig(configPath) {
   const fallback = {
     skills: [],
     agents: [],
     harness: false
   };
-  if (!existsSync11(configPath)) {
+  if (!existsSync9(configPath)) {
     return fallback;
   }
   try {
-    const raw = readFileSync4(configPath, "utf-8");
+    const raw = readFileSync6(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     return {
       skills: Array.isArray(parsed.skills) ? parsed.skills : [],
@@ -764,10 +1015,10 @@ var ADAPTER_REGISTRY = {
 };
 async function installSkills(options) {
   const skillsToInstall = [...options.selectedSkillIds];
-  if (options.enableHarness && !skillsToInstall.includes("groove-harness")) {
+  if (!skillsToInstall.includes("groove-harness")) {
     skillsToInstall.push("groove-harness");
   }
-  if (options.enableHarness && !skillsToInstall.includes("odd-ai")) {
+  if (!skillsToInstall.includes("odd-ai")) {
     skillsToInstall.push("odd-ai");
   }
   syncProjectStore(options.targetPath, skillsToInstall, options.selectedAgents);
@@ -778,7 +1029,7 @@ async function installSkills(options) {
     if (!skill) {
       continue;
     }
-    const skillSourceDir = join13(projectSkillsDir, skill.directoryName);
+    const skillSourceDir = join11(projectSkillsDir, skill.directoryName);
     for (const agentId of options.selectedAgents) {
       const adapter = ADAPTER_REGISTRY[agentId];
       if (!adapter) {
@@ -788,23 +1039,20 @@ async function installSkills(options) {
       createdFiles.push(...files);
     }
   }
-  let harnessInitialized = false;
-  if (options.enableHarness) {
-    const harnessFiles = installHarness({
-      targetPath: options.targetPath,
-      selectedAgents: options.selectedAgents,
-      selectedSkillIds: skillsToInstall,
-      detectedDependencies: options.detectedDependencies || [],
-      language: options.language
-    });
-    createdFiles.push(...harnessFiles);
-    harnessInitialized = true;
-  }
+  const harnessFiles = installHarness({
+    targetPath: options.targetPath,
+    selectedAgents: options.selectedAgents,
+    selectedSkillIds: skillsToInstall,
+    detectedDependencies: options.detectedDependencies || [],
+    language: options.language,
+    forceOnboarding: options.forceOnboarding
+  });
+  createdFiles.push(...harnessFiles);
   const configPath = writeProjectConfig(
     options.targetPath,
     skillsToInstall,
     options.selectedAgents,
-    Boolean(options.enableHarness),
+    true,
     options.language
   );
   createdFiles.push(configPath);
@@ -812,19 +1060,19 @@ async function installSkills(options) {
     installedSkills: skillsToInstall,
     configuredAgents: options.selectedAgents,
     createdFiles,
-    harnessInitialized,
+    harnessInitialized: true,
     language: options.language
   };
 }
 
 // src/domains/ui/ui-orchestrator.ts
-async function resolveLanguageSelection(harnessEnabled) {
-  if (!harnessEnabled) {
-    return "es";
+async function resolveLanguageSelection(harnessExists, configuredLanguage, forceOnboarding) {
+  if (harnessExists && !forceOnboarding) {
+    return configuredLanguage ?? "es";
   }
-  const langChoice = await promptLanguage("es");
-  if (p6.isCancel(langChoice)) {
-    p6.cancel("Installation cancelled. Have a wonderful day!");
+  const langChoice = await promptLanguage(configuredLanguage ?? "es");
+  if (p5.isCancel(langChoice)) {
+    p5.cancel("Installation cancelled. Have a wonderful day!");
     process.exit(0);
   }
   return langChoice;
@@ -837,65 +1085,66 @@ async function resolveOverwriteConfirmation(targetPath, selectedSkills, selected
   if (!anyExists) {
     return true;
   }
-  const confirm3 = await promptConfirmOverwrite();
-  if (p6.isCancel(confirm3) || !confirm3) {
-    p6.cancel("Installation stopped to protect existing skills.");
+  const confirm2 = await promptConfirmOverwrite();
+  if (p5.isCancel(confirm2) || !confirm2) {
+    p5.cancel("Installation stopped to protect existing skills.");
     process.exit(0);
   }
-  return Boolean(confirm3);
+  return Boolean(confirm2);
 }
-async function runInteractiveUi(context) {
+async function runInteractiveUi(context, forceOnboarding = false) {
   console.log(renderBanner());
-  p6.intro(pc2.magenta("Welcome to GrooveSkills! Let's tailor your AI agents with clean architectural standards."));
+  p5.intro(pc2.magenta("Welcome to GrooveSkills! Let's tailor your AI agents with clean architectural standards."));
   if (context.detectedDependencies.length > 0) {
-    p6.note(
+    const harnessInfo = context.harnessExists && !forceOnboarding ? pc2.green(`Active (.grooveskills/memory, lang: ${context.configuredLanguage ?? "es"})`) : pc2.cyan("Will be initialized");
+    p5.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)"}`,
+Active AI folders: ${context.detectedAgents.map((a) => pc2.green(a)).join(", ") || "None (will be created)"}
+GrooveSkills Harness: ${harnessInfo}`,
       "Project Environment"
     );
   }
   const selectedSkills = await promptSkills(context.suggestedSkillIds);
-  if (p6.isCancel(selectedSkills)) {
-    p6.cancel("Installation cancelled. Have a wonderful day!");
+  if (p5.isCancel(selectedSkills)) {
+    p5.cancel("Installation cancelled. Have a wonderful day!");
     process.exit(0);
   }
   const selectedAgents = await promptAgents(context.detectedAgents);
-  if (p6.isCancel(selectedAgents)) {
-    p6.cancel("Installation cancelled. Have a wonderful day!");
-    process.exit(0);
-  }
-  const harnessChoice = await promptHarness(context.harnessExists);
-  if (p6.isCancel(harnessChoice)) {
-    p6.cancel("Installation cancelled. Have a wonderful day!");
+  if (p5.isCancel(selectedAgents)) {
+    p5.cancel("Installation cancelled. Have a wonderful day!");
     process.exit(0);
   }
-  const harnessEnabled = Boolean(harnessChoice);
-  const selectedLanguage = await resolveLanguageSelection(harnessEnabled);
+  const selectedLanguage = await resolveLanguageSelection(
+    context.harnessExists,
+    context.configuredLanguage,
+    forceOnboarding
+  );
   const forceOverwrite = await resolveOverwriteConfirmation(
     context.targetPath,
     selectedSkills,
     selectedAgents
   );
-  const s = p6.spinner();
+  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: harnessEnabled,
+    enableHarness: true,
     detectedDependencies: context.detectedDependencies,
-    language: selectedLanguage
+    language: selectedLanguage,
+    forceOnboarding
   });
   s.stop(pc2.green("All skills and harness have been successfully configured!"));
-  const harnessStatus = result.harnessInitialized ? pc2.green(`Initialized in .grooveskills/ (Language: ${selectedLanguage})`) : pc2.dim("Skipped");
-  p6.note(
+  const harnessStatus = result.harnessInitialized ? pc2.green(`Initialized in .grooveskills/ (Language: ${selectedLanguage})`) : pc2.cyan(`Preserved in .grooveskills/ (Language: ${selectedLanguage})`);
+  p5.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"
   );
-  p6.outro(pc2.green("Your AI programming pair is now empowered with your team's architectural habits! \u{1F680}"));
+  p5.outro(pc2.green("Your AI programming pair is now empowered with your team's architectural habits! \u{1F680}"));
 }
 
 // src/main.ts
@@ -905,22 +1154,25 @@ async function runGrooveSkills(options = {}) {
   const hasSkills = options.skills && options.skills.length > 0;
   const hasAgents = options.agents && options.agents.length > 0;
   const isDirectHarness = Boolean(options.harness) && hasAgents;
-  if (hasSkills && hasAgents || isDirectHarness) {
+  const isDirectInit = Boolean(options.forceOnboarding) && hasAgents;
+  if (hasSkills && hasAgents || isDirectHarness || isDirectInit) {
+    const language = options.language ?? context.configuredLanguage ?? "es";
     await installSkills({
       targetPath,
       selectedSkillIds: options.skills || [],
       selectedAgents: options.agents || [],
       forceOverwrite: Boolean(options.yes),
-      enableHarness: options.harness,
+      enableHarness: true,
       detectedDependencies: context.detectedDependencies,
-      language: options.language
+      language,
+      forceOnboarding: options.forceOnboarding
     });
     return;
   }
-  await runInteractiveUi(context);
+  await runInteractiveUi(context, Boolean(options.forceOnboarding));
 }
 
 export {
   runGrooveSkills
 };
-//# sourceMappingURL=chunk-M7ZPBGQE.js.map
+//# sourceMappingURL=chunk-PLMYUKGW.js.map