@tacuchi/agent-workflow-cli 15.1.0 → 16.0.0

package/skills/w/loops/quick-loop/SKILL.md

@@ -1,123 +1,123 @@
 ---
 name: quick-loop
 description: >-
-  El atajo liviano de agent-workflow: resuelve una tarea acotada (fix, ajuste
-  chico) directamente desde el prompt, editando código con ceremonia mínima.
-  Heir del chasis común de los loops (loops/CHASSIS.md — motor gap-driven con
-  las políticas de loops que editan código: git seguro, BD solo-scripts, gate
-  de revisión de cierre proporcional, sin auto-export); sus deltas viven en
-  el cuerpo: sin fases ni plan-doc (el prompt ES la tarea),
-  session ligera única (<slug>-quick), un solo commit, gate de tamaño a la
-  entrada y escalación EN VIVO a SPEC (handoff + spec-refine directo; a PLAN
-  queda diferida) si el objetivo excede un quick o la tarea crece. NO toca
-  docs/. Lo arranca /w:quick y es reanudable. Invocar para cambios pequeños y
-  directos que no ameritan spec ni plan formal.
+  The agent-workflow lightweight shortcut: solves a scoped task (fix, small
+  tweak) straight from the prompt, with minimal ceremony and a single commit.
+  Heir of the chassis (loops/CHASSIS.md + CODE-POLICIES.md). Deltas: no
+  plan-doc (the prompt IS the task), single light session <slug>-quick, an
+  entry size gate and LIVE escalation to SPEC (to PLAN it stays deferred)
+  when the objective exceeds a quick or the task grows. Never touches docs/.
+  Started by /w:quick; resumable. Invoke for small, direct changes that do
+  not warrant a formal spec or plan.
 ---
 
 # quick-loop
 
-> **Heir** del chasis común — aquí **solo** los deltas de QUICK. El motor vive en el chasis y las *Políticas de loops que editan código* (git · BD · gate proporcional) en `CODE-POLICIES.md` — no se repiten.
+> **Heir** of the common chassis — **only** the QUICK deltas live here. The engine lives in the chassis and the *code-editing loop policies* in `CODE-POLICIES.md` — never repeated.
 
 ## Flow
 QUICK
 
 ## Layer
-2 — la IA lo corre entero (loop mínimo).
+2 — the AI runs it end to end (minimal loop).
 
 ## Started by
-`/w:quick` — **reanudable** (mismo mecanismo de resume del chasis).
+`/w:quick` — **resumable** (same chassis resume mechanism).
 
 ## Reads
