@dforce2055/dai 0.4.0 → 0.6.0

package/CHANGELOG.md

@@ -3,6 +3,40 @@
 Formato basado en [Keep a Changelog](https://keepachangelog.com/). Versionado semver
 (ver `VERSION`).
 
+## [0.6.0] — 2026-07-12
+
+Self-update del CLI y blindaje de autoría del repo.
+
+### Agregado
+- `dai upgrade` (alias `update`): actualiza el CLI global a la última publicada
+  (`npm i -g …@latest`), con `--check` y `--dry-run`. No toca el repo: reporta el
+  drift del scaffold pero deja el `dai sync` explícito del mantenedor (ADR-0012).
+
+### Interno
+- Guard de autoría: rechaza commits autorados/co-autorados por agentes de IA
+  (check de CI `authorship` + hook local + `governance/human-authorship.md`).
+- Eliminado `.mailmap` (ya no cumplía función).
+- **111 tests** (+1: `planUpgrade`).
+
+## [0.5.0] — 2026-07-10
+
+**`archive` en el flujo** ([ADR-0011](docs/adr/0011-archive-gate-de-aprobacion.md)): cerrar el CÓMO
+del lado de las specs canónicas, atado a la aprobación de la PR.
+
+### Agregado
+- **`dai archive [<change>]`**: funde los delta specs del change en las specs canónicas
+  (`openspec/specs/`) y lo archiva. Lo corre el **aprobador** de la PR, en la branch, al aprobar
+  (el fold viaja en la PR → elude la base protegida). Detecta el change activo por su `implements.yaml`
+  o le pasás el nombre; envuelve `openspec archive --yes` (mecánico → comando, no skill). Flag `--skip-specs`.
+
+### Cambiado
+- **`dai check` y `dai ls` saltean `openspec/changes/archive/`**: un change shippeado ya no genera
+  ⚠️ de drift falso ni aparece en el listado. `discoverImplements` acepta `includeArchived` (default
+  `true`); `check`/`ls` lo pasan `false`. `stamp`/`done` mantienen el default (lo necesitan post-merge).
+
+### Interno
+- **110 tests** (+1 desde 0.4.0: filtro `includeArchived`).
+
 ## [0.4.0] — 2026-07-10
 
 **Versionado y upgrade** ([ADR-0010](docs/adr/0010-versionado-y-upgrade.md)): mantené tu repo al
@@ -147,6 +181,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.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
 [0.3.1]: https://github.com/dforce2055/dai/releases/tag/v0.3.1
 [0.3.0]: https://github.com/dforce2055/dai/releases/tag/v0.3.0

package/CONTRIBUTING.md

@@ -16,6 +16,13 @@ git clone <tu-fork> dai && cd dai
 npm test        # 48 tests, sin `npm install` (no hay deps)
 ```
 
+Opcional, para que los hooks del repo te avisen antes de commitear (cero
+dependencias, sin husky):
+
+```bash
+git config core.hooksPath .githooks   # valida convención de commits + autoría humana
+```
+
 ## Reglas de oro
 
 1. **Cero dependencias de runtime.** El CLI corre en redes cerradas sin `npm install`
@@ -29,6 +36,11 @@ npm test        # 48 tests, sin `npm install` (no hay deps)
    necesita un ADR (ver abajo).
 4. **Secretos nunca en el repo.** Tokens solo en `.env` (gitignored) o el secret
    store del CI. git usa **SSH**, las APIs usan **tokens scopeados** (ADR-0007).
+5. **Autoría humana.** El código de `dai` lo **autora y revisa una persona**. No se
+   aceptan commits cuyo *author*, *committer* o `Co-authored-by` sea un agente o bot
+   (Cursor, Copilot, Claude, …). Un agente puede ayudarte, pero el cambio lo firmas
+   tú: con tu identidad y sin el trailer del agente. Un check de CI lo bloquea en cada
+   PR (ver [`governance/human-authorship.md`](governance/human-authorship.md)).
 
 ## Flujo (la propia metodología)
 

package/README.md

@@ -127,7 +127,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 |
+| 1 | **Instalar el CLI** | `npm i -g @dforce2055/dai` (o `npm link` en dev) · `dai --version` · actualizar después: `dai upgrade` | dev |
 | 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 |
@@ -167,6 +167,7 @@ flowchart TD
 | `dai pr [--assignee u] [--base b] [--draft] [--yes]` | crea TU PR/MR precargada: pregunta la branch base (default `main`), muestra el texto y confirma antes de publicar |
 | `dai stamp` | estampa la cobertura inversa en el tracker (branch + commit-ancla) |
 | `dai done [--base main] [--force]` | cierra la US: vuelve a la base, `fetch --prune` + `pull`, y borra la branch local **si está mergeada** (chequeo estricto; `--force` la borra igual). Redes: no estar en la base, sin cambios sueltos, sin commits sin pushear |
+| `dai archive [<change>] [--skip-specs]` | **funde los delta specs del change en las specs canónicas** (`openspec/specs/`) y lo archiva. Lo corre el **aprobador** de la PR (gate de aprobación, [ADR-0011](docs/adr/0011-archive-gate-de-aprobacion.md)); detecta el change activo o le pasás el nombre. Envuelve `openspec archive` |
 | `dai forge comment <ref> --body-file <f>` · `dai forge pr <ref>` | comentar / leer una PR/MR (GitHub/GitLab) |
 | `dai ac-hash <us.md>` | calcula el hash de los criterios de aceptación de una US |
 | `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) |

