@dforce2055/dai 0.6.0 → 0.8.0

package/.env.example

@@ -3,7 +3,7 @@
 # Las variables ya exportadas en la shell/CI ganan sobre el .env.
 
 # ── Backend del tracker ──────────────────────────────────────────────────────
-# md | jira | clickup   (por ahora solo md está implementado)
+# md | jira | clickup
 DAI_PM=md
 
 # Plantilla del link al ticket (para `dai ls` / stamp). {id} se reemplaza.
@@ -17,8 +17,14 @@ DAI_MD_US_DIR=.dai/us
 # DAI_JIRA_BASE_URL=https://miempresa.atlassian.net
 # DAI_JIRA_EMAIL=usuario@miempresa.com
 # DAI_JIRA_TOKEN=          # ← SECRETO. api_token de id.atlassian.com. Nunca commitear.
-# DAI_JIRA_PROJECT=        # clave del proyecto (ej. PROJ) — solo para `dai publish` (crear issues)
-# DAI_JIRA_ISSUETYPE=Story # tipo de issue a crear (default Story) — solo para `dai publish`
+# DAI_JIRA_PROJECT=        # clave del PROYECTO (ej. PROJ), NO la de un ticket (PROJ-123) — para `dai publish`
+# DAI_JIRA_ISSUETYPE=Story # tipo de issue a crear (default Story). Se pisa con `dai publish --issuetype Epic`
+# DAI_JIRA_FIELDS_FILE=.dai/jira-fields.json   # campos propios que tu Jira exige al crear
+#                          # (ADR-0015). Si el archivo no existe, se ignora. Molde en templates/.
+#
+# ¿El proxy de tu empresa intercepta TLS? Node no usa el trust store del sistema, así que
+# falla donde el navegador anda. Declará la CA — NUNCA NODE_TLS_REJECT_UNAUTHORIZED=0:
+# NODE_EXTRA_CA_CERTS=/ruta/ca-empresa.pem
 
 # ── Backend clickup (REST v2) — activar con DAI_PM=clickup ───────────────────
 # DAI_CLICKUP_TOKEN=       # ← SECRETO. token personal scopeado.

package/CHANGELOG.md

