@tacuchi/agent-workflow-cli 12.4.0 → 12.5.0

package/skills/w/commands/README.md

@@ -3,7 +3,7 @@
 > This is the **bundle README** for the `/w:` slash-command namespace. Every command listed here is something the **user** invokes directly.
 > Related layers: [`../loops/`](../loops/) (Layer 2, AI-driven) · artifacts live in `.workflow/sessions/` (Layer 3) · permanent deliverables in `docs/`.
 >
-> **Namespace:** all commands are under `w:` (`w` = *workflow*): `/w:spec-new`, `/w:spec-refine`, `/w:plan-new`, `/w:plan-exec`, `/w:quick`, `/w:workspace-init`, `/w:export-*`.
+> **Namespace:** all commands are under `w:` (`w` = *workflow*): `/w:spec-new`, `/w:spec-refine`, `/w:plan-new`, `/w:plan-exec`, `/w:quick`, `/w:workspace-init`, `/w:status` (transversal), `/w:export-*`.
 
 ---
 
@@ -50,20 +50,22 @@
 
 > **Intentional asymmetry:** in SPEC, `spec-new` generates the draft in a **single pass** (no loop) and the loop is in `spec-refine`. In PLANIFICATION, **both** commands start loops. Total: **5 flow commands / 4 loops**.
 
+> **Transversal (no flow):** [`/w:status`](status.md) is a read-only dashboard of the whole workspace — what's done / pending / discarded, with friendly Spanish dates. It leans on `aw status`, writes nothing, and belongs to no flow.
+
 ## Pipeline
 
 ```mermaid
 flowchart LR
     prompt(["user prompt"]) --> sn["/w:spec-new"]
-    sn -->|generates| spec["docs/specs/NNN-spec.md"]
+    sn -->|generates| spec["docs/specs/NNN-spec-<slug>.md"]
     spec -.->|optional manual edit| spec
     spec --> sr["/w:spec-refine"]
     sr -->|starts| srl(["spec-refine-loop"])
-    srl -->|generates| specr["docs/specs/NNN-spec-refined.md"]
+    srl -->|refines IN PLACE| spec
 
-    specr --> pn["/w:plan-new"]
+    spec --> pn["/w:plan-new"]
     pn -->|starts| pnl(["plan-new-loop"])
-    pnl -->|generates| plan["docs/plans/PPP-plan.md"]
+    pnl -->|generates| plan["docs/plans/PPP-plan-<slug>.md"]
 
     plan --> pe["/w:plan-exec"]
     pe -->|starts| pel(["plan-exec-loop"])
@@ -98,7 +100,7 @@ Each `<command>.md` in this bundle uses this frontmatter + body structure:
 3. **Spec and plan are documents** (`docs/`), not artifacts.
 4. **DB scripts-only**: AI **never executes DML/DDL**; migrations live in `SCRIPTS.sql` (type B) and are delivered via `export-scripts`. Only read-only queries via MCP.
 5. **Git-safe**: verify branch before editing; **propose** commits by source; never `push`/`--amend`/`--no-verify`.
-6. **All loops**: gap-driven convergent · `AskUserQuestion` with ≤3 content tabs + 1 `flow` tab (`Compactar`/`Cerrar`) always · compact/resume · `Cerrar` persists `CHECKPOINT`+`BACKLOG`.
+6. **All loops**: gap-driven convergent · one session per run (research inline) · `AskUserQuestion` with ≤3 content tabs + 1 `flow` tab (`Compactar`/`Cerrar`) always · compact/resume · artifacts as a live log (`CHECKPOINT` always; `BACKLOG` only when deferring).
 
 ## Index
 
@@ -110,6 +112,7 @@ Each `<command>.md` in this bundle uses this frontmatter + body structure:
 | `plan-new` | [`plan-new.md`](plan-new.md) | starts `plan-new-loop` |
 | `plan-exec` | [`plan-exec.md`](plan-exec.md) | starts `plan-exec-loop` |
 | `quick` | [`quick.md`](quick.md) | starts `quick-loop` |
+| `status` | [`status.md`](status.md) | single-pass, read-only (transversal) |
 | `export-scripts` | [`export-scripts.md`](export-scripts.md) | single-pass, read-only |
 | `export-manuals` | [`export-manuals.md`](export-manuals.md) | single-pass, read-only |
 | `export-diagrams` | [`export-diagrams.md`](export-diagrams.md) | single-pass, read-only |

package/skills/w/commands/plan-exec.md

@@ -1,6 +1,6 @@
 ---
 description: Inicia o retoma el loop de ejecución (plan-exec-loop) sobre un plan existente. Aquí ocurre el trabajo real: edición de código, scripts SQL propuestos, herramientas creadas. Git-safe.
-argument-hint: <docs/plans/PPP-plan.md>
+argument-hint: <docs/plans/PPP-plan-<slug>.md>
 allowed-tools:
   [
     "Bash",
@@ -12,7 +12,7 @@ allowed-tools:
 
 # plan-exec — trampolín al loop de ejecución
 
-Arranca o retoma `plan-exec-loop` (Layer 2), que ejecuta el trabajo real fase por fase. El plan (`docs/plans/PPP-plan.md`) es un documento vivo que el loop mantiene actualizado (estado de fases y tareas).
+Arranca o retoma `plan-exec-loop` (Layer 2), que ejecuta el trabajo real fase por fase. El plan (`docs/plans/PPP-plan-<slug>.md`) es un documento vivo que el loop mantiene actualizado (estado de fases y tareas).
 
 ## Ejecutar el loop
 
@@ -25,8 +25,8 @@ Arranca o retoma `plan-exec-loop` (Layer 2), que ejecuta el trabajo real fase po
 
 ## Qué hace el loop (resumen)
 
-- Lee y actualiza `docs/plans/PPP-plan.md` (living doc: estado de fases/tareas).
-- Edita código en las fuentes del workspace (una sesión por fase).
+- Lee y actualiza `docs/plans/PPP-plan-<slug>.md` (living doc: estado de fases/tareas).
+- Edita código en las fuentes del workspace (una sola sesión de ejecución para el run; la ejecución sigue siendo fase por fase, solo que no hay sesión por fase).
 - Escribe herramientas/utilidades reutilizables en `docs/tools/`.
 - Propone commits por fuente (git-safe: verifica rama, propone, nunca push/--amend/--no-verify).
 - Genera artefactos de sesión (`DECISION`, `SCRIPTS.sql`) en `.workflow/sessions/`.

package/skills/w/commands/plan-new.md

@@ -1,6 +1,6 @@
 ---
-description: Inicia o retoma el loop de planificación (plan-new-loop) a partir de un spec refinado. Convierte el "qué" (spec) en el "cómo" (plan). Input ideal: docs/specs/NNN-spec-refined.md.
-argument-hint: <docs/specs/NNN-spec-refined.md | docs/specs/NNN-spec.md | prompt>
+description: Inicia o retoma el loop de planificación (plan-new-loop) a partir de un spec. Convierte el "qué" (spec) en el "cómo" (plan). Input ideal: docs/specs/NNN-spec-<slug>.md ya refinado.
+argument-hint: <docs/specs/NNN-spec-<slug>.md | prompt>
 allowed-tools:
   [
     "Bash",
@@ -16,12 +16,14 @@ Puente SPEC → PLANIFICATION. Convierte el "qué" (spec refinado) en el "cómo"
 
 ## Resolución de input
 
-El skill evalúa `$ARGUMENTS`:
+El skill evalúa `$ARGUMENTS` (los specs viven in place — `docs/specs/NNN-spec-<slug>.md`; localizar vía glob `docs/specs/NNN-spec-*.md` o la ruta exacta):
 
-1. **`docs/specs/NNN-spec-refined.md`** → ideal. Procede directamente a `plan-new-loop`.
-2. **`docs/specs/NNN-spec.md`** (borrador sin refinar) → propone correr `/w:spec-refine` primero; planificar sobre un spec sólido produce mejores planes.
+1. **Spec refinado** (`docs/specs/NNN-spec-<slug>.md` que **ya tiene** `## Refinement decisions` / `## Q&A traceability`) → ideal. Procede directamente a `plan-new-loop`.
+2. **Spec borrador** (mismo archivo, pero **sin** esas dos secciones) → **soft-suggest** correr `/w:spec-refine` primero; planificar sobre un spec sólido produce mejores planes (el usuario puede proceder igual).
 3. **prompt** (sin spec referenciado) → propone usar el flujo SPEC; **por default lanza `/w:spec-new`** con ese prompt para crear el borrador, y desde ahí continúa el flujo natural.
 