-— (el prompt del usuario; no hay documento de entrada).
+— (the user's prompt; there is no input document).
 
 ## Writes
-- **Deliverable según la tarea:** edita código en las fuentes (cambio mínimo) **o** produce un **análisis/diseño** acotado (deliverable no-código, vive en los artefactos de la session — no en `docs/`).
-- Artefactos de la session en `.workflow/sessions/`.
-- **NO toca `docs/`** (sin doc, sin auto-export). Un análisis/diseño que amerite preservarse se promueve aparte (`export-*`) o se escala a SPEC/PLAN (SPEC: en vivo — ver *Delta QUICK*).
+- **Deliverable per task:** edits code in the sources (minimal change) **or** produces a scoped **analysis/design** (non-code deliverable, lives in the session artifacts — never in `docs/`).
+- Session artifacts under `.workflow/sessions/`.
+- **NEVER touches `docs/`** (no doc, no auto-export). An analysis/design worth preserving is promoted separately (`export-*`) or escalated to SPEC/PLAN (SPEC: live — see *QUICK delta*).
 
 ## Internal session
 
-- **SIEMPRE** crea una session ligera con descriptor `<slug>-quick` → `NNN-<slug>-quick` (Type = `quick`, ≈ `exec`): `SESSION` · `DECISION` · `SCRIPTS.sql` · `CHECKPOINT` (+ `BACKLOG` solo si difiere). Una sola session. La investigación es **inline** dentro de ella (`ANALYSIS-FILE`/`CONCLUSIONS` + `SCRIPTS.sql` read-only en su carpeta). El caller pasa solo el descriptor; el CLI antepone el `NNN` global y secuencial (ver chasis). **Excepción:** si el **gate de tamaño** de la entrada escala a SPEC, el run quick no llega a existir — no se crea session quick; la session es la del `spec-refine-loop`.
+- **ALWAYS** creates a light session with descriptor `<slug>-quick` → `NNN-<slug>-quick` (Type = `quick`, ≈ `exec`): `SESSION` · `DECISION` · `SCRIPTS.sql` · `CHECKPOINT` (+ `BACKLOG` only if something is deferred). A single session. Research is **inline** inside it (`ANALYSIS-FILE`/`CONCLUSIONS` + read-only `SCRIPTS.sql` in its folder). The caller passes only the descriptor; the CLI prepends the global sequential `NNN` (see chassis). **Exception:** if the entry **size gate** escalates to SPEC, the quick run never comes to exist — no quick session is created; the session is the `spec-refine-loop` one.
 
 ## Inherits
 
-Leé **[`../CHASSIS.md`](../CHASSIS.md)** (instalación normal) **o** `CHASSIS.md` junto a este archivo (instalación aplanada) — el motor completo del loop (objetivo persistente + verification-first, gap-driven, session única + research inline, structured-choice + control `flow`, compact/resume, artefactos como log vivo, numeración, convergence gate, docs/ boundary) — **y** **[`../CODE-POLICIES.md`](../CODE-POLICIES.md)** (o `CODE-POLICIES.md` junto a este archivo) — las *Políticas de loops que editan código* (git seguro · BD solo-scripts · gate de revisión de cierre **proporcional**) — **siempre antes** de estos deltas.
+Read **[`../CHASSIS.md`](../CHASSIS.md)** — the loop's **full engine** — **and** **[`../CODE-POLICIES.md`](../CODE-POLICIES.md)** — the *code-editing loop policies* — **always before** these deltas. *(If `../` does not resolve: same names next to this file — global layout rule, chassis § Reference resolution.)*
 
 ## Composes
 
-`git` · `sql` (regla BD) · `research` (inline). Resueltas por `.workflow/skills.toml`.
+`git` · `sql` (DB rule) · `research` (inline). Resolved via `.workflow/skills.toml`.
 
-> **Convenciones ambientes (no roles):** estándares de código/testing/redacción y `creating-tools` son skills standalone que el host auto-descubre por su `description` — el workflow no las bindea ni depende de ellas. Doctrina completa: [../../roles/README.md](../../roles/README.md).
+> **Ambient conventions (not roles):** code/testing/writing standards and `creating-tools` are standalone skills the host auto-discovers by `description` — the workflow neither binds nor depends on them. Full doctrine: [../../roles/README.md](../../roles/README.md).
 
-## Delta QUICK — minimal ceremony
+## QUICK delta — minimal ceremony
 
-- **Sin fases, sin plan-doc**: el prompt **es** la tarea (una sola unidad). No hay roadmap.
-- **Verification-first proporcional** (ceremonia mínima): aun acá se **siembra el check antes**, del tamaño de la tarea. Código: un test (repro del bug → fix) o "build/lint/tests existentes siguen verdes" (chore). **Análisis/diseño**: una **rúbrica falsable corta**, *ratificada por el usuario* antes de perseguirla. Es el `SESSION.Success criteria` del run (ver [chasis § *Verification-first*](../CHASSIS.md)).
-- **Git y BD inline** (políticas completas en [`../CODE-POLICIES.md`](../CODE-POLICIES.md)): antes de editar, verificar rama esperada por fuente (`aw check-branch`); commit **propuesto** (aprobar antes) — nunca `push`/`--amend`/`--no-verify`. La IA **nunca ejecuta DML/DDL**: las migraciones se redactan en el `SCRIPTS.sql` de la session (consultas read-only sí, vía MCP).
-- **Una sola session**. **Un solo commit** propuesto al final (solo si hubo cambios de código), **tras el gate de revisión de cierre proporcional** ([`../CODE-POLICIES.md`](../CODE-POLICIES.md) § *Gate de revisión de cierre*): re-lectura del diff + convenciones ambientes; corregir o diferir; nada llega al commit sin revisar.
-- **Gate de tamaño a la ENTRADA** (antes de crear la session): al recibir el objetivo, evaluar si **excede un quick**. Dispara **solo con señales claras** (≥2 de: necesita arquitectura · ≥2 fuentes · varios entregables · feature/refactor grande · requisitos ambiguos que piden elicitación); borderline → **sigue en quick sin preguntar** (si después crece, lo cubre la escalación mid-loop). Un **resume** de una quick existente **no** re-dispara el gate. Si dispara → **structured-choice** (1 pregunta de contenido, recomendación primera + control `flow`; `Cerrar` acá = abortar, nada creado aún):
-  - **Cambiar a SPEC** (recomendada) → **no se crea la session quick**: corre la *Transición en vivo a SPEC* (bullet siguiente).
-  - **Seguir en quick** → continúa normal (`create_or_resume` + loop).
-  - **Recortar alcance** → la IA propone la **sub-tarea que SÍ cabe** en un quick; el loop sigue con ella (`SESSION.Objective` = la sub-tarea; el prompt original queda en el `## Origin` de la session) y el resto se difiere al `BACKLOG` ("recortado en el gate — puede ameritar spec aparte, `/w:spec-new`").
-  - **Anti-duplicado** (espíritu `create_or_resume`): si ya existe un spec cuyo `## Origin` referencia este mismo objetivo (o una session `*-spec-refine` equivalente), la recomendada pasa a ser **retomar ese spec** (semántica `/w:spec-refine`) — nunca materializar un segundo borrador.
-- **Transición en vivo a SPEC** (compartida por el gate y la escalación mid-loop): al aceptar, la línea de trabajo **deja de ser QUICK y pasa a ser flujo SPEC** — el consentimiento explícito en la structured-choice **equivale a invocar el comando** del flujo destino (excepción consentida a la regla de continuidad; ver [`../../SKILL.md`](../../SKILL.md) § *Contexto operativo*). Ya **del lado SPEC**: (1) materializar el **borrador** siguiendo el procedimiento de [`../../commands/spec-new.md`](../../commands/spec-new.md) — o `commands/spec-new.md` dentro de la skill `w` instalada (instalación aplanada) — `aw next-number docs/specs`, slug, esquema, single-pass **SIN investigación**; `## Origin` = "escalado desde `/w:quick`" + el prompt original (+ la session quick de origen si existe); (2) **cargar y ejecutar** [`../spec-refine-loop/SKILL.md`](../spec-refine-loop/SKILL.md) — o `../w-spec-refine-loop/SKILL.md` (instalación aplanada, skill hermana) — sobre ese spec, mismo patrón "cargalo y ejecutalo" de los comandos trampolín. La session del run es la `NNN-<slug>-spec-refine` **normal** de ese loop (el CLI numera; su `## Origin` registra la escalación). El **invariante 2 queda intacto**: quick, mientras es quick, no escribe `docs/` — el borrador lo escribe el flujo SPEC, post-consentimiento.
-- **Escalación mid-loop + handoff**: si la tarea crece (mismas señales del gate) → propone subir a **SPEC/PLAN** (structured-choice, recomendación primera). Si el usuario acepta:
-  - el **código ya editado queda** en el working tree (no se revierte) **y se registra** en `CHECKPOINT` + `BACKLOG` ("cambios sin commitear en `<fuente>` — código a medias; decidir commit/descartar al retomar") — reusando **ambas** mitades del patrón "commit rechazado" ([`../CODE-POLICIES.md`](../CODE-POLICIES.md) § *Git seguro*: no revertir **y** registrar lo sin commitear). Crítico en la rama **SPEC**, que no retoma el working tree;
-  - la session quick va a `finalize`, persistiendo `CHECKPOINT` + `BACKLOG` con el **puntero**: a **PLAN**, "escalado a `docs/plans/PPP` — retomar ahí" (**diferido como hoy**: siembra + puntero, sin entrar en vivo); a **SPEC**, "escalado a `docs/specs/NNN` — **continuado en vivo** (session `NNN-<slug>-spec-refine`)";
-  - los artefactos (`DECISION`, `SCRIPTS.sql`) **quedan en la session quick** como contexto referenciable por la nueva session (no se migran);
-  - **SPEC entra en vivo**: tras el `finalize`, corre la *Transición en vivo a SPEC* (borrador vía procedimiento spec-new **solo si no existe** spec para este objetivo; luego el loop). **Asimetría** intacta: escalar a **PLAN** puede **absorber** el avance (plan-exec retoma el working tree existente); escalar a **SPEC** **reinicia** el ciclo de diseño y trata el código a medias como **contexto/referencia**, no como trabajo ya ingerido.
+- **No phases, no plan-doc**: the prompt **is** the task (a single unit). No roadmap.
+- **Proportional verification-first** (minimal ceremony): even here the check is **seeded before**, sized to the task. Code: one test (bug repro → fix) or "existing build/lint/tests stay green" (chore). **Analysis/design**: a **short falsifiable rubric**, *ratified by the user* before pursuing it. It is the run's `SESSION.Success criteria` (see [chassis § *Verification-first*](../CHASSIS.md)).
+- **Git and DB inline** (full policies in [`../CODE-POLICIES.md`](../CODE-POLICIES.md)): before editing, verify each source's expected branch (`aw check-branch`); **proposed** commit (approve first) — never `push`/`--amend`/`--no-verify`. The AI **never executes DML/DDL**: migrations are drafted into the session's `SCRIPTS.sql` (read-only queries do run, via MCP).
+- **One session. One commit** proposed at the end (only if there were code changes), **after the proportional closing review gate** ([`../CODE-POLICIES.md`](../CODE-POLICIES.md) § *Closing review gate*): diff re-read + ambient conventions; fix or defer; nothing reaches the commit unreviewed.
+- **Entry SIZE GATE** (before creating the session): on receiving the objective, evaluate whether it **exceeds a quick**. It fires **only on clear signals** (≥2 of: needs architecture · ≥2 sources · multiple deliverables · large feature/refactor · ambiguous requirements needing elicitation); borderline → **continue in quick without asking** (if it later grows, mid-loop escalation covers it). A **resume** of an existing quick does **not** re-fire the gate. If it fires → **structured-choice** (1 content question, recommendation first + `flow` control; `Cerrar` here = abort, nothing created yet):
+  - **`Cambiar a SPEC`** (recommended) → **no quick session is created**: run the *Live transition to SPEC* (next bullet).
+  - **`Seguir en quick`** → continue normally (`create_or_resume` + loop).
+  - **`Recortar alcance`** → the AI proposes the **sub-task that DOES fit** a quick; the loop continues with it (`SESSION.Objective` = the sub-task; the original prompt goes into the session's `## Origin`) and the rest is deferred to `BACKLOG` ("trimmed at the gate — may warrant its own spec, `/w:spec-new`").
+  - **Anti-duplicate** (the `create_or_resume` spirit): if a spec whose `## Origin` references this same objective already exists (or an equivalent `*-spec-refine` session), the recommended option becomes **resuming that spec** (`/w:spec-refine` semantics) — never a second draft.
+- **Live transition to SPEC** (shared by the gate and mid-loop escalation). On acceptance, the work line **moves to the SPEC flow**: the explicit consent in the structured-choice **equals invoking the destination command** (*consented exception* — rule 3 of the *Continuity rule*, [`../../SKILL.md`](../../SKILL.md) § *Operating context*). On the SPEC side:
+  1. **Materialize the draft** via the [`../../commands/spec-new.md`](../../commands/spec-new.md) procedure: `aw next-number docs/specs`, slug, schema, single-pass **NO RESEARCH**. `## Origin` = "escalated from `/w:quick`" + the original prompt (+ the origin quick session if it exists).
+  2. **Load and execute** [`../spec-refine-loop/SKILL.md`](../spec-refine-loop/SKILL.md) — flattened: `../w-spec-refine-loop/SKILL.md` — over that spec (trampoline pattern).
+  3. The run's session is that loop's **normal** `NNN-<slug>-spec-refine` (the CLI numbers it; its `## Origin` records the escalation). **Invariant 2 intact**: quick, while it is quick, never writes `docs/` — the draft is written by the SPEC flow, post-consent.
+- **Mid-loop escalation + handoff**: if the task grows (same gate signals) → propose moving up to **SPEC/PLAN** (structured-choice, recommendation first). If the user accepts:
+  1. The **already-edited code stays** in the working tree (never reverted) and is **recorded** in `CHECKPOINT` + `BACKLOG`: "uncommitted changes in `<source>` — decide commit/discard on resume" (the "rejected commit" pattern, [`../CODE-POLICIES.md`](../CODE-POLICIES.md) § *Safe git*).
+  2. The quick session goes to `finalize` with the **pointer** in `BACKLOG`: to **PLAN** → "escalated to `docs/plans/PPP` — resume there" (**deferred** as today: seed + pointer, no live entry); to **SPEC** → "escalated to `docs/specs/NNN` — **continued live** (session `NNN-<slug>-spec-refine`)".
+  3. The artifacts (`DECISION`, `SCRIPTS.sql`) **stay in the quick session** as referenceable context for the new session (never migrated).
+  4. **SPEC enters live**: after `finalize`, run the *Live transition to SPEC* (draft **only if no spec exists** for this objective; then the loop). **Asymmetry** intact: PLAN can **absorb** the progress (plan-exec picks up the existing working tree); SPEC **restarts** the design cycle and treats the half-done code as context/reference, never as ingested work.
 
-## Continuidad entre prompts (contexto operativo)
+## Continuity across prompts (operating context)
 
-`quick` es donde la **regla de continuidad** (ver [`../../SKILL.md`](../../SKILL.md) § *Contexto operativo*) se ve más claro. Dentro de un workspace:
+`quick` is where the **continuity rule** ([`../../SKILL.md`](../../SKILL.md) § *Operating context*) shows most clearly. Inside a workspace:
 
-1. `/w:quick "primer prompt"` (**comando**) → crea la session `NNN-<slug>-quick`, arranca el loop. Los scripts van a **su** `SCRIPTS.sql`.
-2. `"segundo prompt"` (**sin comando**, trabajo relacionado) → **no** crea otra session: **continúa/reabre la más reciente** (la del paso 1) y agrega los nuevos scripts a **esa misma** `SCRIPTS.sql`.
-3. `/w:quick "tercer prompt"` (**comando** otra vez) → **nueva** session, nuevo loop.
+1. `/w:quick "first prompt"` (**command**) → creates session `NNN-<slug>-quick`, starts the loop. Scripts go to **its** `SCRIPTS.sql`.
+2. `"second prompt"` (**no command**, related work) → does **not** create another session: **continues/reopens the most recent one** (from step 1) and appends the new scripts to **that same** `SCRIPTS.sql`.
+3. `/w:quick "third prompt"` (**command** again) → **new** session, new loop.
 
-> El **comando** señala "nueva línea de trabajo"; un **prompt pelado** es "sigo en la misma" → por default continúa/reabre la más reciente (la *última iniciada*). Si es claramente no-relacionado, ofrece elegir (`continuar NNN` | `trabajo nuevo`) o cae a la rama **sin flujo** (escribe en `docs/` por convención + numeración). Sin workspace → comportamiento **vanilla**.
+> The **command** signals "new work line"; a **bare prompt** means "same line" → by default continue/reopen the most recent session (the *last started*). Clearly unrelated → offer choosing (`continuar NNN` | `trabajo nuevo`) or fall to the **no-flow** branch (write into `docs/` by convention + numbering). No workspace → **vanilla** behavior.
 
 ## Sequence
 
 ```
 quick-loop(prompt):
-  # GATE DE TAMAÑO — ANTES de crear session; solo línea de trabajo nueva (un resume no lo re-dispara)
-  si el objetivo excede un quick (≥2 señales claras — ver Delta):
-    si ya hay spec / session spec-refine de este objetivo → recomendar RETOMAR (/w:spec-refine)  # anti-duplicado
-    structured_choice(contenido: [Cambiar a SPEC (recomendada), Seguir en quick, Recortar alcance],
-                      flow: [Compactar, Cerrar])           # Cerrar acá = abortar (nada creado aún)
-    Cambiar a SPEC   → transición en vivo (ver Delta): borrador (procedimiento spec-new) +
-                       cargar y ejecutar ../spec-refine-loop/SKILL.md → FIN (sin session quick)
-    Recortar alcance → objetivo = la sub-tarea propuesta; el resto → BACKLOG al crear la session
-    Seguir en quick  → continuar
-  s = create_or_resume("<slug>-quick")      # CLI antepone NNN global; siempre session ligera
-  seed SESSION.Objective = el prompt
-  seed SESSION.Success criteria = check del deliverable     # verification-first, ANTES: test(s) si código · rúbrica corta RATIFICADA si análisis/diseño
-  seed CHECKPOINT.Pending/Next = la tarea (s)               # ANTES: sembrar intención (artifact-first)
-  trabajar la tarea (loop mínimo):
-    si edita código → verificar rama esperada por fuente (`aw check-branch`); si no → pausar + resolver
-    producir el deliverable: editar código (cambio mínimo) Ó autorar el análisis/diseño
-    si consulta BD read-only → SCRIPTS.sql + ejecutar read-only
-    si cambio BD (DDL/DML) → SCRIPTS.sql (artefacto session, NO ejecutar)
-    si decisión no obvia → DECISION
-    si duda/gap → research inline ó structured-choice         # chasis
-    si la tarea CRECE → proponer escalar a SPEC/PLAN          # structured-choice, recomendación primera
-        acepta PLAN → handoff (avance queda; BACKLOG→plan sembrado — retomar ahí) → goto finalize
-        acepta SPEC → handoff (avance queda; BACKLOG→"continuado en vivo") → finalize →
-                      transición en vivo (ver Delta): borrador si falta + spec-refine-loop
-  convergence gate: Success criteria en verde                # tests verdes si código · rúbrica satisfecha si análisis/diseño
-  si hubo cambios de código:
-    gate de revisión de cierre (proporcional):               # re-lectura del diff + convenciones ambientes instaladas
-        hallazgos → corregir (re-validar) ó diferir justificado (BACKLOG)
-    proponer commit (aprobar antes)                          # nunca push/amend/--no-verify; solo tras el gate
-  structured_choice(contenido: [Cerrar tarea, Preguntar algo más], flow: [Compactar, Cerrar])
-finalize: CHECKPOINT (DESPUÉS: Pending→Completed) + BACKLOG (solo si queda algo diferido) + cerrar session + reportar
+  # SIZE GATE — BEFORE creating a session; new work lines only (a resume does not re-fire it)
+  if the objective exceeds a quick (≥2 clear signals — see delta):
+    if a spec / spec-refine session for this objective already exists → recommend RESUMING it (/w:spec-refine)  # anti-duplicate
+    structured_choice(content: [Cambiar a SPEC (recommended), Seguir en quick, Recortar alcance],
+                      flow: [Compactar, Cerrar])           # Cerrar here = abort (nothing created yet)
+    Cambiar a SPEC   → live transition (see delta): draft (spec-new procedure) +
+                       load and execute ../spec-refine-loop/SKILL.md → END (no quick session)
+    Recortar alcance → objective = the proposed sub-task; the rest → BACKLOG when the session is created
+    Seguir en quick  → continue
+  s = create_or_resume("<slug>-quick")      # CLI prepends global NNN; always a light session
+  seed SESSION.Objective = the prompt
+  seed SESSION.Success criteria = the deliverable's check   # verification-first, BEFORE: test(s) if code · short RATIFIED rubric if analysis/design
+  seed CHECKPOINT.Pending/Next = the task (s)               # BEFORE: seed the intent (artifact-first)
+  work the task (minimal loop):
+    if it edits code → verify each source's expected branch (`aw check-branch`); mismatch → pause + resolve
+    produce the deliverable: edit code (minimal change) OR author the analysis/design
+    if read-only DB query → SCRIPTS.sql + execute read-only
+    if DB change (DDL/DML) → SCRIPTS.sql (session artifact, DO NOT execute)
+    if non-obvious decision → DECISION
+    if doubt/gap → inline research OR structured-choice      # chassis
+    if the task GROWS → propose escalating to SPEC/PLAN      # structured-choice, recommendation first
+        accepts PLAN → handoff (progress stays; BACKLOG→seeded plan — resume there, deferred) → goto finalize
+        accepts SPEC → handoff (progress stays; BACKLOG→"continued live") → finalize →
+                       live transition (see delta): draft if missing + spec-refine-loop
+  convergence gate: Success criteria green                   # tests green if code · rubric satisfied if analysis/design
+  if there were code changes:
+    closing review gate (proportional):                      # diff re-read + installed ambient conventions
+        findings → fix (re-validate) OR defer justified (BACKLOG)
+    propose commit (approve first)                           # never push/amend/--no-verify; only after the gate
+  structured_choice(content: [Cerrar tarea, Preguntar algo más], flow: [Compactar, Cerrar])
+finalize: CHECKPOINT (AFTER: Pending→Completed) + BACKLOG (only if something is deferred) + close session + report
 ```
 
 ## Convergence / exit
 
-- **Success criteria en verde** (proporcional) + gate de revisión de cierre pasado y commit propuesto si hubo código (o aprobado saltarlo) → `Cerrar`.
-- `Cerrar`/`Compactar` (control `flow`) → persiste `CHECKPOINT` + `BACKLOG` (reanudable).
-- **Sin export**: nada va a `docs/`. Si algo amerita preservarse → se promueve aparte vía `export-*`, o se escala (a SPEC **en vivo** — la línea continúa en spec-refine ya como flujo SPEC; a PLAN **diferido**, sembrado + puntero).
+- **Success criteria green** (proportional) + closing review gate passed and commit proposed if there was code (or skipping it approved) → `Cerrar`.
+- `Cerrar`/`Compactar` (`flow` control) → persists `CHECKPOINT` + `BACKLOG` (resumable).
+- **No export**: nothing goes to `docs/`. Anything worth preserving → promoted separately via `export-*`, or escalated (to SPEC **live** — the line continues in spec-refine already as SPEC flow; to PLAN **deferred**, seed + pointer).
 
-> El *convergence gate* de QUICK es **verification-first proporcional**: un `Success criteria` **corto** sembrado al inicio (no la *ausencia* de checklist, sino su versión mínima) — para código, "el cambio hace lo que pedía el prompt + tests/build verdes"; para análisis/diseño, una rúbrica corta ratificada. Mínima ceremonia por diseño, pero **siempre con el check declarado antes**.
+> QUICK's *convergence gate* is **proportional verification-first**: a **short** `Success criteria` seeded at start (not the *absence* of a checklist — its minimal version) — for code, "the change does what the prompt asked + tests/build green"; for analysis/design, a short ratified rubric. Minimal ceremony by design, but **always with the check declared first**.