@@ -3,6 +3,83 @@
 Formato basado en [Keep a Changelog](https://keepachangelog.com/). Versionado semver
 (ver `VERSION`).
 
+## [0.8.0] — 2026-07-15
+
+**El primer analista funcional real usó dai contra un Jira corporativo, y encontró el
+hueco entre "anda en mi Jira de juguete" y "anda en el de una empresa".**
+
+### Agregado
+- **Campos propios de Jira**, declarados por issuetype en `.dai/jira-fields.json` (o
+  `DAI_JIRA_FIELDS_FILE`) con nombre humano, forma, default y opciones válidas. dai valida
+  **antes** de llamar a la red: un typo da `'Mejraa' no es opción de 'clasificacion' —
+  válidas: Mejora | Corrección`, no un 400 críptico. El valor se elige por US con
+  `dai publish us.md --field clasificacion=Corrección` (repetible), porque la clasificación
+  cambia según la historia y un default fijo publicaría todas iguales ([ADR-0015](docs/adr/0015-jira-corporativo.md)).
+- `dai publish --parent <KEY>` — cuelga la US de su épica (antes `createUS` nunca mandaba
+  `parent`, así que las US quedaban sueltas).
+- `dai publish --issuetype <T>` — **`grill-epic` gana su fallback por CLI**: hasta ahora, sin
+  MCP, una épica quedaba en un `.md` para pegar a mano.
+- **Diagnóstico de TLS**: un fallo de certificado ahora enseña `NODE_EXTRA_CA_CERTS` (el caso
+  típico es el proxy corporativo: Node no usa el trust store del sistema) y explica por qué
+  `NODE_TLS_REJECT_UNAUTHORIZED=0` no es una alternativa — apaga la verificación entera y por
+  ahí viaja tu token.
+- **Constitución**: dos reglas nuevas para todos los asistentes — no bajar la seguridad para
+  avanzar, y parar y avisar si el CLI no llega en vez de improvisar la llamada por fuera.
+
+### Cambiado
+- **Copilot lee `SKILL.md` nativo** ([ADR-0014](docs/adr/0014-copilot-agent-skills.md)).
+  `dai init --for copilot` genera `.github/skills/` (copia cruda, **con los `templates/`**) en
+  vez de `.github/prompts/*.prompt.md`, y borra los prompts viejos de dai para que no dupliquen
+  cada `/comando`. Los prompt files propios del equipo no se tocan.
+- **`dai skills install --for copilot` ya existe** → `~/.copilot/skills/`. Antes warneaba
+  *"Copilot no tiene skills instalables"*: era cierto hasta que GitHub adoptó Agent Skills, y
+  por eso una skill "instalada global" no le aparecía a nadie que usara la app o el CLI de
+  Copilot (`~/.claude/skills` solo lo mira VS Code).
+- **`dai doctor` reporta solo los asistentes que el repo usa.** Antes listaba los tres siempre:
+  quien configuraba uno veía 14 warnings de los otros dos y leía "está todo roto". Ahora
+  también chequea Copilot, valida `DAI_JIRA_PROJECT` y que el archivo de campos parsee.
+- **Un flag repetido acumula** (`--field a=1 --field b=2`) en vez de que gane el último en
+  silencio.
+
+### Arreglado
+- **`doc-to-backlog` y `grill-epic` no cargaban en Copilot.** Sus descripciones tenían un `: `
+  suelto (*"…épicas finales: extrae…"*), que un parser YAML lee como el arranque de un mapa y
+  descarta la skill entera — justo las dos que más necesita un analista funcional. El defecto
+  siempre estuvo en la fuente: lo tapaban nuestro `parseFrontmatter` (que es un regex, no YAML)
+  y la conversión a `.prompt.md` (que citaba el valor al serializarlo). Ahora las 7
+  descripciones van citadas, **`validateSkill` valida que `name` y `description` sean escalares
+  YAML válidos**, y el molde de `templates/skill.md` cita por defecto.
+- `DAI_JIRA_PROJECT=PROJ-42` (la clave de un **ticket**, el error de config más común) daba
+  un 400 de Jira que no lo explicaba. Ahora falla **antes de la red**, con los dos caminos:
+  `DAI_JIRA_PROJECT=PROJ`, o `--parent PROJ-42` si querías colgarla de esa épica.
+
+### Quitado
+- `skillToPrompt()` y el adaptador `.github/prompts/` de Copilot. Cuando el formato de una
+  skill es un estándar abierto, el mejor adaptador es ninguno.
+
+### Interno
+- **158 tests** (+39 desde 0.7.0): `jira-fields` ×19, `http`/TLS ×7, contrato YAML del
+  frontmatter ×7, `assertProjectKey` y el payload de `createUS` ×6.
+- **Primera verificación en Windows.** Hasta ahora dai no se había instalado nunca en Windows
+  (no hay CI de esa plataforma): se probó el ciclo completo — install, `dai init --for copilot`,
+  skills globales en `~/.copilot/skills`, y Copilot cargando las 7. Los campos propios de Jira
+  y el diagnóstico de TLS están cubiertos por tests contra un Jira simulado, **todavía no
+  contra un Jira corporativo real**.
+- `lib/jira-fields.mjs` y `lib/http.mjs` nuevos, cero dependencias (como el resto del CLI).
+
+## [0.7.0] — 2026-07-14
+
+**dai es el distribuidor de skills de cualquier stack, sin opinar sobre su contenido.**
+
+### Agregado
+- `dai skills install` — namespace de skills (`dai install` queda como alias). Con
+  `--from <git-url|path>[#ref]` instala **skills externas** por-stack (.NET, Java,
+  Rust…) desde un repo git (público o privado por SSH) o un path local, convertidas
+  para los 3 asistentes (Claude/Cursor/Copilot).
+  Self-service, one-off, sin registro; `dai sync` no las toca ([ADR-0013](docs/adr/0013-skills-externas-install-from.md)).
+  Valida el contrato mínimo (`SKILL.md` con `name` + `description`) y saltea con aviso
+  las malformadas; molde en [`templates/skill.md`](templates/skill.md). No valida el contenido.
+
 ## [0.6.0] — 2026-07-12
 
 Self-update del CLI y blindaje de autoría del repo.
@@ -181,6 +258,8 @@ 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.8.0]: https://github.com/dforce2055/dai/releases/tag/v0.8.0
+[0.7.0]: https://github.com/dforce2055/dai/releases/tag/v0.7.0
 [0.6.0]: https://github.com/dforce2055/dai/releases/tag/v0.6.0
 [0.5.0]: https://github.com/dforce2055/dai/releases/tag/v0.5.0
 [0.4.0]: https://github.com/dforce2055/dai/releases/tag/v0.4.0

package/README.md

@@ -49,7 +49,7 @@ deja las skills disponibles:
 
 ```bash
 npm i -g @dforce2055/dai        # el CLI
-dai install                     # skills de IA → Claude y Cursor (global por defecto)
+dai skills install              # skills de IA → Claude y Cursor (global por defecto)
 ```
 
 Y después, en el chat del asistente, según lo que tengas:
@@ -157,8 +157,10 @@ flowchart TD
 | Comando | Qué hace |
 |---|---|
 | `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 skills install [--global \| --local <repo>] [--force] [--dry-run] [--for claude\|cursor\|all]` | instala/actualiza las skills de dai en Claude y/o Cursor (`--for all` por defecto). `--force` re-copia. Alias: **`dai install`**. Ej: `dai skills install --local . --for cursor --force` |