+> **Refinado vs borrador** se distingue por la **presencia** de `## Refinement decisions` / `## Q&A traceability` en el spec, no por el nombre del archivo (ya no hay `-refined`).
+
 ## Ejecutar el loop
 
 `plan-new-loop` **no** es una skill invocable por nombre — es el manual de operación de este comando (un doc hermano del bundle). **Cargalo y ejecutalo de punta a punta**:
@@ -33,7 +35,7 @@ El skill evalúa `$ARGUMENTS`:
 
 ## Notas de numeración
 
-El plan toma su propio número `PPP` en `docs/plans/`. **No hereda el `NNN` del spec**. El vínculo al spec se establece por referencia (`## Origin` / "Derivado de") en el plan, no por número.
+El plan se nombra `docs/plans/PPP-plan-<slug>.md`. El CLI solo devuelve el número `PPP`; el loop arma el nombre completo (slug = kebab-case corto del Requirement: `[a-z0-9-]`, ≤ ~5 palabras / ≤ 40 chars). **No hereda el `NNN` del spec**. El vínculo al spec se establece por referencia (`## Origin` / "Derivado de") en el plan, no por número.
 
 ## Plan mode
 

package/skills/w/commands/spec-new.md

@@ -1,5 +1,5 @@
 ---
-description: Genera un borrador de especificación (docs/specs/NNN-spec.md) a partir de un prompt, en una sola pasada. Paso 1 del flujo SPEC; no arranca loop.
+description: Genera un borrador de especificación (docs/specs/NNN-spec-<slug>.md) a partir de un prompt, en una sola pasada. Paso 1 del flujo SPEC; no arranca loop.
 argument-hint: <prompt con el requerimiento o idea>
 allowed-tools:
   [
@@ -11,7 +11,7 @@ allowed-tools:
 
 # spec-new — borrador de especificación (single-pass)
 
-Genera `docs/specs/NNN-spec.md` en una sola pasada a partir del prompt en `$ARGUMENTS`. No arranca loop.
+Genera `docs/specs/NNN-spec-<slug>.md` en una sola pasada a partir del prompt en `$ARGUMENTS`. No arranca loop.
 
 > ## ⛔ Single-pass — SIN investigación (regla dura)
 >
@@ -23,11 +23,12 @@ Genera `docs/specs/NNN-spec.md` en una sola pasada a partir del prompt en `$ARGU
 >
 > La investigación a profundidad (cerrar gaps, mapear código, consultar BD, research autónomo) es trabajo de **`spec-refine`**, no de aquí.
 
-1. Ejecutar `aw next-number docs/specs` para obtener `NNN` (única tool de shell necesaria).
-2. Crear `docs/specs/NNN-spec.md` parafraseando `$ARGUMENTS` en el esquema de borrador (ver abajo). Lectura del repo: opcional y mínima (p. ej. un archivo que el usuario citó) — nunca un barrido ni research.
-3. Mostrar el archivo generado y el próximo paso sugerido (`/w:spec-refine docs/specs/NNN-spec.md`).
+1. Ejecutar `aw next-number docs/specs` para obtener `NNN` (única tool de shell necesaria). El CLI solo devuelve el número; el slug lo arma este comando.
+2. Derivar el `<slug>`: kebab-case corto del Requirement — solo `[a-z0-9-]`, ≤ ~5 palabras / ≤ 40 chars.
+3. Crear `docs/specs/NNN-spec-<slug>.md` parafraseando `$ARGUMENTS` en el esquema de borrador (ver abajo). Lectura del repo: opcional y mínima (p. ej. un archivo que el usuario citó) — nunca un barrido ni research.
+4. Mostrar el archivo generado y el próximo paso sugerido (`/w:spec-refine docs/specs/NNN-spec-<slug>.md`).
 
-## Esquema del borrador (`NNN-spec.md`)
+## Esquema del borrador (`NNN-spec-<slug>.md`)
 
 ```markdown
 # Spec NNN — <slug>
@@ -61,7 +62,7 @@ Supuestos asumidos.
 - `Scope` siempre lleva `Out` (qué queda fuera).
 - Los criterios de aceptación deben ser verificables (testeables).
 - Si hay UI involucrada, mencionarlo en `Requirement`/`Context`; el spec UI se autora en `spec-refine` (via capacidad `ui-design`).
-- Alternativa equivalente: el usuario crea el borrador a mano. Ambos caminos producen el mismo `docs/specs/NNN-spec.md`.
+- Alternativa equivalente: el usuario crea el borrador a mano. Ambos caminos producen el mismo `docs/specs/NNN-spec-<slug>.md`.
 
 ## Plan mode
 

package/skills/w/commands/spec-refine.md

@@ -1,6 +1,6 @@
 ---
-description: Inicia o retoma el loop de refinamiento de una especificación (spec-refine-loop). Input: docs/specs/NNN-spec.md (borrador). Output: docs/specs/NNN-spec-refined.md.
-argument-hint: <docs/specs/NNN-spec.md>
+description: Inicia o retoma el loop de refinamiento de una especificación (spec-refine-loop). Input: docs/specs/NNN-spec-<slug>.md (borrador). Actualiza docs/specs/NNN-spec-<slug>.md in place.
+argument-hint: <docs/specs/NNN-spec-<slug>.md>
 allowed-tools:
   [
     "Bash",
@@ -25,12 +25,14 @@ Este comando no refina el spec él mismo: delega al loop `spec-refine-loop` (Lay
 
 ## Resolución de estado (resumable)
 
-El skill detecta el estado previo antes de arrancar:
+El skill detecta el estado previo antes de arrancar, **keyando off el `CHECKPOINT`** (no la existencia de un archivo "refined"):
 
 1. Busca la sesión de refinamiento del spec en `.workflow/sessions/` y su `CHECKPOINT.md`.
 2. **En curso** (existe CHECKPOINT) → continúa desde el avance previo (gaps resueltos, Q&A).
-3. **Sin avance** (sin CHECKPOINT ni refined) → arranca desde cero leyendo `NNN-spec.md`.
-4. **Ya completado** (existe `NNN-spec-refined.md`, sin CHECKPOINT abierto) → re-refinamiento incremental: lee el **refined** como input (NO el borrador stale); al `Guardar`, sobrescribe con confirmación.
+3. **Sin avance** (sin CHECKPOINT y el spec **no** tiene `## Refinement decisions`/`## Q&A traceability`) → arranca desde cero leyendo el spec (`NNN-spec*.md`).
+4. **Ya refinado** (sin CHECKPOINT abierto pero el spec **ya tiene** `## Refinement decisions`/`## Q&A traceability`) → re-refinamiento incremental leyendo el **spec mismo**; al `Guardar`, edita in place con confirmación.
+
+> **Compat (legacy):** el glob `NNN-spec*.md` también captura specs viejos `NNN-spec.md` / `NNN-spec-refined.md`. Re-correr spec-refine los edita in place de ahí en adelante.
 
 ## Plan mode
 

package/skills/w/commands/status.md

@@ -0,0 +1,50 @@
+---
+description: Dashboard read-only del workspace — qué se hizo / qué falta / qué se descartó, con fechas en español (hace 2 días, ayer en la mañana). Se apoya en `aw status`. Comando transversal (no es un flow); no escribe nada.
+argument-hint: (sin argumentos)
+allowed-tools:
+  [
+    "Bash",
+    "Read",
+  ]
+---
+
+# status — estado del workspace (read-only)
+
+Muestra, simple y directo, el estado del workspace agrupado en **Hecho / Falta / Descartó**. Single-pass, read-only: no abre loop, no crea sesiones, no escribe en `docs/` ni en `.workflow/`. Comando **transversal** (no pertenece a ningún flow).
+
+## Ejecutar
+
+1. Corré `aw status` (devuelve JSON; se apoya en `status-service`).
+2. Renderizá un resumen legible a partir del JSON — **no** muestres el JSON crudo. Usá el campo `relative` tal cual (ya viene humanizado en español). Encabezá con `workspace.name`.
+3. Agrupá en tres bloques:
+   - **▸ HECHO** — specs con `refined: true`; plans con su progreso (`tasks_done`/`tasks_total`, `progress_pct`); sesiones `closed`.
+   - **▸ FALTA** — sesiones `active`; plans con tareas pendientes (`tasks_total − tasks_done`); specs con `open_questions > 0`.
+   - **▸ DESCARTÓ** — cada item de `discarded[]` (`kind: deferred` = diferido en BACKLOG; `kind: excluded` = excluido en CHECKPOINT), con su `text`.
+4. Cada línea termina con su fecha relativa tras ` · ` (ej. `· ayer en la mañana`). Si una sección queda vacía, mostrá `— (nada)`. No inventes datos que no estén en el JSON.
+5. Si `workspace.initialized` es `false` y todo está vacío → decí "No es un workspace de agent-workflow (no hay `.workflow/`)" y sugerí `/w:workspace-init`.
+
+Formato sugerido (texto plano):
+
+```
+Workspace: <name>
+
+▸ HECHO
+  • plan <slug> — <done>/<total> tareas (<pct>%) · <relative>
+  • spec <slug> — refinado · <relative>
+  • <folder> (<type>) — cerrada · <relative>
+
+▸ FALTA
+  • <folder> (<type>) — activa · <relative>
+  • plan <slug> — <pendientes> tareas pendientes
+  • spec <slug> — <n> preguntas abiertas
+
+▸ DESCARTÓ
+  • <text> (<kind>) · <relative>
+```
+
+## Plan mode
+Igual que en ejecución: corré `aw status` (read-only) y mostrá el resumen. No hay cambios que aplicar.
+
+## Resources
+- CLI: `aw status` (servicio `status-service`; fechas vía `humanize-es`)
+- Design reference: `docs/referencias/workflow-commands/status.md`

package/skills/w/loops/README.md

@@ -13,7 +13,7 @@ Un loop es una **skill** que le enseña a la IA *cómo iterar* hasta producir un
 Propiedades comunes a **los 4 loops**:
 
 1. **Gap-driven convergente** — cada ciclo: `detect_gaps` → resolver (humano o research) → integrar → repetir hasta que no queden gaps materiales. Los gaps "agotados" (límite `MAX` de intentos) no se re-disparan → garantiza convergencia.
-2. **Puede crear sessions internas** — si refinar/planificar/ejecutar requiere trabajo profundo (ej. investigar el código), el loop crea una session en `.workflow/sessions/` que maneja **sus** artefactos, la cierra y reporta de vuelta. **El usuario nunca crea esas sessions.**
+2. **Una sola session por run + research inline** — el loop crea **una** session en `.workflow/sessions/` (la dueña del run) y maneja **sus** artefactos. La **investigación es inline**: una actividad dentro de esa misma session que escribe `ANALYSIS-FILE`/`CONCLUSIONS` (+ `SCRIPTS.sql` read-only si consulta BD) en su propia carpeta — ya no es una session aparte. **El usuario nunca crea sessions.** Los artefactos son el **registro vivo** del run — **ciclo artifact-first**: sembrar `CHECKPOINT.Pending/Next` (la intención) antes de ejecutar, llevar a `Completed`/DECISION después; CHECKPOINT actualizado en cada límite de gap/fase, BACKLOG solo si difiere. El spec/plan es la base guía.
 3. **AskUserQuestion con dos tipos de tab** (límite host: 4 preguntas/llamada):
    - **tab(s) de contenido** (≤3) — la(s) pregunta(s) real(es) del momento (resolver una duda, elegir MCP, o en convergencia: `Guardar` / `Preguntar algo más`).
    - **tab `flow`** (1, SIEMPRE presente) — control de ciclo de vida por un canal lateral. Así el contenido lo maneja la IA y el ciclo de vida lo dirige el humano.
@@ -26,15 +26,15 @@ El tab `flow` es **fijo**: `Compactar` / `Cerrar`, presente en los 4 loops. Resp
 | Option | What it does |
 |---|---|
 | `Compactar` | Escribe `CHECKPOINT` (session dueña del run) + dispara `/compact` del host y reanuda sin perder el hilo. |
-| `Cerrar` | `finalize`: persiste lo pendiente (`CHECKPOINT` + `BACKLOG`), cierra sessions internas y termina el loop. |
+| `Cerrar` | `finalize`: persiste lo pendiente (`CHECKPOINT` siempre; `BACKLOG` solo si hay algo diferido), cierra la session y termina el loop. |
 
 ## Loops and their flow
 
 | Loop (`name:`) | Flow | Started by | Reads | Writes |
 |---|---|---|---|---|
-| [`spec-refine-loop`](spec-refine-loop/SKILL.md) | SPEC | `/w:spec-refine` | `docs/specs/NNN-spec.md` (o `…-spec-refined.md` si ya existe) | `docs/specs/NNN-spec-refined.md` |
-| [`plan-new-loop`](plan-new-loop/SKILL.md) | PLANIFICATION | `/w:plan-new` | `docs/specs/NNN-spec-refined.md` | `docs/plans/PPP-plan.md` |
-| [`plan-exec-loop`](plan-exec-loop/SKILL.md) | PLANIFICATION | `/w:plan-exec` | `docs/plans/PPP-plan.md` | `docs/plans/PPP-plan.md` (update) + `docs/tools`; resto vía `export-*` |
+| [`spec-refine-loop`](spec-refine-loop/SKILL.md) | SPEC | `/w:spec-refine` | `docs/specs/NNN-spec*.md` (el spec mismo) | `docs/specs/NNN-spec-<slug>.md` (in place) |
+| [`plan-new-loop`](plan-new-loop/SKILL.md) | PLANIFICATION | `/w:plan-new` | `docs/specs/NNN-spec-*.md` | `docs/plans/PPP-plan-<slug>.md` |
+| [`plan-exec-loop`](plan-exec-loop/SKILL.md) | PLANIFICATION | `/w:plan-exec` | `docs/plans/PPP-plan-*.md` | `docs/plans/PPP-plan-<slug>.md` (update) + `docs/tools`; resto vía `export-*` |
 | [`quick-loop`](quick-loop/SKILL.md) | QUICK | `/w:quick` | — (prompt) | edita código + session ligera; **no** `docs/` |
 
 > `/w:spec-new` no tiene loop (es single-pass). Por eso hay **5 comandos / 4 loops**.
@@ -80,12 +80,13 @@ Los **heirs** (`plan-new-loop`, `plan-exec-loop`, `quick-loop`) usan `## Inherit
 ## Chassis / heirs
 
 ```
-spec-refine-loop  ── CHASIS (patrón de referencia: motor gap-driven, sessions,
-        │            AskUserQuestion + tab flow, research autónomo + regla BD,
-        │            compact/resume, Cerrar persiste CHECKPOINT+BACKLOG)
+spec-refine-loop  ── CHASIS (patrón de referencia: motor gap-driven, sesión única,
+        │            AskUserQuestion + tab flow, research autónomo INLINE + regla BD,
+        │            compact/resume, artefactos como log vivo: CHECKPOINT siempre,
+        │            BACKLOG solo si difiere)
         ├── plan-new-loop   (heir)  → deltas: plan rico, gap taxonomy de plan
         ├── plan-exec-loop  (heir)  → deltas: ejecución real (código/BD/git),
-        │                              session por fase, sin auto-export
+        │                              una sola session por run, sin auto-export
         └── quick-loop      (heir)  → deltas: ceremonia mínima, 1 session,
                                        hereda git/BD/no-export de plan-exec
 ```
@@ -103,7 +104,7 @@ Los loops componen **capacidades por su rol**, no skills concretas; la skill que
 | `git` | `git` | `plan-exec-loop` · `quick-loop` |
 | `coding-standards` | `coding-standards` | `plan-exec-loop` · `quick-loop` |
 | `writing` | `writing` | todos los loops |
-| `research` | `research` | todos los loops (research on-demand) |
+| `research` | `research` | todos los loops (research inline) |
 | `testing` | `testing` | `plan-exec-loop` · `quick-loop` |
 | `tools` | `tools` | `plan-exec-loop` |
 | `overview` | `workflow` | cualquiera (orientación) |

package/skills/w/loops/plan-exec-loop/SKILL.md

@@ -1,26 +1,26 @@
 ---
 name: plan-exec-loop
 description: >-
-  Ejecuta un plan de implementación (docs/plans/PPP-plan.md) como living doc: lo
-  lee y actualiza fase a fase mientras edita el código real, gestiona BD y git.
-  Heir del chasis spec-refine-loop: reusa su motor gap-driven (aplicado dentro
-  de una tarea ante decisiones/dudas no obvias), research on-demand con regla BD
-  read-only, AskUserQuestion con ≤3 tabs de contenido + 1 tab flow
-  (Compactar/Cerrar) siempre, y compact/resume con Cerrar que persiste CHECKPOINT
-  + BACKLOG. Sus deltas: una exec session por fase (resume intra-fase); git
-  seguro (verifica rama esperada antes de editar, propone commits por fuente,
-  nunca push/--amend/--no-verify); la IA NUNCA ejecuta DML/DDL (migraciones se
-  redactan en SCRIPTS.sql, solo read-only se ejecuta); validación por fase y
-  final (lo dependiente de migración no aplicada se difiere como handoff a DBA);
-  y SIN auto-export (escribe solo docs/plans + docs/tools; el resto queda como
-  artefacto de session para export-*). Compone git, coding-standards, testing,
-  tools y sql. Lo arranca /w:plan-exec y es reanudable. Invocar para implementar
-  un plan ya generado.
+  Ejecuta un plan de implementación (docs/plans/PPP-plan-<slug>.md) como living
+  doc: lo lee y actualiza fase a fase mientras edita el código real, gestiona BD
+  y git. Heir del chasis spec-refine-loop: reusa su motor gap-driven (aplicado
+  dentro de una tarea ante decisiones/dudas no obvias), research inline con
+  regla BD read-only, AskUserQuestion con ≤3 tabs de contenido + 1 tab flow
+  (Compactar/Cerrar) siempre, y artefactos como log vivo (CHECKPOINT siempre,
+  BACKLOG solo si difiere). Sus deltas: una sola session por run (resume vía
+  checkbox del plan-doc + CHECKPOINT); git seguro (verifica rama esperada antes
+  de editar, propone commits por fuente, nunca push/--amend/--no-verify); la IA
+  NUNCA ejecuta DML/DDL (migraciones se redactan en SCRIPTS.sql, solo read-only
+  se ejecuta); validación por fase y final (lo dependiente de migración no
+  aplicada se difiere como handoff a DBA); y SIN auto-export (escribe solo
+  docs/plans + docs/tools; el resto queda como artefacto de session para
+  export-*). Compone git, coding-standards, testing, tools y sql. Lo arranca
+  /w:plan-exec y es reanudable. Invocar para implementar un plan ya generado.
 ---
 
 # plan-exec-loop
 
-> **Heir** del chasis [`spec-refine-loop`](../spec-refine-loop/SKILL.md). Aquí los **deltas de ejecución** — el trabajo real: código, BD, git. El motor (gap-driven, research on-demand, AskUserQuestion + tab `flow`, compact/resume, `Cerrar` persiste) vive en el chasis.
+> **Heir** del chasis [`spec-refine-loop`](../spec-refine-loop/SKILL.md). Aquí los **deltas de ejecución** — el trabajo real: código, BD, git. El motor (gap-driven, research inline, AskUserQuestion + tab `flow`, compact/resume, artefactos como log vivo) vive en el chasis.
 
 ## Flow
 PLANIFICATION
@@ -29,15 +29,15 @@ PLANIFICATION
 2 — la IA lo corre entero.
 
 ## Started by
-`/w:plan-exec` — **reanudable** (mismo mecanismo de 4 casos del chasis; aquí con resume intra-fase, ver Delta 1).
+`/w:plan-exec` — **reanudable** (mismo mecanismo del chasis; aquí el resume keya off el checkbox del plan-doc + CHECKPOINT, ver Delta 1).
 
 ## Reads
-`docs/plans/PPP-plan.md`
+`docs/plans/PPP-plan-<slug>.md` (localizar vía glob `docs/plans/PPP-plan-*.md` o la ruta exacta de `$ARGUMENTS`).
 
 ## Writes
-- `docs/plans/PPP-plan.md` (**read/update**, living doc: estado de fases/tareas, `Open questions`).
+- `docs/plans/PPP-plan-<slug>.md` (**read/update**, living doc: estado de fases/tareas, `Open questions`).
 - `docs/tools/`: herramientas/utilidades reusables que la IA **crea** durante la ejecución (salida directa, no export).
-- Artefactos de exec session en `.workflow/sessions/` (`SCRIPTS.sql`, `DECISION`, …).
+- Artefactos de la plan-exec session en `.workflow/sessions/` (`SCRIPTS.sql`, `DECISION`, `ANALYSIS-FILE`/`CONCLUSIONS`, …).
 - **NO** escribe en otras carpetas `docs/` ni **gradúa/exporta** otros artefactos automáticamente (ver *Boundary*).
 
 ## Boundary — sin auto-export (hard rule)
@@ -48,10 +48,10 @@ Este loop **nunca gradúa/promueve artefactos** a `docs/`. Las únicas carpetas
 
 Del chasis [`spec-refine-loop`](../spec-refine-loop/SKILL.md), sin cambios:
 
-- Motor **gap-driven** (aplica *dentro de una tarea* ante una decisión/duda no obvia: research session ó AskUserQuestion).
+- Motor **gap-driven** (aplica *dentro de una tarea* ante una decisión/duda no obvia: research inline ó AskUserQuestion).
 - **AskUserQuestion**: ≤3 contenido + 1 `flow` (`Compactar`/`Cerrar`) siempre.
-- **research session** on-demand + **regla BD** read-only (pregunta MCP si >1 sin default → `SCRIPTS.sql` → ejecuta read-only) + research **inconclusa** (degrada/difiere, límite `MAX`).
-- **Compact/resume**; **`Cerrar` persiste** `CHECKPOINT` + `BACKLOG`.
+- **Research INLINE** + **regla BD** read-only (pregunta MCP si >1 sin default → `SCRIPTS.sql` → ejecuta read-only) + research **inconclusa** (degrada/difiere, límite `MAX`).
+- **Compact/resume**; **artefactos como log vivo** (`CHECKPOINT` siempre; `BACKLOG` solo si difiere).
 
 ## Composes
 
@@ -59,25 +59,26 @@ Del chasis [`spec-refine-loop`](../spec-refine-loop/SKILL.md), sin cambios:
 
 ## Internal sessions (managed)
 
-- **control session** descriptor `plan-exec` → `NNN-plan-exec`: dueña del run (`SESSION` + `CHECKPOINT` + `BACKLOG` al cerrar; Type = `control`).
-- **exec session por fase** descriptor `plan-exec-phase-<N>` → `NNN-plan-exec-phase-<N>`: `SESSION` · `DECISION` · `SCRIPTS.sql` · `CHECKPOINT` (Type = `exec`).
-- **research session** descriptor `plan-exec-research-*` → `NNN-plan-exec-research-*`: on-demand (run-and-close), igual que el chasis.
+- **plan-exec session** descriptor `plan-exec` → `NNN-plan-exec`: **una sola session por run** (Type = `exec`). Dueña del run; posee `SESSION` + `CHECKPOINT` + `DECISION` + `SCRIPTS.sql` (+ `BACKLOG` solo si difiere). La investigación es **inline** dentro de esta session: produce `ANALYSIS-FILE`/`CONCLUSIONS` (+ `SCRIPTS.sql` read-only si consulta BD) en su propia carpeta.
 
-> **Numeración**: el caller pasa solo el descriptor; el CLI antepone el `NNN` global y secuencial sobre `.workflow/sessions/` (ver chasis). No reinicia por tipo ni por fase.
+> **Numeración**: el caller pasa solo el descriptor; el CLI antepone el `NNN` global y secuencial sobre `.workflow/sessions/` (ver chasis). No reinicia por tipo.
 
-## Delta 1 — **One exec session per phase** (+ resume intra-fase)
+> **Compat (legacy):** workspaces viejos pueden tener sessions `plan-exec-phase-*` (una por fase) y `*-research-*` — son históricas y se dejan tal cual; los runs nuevos usan una sola session.
 
-- Recorre las `Phases` del plan en orden (respeta deps).
-- Por cada Phase no completada → `create_or_resume("plan-exec-phase-<N>")` (**reusa** la session si la fase quedó a medias; no crea una segunda; el CLI antepone el `NNN` global).
+## Delta 1 — One session per run; per-phase progress in the plan-doc
+
+- Recorre las `Phases` del plan en orden (respeta deps) **dentro de la única session del run** (no hay session-por-fase).
+- El **avance por fase vive en el plan-doc** (`- [x]`) y en el `CHECKPOINT` único (Completed/Pending/Next): **artifact-first** — `CHECKPOINT.Next` se fija a la fase inminente **antes** de iniciarla; el checkbox `- [x]` del plan-doc se voltea **después** de completar la tarea.
 - Ejecuta las `Tasks` de la fase; **salta** las ya marcadas `- [x]` en el plan (el plan-doc es la fuente de verdad por tarea). Marca `- [x]` + estado **en el plan** (living doc; no en un `TASKS` aparte).
-- Registra `DECISION` solo lo **no obvio**.
+- En **cada límite de fase**: actualiza el `CHECKPOINT` (Completed += Phase N, Next = Phase N+1) y propone commits.
+- Registra `DECISION` solo lo **no obvio**, **a medida que se toma** (los `DECISION` por fase se acumulan en el ÚNICO `DECISION`, etiquetados por fase/tarea — ej. `Origin: T2 (F1)`).
 
 ## Delta 2 — Git policy: **rama segura + commits propuestos**
 
 - **Antes de editar** archivos de una fuente: verifica rama actual = rama esperada de esa fuente (estilo `branch-check`). Si no coincide → **pausa y resuelve con el humano**; nunca `stash`/`reset --hard`/`checkout -- .`/`clean` sin confirmación por fuente.
 - **Al cerrar una fase** (o al `Cerrar`): **propone commits por fuente** (propose-then-execute, aprobar antes); nunca `push`/`--amend`/`--no-verify`.
 - **Commit rechazado**: los cambios **quedan en el working tree** (no se revierten). Se permite reproponer / editar mensaje. Se registra en `CHECKPOINT` + `BACKLOG` que la fase quedó **sin commitear** (reanudable).
-- **Precondición entre fases**: `branch-check` valida *identidad* de rama, **no** *limpieza* del working tree. Antes de iniciar la exec session de la siguiente fase, el working tree de cada fuente debe estar **limpio** (committeado) o explícitamente **reconocido** como "cambios sin commitear de la fase N" — para no co-mezclar dos fases en un mismo commit.
+- **Precondición entre fases**: `branch-check` valida *identidad* de rama, **no** *limpieza* del working tree. Antes de iniciar la siguiente fase, el working tree de cada fuente debe estar **limpio** (committeado) o explícitamente **reconocido** como "cambios sin commitear de la fase N" — para no co-mezclar dos fases en un mismo commit.
 
 ## Delta 3 — DB policy: **la IA nunca ejecuta DML**
 
@@ -98,19 +99,19 @@ Distinción por **ejecución**, no por archivo (ver el esquema `SCRIPTS.sql`):
 
 - Una fase cierra **done** cuando sus tareas están `- [x]` y su validación pasó **o** quedó diferida (handoff de SQL). Estado posible: **"done — SQL pendiente de aplicar"**.
 - Todas las fases done → `AskUserQuestion` final (contenido: `Marcar plan done` / `Preguntar algo más`; flow: `Compactar`/`Cerrar`).
-- **Sin export automático**: los artefactos (`SCRIPTS.sql`, `DECISION`, …) quedan en sus sessions. Promoverlos a `docs/` (scripts, manuals, …) es un paso aparte vía `export-*`.
+- **Sin export automático**: los artefactos (`SCRIPTS.sql`, `DECISION`, …) quedan en la session. Promoverlos a `docs/` (scripts, manuals, …) es un paso aparte vía `export-*`.
 
 ## Sequence
 
 ```
-plan-exec-loop(PPP-plan.md):
-  control = create_or_resume("plan-exec")                  # CLI antepone NNN global; CHECKPOINT, resume
-  plan = read(PPP-plan.md)
+plan-exec-loop(PPP-plan-<slug>.md):
+  session = create_or_resume("plan-exec")                  # UNA sola session por run; CLI antepone NNN global; CHECKPOINT, resume
+  plan = read(PPP-plan-<slug>.md)
   para cada Phase en plan (en orden, respeta deps):
-    si Phase done: skip
-    es = create_or_resume("plan-exec-phase-<N>")           # reusa si quedó a medias
+    si Phase done (todas sus Tasks - [x] en el plan): skip # resume vía checkbox del plan-doc
+    seed CHECKPOINT.Next = Phase N (Pending = sus Tasks)   # ANTES de iniciar la fase: sembrar intención (artifact-first)
     para cada Task de la Phase:
-      si Task - [x] en el plan: skip                       # resume intra-fase
+      si Task - [x] en el plan: skip                       # resume intra-fase por checkbox
       verificar rama esperada por fuente (branch-check)
         si no coincide → pausar + resolver con humano
       ejecutar Task:
@@ -118,29 +119,28 @@ plan-exec-loop(PPP-plan.md):
         si crea herramienta/utilidad reusable → docs/tools (salida directa)
         si consulta BD read-only → SCRIPTS.sql + ejecutar read-only
         si cambio BD (DDL/DML) → redactar en SCRIPTS.sql (artefacto session, NO ejecutar)
-        si decisión no obvia → DECISION
-        si duda/gap → research session ó AskUserQuestion   # chasis
-      marcar Task - [x] + estado EN EL PLAN
+        si decisión no obvia → DECISION (etiquetado por fase/tarea, en el ÚNICO DECISION)
+        si duda/gap → research inline ó AskUserQuestion    # chasis
+      marcar Task - [x] + estado EN EL PLAN                # DESPUÉS de completar la Task (el plan-doc es la fuente de verdad por tarea)
     validación de la fase:
         la que corre y falla → volver a la tarea
         la dependiente de migración no aplicada → diferir (Open questions + BACKLOG)
+    update CHECKPOINT (Completed += Phase N, Next = Phase N+1) # DESPUÉS: Pending→Completed + Next = fase siguiente (ver ciclo artifact-first)
     proponer commit(s) por fuente (aprobar antes)          # nunca push/amend/--no-verify
         si rechazado → cambios quedan; registrar "fase sin commitear"
     precondición siguiente fase: working tree limpio o reconocido
-    es.close_and_report()
   validación final (lo que se pueda; lo dependiente de SQL queda como handoff)
   AskUserQuestion(contenido: [Marcar plan done, Preguntar algo más], flow: [Compactar, Cerrar])
   marcar plan done (o "done — SQL pendiente de aplicar")
-  # NO export: los artefactos quedan en sessions; un export-* los promueve aparte
-finalize: CHECKPOINT + BACKLOG + cerrar sessions + reportar
+  # NO export: los artefactos quedan en la session; un export-* los promueve aparte
+finalize: CHECKPOINT (+ BACKLOG si difiere) + cerrar session + reportar
 ```
 
 ```mermaid
 flowchart TD
-    S["create_or_resume control session<br/>read PPP-plan.md"] --> P{"¿más Phases<br/>(no done)?"}
+    S["create_or_resume plan-exec session (única)<br/>read PPP-plan-&lt;slug&gt;.md"] --> P{"¿más Phases<br/>(no done)?"}
     P -->|no| V2["validación final<br/>(dep. de SQL → handoff)"]
-    P -->|sí| ES["create_or_resume exec session (Phase N)"]
-    ES --> T{"¿Task pendiente<br/>(no - [x])?"}
+    P -->|sí| T{"¿Task pendiente<br/>(no - [x])?"}
     T -->|sí| G["branch-check por fuente"]
     G -->|rama ok| DO["editar código · read-only→SCRIPTS.sql<br/>migración DDL/DML→SCRIPTS.sql (no ejecuta) · DECISION"]
     G -->|rama ≠| PA["pausar + resolver con humano"]
@@ -148,16 +148,16 @@ flowchart TD
     DO --> MK["marcar Task - [x] en el PLAN"]
     MK --> T
     T -->|no| VP["validación de fase<br/>(falla→tarea · dep. SQL→diferir)"]
-    VP --> CM["proponer commits por fuente"]
-    CM -->|aprobado| CL["cerrar exec session + reportar"]
+    VP --> CK["update CHECKPOINT (Completed/Next)"]
+    CK --> CM["proponer commits por fuente"]
+    CM -->|aprobado| P
     CM -->|rechazado| RJ["cambios quedan · registrar 'sin commitear'"]
-    RJ --> CL
-    CL --> P
+    RJ --> P
     V2 --> FIN["AskUserQuestion[Marcar plan done · Preguntar más]<br/>plan done (sin auto-export)"]
 ```
 
 ## Convergence / exit
 
 - Plan completo + validación OK (o diferida con handoff) → `Marcar plan done`.
-- `Cerrar` (tab flow, en cualquier momento) → `finalize` persiste `CHECKPOINT` + `BACKLOG` (qué quedó sin ejecutar / sin commitear / sin aplicar), cierra sessions, reporta.
+- `Cerrar` (tab flow, en cualquier momento) → `finalize` persiste `CHECKPOINT` (y `BACKLOG` solo si quedó algo sin ejecutar / sin commitear / sin aplicar), cierra la session, reporta.
 - La promoción de artefactos a `docs/` (vía `export-*`) es **siempre** un paso posterior y explícito, fuera de este loop.

package/skills/w/loops/plan-new-loop/SKILL.md

@@ -1,23 +1,25 @@
 ---
 name: plan-new-loop
 description: >-
-  Genera un plan de implementación rico (docs/plans/PPP-plan.md) a partir de un
-  spec refinado (docs/specs/NNN-spec-refined.md). Heir del chasis
-  spec-refine-loop: reusa íntegro su motor gap-driven convergente, sus sessions
-  internas (control + research on-demand), AskUserQuestion con ≤3 tabs de
-  contenido + 1 tab flow (Compactar/Cerrar) siempre presente, research autónomo
-  con regla BD read-only, y compact/resume con Cerrar que persiste CHECKPOINT +
-  BACKLOG. Sus deltas: el plan absorbe inline el nivel TECHNICAL-NOTE
+  Genera un plan de implementación rico (docs/plans/PPP-plan-<slug>.md) a partir
+  de un spec (docs/specs/NNN-spec-<slug>.md). Heir del chasis spec-refine-loop:
+  reusa íntegro su motor gap-driven convergente, su única session por run,
+  research INLINE, AskUserQuestion con ≤3 tabs de contenido + 1 tab flow
+  (Compactar/Cerrar) siempre presente, research autónomo con regla BD read-only,
+  y artefactos como log vivo (CHECKPOINT siempre, BACKLOG solo si difiere). Sus
+  deltas: el plan absorbe inline el nivel TECHNICAL-NOTE
   (Solution/Impacted/AS-IS/TO-BE/Validations…) + Phases/Tasks con estado vivo;
   el research aquí mapea código/impacto (componentes FE/BE/BD, wiring AS-IS,
-  dependencias); y una gap taxonomy propia de planificación. Lo arranca el
-  comando /w:plan-new y es reanudable. Invocar cuando un spec ya refinado deba
-  convertirse en un plan ejecutable antes de implementar.
+  dependencias); y una gap taxonomy propia de planificación. Distingue spec
+  refinado de borrador por la presencia de Refinement decisions/Q&A traceability
+  (si faltan → soft-suggest correr spec-refine antes). Lo arranca el comando
+  /w:plan-new y es reanudable. Invocar cuando un spec deba convertirse en un plan
+  ejecutable antes de implementar.
 ---
 
 # plan-new-loop
 
-> **Heir** del chasis [`spec-refine-loop`](../spec-refine-loop/SKILL.md). Aquí **solo** los deltas. El motor (gap-driven, sessions, AskUserQuestion + tab `flow`, research autónomo + regla BD, compact/resume, `Cerrar` persiste) vive en el chasis — no se repite.
+> **Heir** del chasis [`spec-refine-loop`](../spec-refine-loop/SKILL.md). Aquí **solo** los deltas. El motor (gap-driven, sesión única, AskUserQuestion + tab `flow`, research inline + regla BD, compact/resume, artefactos como log vivo) vive en el chasis — no se repite.
 
 ## Flow
 PLANIFICATION
@@ -26,33 +28,35 @@ PLANIFICATION
 2 — la IA lo corre entero.
 
 ## Started by
-`/w:plan-new` — **reanudable** (mismo mecanismo de 4 casos que el chasis).
+`/w:plan-new` — **reanudable** (mismo mecanismo del chasis, keyado off CHECKPOINT).
 
 ## Reads
-`docs/specs/NNN-spec-refined.md`
+`docs/specs/NNN-spec-*.md` (glob — localiza el spec por número; o la ruta exacta de `$ARGUMENTS`). **Refinado vs borrador** se distingue por la **presencia** de `## Refinement decisions` / `## Q&A traceability` en el spec: si faltan → **soft-suggest** correr `/w:spec-refine` primero (planificar sobre un spec sólido produce mejores planes), pero el usuario puede proceder.
 
 ## Writes
-`docs/plans/PPP-plan.md` (`generate`; **sobrescribe con confirmación** si existe). Solo escribe `docs/plans` — nunca otras carpetas `docs/` ni auto-export.
+`docs/plans/PPP-plan-<slug>.md` (`generate`; **sobrescribe con confirmación** si existe). Solo escribe `docs/plans` — nunca otras carpetas `docs/` ni auto-export.
+
+> **slug**: kebab-case corto derivado del Requirement del spec — solo `[a-z0-9-]`, ≤ ~5 palabras / ≤ 40 chars. El CLI solo devuelve el número `PPP`; el loop arma el nombre completo. Para localizar planes, glob `docs/plans/PPP-plan-*.md`.
 
 ## Inherits
 
 Del chasis [`spec-refine-loop`](../spec-refine-loop/SKILL.md), sin cambios:
 
-- Motor **gap-driven convergente** (`detect_gaps` → resolver → integrar → repetir; gaps agotados con límite `MAX` no se re-disparan).
-- **Sessions internas**: `control` (descriptor `plan-new` → `NNN-plan-new`: `SESSION` + `CHECKPOINT`, + `BACKLOG` al cerrar; Type = `refine`/`control`) + `research` on-demand (run-and-close, puede cerrar inconclusa).
+- Motor **gap-driven convergente** + **ciclo artifact-first** del chasis (sembrar `CHECKPOINT.Pending/Next` ANTES → `detect_gaps` → resolver → integrar → actualizar `Pending→Completed` DESPUÉS; gaps agotados con límite `MAX` no se re-disparan).
+- **Una sola session por run**: descriptor `plan-new` → `NNN-plan-new` (Type = `refine`): `SESSION` + `CHECKPOINT` (+ `BACKLOG` solo si difiere). La **investigación es inline** dentro de esta session (produce `ANALYSIS-FILE`/`CONCLUSIONS` + `SCRIPTS.sql` read-only en su propia carpeta), no una session aparte.
 - **AskUserQuestion**: ≤3 tabs de contenido + 1 tab `flow` (`Compactar`/`Cerrar`) siempre.
-- **Ask-vs-research rule** + **research autónomo** + **regla BD** (pregunta MCP si >1 sin default → queries a `SCRIPTS.sql` → ejecuta read-only, `sql-mutation-guard`) + manejo de research **inconclusa** (degrada a humano / difiere a `Open questions` + límite `MAX`).
-- **Compact / resume** (4 casos) y **`Cerrar` persiste** `CHECKPOINT` + `BACKLOG`.
-- **Naming + numeración global** del chasis: `<run>` = descriptor `plan-new`; hijas `--name plan-new-research-<gap>`. El CLI antepone el `NNN` global y secuencial (sin reiniciar por tipo); el caller pasa solo el descriptor.
+- **Ask-vs-research rule** + **research autónomo inline** + **regla BD** (pregunta MCP si >1 sin default → queries a `SCRIPTS.sql` → ejecuta read-only, `sql-mutation-guard`) + manejo de research **inconclusa** (degrada a humano / difiere a `Open questions` + límite `MAX`).
+- **Compact / resume** y **artefactos como log vivo (ciclo artifact-first)** (`CHECKPOINT` siempre; `BACKLOG` solo si difiere).
+- **Naming + numeración global** del chasis: `<run>` = descriptor `plan-new`. El CLI antepone el `NNN` global y secuencial (sin reiniciar por tipo); el caller pasa solo el descriptor.
 
-## Delta 1 — Deliverable: PLAN RICO (`PPP-plan.md`)
+## Delta 1 — Deliverable: PLAN RICO (`PPP-plan-<slug>.md`)
 
 El plan absorbe el nivel `TECHNICAL-NOTE` **inline** (decisión del usuario) + roadmap:
 
 ```markdown
 # Plan PPP — <slug>
 
-> Derivado de docs/specs/NNN-spec-refined.md · generado por plan-new-loop
+> Derivado de docs/specs/NNN-spec-<slug>.md · generado por plan-new-loop
 
 ## Origin              spec fuente (o prompt, si se bootstrapeó vía spec-new)
 ## Summary             el cómo, en 1–2 frases
@@ -71,7 +75,7 @@ El plan absorbe el nivel `TECHNICAL-NOTE` **inline** (decisión del usuario) + r
 ## Open questions      pendientes
 ```
 
-> **Implicación de catálogo:** `TECHNICAL-NOTE` deja de ser artefacto de exec session y se vuelve **secciones del plan-doc**. Reconciliado en [`plan-exec-loop`](../plan-exec-loop/SKILL.md): la exec session por fase **no** lleva `TECHNICAL-NOTE` ni `TASKS` propios; el detalle técnico y el progreso viven inline en el plan-doc (living).
+> **Implicación de catálogo:** `TECHNICAL-NOTE` deja de ser artefacto de session y se vuelve **secciones del plan-doc**. Reconciliado en [`plan-exec-loop`](../plan-exec-loop/SKILL.md): la única plan-exec session **no** lleva `TECHNICAL-NOTE` ni `TASKS` propios; el detalle técnico y el progreso viven inline en el plan-doc (living).
 
 ## Delta 2 — Gap taxonomy (de "plan")
 
@@ -90,8 +94,8 @@ Reemplaza la gap taxonomy de spec por una orientada a planificación:
 
 ## Delta 3 — What research investigates here
 
-El research del chasis se especializa: mapear **código/impacto** — componentes FE/BE/BD afectados, wiring AS-IS, dependencias. Alimenta las secciones `Solution`, `Impacted`, `Current state (AS-IS)`. La regla BD del chasis aplica igual (queries read-only a `SCRIPTS.sql`, MCP elegido vía tab de contenido si >1 sin default).
+El research **inline** del chasis se especializa: mapear **código/impacto** — componentes FE/BE/BD afectados, wiring AS-IS, dependencias. Alimenta las secciones `Solution`, `Impacted`, `Current state (AS-IS)`. La regla BD del chasis aplica igual (queries read-only a `SCRIPTS.sql`, MCP elegido vía tab de contenido si >1 sin default).
 
 ## Convergence / exit
 
-Sin gaps materiales → `AskUserQuestion` (contenido: `Guardar plan` / `Preguntar algo más`; flow: `Compactar`/`Cerrar`) → al `Guardar`, escribe `docs/plans/PPP-plan.md` (con confirmación si existe) → `finalize` (persiste `CHECKPOINT` + `BACKLOG`, cierra sessions, reporta). `Cerrar` en cualquier momento → `finalize` igual.
+Sin gaps materiales → `AskUserQuestion` (contenido: `Guardar plan` / `Preguntar algo más`; flow: `Compactar`/`Cerrar`) → al `Guardar`, escribe `docs/plans/PPP-plan-<slug>.md` (con confirmación si existe) → `finalize` (persiste `CHECKPOINT`, y `BACKLOG` solo si difiere; cierra la session, reporta). `Cerrar` en cualquier momento → `finalize` igual.