@dforce2055/dai 0.7.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,70 @@
 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.**
@@ -194,6 +258,7 @@ 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

package/README.md

@@ -266,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.7.0
+0.8.0

package/cli/dai.mjs

@@ -27,10 +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 { parseSource } from "./lib/skills-source.mjs";
-import { skillToPrompt, skillToCursor, validateSkill, constitution, constitutionCursorRule, envFor, mergeEnv, upsertBlock, reconcileGitignore } from "./lib/bootstrap.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));
 
@@ -48,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.
@@ -238,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}`);
 }
 
@@ -423,12 +457,9 @@ async function cmdInstall(opts) {
   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;
 
@@ -439,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-"));
@@ -486,6 +521,7 @@ 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();
@@ -692,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");
@@ -949,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 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");
   }
-
-  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)`);
+  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)");
   }
-  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";
@@ -985,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");
@@ -1016,7 +1092,7 @@ 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;
@@ -1039,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" +

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);
     }

package/cli/lib/bootstrap.mjs

@@ -4,40 +4,78 @@
 
 const REPO_URL = "https://github.com/dforce2055/dai";
 
+// Un escalar YAML "plano" (sin comillas) no puede contener `: ` ni ` #`, ni empezar con
+// un indicador: YAML lo leería como un mapa, un comentario o una estructura.
+//
+// Esto importa porque el parser de acá es un regex, no YAML — se traga cualquier cosa.
+// Mientras dai CONVERTÍA el SKILL.md para Copilot y Cursor, el `JSON.stringify` de la
+// conversión citaba el valor y tapaba el problema sin querer. Al entregar el SKILL.md
+// crudo (ADR-0014) lo lee un parser YAML de verdad, y ahí una descripción con un `: `
+// suelto tira abajo la skill entera. Le pasó a `doc-to-backlog` y a `grill-epic`.
+const YAML_INDICATORS = /^[-?:,[\]{}#&*!|>'"%@`]/;
+export function yamlScalarIssue(raw) {
+  const v = String(raw ?? "").trim();
+  if (v === "") return "está vacío";
+  const quoted = (v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"));
+  if (quoted && v.length >= 2) return null;      // citado: YAML acepta lo que sea adentro
+  if (v.includes(": ")) return "contiene ': ' sin comillas (YAML lo lee como un mapa)";
+  if (v.includes(" #")) return "contiene ' #' sin comillas (YAML lo lee como un comentario)";
+  if (YAML_INDICATORS.test(v)) return `empieza con '${v[0]}', que YAML reserva`;
+  return null;
+}
+
+// El valor crudo de una clave del frontmatter, tal cual está escrito (con comillas si
+// las tiene). Es lo que hay que validar: `parseFrontmatter` ya las saca.
+export function rawFrontmatterValue(md, key) {
+  const m = md.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+  if (!m) return null;
+  const line = m[1].match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+  return line ? line[1].trim() : null;
+}
+
+// Saca las comillas de un escalar YAML citado. Sin comillas, lo devuelve tal cual.
+function unquoteScalar(s) {
+  if (s == null) return null;
+  const v = s.trim();
+  if (v.length >= 2 && v.startsWith('"') && v.endsWith('"')) {
+    try { return JSON.parse(v); } catch { return v.slice(1, -1); }
+  }
+  if (v.length >= 2 && v.startsWith("'") && v.endsWith("'")) return v.slice(1, -1).replace(/''/g, "'");
+  return v;
+}
+
 // Parsea el frontmatter YAML de un SKILL.md → { name, description, body }.
+// Devuelve los valores YA sin comillas, para que quien los reserialice (skillToCursor)
+// no los cite dos veces.
 export function parseFrontmatter(md) {
   const m = md.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
   if (!m) return { name: null, description: null, body: md.trim() };
   const fm = m[1];
-  const name = (fm.match(/^name:\s*(.+)$/m) || [])[1]?.trim() || null;
-  const description = (fm.match(/^description:\s*(.+)$/m) || [])[1]?.trim() || null;
+  const name = unquoteScalar((fm.match(/^name:\s*(.+)$/m) || [])[1]) || null;
+  const description = unquoteScalar((fm.match(/^description:\s*(.+)$/m) || [])[1]) || null;
   return { name, description, body: m[2].trim() };
 }
 
-// Valida el contrato MÍNIMO de un SKILL.md para que dai lo ingiera y lo convierta a
-// los 3 asistentes (y para que Claude/Cursor/Copilot lo carguen): frontmatter con
-// `name` y `description`. Devuelve null si está OK, o un string con el motivo.
+// Valida el contrato MÍNIMO de un SKILL.md para que dai lo ingiera y los asistentes lo
+// carguen: frontmatter con `name` y `description`, y que ambos sean YAML válido — si no,
+// el asistente descarta la skill entera. Devuelve null si está OK, o el motivo.
 // NO valida el contenido de la skill — eso es criterio del equipo (ADR-0013).
 export function validateSkill(md) {
   const { name, description } = parseFrontmatter(md);
   if (!name && !description) return "sin frontmatter (falta name y description)";
   if (!name) return "falta 'name' en el frontmatter";
   if (!description) return "falta 'description' en el frontmatter";
+  for (const key of ["name", "description"]) {
+    const issue = yamlScalarIssue(rawFrontmatterValue(md, key));
+    if (issue) return `'${key}' no es YAML válido: ${issue} — citá el valor con comillas dobles`;
+  }
   return null;
 }
 
-// Transforma un SKILL.md (Claude) en un prompt file de Copilot (.prompt.md).
-// Cambia el frontmatter; el cuerpo (la lógica) es el mismo.
-export function skillToPrompt(md) {
-  const { description, body } = parseFrontmatter(md);
-  const fm = [
-    "---",
-    "mode: agent",
-    description ? `description: ${JSON.stringify(description)}` : null,
-    "---",
-  ].filter((x) => x !== null).join("\n");
-  return `${fm}\n\n${body}\n`;
-}
+// Los archivos de Copilot que dai generaba ANTES de que Copilot adoptara Agent Skills
+// (ADR-0014). `dai init` los borra al reencontrarlos, para que no queden duplicando
+// cada `/comando` con una copia vieja y sin templates.
+export const stalePromptFiles = (skills) => skills.map((n) => `${n}.prompt.md`);
 
 // Transforma un SKILL.md (Claude) en un SKILL.md de Cursor.
 // Conserva name/description/body y ajusta solo el frontmatter.
@@ -60,7 +98,17 @@ export function envFor(pm) {
     return head + "DAI_PM=clickup\nDAI_CLICKUP_TOKEN=\nDAI_CLICKUP_LIST_ID=\nDAI_TRACKER_URL_TEMPLATE=https://app.clickup.com/t/{id}\n";
   }
   if (pm === "jira") {
-    return head + "DAI_PM=jira\nDAI_JIRA_BASE_URL=\nDAI_JIRA_EMAIL=\nDAI_JIRA_TOKEN=\nDAI_JIRA_PROJECT=\nDAI_JIRA_ISSUETYPE=Story\nDAI_TRACKER_URL_TEMPLATE=\n";
+    return head +
+      "DAI_PM=jira\n" +
+      "DAI_JIRA_BASE_URL=\n" +
+      "DAI_JIRA_EMAIL=\n" +
+      "DAI_JIRA_TOKEN=\n" +
+      "# La clave del PROYECTO (p. ej. PROJ), no la de un ticket (PROJ-123).\n" +
+      "DAI_JIRA_PROJECT=\n" +
+      "DAI_JIRA_ISSUETYPE=Story\n" +
+      "# Campos propios que tu Jira exige al crear. Si el archivo no existe, se ignora.\n" +
+      "DAI_JIRA_FIELDS_FILE=.dai/jira-fields.json\n" +
+      "DAI_TRACKER_URL_TEMPLATE=\n";
   }
   return head + "DAI_PM=md\nDAI_MD_US_DIR=.dai/us\n";
 }
@@ -124,7 +172,7 @@ export function reconcileGitignore(text, want) {
 // copilot-instructions.md (Copilot). Mismo núcleo, distinto encabezado.
 export function constitution(kind) {
   const head = kind === "copilot"
-    ? "# Instrucciones de Copilot para este repo\n\nEste repo sigue la metodología **dai**. Aplica 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."
+    ? "# Instrucciones de Copilot para este repo\n\nEste repo sigue la metodología **dai**. Aplica estas reglas en todo lo que generes.\n\n> **Superficie:** las skills de dai (`.github/skills/`) se invocan con `/nombre-skill`, o\n> cuando el agente las detecta por su descripción. Funcionan en el Copilot CLI, en la app,\n> y en modo agente de VS Code / JetBrains (ADR-0014). El CLI `dai` corre en cualquier\n> 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.";
@@ -145,6 +193,8 @@ export function constitution(kind) {
 - **Verifica el comportamiento, no solo que compile:** que pase el chequeo estático o el build no prueba que funcione; ejercita el flujo real antes de darlo por hecho.
 - **La IA confirma antes de construir:** el asistente declara que entendió esta constitución y la va a obedecer antes de generar código.
 - **Secretos:** en \`.env\` (nunca commiteados). git por **SSH**, APIs por **token scopeado**.
+- **No bajes la seguridad para avanzar:** si una llamada falla por el certificado, declara la CA (\`NODE_EXTRA_CA_CERTS\`). **Nunca** \`NODE_TLS_REJECT_UNAUTHORIZED=0\`, \`verify=False\`, \`-k\` ni equivalentes: apagan la verificación de toda la conexión, y por ahí viajan los tokens.
+- **Si el CLI no llega, para y dilo:** cuando \`dai\` no cubre un caso, repórtalo — no improvises una llamada a la API por fuera. El atajo publica igual, pero rompe el link QUÉ↔CÓMO en silencio y nadie se entera hasta que la trazabilidad ya está mal.
 - **Docs vivas:** una constitución o arquitectura desactualizada es un defecto, no documentación.
 - Separa el QUÉ (funcional) del CÓMO (técnico); no mezcles.