+| `dai skills install --from <git-url\|path>[#ref] [--for …]` | instala **skills externas** (por-stack: .NET, Java, …) desde un repo/dir, **convertidas para los 3 asistentes**. Self-service, one-off, sin registro; `dai sync` no las toca. Colisión con una skill de dai → salta ([ADR-0013](docs/adr/0013-skills-externas-install-from.md)). Ej: `dai skills install --from github.com/mi-org/net-skills` |
 | `dai sync [--dry-run] [--for <asistentes>]` | **refresca** skills, constitución, templates y PR template a la versión del CLI — **aditivo** (no pisa tu `CLAUDE.md`), no toca el `.env` ni OpenSpec. Detecta los asistentes del repo o pasás `--for`. `--dry-run` muestra qué cambiaría ([ADR-0010](docs/adr/0010-versionado-y-upgrade.md)) |
+| `dai upgrade [--check] [--dry-run]` · alias `dai update` | **actualiza el CLI global** a la última publicada (`npm i -g …@latest`) — self-update. **No toca el repo**: reporta el drift del scaffold pero deja el `dai sync` al mantenedor. `--check` solo informa · `--dry-run` muestra el comando ([ADR-0012](docs/adr/0012-upgrade-self-update-del-cli.md)) |
 | `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) |
@@ -173,12 +175,33 @@ flowchart TD
 | `dai doctor` · `dai docs <dest>` · `dai version` | diagnóstico del entorno (incluye **version-drift** del scaffold) · copiar la doc · versión (`dai version` avisa si tu repo quedó atrás) |
 
 > **🆕 Mantené tu repo al día — `dai sync`.** Las skills, la constitución y los templates son un
-> *caché derivable* del CLI. Cuando actualizás `dai` (`npm i -g @dforce2055/dai`), **`dai doctor` y
+> *caché derivable* del CLI. Cuando actualizás `dai` (`dai upgrade`), **`dai doctor` y
 > `dai version` te avisan solos** si tu scaffold quedó atrás — con color y un `⬆️` —, y **`dai sync`**
 > lo refresca: **aditivo** (conserva tu `CLAUDE.md` propio), sin tocar el `.env` ni OpenSpec. Probá sin
 > riesgo con `dai sync --dry-run`. El versionado es semver: patch/minor no rompen nada; solo un major
 > pediría migración. ([ADR-0010](docs/adr/0010-versionado-y-upgrade.md))
 
+> **🧩 Skills de cualquier stack — `dai skills install --from`.** Además de las skills de
+> dai, cada equipo suma las suyas (por-stack: .NET, Java, Rust…) desde su propio repo:
+> `dai skills install --from github.com/tu-org/net-skills`. dai las **convierte para los 3
+> asistentes** (Claude/Cursor/Copilot) e instala. **dai es el distribuidor de skills de
+> cualquier stack, sin opinar sobre su contenido** — self-service, sin registro; `dai sync`
+> sigue siendo solo de dai. ([ADR-0013](docs/adr/0013-skills-externas-install-from.md))
+>
+> La fuente puede ser **pública, privada (por SSH) o un path local**: dai no hace auth
+> propia, delega en git — **si podés `git clone` el repo, dai instala desde ahí**. Para
+> privados usá la forma SSH (`git@github.com:tu-org/net-skills.git`), consistente con el
+> modelo de auth de dai ([ADR-0007](docs/adr/0007-modelo-de-autenticacion.md)). Público =
+> cero fricción entre equipos/máquinas.
+>
+> **Cómo armar una skill que dai ingiera.** Cada skill es un directorio con un `SKILL.md`
+> en **formato Agent Skills de Claude**: frontmatter con **`name`** y **`description`**
+> (obligatorios) + el cuerpo con las instrucciones. dai **valida ese contrato**: si a un
+> `SKILL.md` le falta `name`/`description`, o un dir no tiene `SKILL.md`, lo **saltea con
+> un warn** (no instala una skill rota). El **contenido** no lo valida — bajo tu criterio.
+> Molde: [`templates/skill.md`](templates/skill.md) · ejemplos reales: las skills de dai
+> en [`skills/`](skills/).
+
 Skills (se invocan en el asistente): `/doc-to-backlog` · `/grill-intent` · `/grill-epic` · `/grill-user-story` · `/link-us` ·
 `/tdd` · `/dai-review`. Config del tracker (`md`\|`jira`\|`clickup`) y tokens: en `.env` —
 ver [`.env.example`](.env.example). Auth (SSH + tokens): [ADR-0007](docs/adr/0007-modelo-de-autenticacion.md).
@@ -243,12 +266,18 @@ 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 |
-
-El analista sin IDE cierra con **Claude Desktop**; con Copilot necesita **VS Code o el Copilot
-CLI**. El CLI `dai` corre en cualquier terminal, con cualquier asistente o ninguno.
+| **Copilot app / CLI** | ✅ | `~/.copilot/skills/` (global) + `.github/skills/` del repo |
+| **Copilot en VS Code / JetBrains** | ✅ | ídem (modo agente) |
+| **Copilot code review · cloud agent** | ✅ | `.github/skills/` del repo |
+| **Chat de github.com** | ❌ | no carga skills |
+
+**El analista no necesita IDE**: cierra el ciclo con **Claude Desktop** o con la **app / CLI de
+Copilot**. El CLI `dai` corre en cualquier terminal, con cualquier asistente o ninguno.
+
+> Copilot lee el `SKILL.md` **tal cual**, sin conversión ([ADR-0014](docs/adr/0014-copilot-agent-skills.md)).
+> Si vienes de dai ≤ 0.7, corre `dai init --for copilot` una vez: cambia los
+> `.github/prompts/*.prompt.md` por `.github/skills/` (con los `templates/`, que antes se
+> perdían) y limpia los viejos para que no te dupliquen cada `/comando`.
 
 ## Se adapta a cualquier escala
 

package/VERSION

@@ -1 +1 @@
-0.6.0
+0.8.0

package/cli/dai.mjs

@@ -27,9 +27,12 @@ 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, parseAssistants, isAssistantToken } from "./lib/args.mjs";
+import { parseFlags, parseAssistants, isAssistantToken, asList } from "./lib/args.mjs";
 import { versionDrift, planUpgrade } from "./lib/semver.mjs";
-import { skillToPrompt, skillToCursor, constitution, constitutionCursorRule, envFor, mergeEnv, upsertBlock, reconcileGitignore } from "./lib/bootstrap.mjs";
+import { parseSource } from "./lib/skills-source.mjs";
+import { skillToCursor, validateSkill, constitution, constitutionCursorRule, envFor, mergeEnv, upsertBlock, reconcileGitignore, stalePromptFiles } from "./lib/bootstrap.mjs";
+import { parseFieldsFile, parseFieldOverrides, resolveJiraFields } from "./lib/jira-fields.mjs";
+import { assertProjectKey } from "./lib/pm-jira.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
@@ -47,6 +50,9 @@ const C = { y: (m) => paint("33", m), r: (m) => paint("31", m), cy: (m) => paint
 const ROOT = join(HERE, "..");            // raíz del paquete dai (cli/ está adentro)
 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");
+// Copilot lee las skills personales de ~/.copilot/skills (NO de ~/.claude/skills, que
+// solo mira VS Code). Por eso una skill "instalada global" no le aparecía (ADR-0014).
+const COPILOT_SKILLS_DIR = process.env.COPILOT_SKILLS_DIR || join(homedir(), ".copilot", "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.
@@ -237,16 +243,45 @@ async function cmdForge(sub, ref, opts) {
 }
 
 // ── publish: crea la US en el tracker desde un .md (fallback del MCP) ──────────
-async function cmdPublish(file) {
-  if (!file) fail("uso: dai publish <archivo-us.md>", 1);
+
+// Los campos propios que exige el proyecto, declarados en .dai/jira-fields.json
+// (o donde apunte DAI_JIRA_FIELDS_FILE). Sin archivo → {}: un Jira sin campos
+// obligatorios publica igual que siempre.
+function loadJiraFieldsSpec() {
+  const path = process.env.DAI_JIRA_FIELDS_FILE || join(".dai", "jira-fields.json");
+  if (!existsSync(path)) return {};
+  return parseFieldsFile(readFileSync(path, "utf8"), path);
+}
+
+async function cmdPublish(file, opts = {}) {
+  if (!file) fail("uso: dai publish <archivo-us.md> [--parent KEY] [--issuetype T] [--field alias=valor]", 1);
   loadEnv();
   const md = readFileSync(file, "utf8");
   const title = extractTitle(md);
   if (!title) fail("no pude extraer el título de la US (falta un '# Título').", 1);
   const adapter = getAdapter(process.env);
   if (typeof adapter.createUS !== "function") fail(`el backend '${adapter.kind}' no soporta crear US.`, 1);
-  const r = await adapter.createUS({ title, descriptionMarkdown: md });
+
+  const parent = typeof opts.parent === "string" ? opts.parent : undefined;
+  const issuetype = typeof opts.issuetype === "string" ? opts.issuetype : undefined;
+  const project = typeof opts.project === "string" ? opts.project : undefined;
+
+  // Los campos propios son cosa de Jira; los otros backends no los usan.
+  let fields;
+  if (adapter.kind === "jira") {
+    const type = issuetype || process.env.DAI_JIRA_ISSUETYPE || "Story";
+    fields = resolveJiraFields({
+      spec: loadJiraFieldsSpec(),
+      issuetype: type,
+      overrides: parseFieldOverrides(asList(opts.field)),
+    });
+  } else if (opts.field !== undefined) {
+    fail(`--field es solo para jira (DAI_PM=${adapter.kind}).`, 2);
+  }
+
+  const r = await adapter.createUS({ title, descriptionMarkdown: md, parent, issuetype, project, fields });
   ok(`US publicada en ${adapter.kind}: ${r.id}${r.url ? `  →  ${r.url}` : ""}`);
+  if (parent) info(`colgada de ${parent}`);
   info(`Próximo paso (el dev abre el CÓMO):  dai link-us ${r.id}`);
 }
 
@@ -416,17 +451,15 @@ async function cmdPr(opts) {
 
 // ── install: skills → ~/.claude/skills o <repo>/.claude/skills ────────────────
 async function cmdInstall(opts) {
+  if (opts.from !== undefined) return cmdInstallFrom(opts);   // skills externas (ADR-0013)
   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 wantClaude = want.claude, wantCursor = want.cursor, wantCopilot = want.copilot;
+  if (!wantClaude && !wantCursor && !wantCopilot) fail("nada para instalar: pasá --for claude|copilot|cursor|all.");
+  const installFor = [wantClaude && "claude", wantCopilot && "copilot", 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;
 
@@ -437,17 +470,21 @@ async function cmdInstall(opts) {
     return a === "l" ? { scope: "local", repo: process.cwd() } : a === "s" ? { scope: "skip" } : { scope: "global" };
   };
 
+  // Cada asistente tiene SU dir: Claude ~/.claude/skills · Copilot ~/.copilot/skills
+  // (ADR-0014) · Cursor ~/.cursor/skills. Local, el de Copilot es .github/skills.
+  const LOCAL_DIR = { claude: [".claude", "skills"], copilot: [".github", "skills"], cursor: [".cursor", "skills"] };
+  const GLOBAL_DIR = { claude: CLAUDE_SKILLS_DIR, copilot: COPILOT_SKILLS_DIR, cursor: CURSOR_SKILLS_DIR };
+
   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 targetDir = scope === "local" ? join(repo, ...LOCAL_DIR[kind]) : GLOBAL_DIR[kind];
     const target = join(targetDir, name);
-    const label = kind === "cursor" ? `${name} (cursor)` : `${name} (claude)`;
+    const label = `${name} (${kind})`;
 
     let sameAsSource = false;
     if (existsSync(target)) {
-      if (kind === "claude") {
+      if (kind !== "cursor") {
+        // claude y copilot son copia cruda del SKILL.md: comparación directa.
         sameAsSource = dirsEqual(src, target);
       } else {
         const tempRoot = mkdtempSync(join(tmpdir(), "dai-cursor-skill-"));
@@ -484,11 +521,95 @@ async function cmdInstall(opts) {
     const { scope, repo } = await scopeFor(name);
     if (scope === "skip") { warn(`salto ${name}`); continue; }
     if (wantClaude) await installOne({ name, scope, repo, kind: "claude" });
+    if (wantCopilot) await installOne({ name, scope, repo, kind: "copilot" });
     if (wantCursor) await installOne({ name, scope, repo, kind: "cursor" });
   }
   if (rl) rl.close();
 }
 
+// ── skills install --from: skills EXTERNAS (por-stack) desde un repo/dir ───────
+// Self-service, one-off, sin registro ni sync (ADR-0013). Convierte cada skill
+// para los 3 asistentes y la instala en el repo. No pisa las skills built-in de
+// dai (colisión → warn + skip). `dai sync` NO las toca: es solo de dai.
+function cmdInstallFrom(opts) {
+  if (typeof opts.from !== "string" || !opts.from.trim())
+    fail("--from necesita una fuente: un git URL (github.com/org/skills[#ref]) o un path local", 2);
+  let want;
+  try { want = parseAssistants(typeof opts.for === "string" ? opts.for : "all"); }
+  catch (e) { fail(`--for ${e.message}`); }
+
+  let src;
+  try { src = parseSource(opts.from); } catch (e) { fail(`--from ${e.message}`, 2); }
+
+  // Resolver la fuente a un directorio local.
+  let root, tmp = null;
+  if (src.type === "git") {
+    tmp = mkdtempSync(join(tmpdir(), "dai-skills-"));
+    info(`clonando ${src.location}${src.ref ? " @ " + src.ref : ""} …`);
+    const args = ["clone", "--depth", "1"];
+    if (src.ref) args.push("--branch", src.ref);
+    args.push(src.location, tmp);
+    try { git(args); }
+    catch (e) { rmSync(tmp, { recursive: true, force: true }); fail(`no pude clonar la fuente: ${String(e.message).split("\n")[0]}`, 1); }
+    root = tmp;
+  } else {
+    root = src.location;
+    if (!existsSync(root)) fail(`no existe la fuente: ${root}`, 2);
+  }
+
+  const cleanup = () => { if (tmp) rmSync(tmp, { recursive: true, force: true }); };
+
+  // El dir de skills: <root>/skills, o <root> si ya contiene <name>/SKILL.md.
+  const skillsDir = existsSync(join(root, "skills")) ? join(root, "skills") : root;
+  let entries;
+  try {
+    entries = readdirSync(skillsDir).filter((n) => {
+      try { return statSync(join(skillsDir, n)).isDirectory(); } catch { return false; }
+    });
+  } catch { cleanup(); fail(`no pude leer la fuente: ${skillsDir}`, 2); }
+  if (entries.length === 0) { cleanup(); fail("la fuente no tiene directorios de skill", 2); }
+
+  // Destino: repo local (default cwd), o --local <repo> / --global.
+  const repo = opts.global ? homedir() : (typeof opts.local === "string" ? opts.local : process.cwd());
+  const builtins = new Set(readdirSync(join(ROOT, "skills")));
+  const forStr = ["claude", "copilot", "cursor"].filter((a) => want[a]).join("+");
+  info(`skills install --from ${opts.from}  ·  ${entries.length} candidata(s)  ·  asistentes: ${forStr}${opts.dryRun ? "  [dry-run]" : ""}`);
+
+  let installed = 0, skipped = 0;
+  for (const name of entries) {
+    const srcDir = join(skillsDir, name);
+    const skillPath = join(srcDir, "SKILL.md");
+    // Validación estructural (contrato mínimo, no contenido — ADR-0013).
+    if (!existsSync(skillPath)) { warn(`'${name}' no tiene SKILL.md — salto`); skipped++; continue; }
+    if (builtins.has(name)) { warn(`'${name}' choca con una skill de dai — salto (renombrala, p.ej. ${name}-<stack>)`); skipped++; continue; }
+    const md = readFileSync(skillPath, "utf8");
+    const bad = validateSkill(md);
+    if (bad) { warn(`'${name}' inválida: ${bad} — salto (ver templates/skill.md)`); skipped++; continue; }
+    if (opts.dryRun) { info(`[dry-run] ${name} → ${forStr}`); continue; }
+    if (want.claude) {
+      const t = join(repo, ".claude", "skills", name);
+      rmSync(t, { recursive: true, force: true }); mkdirSync(dirname(t), { recursive: true }); cpSync(srcDir, t, { recursive: true });
+    }
+    if (want.cursor) {
+      const t = join(repo, ".cursor", "skills", name);
+      rmSync(t, { recursive: true, force: true }); cpSync(srcDir, t, { recursive: true }); writeFileSync(join(t, "SKILL.md"), skillToCursor(md));
+    }
+    if (want.copilot) {
+      const pdir = join(repo, ".github", "prompts"); mkdirSync(pdir, { recursive: true });
+      writeFileSync(join(pdir, `${name}.prompt.md`), skillToPrompt(md));
+    }
+    ok(name); installed++;
+  }
+  cleanup();
+  if (opts.dryRun) { info("dry-run: nada escrito."); return; }
+  process.stdout.write("\n");
+  if (installed === 0) {
+    fail(`0 skills instaladas${skipped ? ` (${skipped} salteada(s))` : ""} — revisá el formato: cada skill es un dir con SKILL.md y frontmatter (name + description). Molde en templates/skill.md`, 1);
+  }
+  ok(`${installed} skill(s) externa(s) instalada(s)${skipped ? `, ${skipped} salteada(s)` : ""} desde ${opts.from}`);
+  warn("skills externas — bajo tu criterio: dai las convierte e instala, no las vetea ni las trackea. `dai sync` no las toca.");
+}
+
 // ── helpers de prompt interactivo ─────────────────────────────────────────────
 async function askMenu(rl, title, choices, def) {
   process.stdout.write(`\n  ${title}\n`);
@@ -607,12 +728,20 @@ async function cmdInit(repo, opts) {
     ok(`Claude:       .claude/skills/ (${skills.length}) + CLAUDE.md${cCur ? " (bloque dai, aditivo)" : ""} → conoce el método y las skills`);
   }
   if (wantCopilot) {
-    const pdir = join(repo, ".github", "prompts");
-    mkdirSync(pdir, { recursive: true });
-    for (const name of skills) writeFileSync(join(pdir, `${name}.prompt.md`), skillToPrompt(readFileSync(join(skillsSrc, name, "SKILL.md"), "utf8")));
+    // Copilot lee SKILL.md nativo (Agent Skills, ADR-0014): copia cruda, sin convertir.
+    // Así viajan también los templates/ que la conversión a .prompt.md perdía.
+    const dir = join(repo, ".github", "skills");
+    mkdirSync(dir, { recursive: true });
+    for (const name of skills) cpSync(join(skillsSrc, name), join(dir, name), { recursive: true });
     const ciPath = join(repo, ".github", "copilot-instructions.md"), ciCur = existsSync(ciPath) ? readFileSync(ciPath, "utf8") : "";
     writeFileSync(ciPath, upsertBlock(ciCur, constitution("copilot")));
-    ok(`Copilot:      .github/prompts/ (${skills.length}) + copilot-instructions.md${ciCur ? " (bloque dai, aditivo)" : ""}`);
+    ok(`Copilot:      .github/skills/ (${skills.length}) + copilot-instructions.md${ciCur ? " (bloque dai, aditivo)" : ""}`);
+    // Los .prompt.md de versiones previas duplicarían cada /comando con una copia
+    // vieja y sin templates. Solo borramos los que generó dai, nunca los del equipo.
+    const pdir = join(repo, ".github", "prompts");
+    const stale = existsSync(pdir) ? stalePromptFiles(skills).filter((f) => existsSync(join(pdir, f))) : [];
+    for (const f of stale) rmSync(join(pdir, f), { force: true });
+    if (stale.length) info(`              quité ${stale.length} .prompt.md viejo(s) de .github/prompts/ — ahora son skills`);
   }
   if (wantCursor) {
     const dir = join(repo, ".cursor", "skills");
@@ -864,35 +993,52 @@ function cmdDoctor() {
   loadEnv();
   info(`dai doctor — versión v${readFileSync(join(ROOT, "VERSION"), "utf8").trim()}`);
 
-  // Una skill sirve si está en el repo actual (.claude/skills, la puso `dai init`)
-  // O global (~/.claude/skills, la puso `dai install`). Reportamos dónde.
+  // Una skill sirve si está en el repo actual (la puso `dai init`) o global (la puso
+  // `dai install`). Reportamos dónde — y SOLO de los asistentes que este repo usa: antes
+  // se listaban los tres siempre, así que quien configuró uno veía 14 warnings de los
+  // otros dos y leía "está todo roto" cuando estaba todo bien.
   const skillsRoot = join(ROOT, "skills");
   const skillNames = readdirSync(skillsRoot).filter((n) => statSync(join(skillsRoot, n)).isDirectory());
-  const localDir = join(process.cwd(), ".claude", "skills");
-  info("skills (repo local / global ~/.claude/skills):");
-  for (const name of skillNames) {
-    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 skillNames) {
-    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)");
+  const cwd = process.cwd();
+  const ASSISTANTS = [
+    { kind: "claude",  label: "Claude",  local: join(cwd, ".claude", "skills"),  global: CLAUDE_SKILLS_DIR,  home: "~/.claude/skills" },
+    { kind: "copilot", label: "Copilot", local: join(cwd, ".github", "skills"),  global: COPILOT_SKILLS_DIR, home: "~/.copilot/skills" },
+    { kind: "cursor",  label: "Cursor",  local: join(cwd, ".cursor", "skills"),  global: CURSOR_SKILLS_DIR,  home: "~/.cursor/skills" },
+  ];
+  const present = (a) => skillNames.some((n) => existsSync(join(a.local, n)) || existsSync(join(a.global, n)));
+  const active = ASSISTANTS.filter(present);
+
+  if (active.length === 0) {
+    warn("no encontré skills de dai para ningún asistente.");
+    process.stdout.write("    En un repo:  dai init --for claude|copilot|cursor|all\n");
+    process.stdout.write("    O global:    dai install --for all\n");
+  }
+  for (const a of active) {
+    info(`skills ${a.label} (repo local / global ${a.home}):`);
+    for (const name of skillNames) {
+      const local = existsSync(join(a.local, name)), global = existsSync(join(a.global, 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} — falta para ${a.label} (dai init --for ${a.kind}, o dai install --for ${a.kind})`);
+    }
+  }
+  if (active.some((a) => a.kind === "copilot")) {
+    const ci = join(cwd, ".github", "copilot-instructions.md");
+    existsSync(ci) ? ok("constitución Copilot (.github/copilot-instructions.md)") : warn("falta la constitución de Copilot (dai init --for copilot)");
+    // Los .prompt.md viejos duplican cada /comando con una copia sin templates.
+    const pdir = join(cwd, ".github", "prompts");
+    const stale = existsSync(pdir) ? stalePromptFiles(skillNames).filter((f) => existsSync(join(pdir, f))) : [];
+    if (stale.length) warn(`${stale.length} .prompt.md viejo(s) en .github/prompts/ — duplican las skills. Corré \`dai init --for copilot\` para limpiarlos.`);
+  }
+  if (active.some((a) => a.kind === "cursor")) {
+    const localRule = join(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";
@@ -900,9 +1046,24 @@ function cmdDoctor() {
   if (pm === "jira") {
     if (!process.env.DAI_JIRA_BASE_URL) warn("falta DAI_JIRA_BASE_URL en el .env");
     if (!process.env.DAI_JIRA_EMAIL) warn("falta DAI_JIRA_EMAIL en el .env");
-    if (!process.env.DAI_JIRA_TOKEN) warn("falta DAI_JIRA_TOKEN en el .env"); else ok("token de Jira presente");
-    process.env.DAI_JIRA_PROJECT ? ok(`proyecto=${process.env.DAI_JIRA_PROJECT} (para dai publish)`)
-      : warn("DAI_JIRA_PROJECT vacío — solo hace falta para `dai publish` (crear issues)");
+    // Ojo: solo miramos que el token ESTÉ, no que sirva — uno vencido pasa este chequeo
+    // y recién falla al publicar. Verificarlo de verdad es pegarle a la red.
+    if (!process.env.DAI_JIRA_TOKEN) warn("falta DAI_JIRA_TOKEN en el .env"); else ok("token de Jira presente (no verificado: eso lo dice `dai publish`)");
+    if (!process.env.DAI_JIRA_PROJECT) warn("DAI_JIRA_PROJECT vacío — solo hace falta para `dai publish` (crear issues)");
+    else {
+      try { ok(`proyecto=${assertProjectKey(process.env.DAI_JIRA_PROJECT)} (para dai publish)`); }
+      catch (e) { warn(String(e.message)); }
+    }
+    // Campos propios del proyecto: que el archivo parsee ANTES de necesitarlo.
+    const fpath = process.env.DAI_JIRA_FIELDS_FILE || join(".dai", "jira-fields.json");
+    if (!existsSync(fpath)) info(`sin campos propios declarados (${fpath} no existe — normal si tu Jira no los exige)`);
+    else {
+      try {
+        const spec = parseFieldsFile(readFileSync(fpath, "utf8"), fpath);
+        const types = Object.keys(spec);
+        ok(`campos propios: ${fpath} — issuetypes: ${types.length ? types.join(", ") : "(ninguno)"}`);
+      } catch (e) { warn(String(e.message)); }
+    }
   }
   if (pm === "clickup") {
     if (!process.env.DAI_CLICKUP_TOKEN) warn("falta DAI_CLICKUP_TOKEN en el .env"); else ok("token de ClickUp presente");
@@ -931,11 +1092,15 @@ switch (cmd) {
   case "check":   cmdCheck().catch((e) => fail(String(e.message))); break;
   case "stamp":   cmdStamp().catch((e) => fail(String(e.message))); break;
   case "forge":   cmdForge(pos[0], pos[1], opts).catch((e) => fail(String(e.message))); break;
-  case "publish": cmdPublish(pos[0]).catch((e) => fail(String(e.message))); break;
+  case "publish": cmdPublish(pos[0], opts).catch((e) => fail(String(e.message))); break;
   case "pr":      cmdPr(opts).catch((e) => fail(String(e.message))); break;
   case "done":    cmdDone(opts); break;
   case "archive": cmdArchive(pos[0], opts); break;
-  case "install": cmdInstall(opts).catch((e) => fail(String(e.message))); break;
+  case "install": cmdInstall(opts).catch((e) => fail(String(e.message))); break;   // alias de `dai skills install`
+  case "skills":
+    if (pos[0] === "install" || pos[0] === undefined) cmdInstall(opts).catch((e) => fail(String(e.message)));
+    else fail(`subcomando de skills desconocido: '${pos[0]}' (por ahora: install)`, 2);
+    break;
   case "init":    cmdInit(pos[0], opts).catch((e) => fail(String(e.message))); break;
   case "sync":    cmdSync(pos[0], opts); break;
   case "upgrade":
@@ -950,6 +1115,8 @@ switch (cmd) {
       "  ac-hash <us.md>              calcula el ac_hash (ADR-0001)\n" +
       "  ls [--json]                  lista lo que implementa el repo (ADR-0005)\n" +
       "  publish <us.md>              crea la US en el tracker (Jira/ClickUp/md) y devuelve el key\n" +
+      "      [--parent KEY]           la cuelga de su épica · [--issuetype T] p. ej. Epic\n" +
+      "      [--field alias=valor]    campos propios que exige tu Jira (.dai/jira-fields.json); repetible\n" +
       "  link-us <KEY> [--us <md>]    crea branch + implements.yaml; sin --us trae la US del tracker (ADR-0004)\n" +
       "  link-us <KEY> --resync       re-estampa el ac_hash contra la US viva (tras un ⚠️ de check)\n" +
       "  check                        compara vs la US viva → atrasado (ADR-0003)\n" +
@@ -959,7 +1126,8 @@ 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] [--for <asistentes>]   skills → Claude/Cursor\n" +
+      "  skills install [--global | --local <repo>] [--force] [--dry-run] [--for <asistentes>]   instala las skills de dai (alias: `install`)\n" +
+      "  skills install --from <git-url|path>[#ref] [--for <asistentes>]   instala skills EXTERNAS (por-stack), convertidas para los 3 asistentes (ADR-0013)\n" +
       "  init [<repo>]                scaffolder interactivo del repo (asistente, gestor, OpenSpec)\n" +
       "       --for <asistentes>      claude|copilot|cursor (combinables con coma) · o both|all (default all)\n" +
       "                               ej: --for claude,cursor · --for copilot · --for all\n" +

package/cli/lib/args.mjs

@@ -28,6 +28,17 @@ export function parseAssistants(str) {
   return want;
 }
 
+// Un flag REPETIDO acumula en lista en vez de pisarse (`--field a=1 --field b=2`).
+// Antes ganaba el último en silencio, que para --field sería perder datos sin avisar.
+const push = (opts, key, val) => {
+  if (!(key in opts)) { opts[key] = val; return; }
+  if (Array.isArray(opts[key])) opts[key].push(val);
+  else opts[key] = [opts[key], val];
+};
+
+// Normaliza un flag que puede venir 0, 1 o N veces → siempre lista.
+export const asList = (v) => (v === undefined ? [] : Array.isArray(v) ? v : [v]);
+
 export function parseFlags(argv) {
   const opts = {};
   const pos = [];
@@ -36,8 +47,8 @@ export function parseFlags(argv) {
     if (a.startsWith("--")) {
       const key = camel(a.slice(2));
       const next = argv[i + 1];
-      if (next !== undefined && !next.startsWith("--")) { opts[key] = next; i++; }
-      else opts[key] = true;                 // flag booleano
+      if (next !== undefined && !next.startsWith("--")) { push(opts, key, next); i++; }
+      else push(opts, key, true);            // flag booleano
     } else {
       pos.push(a);
     }