@dforce2055/dai 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -3,6 +3,38 @@
 Formato basado en [Keep a Changelog](https://keepachangelog.com/). Versionado semver
 (ver `VERSION`).
 
+## [0.2.0] — 2026-07-08
+
+Soporte para **Cursor** como asistente y un `--for` combinable. Incluye la **primera
+contribución de la comunidad** 🎉 (@sermati).
+
+### Agregado
+- **Adaptador de Cursor** ([ADR-0009](docs/adr/0009-adaptador-cursor.md), aporte de la
+  comunidad): `dai init` / `install` / `doctor` soportan Cursor — generan
+  `.cursor/skills/*/SKILL.md` y `.cursor/rules/dai-constitution.mdc` (regla always-on) desde
+  la misma fuente `skills/*/SKILL.md`.
+- **`--for` combinable**: acepta subconjuntos de asistentes (`--for claude,cursor`,
+  `--for copilot`), además de `both` (Claude+Copilot) y `all` (los tres). Nuevo
+  `parseAssistants()` en `args.mjs`.
+
+### Cambiado
+- **Default de `dai init` = `all`** (Claude + Copilot + Cursor) — deja el repo listo para
+  cualquier asistente.
+- El mensaje de "próximos pasos" de `dai init` apunta a la **URL online** de la guía
+  `PROBAR.md` (antes una ruta local que el usuario instalado no encontraba).
+
+### Interno
+- **93 tests** (+6 desde 0.1.1: `skillToCursor`, `constitutionCursorRule`, `parseAssistants`).
+
+## [0.1.1] — 2026-07-06
+
+Solo documentación y metadata — **el CLI no cambia** (mismo `ac_hash`, mismo protocolo).
+
+### Cambiado
+- `homepage` del paquete → el sitio de GitHub Pages (`dforce2055.github.io/dai`).
+- Badge de npm activado en el README (tras el primer publish).
+- Conteo de tests corregido en `RELEASING.md` (48 → 87).
+
 ## [0.1.0] — 2026-07-06
 
 Primera versión: metodología completa + CLI de trazabilidad, probado end-to-end contra
@@ -43,4 +75,6 @@ ClickUp y Jira Cloud.
 - Tests de las rutas de red (jira/clickup/forge) con `fetch` mockeado. Sin links rotos;
   `files` de npm sin tests ni secretos.
 
+[0.2.0]: https://github.com/dforce2055/dai/releases/tag/v0.2.0
+[0.1.1]: https://github.com/dforce2055/dai/releases/tag/v0.1.1
 [0.1.0]: https://github.com/dforce2055/dai/releases/tag/v0.1.0

package/CODE_OF_CONDUCT.md

@@ -11,7 +11,7 @@ apariencia, religión u orientación.
 
 Comportamientos que esperamos:
 
-- Lenguaje acogedor e inclusivo.
+- Lenguaje respetuoso y considerado.
 - Respeto por puntos de vista y experiencias distintas.
 - Aceptar la crítica constructiva con gracia.
 - Enfocarse en lo mejor para la comunidad.

package/README.md

@@ -1,13 +1,11 @@
 # dai — Desarrollo Asistido por IA
 
+[![npm](https://img.shields.io/npm/v/@dforce2055/dai.svg)](https://www.npmjs.com/package/@dforce2055/dai)
 [![CI](https://github.com/dforce2055/dai/actions/workflows/ci.yml/badge.svg)](https://github.com/dforce2055/dai/actions/workflows/ci.yml)
 [![license: GPL-3.0](https://img.shields.io/badge/license-GPLv3-blue.svg)](LICENSE)
 [![node](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](package.json)
 [![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md)
 [![sitio](https://img.shields.io/badge/sitio-dforce2055.github.io%2Fdai-6366f1.svg)](https://dforce2055.github.io/dai/)
-<!-- El badge de npm se agrega tras `npm publish` (snippet en RELEASING.md):
-[![npm](https://img.shields.io/npm/v/@dforce2055/dai.svg)](https://www.npmjs.com/package/@dforce2055/dai)
--->
 
 
 > **dai ayuda a los equipos a desarrollar software en menos tiempo y con más calidad** —
@@ -30,7 +28,7 @@ escribió, aparece el **vibe coding**, y el *qué* (negocio) se mezcla con el *c
 
 Juntas hacen que la IA potencie tu desarrollo **sin perder el control**: todo lo que se
 construye queda linkeado a por qué se construyó, y **la máquina te avisa sola** cuando algo
-se desincroniza. Del solo developer a un equipo entero de desarrollo — el mismo método, con Claude o Copilot.
+se desincroniza. Del solo developer a un equipo entero de desarrollo — el mismo método, con Claude, Copilot o Cursor.
 
 ## Cómo funciona (3 ideas)
 
@@ -51,7 +49,7 @@ deja las skills disponibles:
 
 ```bash
 npm i -g @dforce2055/dai        # el CLI
-dai install                     # skills de IA → tu Claude (Desktop y Code)
+dai install                     # skills de IA → Claude y Cursor (global por defecto)
 ```
 
 Y después, en el chat del asistente, según lo que tengas:
@@ -130,7 +128,7 @@ flowchart TD
 | # | Fase | Cómo | Quién |
 |---|---|---|---|
 | 1 | **Instalar el CLI** | `npm i -g @dforce2055/dai` (o `npm link` en dev) · `dai --version` | dev |
-| 2 | **Bootstrap del repo** | `dai init` → `.dai` + Claude/Copilot + config + PR template | dev/lead |
+| 2 | **Bootstrap del repo** | `dai init` → `.dai` + Claude/Copilot/Cursor + config + PR template | dev/lead |
 | 3a | **Definir el QUÉ** | `/grill-user-story` (una US) · `/grill-epic` (algo grande) · `/doc-to-backlog` (un doc) — te interrogan hasta una US testeable | PO / analista |
 | 3b | **Publicar la US** | la skill la sube al tracker vía **MCP**, o con **`dai publish <us.md>`** (crea el issue vía token, sin MCP) → devuelve el key | PO / IA |
 | 4 | **Linkear la US** | `dai link-us <ID>` → branch + `openspec/changes/<id>/implements.yaml` | dev |
@@ -158,8 +156,8 @@ flowchart TD
 
 | Comando | Qué hace |
 |---|---|
-| `dai init [<repo>]` | scaffolder interactivo del repo. Flags: `--for claude\|copilot\|both` (asistente, ver arriba) · `--pm md\|jira\|clickup` (tracker) · `--openspec` |
-| `dai install [--global \| --local <repo>] [--force] [--dry-run]` | instala/actualiza las skills de IA en Claude. `--force` re-copia aunque ya existan (para **actualizar** tras una nueva versión). Ej: `dai install --local . --force` (este repo) · `dai install --global --force` (tu Claude) |
+| `dai init [<repo>]` | scaffolder interactivo del repo. Flags: `--for claude\|copilot\|both\|cursor\|all` (asistente, default `all`) · `--pm md\|jira\|clickup` (tracker) · `--openspec` |
+| `dai install [--global \| --local <repo>] [--force] [--dry-run] [--for claude\|cursor\|all]` | instala/actualiza skills de IA en Claude y/o Cursor (`--for all` por defecto). `--force` re-copia aunque ya existan. Ej: `dai install --local . --for cursor --force` · `dai install --global --for all --force` |
 | `dai publish <us.md>` | crea la US en el tracker (Jira/ClickUp/md) desde un `.md` y devuelve el key. Es el fallback del MCP para publicar sin el asistente |
 | `dai link-us <ID> [--us <md>]` | crea branch + `implements.yaml`; sin `--us` trae la US del tracker |
 | `dai link-us <ID> --resync` | re-estampa el `ac_hash` contra la US viva (tras un ⚠️ de check) |
@@ -185,18 +183,23 @@ ver [`.env.example`](.env.example). Auth (SSH + tokens): [ADR-0007](docs/adr/000
 |---|---|---|
 | `--for claude` | `.claude/skills/` + `CLAUDE.md` | tu equipo usa **Claude** (Code / Desktop) |
 | `--for copilot` | `.github/prompts/*.prompt.md` + `.github/copilot-instructions.md` | tu equipo usa **GitHub Copilot** (en VS Code / JetBrains) |
-| `--for both` *(default)* | **ambos** | equipo **mixto** (unos con Claude, otros con Copilot) |
-
-- Es **aditivo, no destructivo**: los dos conjuntos conviven sin pisarse (viven en
+| `--for cursor` | `.cursor/skills/` + `.cursor/rules/dai-constitution.mdc` | tu equipo usa **Cursor Agent** |
+| `--for both` | Claude + Copilot | equipo mixto sin Cursor |
+| `--for all` *(default)* | Claude + Copilot + Cursor | quieres dejar el repo listo para cualquier asistente |
+
+- **Combinables:** pasá un subconjunto separado por coma — `--for claude,cursor` o
+  `--for copilot`. `all` = los tres · `both` = Claude+Copilot. (Igual en `dai install`,
+  aunque ahí Copilot no aplica: no tiene skills instalables.)
+- Es **aditivo, no destructivo**: los conjuntos conviven sin pisarse (viven en
   carpetas distintas). La **misma** skill se transforma al formato de cada asistente.
 - Si ejecutas `dai init` sin flag, te lo pregunta de forma interactiva.
 - **No afecta el CLI:** `dai link-us` / `check` / `stamp` funcionan igual con cualquier
   `--for` (o ninguno) — el flag solo prepara la **invocación de skills** en el asistente.
-- Ante la duda, `--for both`: cubre a todo el equipo y no cuesta nada.
+- Ante la duda, `--for all`: cubre a todo el equipo y no cuesta nada.
 
 ## Lo que obtienes en tu repo
 
-Después de `dai init` (con `--for both`):
+Después de `dai init` (con `--for all`):
 
 ```
 mi-repo/
@@ -208,6 +211,9 @@ mi-repo/
 │   ├── copilot-instructions.md     · La constitución, auto-inyectada en cada chat de Copilot
 │   ├── prompts/*.prompt.md         · Las mismas skills, generadas en formato Copilot
 │   └── pull_request_template.md    · Molde de PR/MR atado al link
+├── .cursor/
+│   ├── skills/                     · Las mismas skills, en formato Cursor
+│   └── rules/dai-constitution.mdc  · Constitución always-on de Cursor
 └── .dai/
     ├── templates/                  · formato-us · epica · DoR · DoD · adr · pull-request
     └── governance/                 · branch-naming · ci-rules · commit-convention
@@ -227,6 +233,7 @@ Las skills se invocan en el asistente — **no en todas sus superficies** (lími
 |---|---|---|
 | **Claude Desktop** | ✅ | `~/.claude/skills/` (global) — sin IDE ni consola |
 | **Claude Code** | ✅ | `~/.claude/skills/` + `.claude/skills/` del repo |
+| **Cursor Agent (IDE)** | ✅ | `.cursor/skills/*/SKILL.md` + `.cursor/rules/*.mdc` |
 | **Copilot en VS Code / JetBrains** | ✅ | los `.github/prompts/*.prompt.md` |
 | **Copilot CLI** | ✅ | custom agents |
 | **Copilot app standalone / github.com chat** | ❌ | los prompt files son solo-IDE |
@@ -258,7 +265,7 @@ Además: [`docs/glosario.md`](docs/glosario.md) · guías por rol ([`po`](docs/g
 dai/
 ├── cli/            🖥️  el binario `dai` (Node, cero dependencias) + su suite de tests
 ├── docs/           📖  la metodología: MANIFIESTO · METODOLOGIA · SCRUM-CON-IA · EJEMPLO ·
-│                       glosario · guias/ · detalle/ (10 pasos) · adr/ (0001–0007)
+│                       glosario · guias/ · detalle/ (10 pasos) · adr/ (0001–0009)
 ├── templates/      🧩  los moldes (formato-us · epica · DoR · DoD · adr · pull-request)
 ├── skills/         🤖  doc-to-backlog · grill-intent · grill-epic · grill-user-story · link-us · tdd · dai-review
 ├── governance/     🛡️  branch-naming · ci-rules · commit-convention

package/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

package/cli/dai.mjs

@@ -27,8 +27,8 @@ import { branchUrl, commitUrl, parseRemote, detectForge } from "./lib/forge-url.
 import { parsePrRef, getPR, postComment } from "./lib/forge-api.mjs";
 import { composePrBody, prTitle, forgeTool } from "./lib/pr.mjs";
 import { dirsEqual } from "./lib/fsutil.mjs";
-import { parseFlags } from "./lib/args.mjs";
-import { skillToPrompt, constitution, envFor } from "./lib/bootstrap.mjs";
+import { parseFlags, parseAssistants } from "./lib/args.mjs";
+import { skillToPrompt, skillToCursor, constitution, constitutionCursorRule, envFor } from "./lib/bootstrap.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
@@ -40,7 +40,8 @@ const ok = (m) => process.stdout.write(`✓ ${m}\n`);
 const info = (m) => process.stdout.write(`› ${m}\n`);
 const warn = (m) => process.stdout.write(`⚠ ${m}\n`);
 const ROOT = join(HERE, "..");            // raíz del paquete dai (cli/ está adentro)
-const SKILLS_DIR = process.env.CLAUDE_SKILLS_DIR || join(homedir(), ".claude", "skills");
+const CLAUDE_SKILLS_DIR = process.env.CLAUDE_SKILLS_DIR || join(homedir(), ".claude", "skills");
+const CURSOR_SKILLS_DIR = process.env.CURSOR_SKILLS_DIR || join(homedir(), ".cursor", "skills");
 function git(args, opts = {}) {
   // stderr en 'pipe' (no 'inherit') para no filtrar errores de git a la salida;
   // quedan en e.stderr para quien quiera inspeccionarlos.
@@ -412,6 +413,15 @@ async function cmdPr(opts) {
 async function cmdInstall(opts) {
   const skillsSrc = join(ROOT, "skills");
   const skills = readdirSync(skillsSrc).filter((n) => statSync(join(skillsSrc, n)).isDirectory());
+  let want;
+  try { want = parseAssistants(typeof opts.for === "string" ? opts.for : "all"); }
+  catch (e) { fail(`--for ${e.message}`); }
+  // Copilot no tiene skills instalables (no hay dir global ni local de skills de Copilot):
+  // sus prompts los genera `dai init` en el repo. Se ignora en `install`.
+  if (want.copilot) warn("Copilot no tiene skills instalables — se generan con `dai init` en el repo. Ignoro 'copilot'.");
+  const wantClaude = want.claude, wantCursor = want.cursor;
+  if (!wantClaude && !wantCursor) fail("nada para instalar: pasá --for claude|cursor|all.");
+  const installFor = [wantClaude && "claude", wantCursor && "cursor"].filter(Boolean).join("+");
   const interactive = process.stdin.isTTY && !opts.global && opts.local === undefined;
   const rl = interactive ? createInterface({ input: process.stdin, output: process.stdout }) : null;
 
@@ -422,25 +432,54 @@ async function cmdInstall(opts) {
     return a === "l" ? { scope: "local", repo: process.cwd() } : a === "s" ? { scope: "skip" } : { scope: "global" };
   };
 
-  info(`Instalando skills de dai`);
-  for (const name of skills) {
-    const { scope, repo } = await scopeFor(name);
-    if (scope === "skip") { warn(`salto ${name}`); continue; }
-    const targetDir = scope === "local" ? join(repo, ".claude", "skills") : SKILLS_DIR;
-    const src = join(skillsSrc, name), target = join(targetDir, name);
+  const installOne = async ({ name, scope, repo, kind }) => {
+    const src = join(skillsSrc, name);
+    const targetDir = scope === "local"
+      ? join(repo, kind === "cursor" ? ".cursor" : ".claude", "skills")
+      : kind === "cursor" ? CURSOR_SKILLS_DIR : CLAUDE_SKILLS_DIR;
+    const target = join(targetDir, name);
+    const label = kind === "cursor" ? `${name} (cursor)` : `${name} (claude)`;
+
+    let sameAsSource = false;
     if (existsSync(target)) {
-      if (dirsEqual(src, target)) { ok(`${name} — ya instalada e idéntica, salto`); continue; }
+      if (kind === "claude") {
+        sameAsSource = dirsEqual(src, target);
+      } else {
+        const tempRoot = mkdtempSync(join(tmpdir(), "dai-cursor-skill-"));
+        const tempTarget = join(tempRoot, name);
+        mkdirSync(tempRoot, { recursive: true });
+        cpSync(src, tempTarget, { recursive: true });
+        const srcMd = readFileSync(join(src, "SKILL.md"), "utf8");
+        writeFileSync(join(tempTarget, "SKILL.md"), skillToCursor(srcMd));
+        sameAsSource = dirsEqual(tempTarget, target);
+        rmSync(tempRoot, { recursive: true, force: true });
+      }
+
+      if (sameAsSource) { ok(`${label} — ya instalada e idéntica, salto`); return; }
       if (!opts.force) {
-        if (!interactive) { warn(`${name} existe y difiere — salto (usa --force)`); continue; }
-        const a = (await rl.question(`   ${name} existe y DIFIERE. ¿[p]isar · [s]altar? (s) `)).trim().toLowerCase();
-        if (a !== "p") { warn(`salto ${name}`); continue; }
+        if (!interactive) { warn(`${label} existe y difiere — salto (usa --force)`); return; }
+        const a = (await rl.question(`   ${label} existe y DIFIERE. ¿[p]isar · [s]altar? (s) `)).trim().toLowerCase();
+        if (a !== "p") { warn(`salto ${label}`); return; }
       }
     }
-    if (opts.dryRun) { info(`[dry-run] ${name} → ${targetDir}`); continue; }
+
+    if (opts.dryRun) { info(`[dry-run] ${label} → ${targetDir}`); return; }
     rmSync(target, { recursive: true, force: true });
     mkdirSync(targetDir, { recursive: true });
     cpSync(src, target, { recursive: true });
-    ok(`${name} → ${targetDir}`);
+    if (kind === "cursor") {
+      const srcMd = readFileSync(join(src, "SKILL.md"), "utf8");
+      writeFileSync(join(target, "SKILL.md"), skillToCursor(srcMd));
+    }
+    ok(`${label} → ${targetDir}`);
+  };
+
+  info(`Instalando skills de dai (${installFor})`);
+  for (const name of skills) {
+    const { scope, repo } = await scopeFor(name);
+    if (scope === "skip") { warn(`salto ${name}`); continue; }
+    if (wantClaude) await installOne({ name, scope, repo, kind: "claude" });
+    if (wantCursor) await installOne({ name, scope, repo, kind: "cursor" });
   }
   if (rl) rl.close();
 }
@@ -483,12 +522,15 @@ async function cmdInit(repo, opts) {
   // Preguntas primero (después cerramos readline para liberar stdin a los instaladores).
   let forOpt = typeof opts.for === "string" ? opts.for.toLowerCase() : null;
   if (!forOpt && rl) forOpt = await askMenu(rl, "¿Para qué asistente de IA preparo el repo? (genera las skills en su formato)", [
-    { value: "both", label: "Claude + Copilot — equipo mixto (recomendado ante la duda)" },
+    { value: "all", label: "Todos (Claude + Copilot + Cursor) — por defecto" },
+    { value: "both", label: "Claude + Copilot — equipo mixto (sin Cursor)" },
     { value: "claude", label: "Solo Claude (Code / Desktop)" },
     { value: "copilot", label: "Solo Copilot (en VS Code / JetBrains)" },
-  ], "both");
-  forOpt = forOpt || "both";
-  if (!["claude", "copilot", "both"].includes(forOpt)) fail(`--for inválido: '${forOpt}' (claude|copilot|both)`);
+    { value: "cursor", label: "Solo Cursor (Agent)" },
+  ], "all");
+  forOpt = forOpt || "all";
+  let want;
+  try { want = parseAssistants(forOpt); } catch (e) { fail(`--for ${e.message}`); }
 
   let pm = typeof opts.pm === "string" ? opts.pm.toLowerCase() : null;
   if (!pm && rl) pm = await askMenu(rl, "¿Dónde van a vivir las User Stories?", [
@@ -515,8 +557,7 @@ async function cmdInit(repo, opts) {
   if (rl) rl.close();
 
   // ── Generación ───────────────────────────────────────────────────────────────
-  const wantClaude = forOpt !== "copilot";
-  const wantCopilot = forOpt !== "claude";
+  const wantClaude = want.claude, wantCopilot = want.copilot, wantCursor = want.cursor;
   process.stdout.write("\n  Configurando…\n\n");
 
   const dai = join(repo, ".dai");
@@ -554,6 +595,20 @@ async function cmdInit(repo, opts) {
     writeFileSync(join(repo, ".github", "copilot-instructions.md"), constitution("copilot"));
     ok(`Copilot:      .github/prompts/ (${skills.length}) + copilot-instructions.md`);
   }
+  if (wantCursor) {
+    const dir = join(repo, ".cursor", "skills");
+    mkdirSync(dir, { recursive: true });
+    for (const name of skills) {
+      const src = join(skillsSrc, name);
+      const target = join(dir, name);
+      cpSync(src, target, { recursive: true });
+      const srcMd = readFileSync(join(src, "SKILL.md"), "utf8");
+      writeFileSync(join(target, "SKILL.md"), skillToCursor(srcMd));
+    }
+    mkdirSync(join(repo, ".cursor", "rules"), { recursive: true });
+    writeFileSync(join(repo, ".cursor", "rules", "dai-constitution.mdc"), constitutionCursorRule());
+    ok(`Cursor:       .cursor/skills/ (${skills.length}) + .cursor/rules/dai-constitution.mdc`);
+  }
 
   // ── OpenSpec ───────────────────────────────────────────────────────────────
   // OpenSpec tiene modo NO-interactivo (`openspec init --tools <lista> --force`),
@@ -561,7 +616,8 @@ async function cmdInit(repo, opts) {
   // dejaba a medias porque se intentaba correr su modo interactivo anidado.)
   process.stdout.write("\n");
   const openspecPresent = () => { try { execFileSync(npmBin("openspec"), ["--version"], { stdio: "ignore" }); return true; } catch { return false; } };
-  const osTools = { claude: "claude", copilot: "github-copilot", both: "claude,github-copilot" }[forOpt] || "claude,github-copilot";
+  const osTools = [want.claude && "claude", want.copilot && "github-copilot", want.cursor && "cursor"]
+    .filter(Boolean).join(",") || "claude,github-copilot,cursor";
   const osHint = "para sumarlo después:  npm i -g @fission-ai/openspec@latest  &&  openspec init --tools " + osTools;
   if (hasOpenspec) {
     ok("OpenSpec:     ya inicializado en el repo");
@@ -596,7 +652,7 @@ async function cmdInit(repo, opts) {
     : `    1. Completa el token de ${pm} en .env, y verifica con: dai doctor\n`);
   process.stdout.write("    2. dai link-us <ID>     → crea la branch + el link a la US\n");
   process.stdout.write("    3. Implementa con test primero, después: dai check\n");
-  process.stdout.write("    Guía paso a paso: docs/PROBAR.md\n\n");
+  process.stdout.write("    Guía paso a paso: https://github.com/dforce2055/dai/blob/main/docs/PROBAR.md\n\n");
 }
 
 // ── docs: documentación conceptual → <destino> ────────────────────────────────
@@ -617,13 +673,29 @@ function cmdDoctor() {
   const localDir = join(process.cwd(), ".claude", "skills");
   info("skills (repo local / global ~/.claude/skills):");
   for (const name of readdirSync(join(ROOT, "skills"))) {
-    const local = existsSync(join(localDir, name)), global = existsSync(join(SKILLS_DIR, name));
+    const local = existsSync(join(localDir, name)), global = existsSync(join(CLAUDE_SKILLS_DIR, name));
     if (local && global) ok(`${name}  (local + global)`);
     else if (local) ok(`${name}  (local, este repo)`);
     else if (global) ok(`${name}  (global)`);
     else warn(`${name} — no instalada (dai init en el repo, o dai install global)`);
   }
 
+  const cursorLocalDir = join(process.cwd(), ".cursor", "skills");
+  info("skills Cursor (repo local / global ~/.cursor/skills):");
+  for (const name of readdirSync(join(ROOT, "skills"))) {
+    const local = existsSync(join(cursorLocalDir, name)), global = existsSync(join(CURSOR_SKILLS_DIR, name));
+    if (local && global) ok(`${name}  (local + global)`);
+    else if (local) ok(`${name}  (local, este repo)`);
+    else if (global) ok(`${name}  (global)`);
+    else warn(`${name} — no instalada en Cursor (dai init --for cursor|all, o dai install --for cursor|all)`);
+  }
+  const localRule = join(process.cwd(), ".cursor", "rules", "dai-constitution.mdc");
+  const globalRule = join(homedir(), ".cursor", "rules", "dai-constitution.mdc");
+  if (existsSync(localRule) && existsSync(globalRule)) ok("constitución Cursor (local + global)");
+  else if (existsSync(localRule)) ok("constitución Cursor (local)");
+  else if (existsSync(globalRule)) ok("constitución Cursor (global)");
+  else warn("falta constitución Cursor (dai-constitution.mdc)");
+
   info("adaptador de PM:");
   const pm = process.env.DAI_PM || "md";
   ok(`DAI_PM=${pm}`);
@@ -680,9 +752,10 @@ switch (cmd) {
       "  pr [--assignee u] [--base b] [--draft] [--yes]   crea TU PR/MR precargada (muestra + confirma)\n" +
       "  forge comment <ref> --body-file <f> · forge pr <ref>   comentar/leer una PR ajena (github/gitlab)\n\n" +
       "Instalación:\n" +
-      "  install [--global | --local <repo>] [--force] [--dry-run]   skills → Claude\n" +
+      "  install [--global | --local <repo>] [--force] [--dry-run] [--for <asistentes>]   skills → Claude/Cursor\n" +
       "  init [<repo>]                scaffolder interactivo del repo (asistente, gestor, OpenSpec)\n" +
-      "       --for claude|copilot|both   para qué asistente preparar el repo (default both; ante duda, both)\n" +
+      "       --for <asistentes>      claude|copilot|cursor (combinables con coma) · o both|all (default all)\n" +
+      "                               ej: --for claude,cursor · --for copilot · --for all\n" +
       "       --pm md|jira|clickup · --openspec   (con flags salteas las preguntas)\n" +
       "  docs <destino>               documentación conceptual → <destino>\n" +
       "  doctor                       diagnóstico del entorno\n\n" +

package/cli/lib/args.mjs

@@ -5,6 +5,23 @@
 
 export const camel = (s) => s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 
+// Parsea el valor de `--for` como una LISTA COMBINABLE de asistentes.
+// Acepta "claude", "copilot", "cursor" (combinables con coma o espacio),
+// "both" (= claude+copilot) y "all" (= los tres). Lanza si hay un token inválido.
+// Ej.: "claude,cursor" → { claude:true, copilot:false, cursor:true }.
+export function parseAssistants(str) {
+  const want = { claude: false, copilot: false, cursor: false };
+  const toks = String(str ?? "all").toLowerCase().split(/[,\s]+/).filter(Boolean);
+  if (toks.length === 0) { want.claude = want.copilot = want.cursor = true; return want; }
+  for (const t of toks) {
+    if (t === "all") { want.claude = want.copilot = want.cursor = true; }
+    else if (t === "both") { want.claude = want.copilot = true; }
+    else if (t in want) { want[t] = true; }
+    else throw new Error(`asistente inválido: '${t}' (claude|copilot|cursor, combinables con coma; o both|all)`);
+  }
+  return want;
+}
+
 export function parseFlags(argv) {
   const opts = {};
   const pos = [];

package/cli/lib/bootstrap.mjs

@@ -27,6 +27,20 @@ export function skillToPrompt(md) {
   return `${fm}\n\n${body}\n`;
 }
 
+// Transforma un SKILL.md (Claude) en un SKILL.md de Cursor.
+// Conserva name/description/body y ajusta solo el frontmatter.
+export function skillToCursor(md) {
+  const { name, description, body } = parseFrontmatter(md);
+  if (!name) return md.trim() + "\n";
+  const fm = [
+    "---",
+    `name: ${name}`,
+    `description: ${JSON.stringify(description || "")}`,
+    "---",
+  ].join("\n");
+  return `${fm}\n\n${body}\n`;
+}
+
 // Contenido del .env según el backend de PM elegido (tokens vacíos, a completar).
 export function envFor(pm) {
   const head = "# Config de dai — completá lo que falte. NUNCA commitees tokens (.env está gitignored).\n";
@@ -44,6 +58,8 @@ export function envFor(pm) {
 export function constitution(kind) {
   const head = kind === "copilot"
     ? "# Instrucciones de Copilot para este repo\n\nEste repo sigue la metodología **dai**. Aplicá estas reglas en todo lo que generes.\n\n> **Superficie:** los prompts de dai (`.github/prompts/`) se invocan solo en VS Code /\n> JetBrains, o como custom agents en el Copilot CLI — no en la app standalone ni en\n> github.com. El CLI `dai` corre en cualquier terminal."
+    : kind === "cursor"
+      ? "# Constitución del proyecto (dai)\n\nEste repo sigue la metodología **dai**. Estas reglas gobiernan todo el trabajo.\n\n> **Superficie:** las skills de dai (`.cursor/skills/`) se invocan con `/nombre-skill`\n> o cuando el agente las detecta por descripción. El CLI `dai` corre en cualquier terminal."
     : "# Constitución del proyecto (dai)\n\nEste repo sigue la metodología **dai**. Estas reglas gobiernan todo el trabajo.";
   return `${head}
 
@@ -72,3 +88,14 @@ export function constitution(kind) {
 Detalle completo de la metodología: ${REPO_URL}
 `;
 }
+
+// Regla de Cursor always-on con el contenido de la constitución (sin título H1).
+export function constitutionCursorRule() {
+  const content = constitution("cursor").replace(/^# .+\n\n/, "");
+  return `---
+description: Metodología dai — constitución del proyecto (valores, reglas, herramientas)
+alwaysApply: true
+---
+
+${content}`;
+}

package/docs/adr/0008-estrategia-de-i18n.md

@@ -0,0 +1,73 @@
+# ADR-0008 — Estrategia de internacionalización (i18n)
+
+- **Estado:** propuesto
+- **Fecha:** 2026-07-06
+- **Decide:** lead / arquitecto de la metodología
+
+## Contexto
+
+`dai` nació y se escribió **en español**. Para su difusión —el README es lo primero que
+se ve en npm y GitHub, y el público de open source es mayoritariamente anglófono— hace
+falta una versión en **inglés**. Pero traducir un proyecto tiene trampas: superficies muy
+distintas (docs, landing HTML, mensajes del CLI, skills que son prompts), y el riesgo de
+que las traducciones **se desincronicen** del original con cada cambio.
+
+Dos cosas juegan a favor: (1) el tono ya es **español neutro internacional** (se sacó el
+voseo y los modismos a propósito), que traduce limpio; y (2) `dai` puede **dogfood-earse**
+—usar un agente para traducir de forma consistente— si se le fija la terminología.
+
+La decisión es cómo estructurar el i18n para que sea **mantenible** y no genere drift.
+
+## Decisión
+
+Adoptamos un modelo de **fuente única + traducciones derivadas**, por superficie:
+
+1. **Fuente de verdad: el español.** Se escribió primero y es el canónico. Cada archivo
+   traducido lleva una nota — *"Translation of the Spanish source; if they diverge, the
+   Spanish wins."* — igual que METODOLOGIA marca a los HTML como vistas derivadas.
+
+2. **Estructura de carpetas.** `docs/es/` (fuente) y `docs/en/` (traducción). En la raíz,
+   `README.es.md` + `README.en.md`, y `README.md` con un **selector de idioma** arriba
+   (`🇪🇸 Español · 🇬🇧 English`). El landing: una versión por idioma o un toggle en la página.
+
+3. **CLI: locale por variable, catálogo cero-dependencias.** El idioma sale de
+   `DAI_LANG` (default `es`; si no, se puede inferir de `LANG`). Los strings viven en un
+   catálogo (`cli/lib/i18n.mjs`, objeto `{ es, en }`) accedido por una función `t(key,…)`.
+   Sin librería de i18n — fiel al ethos de cero dependencias (ADR-0006).
+
+4. **Skills: se generan en el idioma elegido.** `dai init --lang en|es` copia la variante
+   del `SKILL.md`. La IA ya es multilingüe; solo cambia el idioma de las instrucciones.
+
+5. **Glosario de términos ES→EN fijo.** Para que la terminología no varíe entre archivos:
+   QUÉ→WHAT, CÓMO→HOW, estampar→stamp, trazabilidad→traceability, atrasado→stale, etc. Es
+   el insumo que guía la traducción (humana o asistida).
+
+6. **Implementación por fases** (no todo de una): (1) README + landing en inglés · (2) docs
+   core (MANIFIESTO, METODOLOGIA, glosario, EJEMPLO, guías) · (3) CLI i18n + skills · (4) el
+   resto (detalle/, ADRs, templates). Se prioriza por alcance, no por completitud.
+
+## Consecuencias
+
+- ✅ Alcance internacional con el README/landing en inglés (fase 1) sin reescribir todo.
+- ✅ Regla anti-drift clara: una sola fuente de verdad; las traducciones nunca "ganan".
+- ✅ El CLI localiza sin sumar dependencias; `DAI_LANG` es opt-in (default español).
+- ✅ La terminología queda estable entre superficies gracias al glosario ES→EN.
+- ⚠️ Doble mantenimiento: cada cambio en un `.md` fuente obliga a re-traducir su par. Se
+  mitiga traduciendo con un agente + el glosario, y aceptando *lag* temporal en `en/`.
+- ⚠️ El CLI necesita un refactor de strings (de literales a `t(key)`) — es mecánico pero toca
+  muchos puntos; se hace de una sola vez.
+- ⚠️ Hay que decidir, al implementar, si el `README.md` raíz redirige (selector) o **es** una
+  de las lenguas (npm muestra el `README.md` — probablemente convenga inglés ahí).
+
+## Alternativas consideradas
+
+- **Un framework de docs con i18n (Docusaurus / VitePress / mkdocs)** — descartado por ahora:
+  aporta i18n y versionado, pero cambia todo el setup de docs (hoy markdown plano + un HTML
+  autocontenido) y suma tooling/dependencias pesadas para un proyecto en `0.x`. Reconsiderable
+  si la doc crece mucho.
+- **Inglés como fuente de verdad** — descartado: el contenido se authoró en español; invertir
+  la fuente ahora duplicaría el riesgo de error justo en el material canónico (manifiesto,
+  metodología). El español queda como fuente hasta que haya razón fuerte para migrar.
+- **Traducción automática sin glosario ni fuente fija** — descartado: garantiza drift
+  terminológico (el mismo término traducido distinto en cada archivo) y pérdida de la
+  precisión del método. La traducción se ancla a un glosario y a una fuente única.

package/docs/adr/0009-adaptador-cursor.md

@@ -0,0 +1,63 @@
+# ADR-0009 — Adaptador nativo para Cursor
+
+- **Estado:** propuesto
+- **Fecha:** 2026-07-07
+- **Decide:** lead / arquitecto de la metodología
+
+## Contexto
+
+ADR-0002 consolidó la estrategia agnóstica por asistente con tres capas: contenido
+portable, CLI determinista y adaptadores delgados/generados por asistente. La
+implementación actual cubre Claude y Copilot, pero no Cursor de forma nativa.
+
+En la práctica, equipos que usan Cursor quedan con una experiencia incompleta: no
+hay scaffolding en `.cursor/skills/`, no existe constitución always-on en rules, y
+`dai doctor` / `dai install` no diagnostican ni instalan superficies de Cursor.
+
+Cursor soporta skills (`.cursor/skills/<name>/SKILL.md`) y rules
+(`.cursor/rules/*.mdc`) de forma nativa, y OpenSpec soporta `cursor` en `--tools`.
+Eso permite agregar soporte sin romper el contrato existente ni duplicar lógica.
+
+## Decisión
+
+Incorporamos Cursor como tercer adaptador generado en la capa 3:
+
+1. `dai init --for` acepta `cursor` y `all`, además de `claude`, `copilot`, `both`.
+2. El default de `dai init` pasa a `all` (Claude + Copilot + Cursor).
+3. `both` mantiene su significado histórico (Claude + Copilot), para compatibilidad
+   semántica.
+4. Las skills de Cursor se generan en `.cursor/skills/` desde la misma fuente
+   (`skills/*/SKILL.md`) con `skillToCursor()`.
+5. El transformador de Cursor conserva `name`, `description` y cuerpo, y no agrega
+   `disable-model-invocation` (se permite auto-invocación por descripción).
+6. La constitución de Cursor se genera como rule `.mdc` en
+   `.cursor/rules/dai-constitution.mdc` con `alwaysApply: true`.
+7. `dai doctor` reporta skills y constitución en rutas locales/globales de Cursor.
+8. `dai install` soporta Cursor vía `--for claude|cursor|all` (default `all`).
+9. OpenSpec mapea `--for all` a `claude,github-copilot,cursor`.
+
+## Consecuencias
+
+- ✅ La metodología mantiene su principio agnóstico también para Cursor, sin bifurcar
+  contenido de skills.
+- ✅ Equipos mixtos pueden coexistir en un repo con Claude, Copilot y Cursor sin
+  pisarse (carpetas separadas).
+- ✅ El runtime mecánico sigue centralizado en CLI (`dai`), sin mover lógica
+  determinista a prompts.
+- ✅ Cursor recibe constitución always-on alineada a Claude/Copilot.
+- ⚠️ Cambia el comportamiento por defecto de `dai init` (de `both` a `all`); requiere
+  documentación clara para evitar sorpresa.
+- ⚠️ `dai install` ahora maneja más de un target de asistente y aumenta la superficie
+  de mantenimiento.
+
+## Alternativas consideradas
+
+- **Depender de `.claude/skills/` por compatibilidad de Cursor** — descartado: no da
+  soporte profesional de rules/doctor/install y contradice la idea de adaptador
+  nativo generado.
+- **Redefinir `both` para incluir Cursor** — descartado: rompe semántica histórica del
+  valor; se prefiere agregar `all`.
+- **Forzar `disable-model-invocation: true` en Cursor** — descartado para este repo:
+  se busca paridad de auto-invocación con Claude.
+- **Constitución de Cursor en `AGENTS.md`** — descartado: la superficie nativa always-on
+  de Cursor son `.cursor/rules/*.mdc`.

package/docs/adr/README.md

@@ -13,6 +13,8 @@ decisión cambia, se escribe un ADR nuevo que supersede al viejo. Molde en
 | [0005](0005-superficie-comandos-y-stamp.md) | Superficie de comandos (`ls`/`check`/`stamp`) y contenido del stamp (branch + commit-ancla) | aceptado |
 | [0006](0006-distribucion-y-licencia.md) | Distribución (npm + fallback) y licencia (GPLv3) | aceptado |
 | [0007](0007-modelo-de-autenticacion.md) | Modelo de auth: SSH para git, tokens scopeados para forge/tracker, sin contraseñas | aceptado |
+| [0008](0008-estrategia-de-i18n.md) | Estrategia de i18n: fuente única (español) + traducciones derivadas, `DAI_LANG` en el CLI, por fases | propuesto |
+| [0009](0009-adaptador-cursor.md) | Adaptador nativo para Cursor (skills + rules) con `dai init`/`install`/`doctor` | propuesto |
 
 > Estas son las decisiones que cierran las "Decisiones abiertas" de
 > [`METODOLOGIA.md §7`](../METODOLOGIA.md) y las enmiendas al

package/index.html

@@ -208,6 +208,7 @@
   <div class="cta">
     <a class="btn p" href="#empezar">Empezar ahora</a>
     <a class="btn s" href="https://github.com/dforce2055/dai">Ver en GitHub</a>
+    <a class="btn s" href="https://www.npmjs.com/package/@dforce2055/dai">Ver en npm</a>
   </div>
   <div class="install">
     <span class="m"># instala el CLI (Node ≥18, cero dependencias)</span><br>
@@ -436,6 +437,7 @@
     <span><b style="color:var(--brand)">dai</b> — Desarrollo Asistido por IA</span>
     <span class="sp"></span>
     <a href="https://github.com/dforce2055/dai">GitHub</a>
+    <a href="https://www.npmjs.com/package/@dforce2055/dai">npm</a>
     <a href="https://github.com/dforce2055/dai/blob/main/docs/MANIFIESTO.md">Manifiesto</a>
     <a href="https://github.com/dforce2055/dai/blob/main/LICENSE">GPLv3</a>
   </div>

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@dforce2055/dai",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Metodología de desarrollo asistido por IA — CLI de acciones deterministas (trazabilidad QUÉ↔CÓMO).",
   "repository": { "type": "git", "url": "git+https://github.com/dforce2055/dai.git" },
-  "homepage": "https://github.com/dforce2055/dai#readme",
+  "homepage": "https://dforce2055.github.io/dai/",
   "bugs": { "url": "https://github.com/dforce2055/dai/issues" },
   "keywords": [
     "ai",