package/VERSION

@@ -1 +1 @@
-0.4.0
+0.6.0

package/cli/dai.mjs

@@ -28,7 +28,7 @@ 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 { versionDrift } from "./lib/semver.mjs";
+import { versionDrift, planUpgrade } from "./lib/semver.mjs";
 import { skillToPrompt, skillToCursor, constitution, constitutionCursorRule, envFor, mergeEnv, upsertBlock, reconcileGitignore } from "./lib/bootstrap.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -71,7 +71,7 @@ function cmdAcHash(arg) {
 // ── ls ──────────────────────────────────────────────────────────────────────
 function cmdLs(opts) {
   const root = opts.root || process.cwd();
-  const found = discoverImplements(root);
+  const found = discoverImplements(root, { includeArchived: false });
   const rows = [];
   for (const f of found) {
     for (const im of f.implements || []) {
@@ -170,7 +170,7 @@ function gitCommit() { try { return git(["rev-parse", "HEAD"]); } catch { return
 async function cmdCheck() {
   loadEnv();
   const adapter = getAdapter(process.env);
-  const found = discoverImplements(process.cwd());
+  const found = discoverImplements(process.cwd(), { includeArchived: false });
   let worst = 0, n = 0;
   const atrasadas = [];
   for (const f of found) for (const im of f.implements || []) {
@@ -682,6 +682,39 @@ function cmdDocs(dest) {
   ok(`documentación copiada a ${dest}`);
 }
 
+// ── archive: funde los delta specs del change en los specs canónicos y lo archiva ─
+// Lo corre el APROBADOR de la PR, en la branch, al aprobar: es el gate de aprobación
+// (el fold va atado a la aprobación, no a la autoría). Envuelve `openspec archive
+// <change> --yes` — mecánico, va al CLI y no a una skill (ADR-0002). El fold queda
+// sin commitear para que el aprobador lo revise y lo incluya en la PR antes de mergear.
+function cmdArchive(changeArg, opts) {
+  const repo = process.cwd();
+  if (!existsSync(join(repo, "openspec"))) fail("no hay OpenSpec en este repo (falta openspec/). Nada que archivar.", 2);
+
+  let change = changeArg;
+  if (!change) {
+    // Detectar el change ACTIVO (no archivado) por su implements.yaml.
+    const active = discoverImplements(repo, { includeArchived: false })
+      .filter((f) => /[/\\]openspec[/\\]changes[/\\]/.test(f.path))
+      .map((f) => basename(dirname(f.path)));
+    const uniq = [...new Set(active)];
+    if (uniq.length === 0) fail("no encontré un change activo para archivar (¿ya está archivado, o falta `dai link-us`?).", 2);
+    if (uniq.length > 1) fail(`hay varios changes activos: ${uniq.join(", ")}.\n  Pasá cuál: dai archive <change>`, 2);
+    change = uniq[0];
+  }
+
+  info(`archivando '${change}' — funde los delta specs en openspec/specs/ y mueve el change a archive/…`);
+  const args = ["archive", change, "--yes"];
+  if (opts.skipSpecs) args.push("--skip-specs");
+  try {
+    execFileSync(npmBin("openspec"), args, { stdio: "inherit", cwd: repo });
+  } catch (e) {
+    fail(`openspec archive falló (¿tasks incompletas? ¿change inexistente?): ${String(e.message).split("\n")[0]}`, 1);
+  }
+  process.stdout.write("\n");
+  ok(`'${change}' archivado. Revisá los cambios (specs fundidas + change en archive/) y commitealos en la PR antes de mergear.`);
+}
+
 // ── sync: refresca las copias scaffoldeadas a la versión del CLI (ADR-0010) ───
 // Las copias (skills, constitución, templates, PR template) son un CACHÉ derivable
 // del CLI: `dai sync` las re-genera a la versión instalada, aditivo (no pisa la
@@ -789,6 +822,43 @@ function reportDrift(repo = process.cwd()) {
   return status;
 }
 
+// ── upgrade: self-update del CLI global (ADR-0012) ────────────────────────────
+// Actualiza el paquete npm global de dai a la última publicada. NO toca el repo:
+// si hay drift del scaffold, solo lo reporta (el `dai sync` queda explícito, del
+// mantenedor). El nombre sale de package.json → robusto si cambia el scope.
+function cmdUpgrade(opts) {
+  const name = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf8")).name;
+  const currentV = readFileSync(join(ROOT, "VERSION"), "utf8").trim();
+  const manual = C.cy(`npm i -g ${name}@latest`);
+  info(`dai upgrade — CLI v${currentV} (${name})`);
+
+  let latestV;
+  try {
+    latestV = execFileSync(npmBin("npm"), ["view", name, "version"], { encoding: "utf8" }).trim();
+  } catch {
+    fail(`no pude consultar el registry (¿sin red?). Actualizá a mano: ${manual}`, 1);
+  }
+
+  const plan = planUpgrade(currentV, latestV);
+  if (plan.action === "unknown") { warn(`no pude comparar versiones (actual '${currentV}', última '${latestV}')`); return; }
+  if (plan.action === "up-to-date") { ok(`ya estás en la última (v${currentV})`); reportDrift(); return; }
+  if (plan.action === "ahead") { info(`tu CLI (v${currentV}) es más nuevo que el registry (v${latestV}) — nada que actualizar`); reportDrift(); return; }
+
+  // plan.action === "upgrade"
+  if (opts.check) { process.stdout.write(`${C.b(C.y("⬆️  hay update"))} — v${plan.from} → v${plan.to}. Corré ${C.cy("dai upgrade")}\n`); return; }
+  if (opts.dryRun) { info(`[dry-run] correría: npm i -g ${name}@latest  (v${plan.from} → v${plan.to})`); return; }
+
+  info(`actualizando v${plan.from} → v${plan.to} …`);
+  try {
+    execFileSync(npmBin("npm"), ["install", "-g", `${name}@latest`], { stdio: "inherit" });
+  } catch {
+    fail(`el install falló. Probá a mano: ${manual}`, 1);
+  }
+  ok(`CLI actualizado a v${plan.to}`);
+  const st = reportDrift();
+  if (st === null) process.stdout.write("  (No estás en un repo dai — entrá al repo y, si hace falta, corré `dai sync`.)\n");
+}
+
 // ── doctor: diagnóstico ───────────────────────────────────────────────────────
 function cmdDoctor() {
   loadEnv();
@@ -864,9 +934,12 @@ switch (cmd) {
   case "publish": cmdPublish(pos[0]).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 "init":    cmdInit(pos[0], opts).catch((e) => fail(String(e.message))); break;
   case "sync":    cmdSync(pos[0], opts); break;
+  case "upgrade":
+  case "update":  cmdUpgrade(opts); break;
   case "docs":    cmdDocs(pos[0]); break;
   case "doctor":  cmdDoctor(); break;
   case "version": cmdVersion(); break;
@@ -882,6 +955,7 @@ switch (cmd) {
       "  check                        compara vs la US viva → atrasado (ADR-0003)\n" +
       "  stamp                        estampa la cobertura en el tracker (ADR-0005)\n" +
       "  done [--base main] [--force] cierra la US: vuelve a la base, actualiza y borra la branch local (si está mergeada)\n" +
+      "  archive [<change>] [--skip-specs]   funde los delta specs del change en las specs canónicas y lo archiva (lo corre el aprobador en la PR)\n" +
       "  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" +
@@ -891,6 +965,7 @@ switch (cmd) {
       "                               ej: --for claude,cursor · --for copilot · --for all\n" +
       "       --pm md|jira|clickup · --openspec   (con flags salteas las preguntas)\n" +
       "  sync [<repo>] [--dry-run] [--for <asistentes>]   refresca skills/constitución/templates a la versión del CLI (aditivo; no toca .env ni OpenSpec)\n" +
+      "  upgrade [--check] [--dry-run]   (alias: update) actualiza el CLI global a la última (npm i -g …@latest) y avisa si el repo quedó atrasado (ADR-0012)\n" +
       "  docs <destino>               documentación conceptual → <destino>\n" +
       "  doctor                       diagnóstico del entorno\n\n" +
       "  (config: .env — ver .env.example)\n"

package/cli/lib/implements.mjs

@@ -71,7 +71,10 @@ export function parseImplements(text) {
 }
 
 // Camina el árbol desde root y devuelve { path, ...parsed } por cada implements.yaml.
-export function discoverImplements(root) {
+// `includeArchived: false` saltea `openspec/changes/archive/` — los changes shippeados
+// no deben aparecer en `check`/`ls` (ADR-0010). Por defecto los incluye (stamp/done los
+// necesitan post-merge).
+export function discoverImplements(root, { includeArchived = true } = {}) {
   const found = [];
   const walk = (dir) => {
     let entries;
@@ -81,7 +84,9 @@ export function discoverImplements(root) {
       let st;
       try { st = statSync(full); } catch { continue; }
       if (st.isDirectory()) {
-        if (!SKIP_DIRS.has(name)) walk(full);
+        if (SKIP_DIRS.has(name)) continue;
+        if (!includeArchived && name === "archive") continue;
+        walk(full);
       } else if (name === "implements.yaml") {
         try {
           found.push({ path: full, ...parseImplements(readFileSync(full, "utf8")) });

package/cli/lib/semver.mjs

@@ -28,3 +28,18 @@ export function versionDrift(repoV, cliV) {
   if (cmp < 0) return "cli-behind";
   return c.major > r.major ? "major-behind" : "minor-behind";
 }
+
+// Plan de `dai upgrade` (ADR-0012): compara el CLI instalado (currentV) con la
+// última publicada en el registry (latestV). Núcleo puro; el I/O (npm view /
+// npm i -g) vive en el comando.
+//   up-to-date → iguales                        → { action, version }
+//   ahead      → el CLI local es más nuevo       → { action, current, latest }
+//   upgrade    → hay una versión más nueva        → { action, from, to }
+//   unknown    → alguna versión no parsea         → { action }
+export function planUpgrade(currentV, latestV) {
+  const cmp = compareVersions(currentV, latestV);
+  if (cmp === null) return { action: "unknown" };
+  if (cmp === 0) return { action: "up-to-date", version: currentV };
+  if (cmp > 0) return { action: "ahead", current: currentV, latest: latestV };
+  return { action: "upgrade", from: currentV, to: latestV };
+}

package/docs/adr/0011-archive-gate-de-aprobacion.md

@@ -0,0 +1,68 @@
+# ADR-0011 — `archive` es un gate de aprobación (`dai archive`)
+
+- **Estado:** aceptado
+- **Fecha:** 2026-07-10
+- **Decide:** lead / arquitecto de la metodología
+
+## Contexto
+
+OpenSpec tiene `archive`: cuando un change está completo, **funde sus delta specs** en las
+specs canónicas (`openspec/specs/<capability>/spec.md`) y **mueve el change** a
+`openspec/changes/archive/`. Pero en el flujo dai (`link-us → propose → apply/tdd → check
+→ pr → dai-review → merge → stamp → done`) el `archive` **no tenía lugar**: ni cuándo, ni
+quién. Sin eso, las specs vivas del repo quedan desincronizadas de lo shippeado.
+
+Dos preguntas de fondo: **¿quién lo corre?** y **¿en qué momento?**
+
+## Decisión
+
+### `archive` = el acto de aceptar el change en las specs canónicas → lo hace **quien aprueba la PR**
+
+Fundir un change en las specs oficiales es **bendecir** ese cambio. Por eso lo ata a la
+**aprobación**, no a la autoría: lo corre **quien aprueba la PR**, no el autor. Es un
+**gate de aprobación**, no un paso de cierre del autor (un autor no debería fundir sus
+propios cambios en la spec oficial de un equipo).
+
+Ownership por **dial de ceremonia** (N1/N2/N3):
+
+- **N1/N2 — `dai archive` (comando):** el aprobador lo corre **en la branch de la PR** al
+  aprobar → funde los deltas + mueve el change + lo deja **sin commitear** para revisarlo →
+  lo incluye en la PR → mergea normal. **Resuelve solo el problema de base protegida**: el
+  fold viaja dentro de la PR, no hay push directo a `main`.
+- **N3 — workflow de CI opt-in** (roadmap): el merge aprobado dispara el `archive` solo.
+
+### `dai archive` es un **comando**, no una skill
+
+Archivar es **mecánico** (detectar el change + `openspec archive <change> --yes`): sin
+juicio → va al CLI, como `dai stamp`/`check`/`done` (ADR-0002). `dai-review` es skill
+porque revisar código sí requiere juicio; archivar no. `dai archive` **envuelve**
+`openspec archive`, detectando el change activo por su `implements.yaml` (reusa
+`discoverImplements`); si hay varios, pide el nombre.
+
+### `dai check` y `dai ls` saltean `openspec/changes/archive/`
+
+Un change archivado está **shippeado**: no debe aparecer en `check` (daría un ⚠️ de drift
+falso si el PO edita esa US después) ni en `ls`. `discoverImplements` acepta
+`includeArchived` (default `true`); `check`/`ls` lo pasan en `false`. **`dai stamp`/`done`/
+`archive` mantienen el default** — sí necesitan encontrar el `implements.yaml` (p. ej.
+`stamp` post-merge, cuando el change ya se archivó en la branch).
+
+## Consecuencias
+
+- ✅ El `archive` queda **atado a la aprobación** — las specs canónicas reflejan solo lo bendecido.
+- ✅ La variante `dai archive` (N1/N2) **elude la base protegida** sin tokens ni CI: el fold entra por la PR.
+- ✅ `check`/`ls` dejan de reportar ruido de changes shippeados.
+- ✅ Coherente con el ADN: es una **herramienta opcional** (no obliga), mecánica → CLI.
+- ⚠️ Edge: en PRs desde **fork**, el aprobador puede no tener push a la branch del autor →
+  ahí cae al workflow de CI, o lo corre el autor.
+- ⚠️ El **nudge** (que `/dai-review` recuerde archivar al aprobar) y el **workflow de CI**
+  quedan como follow-up (roadmap), igual que documentar el paso en `SCRUM-CON-IA`.
+
+## Alternativas consideradas
+
+- **Que lo corra el autor, en el PR** — descartado: fundir en la spec oficial es un acto de
+  aprobación; el autor no debería bendecir su propio cambio. Va atado a quien aprueba.
+- **Post-merge sobre la base (commit directo)** — descartado como default: choca con branch
+  protection (push directo a `main`). Queda para el workflow de CI (con follow-up PR o App token).
+- **Una skill `/dai-archive`** — descartado: archivar es mecánico, no necesita un LLM (ADR-0002).
+  El comando puede invocarse desde el asistente igual, sin ser skill.

package/docs/adr/0012-upgrade-self-update-del-cli.md

@@ -0,0 +1,59 @@
+# ADR-0012 — `dai upgrade` (self-update del CLI)
+
+- **Estado:** aceptado
+- **Fecha:** 2026-07-12
+- **Decide:** lead / arquitecto de la metodología
+
+## Contexto
+
+dai tiene **dos cosas versionadas e independientes**: el **CLI** (el paquete npm
+global, una copia por dev) y el **scaffold del repo** (`.dai/`, skills, `.dai/VERSION`,
+compartido y commiteado). El drift entre ambos ya se **detecta** (`versionDrift`,
+ADR-0010) y `dai doctor`/`dai version` imprimen el estado.
+
+Pero actualizar el **CLI** era **manual**: cuando el detector veía el CLI atrasado,
+imprimía el texto `npm i -g @dforce2055/dai` para que el dev lo copiara y corriera a
+mano. No había comando. Fricción repetida, y un detector que empujaba a algo que no
+existía como acción de dai.
+
+Escenario típico: un dev vuelve el lunes con el CLI en v0.2.0 y ya salió v0.5.0.
+Tiene que actualizar su CLI (y después traer el repo con `git pull`, que el
+mantenedor ya sincronizó).
+
+## Decisión
+
+Agregamos **`dai upgrade`** (alias `update`): **self-update del CLI global** a la
+última versión publicada en el registry.
+
+- **Scope: solo el CLI.** Corre `npm i -g <name>@latest` (el `<name>` sale de
+  `package.json`, robusto si cambia el scope). `--check` solo informa; `--dry-run`
+  muestra el comando sin correrlo.
+- **NO toca el repo.** Tras actualizar, **reporta** el drift del scaffold (`reportDrift`)
+  pero **no corre `dai sync`**. El `sync` queda como acto **explícito del mantenedor**:
+  un dev con CLI viejo que sincronizara **degradaría** el `.dai/` del repo, y sincronizar
+  desde cada máquina genera commits en conflicto.
+- **El núcleo es puro y testeado** (`planUpgrade` en `lib/semver.mjs`): decide
+  `up-to-date | ahead | upgrade`. El I/O (`npm view` / `npm i -g`) es la cáscara del
+  comando, no se unit-testea (mismo criterio que el `fetch`).
+
+## Consecuencias
+
+- **Más fácil:** un comando cierra el loop de "CLI atrasado" en vez de copiar un hint.
+  La separación de roles queda nítida: **`upgrade` = tu CLI** (self-update),
+  **`sync` = el repo** (mantenedor, commiteado).
+- **Se acepta pagar:** depende del **registry** (es online; en redes cerradas —ADR-0006—
+  falla con mensaje claro y fallback al `npm i -g` manual). Asume **npm** como package
+  manager del global (no pnpm/yarn/volta/asdf); si el install falla, deriva al comando
+  manual. No auto-sincroniza el repo (a propósito).
+
+## Alternativas consideradas
+
+- **Auto-correr `dai sync` tras el upgrade** — descartado: un dev degradaría el repo con
+  un CLI viejo y sincronizar desde cada máquina genera conflictos. El `sync` es del
+  mantenedor.
+- **Pinnear dai como devDependency por-repo** (sin global → sin drift, alineado en
+  `npm install`) — descartado como default: dai se diseñó **global y zero-dep para redes
+  cerradas** (ADR-0006), y no todos los repos son npm. Queda como opción del consumidor,
+  no del método.
+- **No hacer nada** (dejar el hint manual) — descartado: fricción repetida sobre una
+  acción que el propio detector ya recomendaba.

package/docs/adr/README.md

@@ -16,6 +16,7 @@ decisión cambia, se escribe un ADR nuevo que supersede al viejo. Molde en
 | [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 |
 | [0010](0010-versionado-y-upgrade.md) | Versionado y upgrade: compatibilidad por semver, `doctor` version-drift, `dai sync` aditivo | propuesto |
+| [0011](0011-archive-gate-de-aprobacion.md) | `archive` es un gate de aprobación: `dai archive` (comando) lo corre el aprobador; `check`/`ls` saltean `archive/` | aceptado |
 
 > Estas son las decisiones que cierran las "Decisiones abiertas" de
 > [`METODOLOGIA.md §7`](../METODOLOGIA.md) y las enmiendas al

package/governance/commit-convention.md

@@ -35,6 +35,10 @@
 
 Se dejan pasar sin validar: `Merge …`, `Revert …`, `fixup!`/`squash!` y commits de bots (`🤖…`).
 
+> Esto es solo la validación de **formato**. La **autoría** es otra regla: en el repo
+> de dai no se aceptan commits autorados ni co-autorados por un agente
+> (ver [`human-authorship.md`](human-authorship.md)).
+
 ## Relación con la trazabilidad
 
 El link formal QUÉ↔CÓMO vive en el `implements.yaml` (no en el mensaje del commit). Pero si

package/governance/human-authorship.md

@@ -0,0 +1,61 @@
+# Autoría humana — quién firma el código de dai
+
+> El código de `dai` lo **autora y revisa una persona**. Un agente puede ayudarte a
+> escribirlo, pero el commit lo firmas tú: con tu identidad, y sin dejar al agente
+> como co-autor. No es una postura sobre cómo trabajas — es una regla de contribución
+> de **este repo**, y un check la blinda, sin depender de que nadie "se acuerde"
+> (mismo espíritu que [`ci-rules.md`](ci-rules.md) y [`commit-convention.md`](commit-convention.md)).
+
+## La regla
+
+Ningún commit que entre a `dai` puede tener un **agente o bot** como:
+
+- **author** — quien escribió el cambio,
+- **committer** — quien lo registró, ni
+- **`Co-authored-by:`** — un co-autor en el mensaje.
+
+Concretamente se rechazan identidades de asistentes de código (Cursor, GitHub
+Copilot, Claude, Devin, Codeium, Windsurf, … y cualquier `…[bot]`). La lista es
+editable en [`scripts/no-agent-authors.sh`](../scripts/no-agent-authors.sh).
+
+## Por qué
+
+- **La persona firma ([Art. 5](../docs/MANIFIESTO.md#art-5)).** El código que entra a
+  `dai` es una decisión de una persona que lo entiende y se hace responsable. Un
+  commit firmado por un agente diluye ese "alguien responde por esto".
+- **No vibe coding ([Art. 7](../docs/MANIFIESTO.md#art-7)).** El aporte no es "lo que
+  salió del chat": es un cambio que revisaste, entendiste y hiciste tuyo.
+- **Higiene del historial.** El grafo de *Contributors* del repo se arma con
+  author/committer/co-author. Un trailer de agente mete al bot como contribuidor —
+  y sacarlo después obliga a reescribir historia.
+
+## Distinción importante (no es scope de la metodología)
+
+Esto **no** dice cómo debes usar agentes en *tus* proyectos. La metodología es
+agnóstica de la herramienta de abajo ([Art. 2](../docs/MANIFIESTO.md#art-2)): usa los
+agentes como quieras. Esta regla gobierna **la contribución al repo de dai**, igual
+que el naming de ramas o la convención de commits. Por eso vive en `governance/` y
+**no** se publica como parte de las plantillas de la metodología.
+
+## Cómo cumplirla
+
+Si un agente te ayudó con un cambio: **revísalo, apropiate de él y commitealo con tu
+identidad**, sin el trailer `Co-authored-by`. Configura tu identidad una vez:
+
+```bash
+git config user.name  "Tu Nombre"
+git config user.email "tu@email"
+```
+
+## Cómo se blinda
+
+Dos capas, un solo script ([`scripts/no-agent-authors.sh`](../scripts/no-agent-authors.sh),
+cero dependencias):
+
+| Capa | Qué | Cuándo |
+|---|---|---|
+| **Hook local** | [`.githooks/commit-msg`](../.githooks/commit-msg) valida el commit en curso (`--pending`). | Al commitear, si activaste `git config core.hooksPath .githooks`. Es opt-in y salteable — feedback temprano, no barrera. |
+| **CI (el gate)** | El job `authorship` de [`ci.yml`](../.github/workflows/ci.yml) valida todos los commits del PR (`--range`). | En cada PR. Como *required check* **bloquea el merge**. No es salteable. |
+
+El hook avisa temprano; el CI es la barrera real. El commit siempre es de una persona
+antes de que un mantenedor lo firme ([`CONTRIBUTING.md`](../CONTRIBUTING.md)).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dforce2055/dai",
-  "version": "0.4.0",
+  "version": "0.6.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://dforce2055.github.io/dai/",